Zazwyczaj po podłączeniu mojego Zebra LP 2844-Z doport USB, komputer widzi go jako drukarkę i mogę drukować na nim z notatnika, jak każda inna drukarka ogólna. Jednak moja aplikacja ma pewne funkcje kodów kreskowych. Moja aplikacja analizuje niektóre dane wejściowe i generuje ciąg ZPL w pamięci. Jak mam wysłać te dane ZPL na urządzenie USB?
Odpowiedzi:
16 dla odpowiedzi nr 1Znalazłem odpowiedź ... lub przynajmniej najłatwiejsza odpowiedź (jeśli jest ich wiele). Po zainstalowaniu drukarki zmieniłem nazwę na „ICS Label Printer”. Oto jak zmienić opcje, aby umożliwić przekazywanie poleceń ZPL:
- Kliknij prawym przyciskiem myszy „ICS Label Printer” i wybierz „Właściwości”.
- Na karcie „Ogólne” kliknij przycisk „Preferencje drukowania ...”.
- Na karcie „Ustawienia zaawansowane” kliknij przycisk „Inne”.
- Upewnij się, że zaznaczono pole „Włącz tryb przekazywania”.
- Upewnij się, że „Rozpocznij sekwencję:” to „$ {”.
- Upewnij się, że „End sekwencji:” to „} $”.
- Kliknij przycisk „Zamknij”.
- Kliknij przycisk „OK”.
- Kliknij przycisk „OK”.
W moim kodzie muszę tylko dodać „$ {” dopoczątek mojego ZPL i „} $” do końca i wydrukuj go jako zwykły tekst. Jest to związane ze „sterownikiem systemu Windows dla drukarki ZDesigner LP 2844-Z w wersji 2.6.42 (kompilacja 2382)”. Działa jak marzenie!
14 dla odpowiedzi № 2
Znalazłem jeszcze łatwiejszy sposób na pisanie do Zebrydrukarka przez port COM. Poszedłem do panelu sterowania Windows i dodałem nową drukarkę. Jako port wybrałem COM1 (port, do którego podłączono drukarkę). Użyłem sterownika drukarki „Ogólny / Tylko tekst”. Wyłączyłem bufor wydruku (standardowa opcja w preferencjach drukarki), a także wszystkie zaawansowane opcje drukowania. Teraz mogę po prostu wydrukować dowolny ciąg do tej drukarki, a jeśli ciąg zawiera ZPL, drukarka dobrze renderuje ZPL! Nie potrzeba specjalnych „początkowych sekwencji” ani takich funky. Tak dla uproszczenia!
9 dla odpowiedzi nr 3
Rozwiązanie Visual Studio C # (znaleźć w http://support.microsoft.com/kb/322091)
Krok 1.) Utwórz klasę 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;
}
}
Krok 2.) Utwórz formularz z polem tekstowym i przyciskiem (pole tekstowe będzie zawierać ZPL, aby wysłać w tym przykładzie). W przycisku kliknij wydarzenie dodaj kod ...
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.");
}
}
Dzięki temu rozwiązaniu możesz dostosować, aby się spotkaćspecyficzne wymagania. Być może koduje konkretną drukarkę. Być może tekst ZPL pochodzi bardziej dynamicznie niż z pola tekstowego. Cokolwiek. Być może nie potrzebujesz interfejsu graficznego, ale pokazuje to, jak wysłać ZPL. Twoje użycie zależy od twoich potrzeb.
7 dla odpowiedzi № 4
Nie wspomniałeś o języku, więc dam ci kilka wskazówek, jak to zrobić za pomocą prostego interfejsu Windows API w C.
Najpierw otwórz połączenie z drukarką za pomocą OpenPrinter. Następnie uruchom dokument za pomocą StartDocPrinter mając pDatatype dziedzinie DOC_INFO_1 struktura ustawiona na "RAW" - informuje to sterownik drukarki, aby nie kodował niczego, co trafia do drukarki, ale przekazuje go bez zmian. Posługiwać się StartPagePrinter wskazać pierwszą stronę, WritePrinter aby wysłać dane do drukarki i zamknąć je za pomocą EndPagePrinter, EndDocPrinter i ClosePrinter kiedy skończysz.
2 dla odpowiedzi № 5
ZPL to właściwa droga. W większości przypadków poprawne jest użycie sterownika abstrakcyjnego do poleceń GDI; jednak drukarki etykiet Zebra to szczególny przypadek. Najlepszym sposobem drukowania na drukarce Zebra jest bezpośrednie wygenerowanie ZPL. Należy pamiętać, że rzeczywisty sterownik drukarki dla drukarki Zebra to drukarka „zwykłego tekstu” - nie ma „sterownika”, który można by zaktualizować lub zmienić w takim znaczeniu, w jakim myślimy, że większość drukarek ma sterowniki. To tylko kierowca w absolutnie minimalistycznym sensie.
0 dla odpowiedzi № 6
Spędziłem na tym 8 godzin. To jest proste...
Powinieneś mieć taki kod:
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;
Zmień tę zmienną zawartość z 3 (otwarty plik już istnieje) na 1 (utwórz nowy plik). Będzie działać w systemie Windows 7 i XP.
0 dla odpowiedzi № 7
Zainstaluj udostępnianie swojej drukarki: localhostzebra Wyślij ZPL jako tekst, najpierw spróbuj skopiować:
skopiuj plik.zpl localhostzebra
bardzo proste, prawie bez kodowania.
-1 dla odpowiedzi № 8
Możesz użyć COM lub P / Invoke z.Net, aby otworzyć sterownik Winspool.drv i wysłać bajty bezpośrednio do urządzeń. Ale nie chcesz tego robić; zazwyczaj działa to tylko w przypadku jednego urządzenia w jednej wersji jednego sterownika, z którym testujesz, i psuje się wszystkim innym. Weź to z długiego, bolesnego, osobistego doświadczenia.
Co chcesz zrobić, to uzyskać czcionkę lub bibliotekę kodów kreskowych, która rysuje kody kreskowe za pomocą zwykłych starych poleceń GDI lub GDI +; jest jeden dla .Net tutaj. Działa to na wszystkich urządzeniach, nawet po zmianie sterownika przez Zebrę.