我正在尝试使用Zebra TTP8200热敏打印机。对于我的应用程序，我需要连续打印绘图仪类型跟踪，直到用户点击停止按钮。我玩过ZPL语言，我可以成功生成位图数据，并通过输出ZPL作为原始数据，一次一行（或几行）转储我的位图。
我正在使用一些Microsoft demo code将原始数据输出到打印机，这很有效，只有一个问题：假脱机程序。事实证明，每次使用MS rawprn.exe代码输出一些数据时，它实际上都是假脱机作为打印作业，然后传输到打印机。通过假脱机程序需要10秒钟，显然太慢了。在驱动程序中禁用假脱机没有帮助，这只是意味着当作业通过假脱机程序并打印完成时程序挂起。
有没有办法绕过假脱机程序并直接输出数据到USB打印机？到目前为止，我的研究结果并未出现在Windows API中。理想情况下，我希望能够像使用串行打印机一样使用打印机 - 打开端口并将数据推入。
非常感谢任何提示！
答案 0 :(得分：2)
如果USB打印机可用作COM端口，则只需写入COM端口即可。像这样，从DOS提示符：
dir > com1
前一个示例将dir命令的结果输出到打印机。
或者，这是另一个例子：
copy file.txt com1
前一个示例会将file.txt的内容输出到打印机。
输出格式正确的ZPL数据将比纯文本更难。不过，我已经使用Ruby（以及Epson / ESC命令）从Linux开始工作。
答案 1 :(得分：2)
有没有办法绕过假脱机程序并直接输出数据 USB打印机？
是的，绝对的。它内置于大多数操作系统中，通过USB进行原始打印比以太网和COM / LPT稍微明显一点。请注意，许多应用程序（如记事本）无法打印原始应用程序，因此您的应用程序也需要支持此功能。
现在使用原始打印应用程序，使用新创建的打印机。
P.S。 这些说明也可以在这里获得，并附有截图，作为Java开源原始打印教程的一部分。该项目还为其他平台（Ubuntu，OS X）提供了教程。
http://qzindustries.com/TutorialRawWin
-Tres
答案 2 :(得分：0)
C＃中的以下类是我从Microsoft知识库文章中改编的。此类中有一些方法可以将打印作业作为string和byte[]发送。请注意，有一些对log4net的引用，可以使用您选择的日志框架删除/替换。 ：
/// <summary>
/// Class used to aid in sending raw printer data (PS, PRN, etc) directly to the printer.
/// This class was taken from http://support.microsoft.com/kb/322091
/// </summary>
public class PrintQueueUtility
{
private static ILog log = LogManager.GetLogger(typeof(PrintQueueUtility));
[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);
/// <summary>Method which sends a <see langword="byte"/> array to a printer queue with a specific document name.</summary>
/// <param name="bytes">Byte array to send to the printer.</param>
/// <param name="printerName">Name of the printer to send the <paramref name="bytes"/> to.</param>
/// <param name="documentName">The document Name.</param>
/// <returns><see cref="bool"/> indicating whether or not the method succeeded at adding something to the print queue.</returns>
public static bool SendBytesToPrinter(byte[] bytes, string printerName, string documentName)
{
bool success;
// Allocate some unmanaged memory for those bytes into an unmanaged pointer.
IntPtr unmanagedBytes = Marshal.AllocCoTaskMem(bytes.Length);
// Copy the managed byte array into the unmanaged array.
Marshal.Copy(bytes, 0, unmanagedBytes, bytes.Length);
// Send the unmanaged bytes to the printer.
success = SendUnmanagedBytesToPrinter(unmanagedBytes, printerName, documentName, bytes.Length);
// Free the unmanaged memory that you allocated earlier.
Marshal.FreeCoTaskMem(unmanagedBytes);
return success;
}
/// <summary>Method which sends a string to the printer queue with a specific document name.</summary>
/// <param name="data"><see cref="String"/> data to send to the printer.</param>
/// <param name="printerName">Name of the printer to send the data to.</param>
/// <param name="documentName">Name of the document in the printer queue.</param>
/// <returns><see cref="bool"/> indicating whether or not the method succeeded at adding something to the print queue.</returns>
public static bool SendStringToPrinter(string data, string printerName, string documentName)
{
bool success;
IntPtr unmanagedBytes;
// How many characters are in the string?
var characterCount = data.Length;
// Assume that the printer is expecting ANSI text, and then convert
// the string to ANSI text.
unmanagedBytes = Marshal.StringToCoTaskMemAnsi(data);
// Send the converted ANSI string to the printer.
success = SendUnmanagedBytesToPrinter(unmanagedBytes, printerName, documentName, characterCount);
Marshal.FreeCoTaskMem(unmanagedBytes);
return success;
}
private static bool SendUnmanagedBytesToPrinter(IntPtr unmanagedBytes, string printerName, string documentName, int count)
{
int error;
int written;
IntPtr printer;
var di = new DOCINFOA();
var success = false;
di.pDocName = documentName;
di.pDataType = "RAW";
// Open the printer.
if (OpenPrinter(printerName.Normalize(), out printer, IntPtr.Zero))
{
// Start a document.
if (StartDocPrinter(printer, 1, di))
{
// Start a page.
if (StartPagePrinter(printer))
{
// Write the bytes.
success = WritePrinter(printer, unmanagedBytes, count, out written);
EndPagePrinter(printer);
}
EndDocPrinter(printer);
}
ClosePrinter(printer);
}
// If you did not succeed, GetLastError may give more information
// about why not.
if (!success)
{
error = Marshal.GetLastWin32Error();
log.ErrorFormat("Sending bytes to printer {0} failed. Last Win32 error = {1}", printerName, error);
}
return success;
}
// Structure and API declarations:
[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;
}
答案 3 :(得分：0)
感谢您的评论。
经过多次挖掘后，我发现this interesting article使用了usbprint.sys提供的Windows打印机功能。通过一些黑客攻击示例代码似乎工作。我想我会走这条路。
文章中给出了最终代码：
/* Code to find the device path for a usbprint.sys controlled
* usb printer and print to it
*/
#include <usb.h>
#include <usbiodef.h>
#include <usbioctl.h>
#include <usbprint.h>
#include <setupapi.h>
#include <devguid.h>
#include <wdmguid.h>
/* This define is required so that the GUID_DEVINTERFACE_USBPRINT variable is
* declared an initialised as a static locally, since windows does not include it
* in any of its libraries
*/
#define SS_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
static const GUID name \
= { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
SS_DEFINE_GUID(GUID_DEVINTERFACE_USBPRINT, 0x28d78fad, 0x5a12, 0x11D1, 0xae,
0x5b, 0x00, 0x00, 0xf8, 0x03, 0xa8, 0xc2);
void SomeFunctionToWriteToUSB()
{
HDEVINFO devs;
DWORD devcount;
SP_DEVINFO_DATA devinfo;
SP_DEVICE_INTERFACE_DATA devinterface;
DWORD size;
GUID intfce;
PSP_DEVICE_INTERFACE_DETAIL_DATA interface_detail;
intfce = GUID_DEVINTERFACE_USBPRINT;
devs = SetupDiGetClassDevs(&intfce, 0, 0, DIGCF_PRESENT |
DIGCF_DEVICEINTERFACE);
if (devs == INVALID_HANDLE_VALUE) {
return;
}
devcount = 0;
devinterface.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
while (SetupDiEnumDeviceInterfaces(devs, 0, &intfce, devcount, &devinterface)) {
/* The following buffers would normally be malloced to he correct size
* but here we just declare them as large stack variables
* to make the code more readable
*/
char driverkey[2048];
char interfacename[2048];
char location[2048];
char description[2048];
/* If this is not the device we want, we would normally continue onto the
* next one or so something like
* if (!required_device) continue; would be added here
*/
devcount++;
size = 0;
/* See how large a buffer we require for the device interface details */
SetupDiGetDeviceInterfaceDetail(devs, &devinterface, 0, 0, &size, 0);
devinfo.cbSize = sizeof(SP_DEVINFO_DATA);
interface_detail = calloc(1, size);
if (interface_detail) {
interface_detail->cbSize = sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA);
devinfo.cbSize = sizeof(SP_DEVINFO_DATA);
if (!SetupDiGetDeviceInterfaceDetail(devs, &devinterface, interface_detail,
size, 0, &devinfo)) {
free(interface_detail);
SetupDiDestroyDeviceInfoList(devs);
return;
}
/* Make a copy of the device path for later use */
strcpy(interfacename, interface_detail->DevicePath);
free(interface_detail);
/* And now fetch some useful registry entries */
size = sizeof(driverkey);
driverkey[0] = 0;
if (!SetupDiGetDeviceRegistryProperty(devs, &devinfo, SPDRP_DRIVER, &dataType,
(LPBYTE)driverkey, size, 0)) {
SetupDiDestroyDeviceInfoList(devs);
return;
}
size = sizeof(location);
location[0] = 0;
if (!SetupDiGetDeviceRegistryProperty(devs, &devinfo,
SPDRP_LOCATION_INFORMATION, &dataType,
(LPBYTE)location, size, 0)) {
SetupDiDestroyDeviceInfoList(devs);
return;
}
usbHandle = CreateFile(interfacename, GENERIC_WRITE, FILE_SHARE_READ,
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL |
FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (usbHandle != INVALID_HANDLE_VALUE) {
/* Now perform all the writing to the device ie.
* while (some condition) WriteFile(usbHandle, buf, size, &bytes_written);
*/
CloseHandle(usbHandle);
}
}
}
SetupDiDestroyDeviceInfoList(devs);
}
再次感谢您的建议。