Siéntete libre de compartir nuestra web y códigos en tus redes, apóyanos para hacer crecer esta comunidad.
Solución:
Encontré la respuesta … o al menos, la respuesta más fácil (si hay varias). Cuando instalé la impresora, le cambié el nombre a “Impresora de etiquetas ICS”. A continuación, se explica cómo cambiar las opciones para permitir la transferencia de comandos ZPL:
- Haga clic con el botón derecho en “Impresora de etiquetas ICS” y seleccione “Propiedades”.
- En la pestaña “General”, haga clic en el botón “Preferencias de impresión …”.
- En la pestaña “Configuración avanzada”, haga clic en el botón “Otro”.
- Asegúrese de que haya una marca en la casilla denominada “Habilitar el modo de paso a través”.
- Asegúrese de que la “secuencia de inicio:” sea “$ “.
- Asegúrese de que “Finalizar secuencia:” sea ” $”.
- Haga clic en el botón “Cerrar”.
- Haga clic en el botón “Aceptar”.
- 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 impresora ZDesigner LP 2844-Z versión 2.6.42 (compilación 2382)”. ¡Funciona de maravilla!
He encontrado una forma más sencilla 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 estaba conectada la impresora). Utilicé un controlador de impresora “Genérico / Sólo texto”. Inhabilité 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, puedo imprimir cualquier string a esa impresora y si el string contiene ZPL, la impresora reproduce ZPL perfectamente. No hay necesidad de “secuencias de inicio” especiales o cosas divertidas como esa. ¡Hurra por la simplicidad!
Solución de Visual Studio C # (que se encuentra en http://support.microsoft.com/kb/322091)
Paso 1.) Crear 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 un cuadro de texto y un botón (el cuadro de texto contendrá el ZPL para enviar en este ejemplo). En el botón, haga clic en el 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 requisitos específicos. Quizás codifique la impresora específica. Quizás derive el texto ZPL de forma dinámica en lugar de un cuadro de texto. Lo que. Quizás no necesite una interfaz gráfica, pero esto muestra cómo enviar el ZPL. Su uso depende de sus necesidades.
Valoraciones y reseñas
Si aceptas, eres capaz de dejar un ensayo acerca de qué le añadirías a este escrito.