Enviar ZPL en bruto a la impresora Zebra a través de USB

zebra-printers

Question

Normalmente, cuando conecto mi Zebra LP 2844-Z al puerto USB, la computadora lo ve como una impresora y puedo imprimirlo desde el bloc de notas como cualquier otra impresora genérica. Sin embargo, mi aplicación tiene algunas características de código de barras. Mi aplicación analiza algunas entradas y genera una cadena de ZPL en memoria. ¿Cómo enviaría estos datos ZPL a mi dispositivo USB?

Answer 1

Encontré la respuesta ... o al menos, la respuesta más fácil (si hay varias). Cuando instalé la impresora, la cambié de nombre a "Impresora de etiquetas ICS". Aquí le mostramos cómo cambiar las opciones para permitir los comandos ZPL de paso:

1. Haga clic derecho en la "Impresora de etiquetas ICS" y seleccione "Propiedades".
2. En la pestaña "General", haga clic en el botón "Preferencias de impresión ...".
3. En la pestaña "Configuración avanzada", haga clic en el botón "Otro".
4. Asegúrese de que haya una marca en la casilla "Habilitar el modo Passthrough".
5. Asegúrese de que la "secuencia de inicio:" sea "$ {".
6. Asegúrese de que la "secuencia final:" es "} $".
7. Haga clic en el botón "Cerrar".
8. Haga clic en el botón "Aceptar".
9. Haga clic en el botón "Aceptar".

En mi código, solo tengo que agregar "$ {" al principio de mi ZPL y "} $" al final e imprimirlo como texto sin formato. Esto es con el "controlador de Windows para la impresora ZDesigner LP 2844-Z versión 2.6.42 (compilación 2382)". ¡Funciona de maravilla!

Answer 2

He encontrado una forma más fácil de escribir en una impresora Zebra a través de un puerto COM. Fui al panel de control de Windows y agregué una nueva impresora. Para el puerto, elegí COM1 (el puerto al que se conectó la impresora). Utilicé un controlador de impresora "Genérico / Sólo texto". Deshabilité la cola de impresión (una opción estándar en las preferencias de la impresora), así como todas las opciones de impresión avanzadas. Ahora, solo puedo imprimir cualquier cadena en esa impresora y si la cadena contiene ZPL, ¡la impresora procesa la ZPL muy bien! No hay necesidad de "secuencias de inicio" especiales o cosas así. ¡Yay por la simplicidad!

Answer 3

Instale y comparta su impresora: / localhost / zebra Envíe ZPL como texto, intente copiar primero:

copie el archivo.zpl / localhost / zebra

Muy simple, casi sin codificación.

Answer 4

No has mencionado un idioma, así que te daré algunos consejos sobre cómo hacerlo con la API de Windows en C.

Primero, abra una conexión a la impresora con OpenPrinter . A continuación, inicie un documento con StartDocPrinter con el campo pDatatype de la estructura DOC_INFO_1 establecida en "RAW" : esto indica al controlador de la impresora que no debe codificar nada que vaya a la impresora, sino que debe pasarlo sin cambios. Utilice StartPagePrinter para indicar la primera página, WritePrinter para enviar los datos a la impresora y ciérrelos con EndPagePrinter , EndDocPrinter y ClosePrinter cuando haya terminado.

Answer 5

Pasé 8 horas para hacer eso. Es simple...

Deberías tener un código como ese:

private const int GENERIC_WRITE = 0x40000000;

//private const int OPEN_EXISTING = 3;
private const int OPEN_EXISTING = 1;
private const int FILE_SHARE_WRITE = 0x2;
private StreamWriter _fileWriter;
private FileStream _outFile;
private int _hPort;

Cambie el contenido de la variable de 3 (el archivo abierto ya existe) a 1 (cree un nuevo archivo). Funcionará en Windows 7 y XP.

Answer 6

Puede usar COM, o P / Invoke desde .Net, para abrir el controlador Winspool.drv y enviar bytes directamente a los dispositivos. Pero no quieres hacer eso; Por lo general, esto solo funciona para un dispositivo en la versión del controlador con el que se prueba y se rompe en todo lo demás. Toma esto de una experiencia personal larga y dolorosa.

Lo que desea hacer es obtener una fuente de código de barras o una biblioteca que dibuje códigos de barras utilizando comandos GDI o GDI + sin formato; Hay uno para .Net here . Esto funciona en todos los dispositivos, incluso después de que Zebra cambie el controlador.

Answer 7

ZPL es la manera correcta de ir. En la mayoría de los casos, es correcto usar un controlador que abstrae los comandos GDI; Sin embargo, las impresoras de etiquetas Zebra son un caso especial. La mejor manera de imprimir en una impresora Zebra es generar ZPL directamente. Tenga en cuenta que el controlador de impresora real para una impresora Zebra es una impresora de "texto simple"; no hay un "controlador" que pueda actualizarse o cambiarse en el sentido en que pensamos que la mayoría de las impresoras tienen controladores. Es solo un conductor en el sentido minimalista absoluto.

Answer 8

Solución Visual Studio C # (encontrada en http://support.microsoft.com/kb/322091 )

Paso 1.) Crea la clase RawPrinterHelper ...

using System;
using System.IO;
using System.Runtime.InteropServices;

public class RawPrinterHelper
{
    // Structure and API declarions:
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public class DOCINFOA
    {
        [MarshalAs(UnmanagedType.LPStr)]
        public string pDocName;
        [MarshalAs(UnmanagedType.LPStr)]
        public string pOutputFile;
        [MarshalAs(UnmanagedType.LPStr)]
        public string pDataType;
    }
    [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);

    [DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool ClosePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool StartDocPrinter(IntPtr hPrinter, Int32 level, [In, MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);

    [DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool EndDocPrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool StartPagePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool EndPagePrinter(IntPtr hPrinter);

    [DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, out Int32 dwWritten);

    // SendBytesToPrinter()
    // When the function is given a printer name and an unmanaged array
    // of bytes, the function sends those bytes to the print queue.
    // Returns true on success, false on failure.
    public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
    {
        Int32 dwError = 0, dwWritten = 0;
        IntPtr hPrinter = new IntPtr(0);
        DOCINFOA di = new DOCINFOA();
        bool bSuccess = false; // Assume failure unless you specifically succeed.

        di.pDocName = "My C#.NET RAW Document";
        di.pDataType = "RAW";

        // Open the printer.
        if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
        {
            // Start a document.
            if (StartDocPrinter(hPrinter, 1, di))
            {
                // Start a page.
                if (StartPagePrinter(hPrinter))
                {
                    // Write your bytes.
                    bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
                    EndPagePrinter(hPrinter);
                }
                EndDocPrinter(hPrinter);
            }
            ClosePrinter(hPrinter);
        }
        // If you did not succeed, GetLastError may give more information
        // about why not.
        if (bSuccess == false)
        {
            dwError = Marshal.GetLastWin32Error();
        }
        return bSuccess;
    }

    public static bool SendFileToPrinter(string szPrinterName, string szFileName)
    {
        // Open the file.
        FileStream fs = new FileStream(szFileName, FileMode.Open);
        // Create a BinaryReader on the file.
        BinaryReader br = new BinaryReader(fs);
        // Dim an array of bytes big enough to hold the file''s contents.
        Byte[] bytes = new Byte[fs.Length];
        bool bSuccess = false;
        // Your unmanaged pointer.
        IntPtr pUnmanagedBytes = new IntPtr(0);
        int nLength;

        nLength = Convert.ToInt32(fs.Length);
        // Read the contents of the file into the array.
        bytes = br.ReadBytes(nLength);
        // Allocate some unmanaged memory for those bytes.
        pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
        // Copy the managed byte array into the unmanaged array.
        Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
        // Send the unmanaged bytes to the printer.
        bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, nLength);
        // Free the unmanaged memory that you allocated earlier.
        Marshal.FreeCoTaskMem(pUnmanagedBytes);
        return bSuccess;
    }
    public static bool SendStringToPrinter(string szPrinterName, string szString)
    {
        IntPtr pBytes;
        Int32 dwCount;
        // How many characters are in the string?
        dwCount = szString.Length;
        // Assume that the printer is expecting ANSI text, and then convert
        // the string to ANSI text.
        pBytes = Marshal.StringToCoTaskMemAnsi(szString);
        // Send the converted ANSI string to the printer.
        SendBytesToPrinter(szPrinterName, pBytes, dwCount);
        Marshal.FreeCoTaskMem(pBytes);
        return true;
    }
}

Paso 2.) Cree un formulario con cuadro de texto y botón (el cuadro de texto contendrá la ZPL para enviar en este ejemplo). En el botón clic del evento agregar código ...

private void button1_Click(object sender, EventArgs e)
        {
            // Allow the user to select a printer.
            PrintDialog pd = new PrintDialog();
            pd.PrinterSettings = new PrinterSettings();
            if (DialogResult.OK == pd.ShowDialog(this))
            {
                // Send a printer-specific to the printer.
                RawPrinterHelper.SendStringToPrinter(pd.PrinterSettings.PrinterName, textBox1.Text);
                MessageBox.Show("Data sent to printer.");
            }
            else
            {
                MessageBox.Show("Data not sent to printer.");
            }
        }

Con esta solución, puede ajustar para cumplir con los requisitos específicos. Tal vez hardcode la impresora específica. Quizás derive el texto ZPL dinámicamente en lugar de hacerlo desde un cuadro de texto. Lo que sea. Quizás no necesite una interfaz gráfica, pero esto muestra cómo enviar el ZPL. Su uso depende de sus necesidades.