Invia ZPL prima alla stampante Zebra tramite USB

Question

In genere, quando collego il mio Zebra LP 2844-Z alla porta USB, il computer lo vede come una stampante e posso stampare da questo documento come qualsiasi altra stampante generica. Tuttavia, la mia applicazione ha alcune caratteristiche di codici a barre. La mia applicazione analizza alcuni input e genera una stringa in memoria di ZPL. Come faccio a inviare questi dati ZPL al mio dispositivo USB?

Answer 1

ho trovato ancora un modo più semplice di scrivere a una stampante Zebra sopra una porta COM. Sono andato al pannello di controllo di Windows e ha aggiunto una nuova stampante. Per la porta, ho scelto COM1 (la porta la stampante è stata collegata a). Ho usato un "Solo testo generico /" driver della stampante. Ho disabilitato lo spooler di stampa (opzione standard nelle preferenze di stampa), così come tutte le opzioni di stampa avanzate. Ora, posso solo stampare qualsiasi stringa a quella stampante e se la stringa contiene ZPL, la stampante rende lo ZPL proprio bene! Non c'è bisogno di roba speciale "start sequenze" o funky del genere. Yay per semplicità!

Answer 2

Ho trovato la risposta ... o per lo meno, la risposta più semplice (se ci sono più). Quando ho installato la stampante, ho rinominato in "Label Printer ICS". Ecco come modificare le opzioni per consentire pass-through comandi ZPL:

1. pulsante destro del mouse sul "Label Printer ICS" e scegliete "Proprietà".
2. Nella scheda "Generale", cliccare su "Preferenze stampa ..." pulsante.
3. Nella scheda "Impostazioni avanzate", fai clic sul pulsante "Altro".
4. Assicurarsi che ci sia un controllo nella casella "Attiva modalità Passthrough".
5. Assicurarsi che la "sequenza di avvio:". È "$ {"
6. Assicurarsi che la "sequenza finale:". È "} $"
7. Fare clic sul pulsante "Chiudi".
8. Fare clic sul pulsante "OK".
9. Fare clic sul pulsante "OK".

Nel mio codice, ho solo bisogno di aggiungere "$ {" per l'inizio del mio ZPL e "} $" alla fine e stamparlo come testo normale. Questo è con il "driver di Windows per ZDesigner LP stampante 2844-Z versione 2.6.42 (Costruire 2382)". Funziona come un fascino!

Answer 3

visivo # soluzione Studio C (che si trova a http://support.microsoft. com / kb / 322.091 )

Passaggio 1). Crea classe 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;
    }
}

Passaggio 2). Creare un modulo con casella di testo e il pulsante (casella di testo conterrà lo ZPL per inviare in questo esempio). Nel tasto di scatto codice di evento add ...

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 questa soluzione, è possibile modificare per soddisfare i requisiti specifici. Forse hardcode la stampante specifica. Forse ricavare il testo ZPL dinamico piuttosto che da una casella di testo. Qualunque cosa. Forse non hai bisogno di un'interfaccia grafica, ma questo mostra come inviare lo ZPL. L'utilizzo dipende dalle vostre esigenze.

Answer 4

Non hai menzionato una lingua, così ho intenzione di darvi alcuni alcuni suggerimenti come farlo con le API di Windows direttamente in C.

In primo luogo, aprire una connessione alla stampante con OpenPrinter . Successivamente, inizia un documento con StartDocPrinter avere il campo della pDatatype DOC_INFO_1 struttura insieme a "RAW" - questo dice il driver della stampante non codificare qualsiasi cosa si muova alla stampante, ma per passarlo insieme invariato. Utilizzare StartPagePrinter per indicare la prima pagina, WritePrinter per inviare i dati alla stampante, e vicino con EndPagePrinter, EndDocPrinter e ClosePrinter quando fatto.

Answer 5

ZPL è il modo corretto di andare. Nella maggior parte dei casi è corretto utilizzare un driver che abstracts ai comandi GDI; tuttavia stampanti di etichette Zebra sono un caso speciale. Il modo migliore per stampare su una stampante Zebra è quello di generare direttamente ZPL. Si noti che il driver della stampante reale per una stampante Zebra è una stampante "plain text" - non c'è un "driver" che potrebbero essere aggiornate o modificate nel senso che pensiamo di maggior parte delle stampanti con i driver. E 'solo un pilota in senso minimalista assoluto.

Answer 6

Ho trascorso 8 ore per farlo. E 'semplice ...

Si shoud ha un codice del genere:

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;

Cambia che il contenuto variabile da 3 (file aperto esiste già) a 1 (creare un nuovo file). Si lavorerà a Windows 7 e XP.

Answer 7

Installa una condivisione della stampante: \ localhost \ zebra Invia ZPL come testo, provare con copia prima:

Copia file.zpl \ localhost \ zebra

molto semplice, quasi nessuna codifica.

Answer 8

È possibile utilizzare COM, o P / Invoke da .Net, per aprire il driver Winspool.drv e inviare i dati direttamente ai dispositivi. Ma non si vuole farlo; questo in genere funziona solo per un device da una versione del un driver si prova con, e si rompe su tutto il resto. Prendete questo dalla lunga, dolorosa, esperienza personale.

Che cosa si vuole fare è ottenere un font di codici a barre o una libreria che richiama i codici a barre con semplice vecchia GDI o GDI + comandi; ce n'è uno per .Net qui . Questo funziona su tutti i dispositivi, anche dopo Zebra cambia il driver.