Envoyer raw ZPL pour imprimante Zebra via USB

J'ai trouvé la réponse... ou au moins, la réponse la plus facile si il y en a plusieurs). Quand j'ai installé l'imprimante, je l'ai renommé pour "SCI de l'Imprimante d'Étiquettes". Voici comment modifier les options pour permettre pass-through commandes ZPL:

1. Clic droit sur "ICS Imprimante d'Étiquettes" et choisissez "Propriétés".
2. Sur l'onglet "Général", cliquez sur "options d'Impression..." bouton.
3. Sur la "Configuration Avancée" de l'onglet, cliquez sur le bouton "Autres".
4. Assurez-vous que il y a une coche dans la case "Activer le Mode Passthrough".
5. Assurez-vous que le "Début de la séquence:" est "${".
6. Assurez-vous que la "Fin de la séquence:" y "}$".
7. Cliquez sur le bouton "Fermer".
8. Cliquez sur le bouton "OK".
9. Cliquez sur le bouton "OK".

Dans mon code, j'ai juste à ajouter "${" au début de mon ZPL et "}$" à la fin et l'imprimer sous forme de texte brut. C'est avec le "pilote Windows pour ZDesigner LP 2844-Z imprimante Version 2.6.42 (Build 2382)". Fonctionne comme un charme!

Visual Studio C# solution (qui se trouve à http://support.microsoft.com/kb/322091)

L'étape 1.) Créer une 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;
    }
}

L'étape 2.) Créer un formulaire avec une zone de texte et un bouton (zone de texte maintenez la ZPL à envoyer dans cet exemple). Dans l'événement clic du bouton ajouter un code...

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.");
            }
        }

Avec cette solution, vous pouvez personnaliser pour répondre à des exigences spécifiques. Peut-être coder en dur l'imprimante spécifique. Peut-être dériver le ZPL texte de façon dynamique, plutôt que d'une zone de texte. Quoi que ce soit. Peut-être que vous n'avez pas besoin d'une interface graphique, mais cela montre comment envoyer de la ZPL. Votre utilisation dépend de vos besoins.

ZPL est la bonne façon de procéder. Dans la plupart des cas, il est correct d'utiliser un pilote que les résumés des commandes GDI; cependant Zebra imprimantes d'étiquettes sont un cas particulier. La meilleure façon d'imprimer sur une imprimante Zebra est de générer ZPL directement. Notez que le pilote d'imprimante pour une imprimante Zebra est un "texte brut" imprimante - il n'y a pas un "pilote" qui pourrait être mis à jour ou modifié dans le sens que nous pensons de la plupart des imprimantes ayant des conducteurs. C'est juste un pilote dans l'absolu minimaliste sens.

Installer un partage de votre imprimante: \localhost\zebra
Envoyer ZPL en tant que texte, essayez avec une copie de:

la copie du fichier.zpl \localhost\zebra

très simple, presque pas de codage.