web-dev-qa-db-fra.com

Envoyez le fichier ZPL brut à l'imprimante Zebra via USB

En règle générale, lorsque je connecte mon Zebra LP 2844-Z au port USB, l'ordinateur le perçoit comme une imprimante et je peux y imprimer depuis le bloc-notes comme toute autre imprimante générique. Cependant, mon application possède certaines fonctionnalités de code à barres. Mon application analyse certaines entrées et génère une chaîne en mémoire de ZPL. Comment pourrais-je envoyer ces données ZPL sur mon périphérique USB?

usbzebra-printerszpl
18
Jason 'Bug' Fenter

J'ai encore trouvé un moyen plus simple d'écrire sur une imprimante Zebra via un port COM. Je suis allé au panneau de configuration Windows et j'ai ajouté une nouvelle imprimante. Pour le port, j'ai choisi COM1 (le port auquel l'imprimante était connectée). J'ai utilisé un pilote d'imprimante "Générique/Texte seulement". J'ai désactivé le spouleur d'impression (une option standard dans les préférences de l'imprimante) ainsi que toutes les options d'impression avancées. Maintenant, je peux simplement imprimer n'importe quelle chaîne sur cette imprimante et si la chaîne contient ZPL, l'imprimante rend le ZPL parfaitement Pas besoin de "séquences de démarrage" spéciales ou de trucs géniaux comme ça. Yay pour la simplicité!

15
Jason 'Bug' Fenter

J'ai trouvé la réponse ... ou du moins la réponse la plus simple (s'il y en a plusieurs). Lorsque j'ai installé l'imprimante, je l'ai renommée "Imprimante d'étiquettes ICS". Voici comment modifier les options pour autoriser les commandes ZPL directes:

  1. Cliquez avec le bouton droit de la souris sur "Imprimante d'étiquettes ICS" et choisissez "Propriétés".
  2. Sur l'onglet "Général", cliquez sur le bouton "Options d'impression ...".
  3. Sur l'onglet "Advanced Setup", cliquez sur le bouton "Other".
  4. Assurez-vous que la case "Activer le mode Passthrough" est cochée.
  5. Assurez-vous que la "séquence de démarrage:" est "$ {".
  6. Assurez-vous que la "séquence de fin:" est "} $".
  7. Cliquez sur le bouton "Fermer".
  8. Cliquez sur le bouton "OK".
  9. Cliquez sur le bouton "OK".

Dans mon code, il me suffit d'ajouter "$ {" au début de mon ZPL et "} $" à la fin, puis de l'imprimer en texte brut. C’est avec le "pilote Windows pour l’imprimante ZDesigner LP 2844-Z version 2.6.42 (Build 2382)". Fonctionne comme un charme!

16
Jason 'Bug' Fenter

Solution Visual Studio C # (disponible à l'adresse http://support.Microsoft.com/kb/322091 )

Étape 1.) Créer la 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;
    }
}

Étape 2.) Créez un formulaire avec une zone de texte et un bouton (cette zone contiendra le fichier ZPL à envoyer dans cet exemple). Dans un clic sur un événement, ajoutez le 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 modifier pour répondre à des exigences spécifiques. Peut-être coder en dur l'imprimante spécifique. Peut-être dériver le texte ZPL dynamiquement plutôt que d'une zone de texte. Peu importe. Vous n'avez peut-être pas besoin d'une interface graphique, mais cela montre comment envoyer le fichier ZPL. Votre utilisation dépend de vos besoins.

10
barrypicker

Vous n'avez pas mentionné de langue, je vais donc vous donner quelques astuces pour le faire avec l'API Windows droite en C.

Commencez par ouvrir une connexion à l’imprimante avec OpenPrinter . Ensuite, démarrez un document avec StartDocPrinter avec le champ pDatatype du DOC_INFO_1 structure défini sur "RAW" - ceci indique au pilote d’imprimante de ne pas encoder ce qui va à l’imprimante, mais de le transmettre tel quel. Utilisez StartPagePrinter pour indiquer la première page, WritePrinter pour envoyer les données à l'imprimante et fermez-la avec EndPagePrinter, EndDocPrinter et ClosePrinter à la fin.

8
Mark Ransom

ZPL est la bonne façon de faire. Dans la plupart des cas, il est correct d'utiliser un pilote qui résume les commandes GDI; Cependant, les imprimantes d'étiquettes Zebra constituent un cas particulier. Le meilleur moyen d’imprimer sur une imprimante Zebra est de générer directement du ZPL. Notez que le pilote d’imprimante d’une imprimante Zebra est une imprimante à "texte brut". Il n’ya pas de "pilote" susceptible d’être mis à jour ou modifié dans le sens où nous pensons que la plupart des imprimantes ont des pilotes. C'est juste un conducteur au sens minimaliste absolu.

3
Ian

Installez un partage de votre imprimante:\localhost\zebra Envoyez ZPL sous forme de texte, essayez d’abord avec copie:

copier le fichier file.zpl\localhost\zebra

très simple, presque pas de codage.

0
Thomas

J'ai passé 8 heures à faire ça ... c'est simple ...

Vous devriez avoir un code comme ça:

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;

Modifiez le contenu de cette variable de 3 (le fichier ouvert existe déjà) à 1 (créez un nouveau fichier) .

0
Rodrigo Aquino