13

我正在尝试找到一种将图像打印到斑马的方法并且遇到了很多麻烦。

根据文档:

第一种编码称为 B64,使用 MIME Base64 方案对数据进行编码。Base64 用于对电子邮件附件进行编码......
Base64 将 6 位编码为字节,比未封装的数据扩展 33%。
第二种编码称为 Z64,首先使用 LZ77 算法压缩数据以减小其大小。(此算法由 PKZIP 使用,并且是 PNG 图形格式的组成部分。)
然后使用上述 MIME Base64 方案对压缩数据进行编码。
将通过 Base64 编码的数据计算 CRC。

但它没有更多的信息。

基本上我正在尝试编码

private byte[] GetItemFromPath(string filepath)
{   
    using (MemoryStream ms = new MemoryStream())
    {
        using (Image img = Image.FromFile(filepath))
        {
            img.Save(ms, ImageFormat.Png);
            return ms.ToArray();
        }
    }
}

然后尝试使用以下内容进行打印:

var initialArray = GetItemFromPath("C:\\RED.png");
string converted = Convert.ToBase64String(b);

PrintThis(string.Format(@"~DYRED.PNG,P,P,{1},0,:B64:
{0}
^XA
^F0200,200^XGRED.PNG,1,1^FS
^XZ", converted .ToString(), initialArray.Length));

从它的声音来看,B64或Z64都可以接受。

我尝试了一些变体,以及几种生成 CRC 和计算“大小”的方法。但似乎没有一个工作,将图形下载到打印机总是中止。

有没有人设法完成这样的事情?或者知道我哪里出错了?

4

6 回答 6

17

我得到这个答案的所有功劳都来自LabView 论坛用户 Raydur。他发布了一个 LabView 解决方案,该解决方案可以在 LabView 中打开以向下发送图像。我个人没有用我的打印机运行它,我只是用它来找出正确的图像代码,这样我就可以在我的代码中复制它。我缺少的一件大事是填充我的十六进制代码。例如,1A 可以,但是如果你只有 A,你需要在它前面填充一个 0 来发送 0A。您发送的 ZPL 中文件的大小也是字节数组的原始大小,而不是数据的最终字符串表示形式。

我搜索了很多很多论坛和 Stackoverflow 帖子,试图弄清楚这一点,因为这似乎是一件很简单的事情。我已经尝试过在其他地方发布的每一个解决方案,但我真的只想打印 a.PNG,因为我的打印机(Mobile QLN320)的手册内置了对它的支持。它说要么以 Base64 或 16 进制发送它,我都尝试过都无济于事。对于任何想要使用 Base64 的人,我在一本较旧的手册中发现您需要手动计算您发送的每个数据包的 CRC 码,因此我选择使用更简单的十六进制路由。所以这是我要工作的代码!

        string ipAddress = "192.168.1.30";
        int port = 6101;

        string zplImageData = string.Empty;
        //Make sure no transparency exists. I had some trouble with this. This PNG has a white background
        string filePath = @"C:\Users\Path\To\Logo.png";
        byte[] binaryData = System.IO.File.ReadAllBytes(filePath);
        foreach (Byte b in binaryData)
        {
            string hexRep = String.Format("{0:X}", b);
            if (hexRep.Length == 1)
                hexRep = "0" + hexRep;
            zplImageData += hexRep;
          }
          string zplToSend = "^XA" + "^MNN" + "^LL500" + "~DYE:LOGO,P,P," + binaryData.Length + ",," + zplImageData+"^XZ";
          string printImage = "^XA^FO115,50^IME:LOGO.PNG^FS^XZ";

        try
        {
            // Open connection
            System.Net.Sockets.TcpClient client = new System.Net.Sockets.TcpClient();
            client.Connect(ipAddress, port);

            // Write ZPL String to connection
            System.IO.StreamWriter writer = new System.IO.StreamWriter(client.GetStream(),Encoding.UTF8);
            writer.Write(zplToSend);
            writer.Flush();
            writer.Write(printImage);
            writer.Flush();
            // Close Connection
            writer.Close();
            client.Close();
        }
        catch (Exception ex)
        {
            // Catch Exception
        }
于 2014-03-25T00:30:12.867 回答
8

The ZPL II Programming Guide documents the ~DG command and GRF format (page 124) to download images. Volume Two adds details on an optional compression format (page 52).

First, you have to convert the image to a 1bpp bi-level image, then convert it to a hex-encoded string. You can further compress the image to reduce transmission time. You can then print the image with the ^ID command.

While there is inherent support for PNG images in the ~DY command, it is poorly documented and does not seem to work on certain models of printers. The ZB64 format is basically not documented, and attempts to get more information from Zebra support have been fruitless. If you have your heart set on ZB64, you can use the Java based Zebralink SDK (look to ImagePrintDemo.java and com.zebra.sdk.printer.internal.GraphicsConversionUtilZpl.sendImageToStream).

Once you have the command data, it can be sent via TCP/IP if the printer has a print-server, or it can be sent by writing in RAW format to the printer.

The code below prints a 5 kB PNG as a 13 kB compressed GRF (60 kB uncompressed):

class Program
{
    static unsafe void Main(string[] args)
    {
        var baseStream = new MemoryStream();
        var tw = new StreamWriter(baseStream, Encoding.UTF8);

        using (var bmpSrc = new Bitmap(Image.FromFile(@"label.png")))
        {
            tw.WriteLine(ZplImage.GetGrfStoreCommand("R:LBLRA2.GRF", bmpSrc));
        }
        tw.WriteLine(ZplImage.GetGrfPrintCommand("R:LBLRA2.GRF"));
        tw.WriteLine(ZplImage.GetGrfDeleteCommand("R:LBLRA2.GRF"));

        tw.Flush();
        baseStream.Position = 0;

        var gdipj = new GdiPrintJob("ZEBRA S4M-200dpi ZPL", GdiPrintJobDataType.Raw, "Raw print", null);
        gdipj.WritePage(baseStream);
        gdipj.CompleteJob();
    }
}

class ZplImage
{
    public static string GetGrfStoreCommand(string filename, Bitmap bmpSource)
    {
        if (bmpSource == null)
        {
            throw new ArgumentNullException("bmpSource");
        }
        validateFilename(filename);

        var dim = new Rectangle(Point.Empty, bmpSource.Size);
        var stride = ((dim.Width + 7) / 8);
        var bytes = stride * dim.Height;

        using (var bmpCompressed = bmpSource.Clone(dim, PixelFormat.Format1bppIndexed))
        {
            var result = new StringBuilder();

            result.AppendFormat("^XA~DG{2},{0},{1},", stride * dim.Height, stride, filename);
            byte[][] imageData = GetImageData(dim, stride, bmpCompressed);

            byte[] previousRow = null;
            foreach (var row in imageData)
            {
                appendLine(row, previousRow, result);
                previousRow = row;
            }
            result.Append(@"^FS^XZ");

            return result.ToString();
        }
    }

    public static string GetGrfDeleteCommand(string filename)
    {
        validateFilename(filename);

        return string.Format("^XA^ID{0}^FS^XZ", filename);
    }

    public static string GetGrfPrintCommand(string filename)
    {
        validateFilename(filename);

        return string.Format("^XA^FO0,0^XG{0},1,1^FS^XZ", filename);
    }

    static Regex regexFilename = new Regex("^[REBA]:[A-Z0-9]{1,8}\\.GRF$");

    private static void validateFilename(string filename)
    {
        if (!regexFilename.IsMatch(filename))
        {
            throw new ArgumentException("Filename must be in the format "
                + "R:XXXXXXXX.GRF.  Drives are R, E, B, A.  Filename can "
                + "be alphanumeric between 1 and 8 characters.", "filename");
        }
    }

    unsafe private static byte[][] GetImageData(Rectangle dim, int stride, Bitmap bmpCompressed)
    {
        byte[][] imageData;
        var data = bmpCompressed.LockBits(dim, ImageLockMode.ReadOnly, PixelFormat.Format1bppIndexed);
        try
        {
            byte* pixelData = (byte*)data.Scan0.ToPointer();
            byte rightMask = (byte)(0xff << (data.Stride * 8 - dim.Width));
            imageData = new byte[dim.Height][];

            for (int row = 0; row < dim.Height; row++)
            {
                byte* rowStart = pixelData + row * data.Stride;
                imageData[row] = new byte[stride];

                for (int col = 0; col < stride; col++)
                {
                    byte f = (byte)(0xff ^ rowStart[col]);
                    f = (col == stride - 1) ? (byte)(f & rightMask) : f;
                    imageData[row][col] = f;
                }
            }
        }
        finally
        {
            bmpCompressed.UnlockBits(data);
        }
        return imageData;
    }

    private static void appendLine(byte[] row, byte[] previousRow, StringBuilder baseStream)
    {
        if (row.All(r => r == 0))
        {
            baseStream.Append(",");
            return;
        }

        if (row.All(r => r == 0xff))
        {
            baseStream.Append("!");
            return;
        }

        if (previousRow != null && MatchByteArray(row, previousRow))
        {
            baseStream.Append(":");
            return;
        }

        byte[] nibbles = new byte[row.Length * 2];
        for (int i = 0; i < row.Length; i++)
        {
            nibbles[i * 2] = (byte)(row[i] >> 4);
            nibbles[i * 2 + 1] = (byte)(row[i] & 0x0f);
        }

        for (int i = 0; i < nibbles.Length; i++)
        {
            byte cPixel = nibbles[i];

            int repeatCount = 0;
            for (int j = i; j < nibbles.Length && repeatCount <= 400; j++)
            {
                if (cPixel == nibbles[j])
                {
                    repeatCount++;
                }
                else
                {
                    break;
                }
            }

            if (repeatCount > 2)
            {
                if (repeatCount == nibbles.Length - i
                    && (cPixel == 0 || cPixel == 0xf))
                {
                    if (cPixel == 0)
                    {
                        if (i % 2 == 1)
                        {
                            baseStream.Append("0");
                        }
                        baseStream.Append(",");
                        return;
                    }
                    else if (cPixel == 0xf)
                    {
                        if (i % 2 == 1)
                        {
                            baseStream.Append("F");
                        }
                        baseStream.Append("!");
                        return;
                    }
                }
                else
                {
                    baseStream.Append(getRepeatCode(repeatCount));
                    i += repeatCount - 1;
                }
            }
            baseStream.Append(cPixel.ToString("X"));
        }
    }

    private static string getRepeatCode(int repeatCount)
    {
        if (repeatCount > 419)
            throw new ArgumentOutOfRangeException();

        int high = repeatCount / 20;
        int low = repeatCount % 20;

        const string lowString = " GHIJKLMNOPQRSTUVWXY";
        const string highString = " ghijklmnopqrstuvwxyz";

        string repeatStr = "";
        if (high > 0)
        {
            repeatStr += highString[high];
        }
        if (low > 0)
        {
            repeatStr += lowString[low];
        }

        return repeatStr;
    }

    private static bool MatchByteArray(byte[] row, byte[] previousRow)
    {
        for (int i = 0; i < row.Length; i++)
        {
            if (row[i] != previousRow[i])
            {
                return false;
            }
        }

        return true;
    }
}

internal static class NativeMethods
{
    #region winspool.drv

    #region P/Invokes

    [DllImport("winspool.Drv", SetLastError = true, CharSet = CharSet.Unicode)]
    internal static extern bool OpenPrinter(string szPrinter, out IntPtr hPrinter, IntPtr pd);

    [DllImport("winspool.Drv", SetLastError = true, CharSet = CharSet.Unicode)]
    internal static extern bool ClosePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", SetLastError = true, CharSet = CharSet.Unicode)]
    internal static extern UInt32 StartDocPrinter(IntPtr hPrinter, Int32 level, IntPtr di);

    [DllImport("winspool.Drv", SetLastError = true, CharSet = CharSet.Unicode)]
    internal static extern bool EndDocPrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", SetLastError = true, CharSet = CharSet.Unicode)]
    internal static extern bool StartPagePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", SetLastError = true, CharSet = CharSet.Unicode)]
    internal static extern bool EndPagePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", SetLastError = true, CharSet = CharSet.Unicode)]
    internal static extern bool WritePrinter(
        // 0
        IntPtr hPrinter,
        [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pBytes,
        // 2
        UInt32 dwCount,
        out UInt32 dwWritten);

    #endregion

    #region Structs

    [StructLayout(LayoutKind.Sequential)]
    internal struct DOC_INFO_1
    {
        [MarshalAs(UnmanagedType.LPWStr)]
        public string DocName;
        [MarshalAs(UnmanagedType.LPWStr)]
        public string OutputFile;
        [MarshalAs(UnmanagedType.LPWStr)]
        public string Datatype;
    }

    #endregion

    #endregion
}

/// <summary>
/// Represents a print job in a spooler queue
/// </summary>
public class GdiPrintJob
{
    IntPtr PrinterHandle;
    IntPtr DocHandle;

    /// <summary>
    /// The ID assigned by the print spooler to identify the job
    /// </summary>
    public UInt32 PrintJobID { get; private set; }

    /// <summary>
    /// Create a print job with a enumerated datatype
    /// </summary>
    /// <param name="PrinterName"></param>
    /// <param name="dataType"></param>
    /// <param name="jobName"></param>
    /// <param name="outputFileName"></param>
    public GdiPrintJob(string PrinterName, GdiPrintJobDataType dataType, string jobName, string outputFileName)
        : this(PrinterName, translateType(dataType), jobName, outputFileName)
    {
    }

    /// <summary>
    /// Create a print job with a string datatype
    /// </summary>
    /// <param name="PrinterName"></param>
    /// <param name="dataType"></param>
    /// <param name="jobName"></param>
    /// <param name="outputFileName"></param>
    public GdiPrintJob(string PrinterName, string dataType, string jobName, string outputFileName)
    {
        if (string.IsNullOrWhiteSpace(PrinterName))
            throw new ArgumentNullException("PrinterName");
        if (string.IsNullOrWhiteSpace(dataType))
            throw new ArgumentNullException("PrinterName");

        IntPtr hPrinter;
        if (!NativeMethods.OpenPrinter(PrinterName, out hPrinter, IntPtr.Zero))
            throw new Win32Exception();
        this.PrinterHandle = hPrinter;

        NativeMethods.DOC_INFO_1 docInfo = new NativeMethods.DOC_INFO_1()
        {
            DocName = jobName,
            Datatype = dataType,
            OutputFile = outputFileName
        };
        IntPtr pDocInfo = Marshal.AllocHGlobal(Marshal.SizeOf(docInfo));
        RuntimeHelpers.PrepareConstrainedRegions();
        try
        {
            Marshal.StructureToPtr(docInfo, pDocInfo, false);
            UInt32 docid = NativeMethods.StartDocPrinter(hPrinter, 1, pDocInfo);
            if (docid == 0)
                throw new Win32Exception();
            this.PrintJobID = docid;
        }
        finally
        {
            Marshal.FreeHGlobal(pDocInfo);
        }
    }

    /// <summary>
    /// Write the data of a single page or a precomposed PCL document
    /// </summary>
    /// <param name="data"></param>
    public void WritePage(Stream data)
    {
        if (data == null)
            throw new ArgumentNullException("data");
        if (!data.CanRead && !data.CanWrite)
            throw new ObjectDisposedException("data");
        if (!data.CanRead)
            throw new NotSupportedException("stream is not readable");

        if (!NativeMethods.StartPagePrinter(this.PrinterHandle))
            throw new Win32Exception();

        byte[] buffer = new byte[0x14000]; /* 80k is Stream.CopyTo default */
        uint read = 1;
        while ((read = (uint)data.Read(buffer, 0, buffer.Length)) != 0)
        {
            UInt32 written;
            if (!NativeMethods.WritePrinter(this.PrinterHandle, buffer, read, out written))
                throw new Win32Exception();

            if (written != read)
                throw new InvalidOperationException("Error while writing to stream");
        }

        if (!NativeMethods.EndPagePrinter(this.PrinterHandle))
            throw new Win32Exception();
    }

    /// <summary>
    /// Complete the current job
    /// </summary>
    public void CompleteJob()
    {
        if (!NativeMethods.EndDocPrinter(this.PrinterHandle))
            throw new Win32Exception();
    }

    #region datatypes
    private readonly static string[] dataTypes = new string[] 
    { 
        // 0
        null, 
        "RAW", 
        // 2
        "RAW [FF appended]",
        "RAW [FF auto]",
        // 4
        "NT EMF 1.003", 
        "NT EMF 1.006",
        // 6
        "NT EMF 1.007", 
        "NT EMF 1.008", 
        // 8
        "TEXT", 
        "XPS_PASS", 
        // 10
        "XPS2GDI" 
    };

    private static string translateType(GdiPrintJobDataType type)
    {
        return dataTypes[(int)type];
    }
    #endregion
}

public enum GdiPrintJobDataType
{
    Unknown = 0,
    Raw = 1,
    RawAppendFF = 2,
    RawAuto = 3,
    NtEmf1003 = 4,
    NtEmf1006 = 5,
    NtEmf1007 = 6,
    NtEmf1008 = 7,
    Text = 8,
    XpsPass = 9,
    Xps2Gdi = 10
}
于 2015-01-06T04:35:43.307 回答
3

出于某种原因,我无法让 B64 工作,但幸运的是,我能够使用普通的旧 JavaScript 通过谷歌搜索让 Z64 工作(在 3 天左右的时间里)。

在 ZPL 编程指南的其他地方,您偶然发现了 CISDFCRC16 命令——让我们保持神秘,为什么不——部分,其中指出:

“该字段的值是使用 CRC16-CCITT 多项式计算指定文件内容的 CRC-16,即 x^16 + x^12 + x^5 + 1。使用初始 CRC 0x0000 计算。”

除了 Japanglish,您现在可以查看16 位参数化 CRC 算法目录( http://reveng.sourceforge.net/crc-catalogue/16.htm ) 并查找 XMODEM 算法,它恰好是

width=16 poly=0x1021 init=0x0000 refin=false refout=false
xorout=0x0000 check=0x31c3 name="XMODEM"

啊哈。然后我开始寻找我需要的其余代码并偶然发现以下内容:

所以我将文件读取为字节数组(Uint8Array),将其解析为字符串,用 LZ77 压缩,将其转回字节数组并使用 base64 对其进行编码,此时我计算 CRC 并将其全部粘贴到我的ZPL ~DT 命令可节省约 40%。美丽的。

不幸的是,我正在开发一个专有的解决方案,所以我不能发布任何代码。

祝你好运!

- 一个人做过的事,另一个人能做的。

于 2015-08-28T22:23:50.083 回答
1

查看 ZPL 手册后,您需要计算图像的循环冗余校验(CRC)。这是一些计算 CRC 的 C 代码(来源):

// Update the CRC for transmitted and received data using
// the CCITT 16bit algorithm (X^16 + X^12 + X^5 + 1).

unsigned char ser_data;
static unsigned int crc;

crc  = (unsigned char)(crc >> 8) | (crc << 8);
crc ^= ser_data;
crc ^= (unsigned char)(crc & 0xff) >> 4;
crc ^= (crc << 8) << 4;
crc ^= ((crc & 0xff) << 4) << 1;

您还可以参考 CRC 的 Wikipedia 页面,因为它还包含其他代码示例。

https://en.wikipedia.org/wiki/Cyclic_redundancy_check

您发送的其他所有内容看起来都不错。我会考虑使用 Zebra SDK 之一。我知道安卓系统会将图像发送到打印机并为您保存。

于 2012-02-24T20:39:10.967 回答
0

虽然这个问题有 C# 标签,但其他几个答案并不是严格意义上的 C#,所以这里有一个使用 Node 8.5+ (javascript)、使用 java 和Zebra SDK的答案。对于也可以使用 SDK 并执行 POST 请求的任何 .NET 语言,相同的步骤都非常相似。

const { promisify } = require('util');
const java = require('java');
java.asyncOptions = {
  asyncSuffix: "",
  syncSuffix: "Sync",
  promiseSuffix: "Promise", // Generate methods returning promises, using the suffix Promise.
  promisify
};
// Include all .jar's under C:\Program Files\Zebra Technologies\link_os_sdk\PC\v2.14.5198\lib
// in your lib folder
java.classpath.push(__dirname + "/lib/ZSDK_API.jar"); 

var ByteArrayOutputStream = java.import('java.io.ByteArrayOutputStream');
var ZebraImageFactory = java.import('com.zebra.sdk.graphics.ZebraImageFactory');
var PrinterUtil = java.import('com.zebra.sdk.printer.PrinterUtil');

const main = async function () {
  let path = `C:\\images\\yourimage.png`;
  let os = new ByteArrayOutputStream();
  let image = await ZebraImageFactory.getImagePromise(path);
  PrinterUtil.convertGraphicPromise("E:IMAGE.PNG", image, os);
  console.log(os.toStringSync()); // junk:Z64:~:CRC
  console.log('done');
};
main();

然后您可以通过 ZPL 打印图像,例如:

^XA
~DYE:IMAGE,P,P,1,,:B64:<YOURB64>:<YOURCRC>
^FO0,0^IME:IMAGE.PNG
^XZ

使用类似的东西

await axios.post(`${printer.ip}/pstprnt`, zpl);
于 2019-01-08T20:52:47.983 回答
0

在这个 GitHub 项目中,您将找到所需的一切。https://github.com/BinaryKits/BinaryKits.Zpl

还有一个 PNG 到 GRF 图像转换器,具有额外的数据压缩功能。

var elements = new List<ZplElementBase>();
elements.Add(new ZplDownloadGraphics('R', "SAMPLE", System.IO.File.ReadAllBytes("sample.png")));
elements.Add(new ZplRecallGraphic(100, 100, 'R', "SAMPLE"));

var renderEngine = new ZplEngine(elements);
var zpl = renderEngine.ToZplString(new ZplRenderOptions());
于 2021-08-22T17:56:17.030 回答