Myujth

I am trying to send ZPL commands to a Zebra ZT230 printer. The printer and drivers are installed and the printer port is "USB003". The PC communicates perfectly with the printer via either Zebra Printer Setup Utilities or ZebraDesign. I tried the following code:

Private Declare Function CreateFile Lib "kernel32.dll" (ByVal lpFileName As String, ByVal dwDesiredAccess As FileAccess, _
ByVal dwShareMode As UInteger, ByVal lpSecurityAttributes As IntPtr, ByVal dwCreationDisposition As FileMode, _
ByVal dwFlagsAndAttributes As UInteger, ByVal hTemplateFile As IntPtr) As System.Runtime.InteropServices.SafeHandle

 ' Command to be sent to the printer
 Dim command As String = "^XA^FO10,10,^AO,30,20^FDFDTesting^FS^FO10,30^BY3^BCN,100,Y,N,N^FDTesting^FS^XZ"
 ' Create a buffer with the command
 Dim buffer() As Byte = New Byte((command.Length) - 1) 
 buffer = System.Text.Encoding.ASCII.GetBytes(command)
 ' Use the CreateFile external func to connect to the LPT1 port
 Dim printer As System.Runtime.InteropServices.SafeHandle = CreateFile("USB003:", FileAccess.ReadWrite, 0, IntPtr.Zero, FileMode.Open, 0, IntPtr.Zero)
 ' Aqui verifico se a impressora � v�lida
 If (printer.IsInvalid = true) Then
 Return
 End If

 ' Open the filestream to the lpt1 port and send the command
 Dim lpt1 As FileStream = New FileStream(printer, FileAccess.ReadWrite)
 lpt1.Write(buffer, 0, buffer.Length)
 ' Close the FileStream connection
 lpt1.Close 

I get an error on this line:
Dim printer As System.Runtime.InteropServices.SafeHandle = CreateFile("USB003:", FileAccess.ReadWrite, 0, IntPtr.Zero, FileMode.Open, 0, IntPtr.Zero)

The error message and stack trace is:

Cannot marshal 'return value': Returned SafeHandles cannot be abstract.

at PerfectPotatoInventory.vb.PotatoGlobals.CreateFile(String& lpFileName, FileAccess dwDesiredAccess, UInt32 dwShareMode, IntPtr lpSecurityAttributes, FileMode dwCreationDisposition, UInt32 dwFlagsAndAttributes, IntPtr hTemplateFile)
at PerfectPotatoInventory.vb.PotatoGlobals.PrintLabelsTest() in C:PotatoesPerfectPotatoInventory.vbPerfectPotatoInventory.vbPotatoGlobals.vb:line 798

I am working in VB.net using VS2008 with target x86 and .Net 3.5.

Please advise what I am doing wrong.

Add this class to your project

Imports System.IO
Imports System.Drawing.Printing
Imports System.Runtime.InteropServices
Public Class RAWPOSPrinter
' Structure and API declarions:
<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)> _
Structure DOCINFOW
 <MarshalAs(UnmanagedType.LPWStr)> Public pDocName As String
 <MarshalAs(UnmanagedType.LPWStr)> Public pOutputFile As String
 <MarshalAs(UnmanagedType.LPWStr)> Public pDataType As String
End Structure

<DllImport("winspool.Drv", EntryPoint:="OpenPrinterW", _
 SetLastError:=True, CharSet:=CharSet.Unicode, _
 ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function OpenPrinter(ByVal src As String, ByRef hPrinter As IntPtr, ByVal pd As Long) As Boolean
End Function
<DllImport("winspool.Drv", EntryPoint:="ClosePrinter", _
 SetLastError:=True, CharSet:=CharSet.Unicode, _
 ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function ClosePrinter(ByVal hPrinter As IntPtr) As Boolean
End Function
<DllImport("winspool.Drv", EntryPoint:="StartDocPrinterW", _
 SetLastError:=True, CharSet:=CharSet.Unicode, _
 ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function StartDocPrinter(ByVal hPrinter As IntPtr, ByVal level As Int32, ByRef pDI As DOCINFOW) As Boolean
End Function
<DllImport("winspool.Drv", EntryPoint:="EndDocPrinter", _
 SetLastError:=True, CharSet:=CharSet.Unicode, _
 ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function EndDocPrinter(ByVal hPrinter As IntPtr) As Boolean
End Function
<DllImport("winspool.Drv", EntryPoint:="StartPagePrinter", _
 SetLastError:=True, CharSet:=CharSet.Unicode, _
 ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function StartPagePrinter(ByVal hPrinter As IntPtr) As Boolean
End Function
<DllImport("winspool.Drv", EntryPoint:="EndPagePrinter", _
 SetLastError:=True, CharSet:=CharSet.Unicode, _
 ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function EndPagePrinter(ByVal hPrinter As IntPtr) As Boolean
End Function
<DllImport("winspool.Drv", EntryPoint:="WritePrinter", _
 SetLastError:=True, CharSet:=CharSet.Unicode, _
 ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function WritePrinter(ByVal hPrinter As IntPtr, ByVal pBytes As IntPtr, ByVal dwCount As Int32, ByRef dwWritten As Int32) As Boolean
End Function

' 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 or False on failure.
Public Shared Function SendBytesToPrinter(ByVal szPrinterName As String, ByVal pBytes As IntPtr, ByVal dwCount As Int32) As Boolean
 Dim hPrinter As IntPtr ' The printer handle.
 Dim dwError As Int32 ' Last error - in case there was trouble.
 Dim di As DOCINFOW ' Describes your document (name, port, data type).
 Dim dwWritten As Int32 ' The number of bytes written by WritePrinter().
 Dim bSuccess As Boolean ' Your success code.

 ' Set up the DOCINFO structure.
 di = New DOCINFOW
 With di
 .pDocName = "RAW DOC"
 .pDataType = "RAW"
 End With
 ' Assume failure unless you specifically succeed.
 bSuccess = False
 If OpenPrinter(szPrinterName, hPrinter, 0) Then
 If StartDocPrinter(hPrinter, 1, di) Then
 If StartPagePrinter(hPrinter) Then
 ' Write your printer-specific bytes to the printer.
 bSuccess = WritePrinter(hPrinter, pBytes, dwCount, dwWritten)
 EndPagePrinter(hPrinter)
 End If
 EndDocPrinter(hPrinter)
 End If
 ClosePrinter(hPrinter)
 End If
 ' If you did not succeed, GetLastError may give more information
 ' about why not.
 If bSuccess = False Then
 dwError = Marshal.GetLastWin32Error()
 End If
 Return bSuccess
End Function ' SendBytesToPrinter()

' SendFileToPrinter()
' When the function is given a file name and a printer name, 
' the function reads the contents of the file and sends the
' contents to the printer.
' Presumes that the file contains printer-ready data.
' Shows how to use the SendBytesToPrinter function.
' Returns True on success or False on failure.
Public Shared Function SendFileToPrinter(ByVal szPrinterName As String, ByVal szFileName As String) As Boolean
 ' Open the file.
 Dim fs As New FileStream(szFileName, FileMode.Open)
 ' Create a BinaryReader on the file.
 Dim br As New BinaryReader(fs)
 ' Dim an array of bytes large enough to hold the file's contents.
 Dim bytes(fs.Length) As Byte
 Dim bSuccess As Boolean
 ' Your unmanaged pointer.
 Dim pUnmanagedBytes As IntPtr

 ' Read the contents of the file into the array.
 bytes = br.ReadBytes(fs.Length)
 ' Allocate some unmanaged memory for those bytes.
 pUnmanagedBytes = Marshal.AllocCoTaskMem(fs.Length)
 ' Copy the managed byte array into the unmanaged array.
 Marshal.Copy(bytes, 0, pUnmanagedBytes, fs.Length)
 ' Send the unmanaged bytes to the printer.
 bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, fs.Length)
 ' Free the unmanaged memory that you allocated earlier.
 Marshal.FreeCoTaskMem(pUnmanagedBytes)
 Return bSuccess
End Function ' SendFileToPrinter()

' When the function is given a string and a printer name,
' the function sends the string to the printer as raw bytes.
Public Shared Sub SendStringToPrinter(ByVal szPrinterName As String, ByVal szString As String)
 Dim pBytes As IntPtr
 Dim dwCount As Int32
 ' 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)
End Sub
End Class

Then in your code, call the following:

RAWPOSPrinter.SendStringToPrinter("<NAME OF PRINTER AS IT APPEARS IN DEVICES AND PRINTERS>", "<YOUR ZEBRA COMMAND STRING>")

Using the Zebra .Net SDK you can call the following function:
PrinterUtil.SendContents Method (String, String)

Where the first string is the ZPL to send and the second string is the printer connection string. More detail can be found here:
http://techdocs.zebra.com/link-os/2-14/pc_net/