HID-USB设备读写开发测试

红太狼 2022-08-04 12:40 495阅读 0赞

[http://bbs.csdn.net/topics/390691197][http_bbs.csdn.net_topics_390691197]

看过一个文章“Windows主机端与自定义USB HID设备通信详解"，有这样一段文字。  
  
1 、 ReadFile 的调用不会引起设备的任何反应，即 HID 设备与主机之间的中断 IN 传输不与 ReadFile 打交道。实际上主机会在最大间隔时间（由设备的端点描述符来指定）内轮询设备，发出中断 IN 传输的请求。“读取”即意味着从某个 buffer 里面取回数据，实际上这个 buffer 就是 HID 设备驱动中的 buffer 。这个 buffer 的大小可以通过 HidD\_SetNumInputBuffers 来改变。在 XP 上缺省值是 32 （个报告）。  
  
实贱表明：  
  
是”USB人体输入学设备驱动“会在最大间隔时间（由设备的端点描述符来指定）内轮询设备，发出中断 IN 传输的请求。然后将数据收到自已驱动中的 buffer！但ReadFile也不直接与”USB人体输入学设备驱动“打交道！有兴趣大家可以用BUS HOUND看一下！你只监视”USB人体输入学设备“，你不调用ReadFile，下位机也会有数据发上来。BUS HOUND可以看到数据。下位机没数据时！你调用ReadFile，”USB人体输入学设备“，也不会有动作！  
  
而当您监视了！HID compliant device设备，你不ReadFile，就是”USB人体输入学设备“有接收到数据，HID compliant device设备也不会有数据请求的！只有当你ReadFile了！HID compliant device设备就会出现一次数据请求！你就能看到HID compliant device的数据。  
  
更细一点的测试是！HID下位机连发了向个报告时（ReadFile不去读），”**USB人体输入学设备驱动**“会都接收这些报告数据，然后放在自己的buffer中！接收你调用一次**ReadFile，”HID compliant device驱动**“就会向”USB人体输入学设备驱动“请求一次数据，然后它如果和ReadFile相交成功的话，ReadFile就会正确读到一个报告数据。你再调用ReadFile会再读到一个！直到”USB人体输入学设备驱动“收到的数据全部被读完！  
  
现在的我的情况就出现在HID compliant device驱动和ReadFile相交这块！ReadFile绝大多数时可以成功读到数据，但总会不定期的有一次不成功！  
  
还有一个怪的现象！ReadFile好象只是发出了一个Windows IO请求,而这个Windows IO请求好象没成功和”HID compliant device驱动“交互。因为从现象上看HID compliant device设备驱动好象没有超时机制！如ReadFile后 wait用永久等待的方式在等，当出现这种情况程序会卡死在这里永远等待，但当下一次下位机设备发上新的数据时！wait也会结束等待，读出最新的数据。而不成功的那次数据就好象从来没出现过一样，人间蒸发了！这中间到底那块出了问题！是我想知道的！  
  
有没有明白这块驱动机制的达人细一点的讲述一下，HID compliant device设备驱动向”USB人体输入学设备“请求数据 及和Readfile交互的细节！猜想分析都行！

[http://bbs.csdn.net/topics/390511409][http_bbs.csdn.net_topics_390511409]

打开HID例程程序

[http://blog.10jqka.com.cn/103723137/6082311.shtml][http_blog.10jqka.com.cn_103723137_6082311.shtml]

**调试了好长时间，终于发现这个 87的用法错误的妙处！ 凡是格式不符合设备接收协议的  
  
都应该是这个返回值。 刚开始我可能凑巧没有初始化的时候，他自己偶然自动这样，  
  
所以，有时候可以侥幸过关。  
  
不错，记录之，以供后人参考。  
  
以下转载自：**  
  
说明：  
  
\- 以下结论都是基于Windows XP系统所得出的，不保证在其他系统的适用性。  
  
\- 在此讨论的是HID自定义设备，对于标准设备，譬如USB鼠标和键盘，由于操纵系统对其独占，很多操纵未必能正确执行。  
  
**1. 所使用的典型Windows API**  
  
CreateFile  
  
ReadFile  
  
WriteFile  
  
以下函数是DDK的内容：  
  
HidD\_SetFeature  
  
HidD\_GetFeature  
  
HidD\_SetOutputReport  
  
HidD\_GetInputReport  
  
其中，CreateFile用于打开设备；ReadFile、HidD\_GetFeature、HidD\_GetInputReport用于设备到主机方向的数据通讯；WriteFile、HidD\_SetFeature、HidD\_SetOutputReport用于主机到设备方向的数据通讯。鉴于实际应用，后文主要讨论CreateFile，WriteFile，ReadFile，HidD\_SetFeature四个函数，明白了这四个函数，其它的可以类推之。  
  
2. **几个常见错误**  
  
 当使用以上API时，假如操纵失败，调用GetLastError()会得到以下常见错误：  
  
6： 句柄无效  
  
23： 数据错误（循环冗余码检查）  
  
87： 参数错误  
  
1784： 用户提供的buffer无效  
  
后文将会具体说明这些错误情况。  
  
**3. 主机端设备枚举程序流程  
  
  
  
  
  
4. 函数使用说明**  
  
CreateFile(devDetail->DevicePath, //设备路径  
  
GENERIC\_READ | GENERIC\_WRITE, //访问方式  
  
FILE\_SHARE\_READ | FILE\_SHARE\_WRITE, //共享模式  
  
NULL,  
  
OPEN\_EXISTING, //文件不存在时，返回失败  
  
FILE\_FLAG\_OVERLAPPED, //以重叠（异步）模式打开  
  
NULL);  
  
在这里，CreateFile用于打开HID设备，其中设备路径通过函数SetupDiGetInte\*\*\*ceDeviceDetail取得。CreateFile有以下几点需要留意：  
  
\- 访问方式： 假如是系\*\*\*占设备，例如鼠标、育儿嫂键盘等等，应将此参数设置为0，否则后续函数操纵将失败（譬如HidD\_GetAttributes）；也就是说，不能对独占设备进行除了查询以外的任何操纵，所以能够使用的函数也是很有限的，下文的一些函数并不一定适合这些设备。在此顺便列出MSDN上关于此参数的说明：  
  
If this parameter is zero, the application can query file and device attributes without accessing the device. This is useful if an application wants to determine the size of a floppy disk drive and the formats it supports without requiring a floppy in the drive. It can also be used to test for the file's or directory's existence without opening it for read or write access。  
  
\- 重叠（异步）模式：此参数并不会在此处表现出明显的意义，它主要是对后续的WriteFile，ReadFile有影响。假如这里设置为重叠（异步）模式，那么在使用WriteFile，ReadFile时也应该使用重叠（异步）模式，反之亦然。这首先要求WriteFile，ReadFile的最后一个参数不能为空（NULL）。否则，便会返回87（参数错误）错误号。当然，87号错误并不代表就是此参数不正确，更多的信息将在具体讲述这两个函数时指出。此参数为0时，代表同步模式，即WriteFile，ReadFile操纵会在数据处理完成之后才返回，否则阻塞在函数内部。  
  
ReadFile(hDev, //设备句柄，即CreateFile的返回值  
  
recvBuffer, //用于接收数据的buffer  
  
IN\_REPORT\_LEN, //要读取数据的长度  
  
&recvBytes, //实际收到的数据的字节数  
  
&ol); //异步模式  
  
在这里，ReadFile用于读取HID设备通过中断IN传输发来的**输进报告**。有以下几点要留意：  
  
1、白癜风ReadFile的调用不会引起设备的任何反应，即HID设备与主机之间的中断IN传输不与ReadFile打交道。实际上主机会在最大间隔时间（由设备的端点描述符来指定）内轮询设备，发出中断IN传输的请求。“读取”即意味着从某个buffer里面取回数据，实际上这个buffer就是HID设备驱动中的buffer。这个buffer的大小可以通过HidD\_SetNumInputBuffers来改变。在XP上缺省值是32（个报告）。  
  
2、读取的数据对象是输进报告，也即通过中断输进管道传进的数据。所以，假如设备不支持中断IN传输，那么是无法使用此函数来得到预期结果的。实际上这种情况不可能在HID中出现，由于协议指明了至少要有一个中断IN端点。  
  
3、IN\_REPORT\_LEN代表要读取的数据的长度（实际的数据正文+一个byte的报告ID），这里是一个常数，主要是由于设备固件的信息我是完全知道的，当然知道要读取多少数据（也就是报告的长度）；不过也可以通过另外的函数（HidD\_GetPreparsedData）来事先取得报告的长度，这里不做具体讨论。由于很难想象在不了解固件信息的情况下来做自定义设备的HID通讯，在实际应用中一般来说就是固件与PC程序匹配着来开发。此参数假如设置过大，不会有实质性的错误，在recvBytes参数中会输出实际读到的长度；假如设置过小，即小于报告的长度，会返回1784号错误（用户提供的buffer无效）。  
  
4、关于异步模式。前面已经提过，此参数的设置必须与CreateFile时的设置相对应，否则会返回87号错误（参数错误）。假如不需要异步模式，此参数需置为NULL。在这种情况下，ReadFile会一直等待直到数据读取成功，所以会阻塞住程序确当前过程。  
  
WriteFile(hDev, //设备句柄，即CreateFile的返回值  
  
reportBuf, //存有待发送数据的buffer  
  
OUT\_REPORT\_LEN, //待发送数据的长度  
  
&sendBytes, //实际收到的数据的字节数  
  
&ol); //异步模式  
  
在这里，WriteFile用于传输一个**输出报告**给HID设备。有以下几点要留意：  
  
1、 与ReadFile不同，WriteFile函数被调用后，固然也是经过驱动程序，但是终极会反映到设备中。也就是说，调用WriteFile后，设备会接收到输出报告的请求。假如设备使用了中断OUT传输，则WriteFile会通过中断OUT管道来进行传输；否则会使用SetReport请求通过控制管道来传输。  
  
2、 OUT\_REPORT\_LEN代表要写进的数据长度（实际的数据正文+一个byte的报告ID）。硬度计假如大于实际报告的长度，则使用实际报告长度；假如小于实际报告长度，会返回1784号错误（用户提供的buffer无效）。  
  
3、 reportBuf\[0\]必须存有待发送报告的ID，并且此报告ID指示的必须是输出报告，否则会返回87号错误（参数错误）。这种情况可能轻易被程序员忽略，结果不知错误号所反映的是什么，网上也经常有类似疑问的帖子。顺便指出，输进报告、输进报告、特征报告这些报告类型，是反映在HID设备的报告描述符中。后文将做举例讨论。  
  
4、 关于异步模式。前面已经提过，此参数的设置必须与CreateFile时的设置相对应，否则会返回87号错误（参数错误）。假如不需要异步模式，此参数需置为NULL。在这种情况下，WriteFile会一直等待直到数据读取成功，所以会阻塞住程序确当前过程。  
  
HidD\_SetFeature(hDev, //设备句柄，即CreateFile的返回值  
  
reportBuf, //存有待发送数据的buffer  
  
FEATURE\_REPORT\_LEN); //buffer的长度  
  
HidD\_SetOutputReport(hDev, //设备句柄，即CreateFile的返回值  
  
reportBuf, //存有待发送数据的buffer  
  
OUT\_REPORT\_LEN); //buffer的长度  
  
HidD\_SetFeature发送一个**特征报告**给设备，HidD\_ SetOutputReport发送一个**输出报告**给设备。留意以下几点：  
  
1、 跟WriteFile类似，必须在reportBuf\[0\]中指明要发送的报告的ID，并且和各自适合的类型相对应。也就是说，HidD\_SetFeature只能发送特征报告，因此报告ID必须是特征报告的ID；HidD\_SetOutputReport只能发送输出报告，因此报告ID只能是输出报告的ID。  
  
2、 这两个函数最常返回的错误代码是23（数据错误）。包括但不仅限于以下情况：  
  
\- 报告ID与固件描述的不符。  
  
\- 传进的buffer长度少于固件描述的报告的长度。  
  
占有关资料反映（非官方文档），只要是驱动程序对请求无反应，都会产生此错误。 **5. 常见错误汇总**  
  
\- HID ReadFile  
  
\- Error Code 6 (handle is invalid)  
  
传进的句柄无效  
  
\- Error Code 87 (参数错误)  
  
很可能是createfile时声明了异步方式，但是读取时按同步读取。  
  
\- Error Code 1784 (用户提供的buffer无效):  
  
传参时传进的“读取buffer长度”与实际的报告长度不符。  
  
\- HID WriteFile  
  
\- Error Code 6 (handle is invalid)  
  
传进的句柄无效  
  
\- Error Code 87（参数错误）  
  
\- CreateFile时声明的同步/异步方式与实际调用WriteFile时传进的不同。  
  
\- 报告ID与固件中定义的不一致（buffer的首字节是报告ID）  
  
\- Error Code 1784 (用户提供的buffer无效)  
  
传参时传进的“写进buffer长度”与实际的报告长度不符。  
  
\- HidD\_SetFeature  
  
\- HidD\_SetOutputReport  
  
\- Error Code 1 (incorrect function)  
  
不支持此函数，很可能是设备的报告描述符中未定义这样的报告类型（输进、输出、特征）  
  
\- Error Code 6 (handle is invalid)  
  
传进的句柄无效  
  
\- Error Code 23（数据错误（循环冗余码检查））  
  
\- 报告ID与固件中定义的不相符（buffer的首字节是报告ID）  
  
\- 传进的buffer长度少于固件定义的报告长度（报告正文+1byte, 1byte为报告ID）  
  
\- 据相关资料反映（非官方文档），只要是驱动程序不接受此请求（对请求无反应），都会产生此错误  
  
**6. 报告描述符及数据通讯程序示例**  
  
报告描述符（由于是汇编代码，所以不必留意其语法，仅需留意表中的每个数据都占1个字节）：  
  
\_ReportDescriptor: //报告描述符  
  
.dw 0x06, 0x00, 0xff //用法页  
  
.dw 0x09, 0x01 //用法(供给商用法1)  
  
.dw 0xa1, 0x01 //集合开始  
  
.dw 0x85, 0x01 //**报告ID(1)**  
  
 .dw 0x09, 0x01 //用法(供给商用法1)  
  
.dw 0x15, 0x00 //逻辑最小值(0)  
  
.dw 0x26, 0xff, 0x0 //逻辑最大值(255)  
  
.dw 0x75, 0x08 //报告大小(8)  
  
.dw 0x95, 0x07 //报告计数(7)  
  
.dw 0x81, 0x06 //**输进**（数据，变量，相对值）  
  
.dw 0x09, 0x01 //用法(供给商用法1)  
  
.dw 0x85, 0x03 //**报告ID（3）**  
  
 .dw 0xb1, 0x06 //**特征**（数据，变量，相对值）  
  
.dw 0x09, 0x01 //用法(供给商用法1)  
  
.dw 0x85, 0x02 //**报告ID（2）**  
  
 .dw 0xb1, 0x06 //**特征**（数据，变量，相对值）  
  
.dw 0x09, 0x01 //用法(供给商用法1)  
  
.dw 0x85, 0x04 //**报告ID（4）**  
  
 .dw 0x91, 0x06 //**输出**（数据，变量，相对值）  
  
.dw 0xc0 //结合结束  
  
\_ReportDescriptor\_End:  
  
这个报告描述符，定义了4个不同的报告：输进报告1，特征报告2，特征报告3，输出报告4（数字代表其报告ID）。led照明为了简化，每个报告都是7个字节（加上报告ID就是8个字节）。下面用一个简单的示例来描述PC端与USB HID设备进行通讯的一般方法。  
  
\#define USB\_VID 0xFC0  
  
\#define USB\_PID 0x420  
  
HANDLE OpenMyHIDDevice(int overlapped);  
  
void HIDSampleFunc()  
  
\{  
  
HANDLE hDev;  
  
BYTE recvDataBuf\[8\];  
  
BYTE reportBuf\[8\];  
  
DWORD bytes;  
  
hDev = OpenMyHIDDevice(0); //打开设备，不使用重叠（异步）方式;  
  
if (hDev == INVALID\_HANDLE\_VALUE)  
  
return;  
  
reportBuf\[0\] = 4; //输出报告的报告ID是4  
  
memset(reportBuf, 0, 8);  
  
reportBuf\[1\] = 1;  
  
if (!WriteFile(hDev, reportBuf, 8, &bytes, NULL)) //写进数据到设备  
  
return;  
  
ReadFile(hDev, recvDatatBuf, 8, &bytes, NULL); //读取设备发给主机的数据  
  
\}  
  
HANDLE OpenMyHIDDevice(int overlapped)  
  
\{  
  
HANDLE hidHandle;  
  
GUID hidGuid;  
  
HidD\_GetHidGuid(&hidGuid);  
  
HDEVINFO hDevInfo = SetupDiGetClassDevs(  
  
&hidGuid,  
  
NULL,  
  
NULL,  
  
(DIGCF\_PRESENT | DIGCF\_DEVICEINTERFACE));  
  
if (hDevInfo == INVALID\_HANDLE\_VALUE)  
  
\{  
  
return INVALID\_HANDLE\_VALUE;  
  
\}  
  
SP\_DEVICE\_INTERFACE\_DATA devInfoData;  
  
devInfoData.cbSize = sizeof (SP\_DEVICE\_INTERFACE\_DATA);  
  
int deviceNo = 0;  
  
SetLastError(NO\_ERROR);  
  
while (GetLastError() != ERROR\_NO\_MORE\_ITEMS)  
  
\{  
  
if (SetupDiEnumInte\*\*\*ceDevice (hDevInfo,  
  
0,  
  
&hidGuid,  
  
deviceNo,  
  
&devInfoData))  
  
\{  
  
ULONG requiredLength = 0;  
  
SetupDiGetInte\*\*\*ceDeviceDetail(hDevInfo,  
  
&devInfoData,  
  
NULL,  
  
0,  
  
&requiredLength,  
  
NULL);  
  
PSP\_INTERFACE\_DEVICE\_DETAIL\_DATA devDetail =  
  
(SP\_INTERFACE\_DEVICE\_DETAIL\_DATA\*) malloc (requiredLength);  
  
devDetail->cbSize = sizeof(SP\_INTERFACE\_DEVICE\_DETAIL\_DATA);  
  
if(!SetupDiGetInte\*\*\*ceDeviceDetail(hDevInfo,  
  
&devInfoData,  
  
devDetail,  
  
requiredLength,  
  
NULL,  
  
NULL))  
  
\{  
  
free(devDetail);  
  
SetupDiDestroyDeviceInfoList(hDevInfo);  
  
return INVALID\_HANDLE\_VALUE;  
  
\}  
  
if (overlapped)  
  
\{  
  
hidHandle = CreateFile(devDetail->DevicePath,  
  
GENERIC\_READ | GENERIC\_WRITE,  
  
FILE\_SHARE\_READ | FILE\_SHARE\_WRITE,  
  
NULL,  
  
OPEN\_EXISTING,  
  
FILE\_FLAG\_OVERLAPPED,  
  
NULL);  
  
\}  
  
else  
  
\{  
  
hidHandle = CreateFile(devDetail->DevicePath,  
  
GENERIC\_READ | GENERIC\_WRITE,  
  
FILE\_SHARE\_READ | FILE\_SHARE\_WRITE,  
  
NULL,  
  
OPEN\_EXISTING,  
  
0,  
  
NULL);  
  
\}  
  
free(devDetail);  
  
if (hidHandle==INVALID\_HANDLE\_VALUE)  
  
\{  
  
SetupDiDestroyDeviceInfoList(hDevInfo);  
  
free(devDetail);  
  
return INVALID\_HANDLE\_VALUE;  
  
\}  
  
\_HIDD\_ATTRIBUTES hidAttributes;  
  
if(!HidD\_GetAttributes(hidHandle, &hidAttributes))  
  
\{  
  
CloseHandle(hidHandle);  
  
SetupDiDestroyDeviceInfoList(hDevInfo);  
  
return INVALID\_HANDLE\_VALUE;  
  
\}  
  
if (USB\_VID == hidAttributes.VendorID  
  
&& USB\_PID == hidAttributes.ProductID)  
  
\{  
  
break;  
  
\}  
  
else  
  
\{  
  
CloseHandle(hidHandle);  
  
\++deviceNo;  
  
\}  
  
\}  
  
\}  
  
SetupDiDestroyDeviceInfoList(hDevInfo);  
  
return hidHandle;  
  
\}

[http://bbs.21ic.com/icview-455726-1-1.html][http_bbs.21ic.com_icview-455726-1-1.html]

[HID 数据传输上位机READFILE不到数据的问题][http_bbs.21ic.com_icview-455726-1-1.html]

一个AVR和上位机的通讯实验，上位机VC2010  
功能：上位机发送8位数据，HID设备返回相同数据  
BUS HOUND 能检测出数据返回数据，可是READFILE（）读不出数据，这是为什么？  
找了两天的资料，说什么的都有呀，头快爆炸了  
  
  
  
固件程序代码

1.  char usbDescriptorHidReport\[33\] = \{ // USB report descriptor  
    
2.  0x06,0x00,0xFF, //USAGE\_PAGE (Vendor Defined Page 1)  
    
3.  0x09,0x01, //USAGE (Vendor Usage 1)  
    
4.  0xA1,0x01, //COLLECTION (Application)  
    
5.  0x19,0x01, //(Vendor Usage 1)  
    
6.  0x29,0x08, //(Vendor Usage 1)  
    
7.  0x85,0x01, //报告ID(1)  
    
8.  0x15,0x00, //LOGICAL\_MINIMUM (0)  
    
9.  0x26,0xFF,0x00, //LOGICAL\_MAXIMUM (255)  
    
10. 0x75,0x08, //REPORT\_SIZE (8)  
    
11. 0x95,0x07, //REPORT\_COUNT (7)  
    
12. 0x81,0x02, //INPUT (Data,Var,Abs)  
    
13. 0x19,0x01, //(Vendor Usage 1)  
    
14. 0x29,0x08, //(Vendor Usage 1)  
    
15. 0x85,0x02, //报告ID(2)上位机VC-WriteFile函数缓冲区0位必须设置此ID数  
    
16. 0x91,0x02, //OUTPUT (Data,Var,Abs)  
    
17. 0xC0 // END\_COLLECTION // END\_COLLECTION  
    
18. \};  
    
19. static uchar rcbuf\[8\]=\{0\};  
    
20. static uchar rpbuf\[8\]=\{0\};  
    
21. void write()//AVRM16属低速设备，每次只能发8个字节  
    
22. \{  
    
23. if(usbInterruptIsReady())  
    
24. \{  
    
25. usbSetInterrupt(rcbuf, sizeof(rcbuf));  
    
26. \}  
    
27. return;  
    
28. \}  
    
29.   
    
30. uchar usbFunctionSetup(uchar data\[8\])  
    
31. \{  
    
32. //LCDprintf(1,(void \*)data);  
    
33.   
    
34. /\* 这里你可以根据data\[8\]里面的参数做一些判断，决定返回哪些数据 \*/  
    
35. return USB\_NO\_MSG; //USB\_NO\_MSG=0xff  
    
36. \}  
    
37. /\*  
    
38. 上位机通过函数要求读数据(UsbRequestType.EndpointIn)，  
    
39. vusb Driver则自动会调用usbFunctionRead()函数来把数据  
    
40. (rpbuf数组里的数据)返回给上位机，其中len参数就是的参  
    
41. 数bufferLen。  
    
42. \*/  
    
43. uchar usbFunctionRead(uchar \*data, uchar len) \{  
    
44. uchar i;  
    
45. for(i=0;i<len;i++)\{  
    
46. data\[i\]=rpbuf\[i\];  
    
47. \}  
    
48. // LCDprintf(2,(void \*)data);  
    
49. return len;  
    
50. \}  
    
51. /\*  
    
52. 如果上位机通过函数要求向单片机写数据(UsbRequestType.EndpointOut)，  
    
53. vusb Driver自动会调用usbFunctionWrite()函数来接收上位机传来的数据，  
    
54. 并保存到rcbuf数组中。  
    
55. \*/  
    
56. uchar usbFunctionWrite(uchar \*data, uchar len) \{  
    
57. uchar i;  
    
58. for(i=0;i<len;i++)\{  
    
59. rcbuf\[i\]=data\[i\];  
    
60. \}  
    
61. write();  
    
62. // LCDprintf(3,(void \*)rcbuf);  
    
63. return len;  
    
64. \}  
    
65.   
    
66. /\* ------------------------------------------------------------------------- \*/  
    
67. int main(void)  
    
68. \{  
    
69. DDRC = 0xFF;  
    
70. PORTC = 0xFF;  
    
71. init\_devices();  
    
72. \_delay\_ms(50);  
    
73. LCD\_init(); //LCD初始化  
    
74. LCD\_clear(); //清屏  
    
75. clear\_img();  
    
76. DDRC = 0xff;  
    
77. PORTC = 0xff;  
    
78. LCDprintf(1,"USBhid通讯实验");  
    
79. wdt\_enable(WDTO\_2S);  
    
80. // odDebugInit();  
    
81. usbInit();  
    
82. sei();  
    
83. // DBG1(0x00, 0, 0);  
    
84. for(;;)\{ /\* main event loop \*/  
    
85. wdt\_reset();  
    
86. usbPoll();  
    
87. \}  
    
88. return 0;  
    
89. \}

*复制代码*

上位机VC代码

1.  \#define USB\_VID 0x16c0  
    
2.  \#define USB\_PID 0x05e1  
    
3.  HANDLE OpenMyHIDDevice(int overlapped);  
    
4.  LPVOID lpMsgBuf;  
    
5.  /\*用FormatMessage()得到由GetLastError()返回的出错编码所对应错误信息\*/  
    
6.  \#define error FormatMessage( FORMAT\_MESSAGE\_ALLOCATE\_BUFFER|FORMAT\_MESSAGE\_FROM\_SYSTEM|FORMAT\_MESSAGE\_IGNORE\_INSERTS,NULL, GetLastError(), MAKELANGID(LANG\_NEUTRAL, SUBLANG\_DEFAULT),(LPTSTR) &lpMsgBuf,0, NULL )  
    
7.  /\*---------------------------------------------\*/  
    
8.  BYTE lpBuf\[8\];  
    
9.    
    
10. bool write(HANDLE hComm)  
    
11. \{  
    
12. OVERLAPPED osWrite = \{0\};  
    
13. DWORD dwWritten;  
    
14. BOOL fRes;  
    
15. memset(lpBuf, 0, 8);//数组清零  
    
16. lpBuf\[0\]=2;  
    
17. lpBuf\[1\]=4;  
    
18. // Create this writes OVERLAPPED structure hEvent.  
    
19. osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);  
    
20. if (osWrite.hEvent == NULL)  
    
21. // Error creating overlapped event handle.  
    
22. return false;  
    
23.   
    
24. // Issue write.  
    
25. if (!WriteFile(hComm, lpBuf, 8, &dwWritten, &osWrite))  
    
26. \{  
    
27. if (GetLastError() != ERROR\_IO\_PENDING)  
    
28. \{  
    
29. // WriteFile failed, but it isn't delayed. Report error and abort.  
    
30. fRes = false;  
    
31. \}  
    
32. else  
    
33. \{  
    
34. // Write is pending.  
    
35.   
    
36. \#define WRITE\_TIMEOUT 500 //write timeout  
    
37. DWORD dwRes = WaitForSingleObject(osWrite.hEvent, WRITE\_TIMEOUT);  
    
38. switch(dwRes)  
    
39. \{  
    
40. // Read completed.  
    
41. case WAIT\_OBJECT\_0:  
    
42. if (!GetOverlappedResult(hComm, &osWrite, &dwWritten, TRUE))  
    
43. fRes = FALSE;  
    
44. else  
    
45. // Write operation completed successfully.  
    
46. fRes = true;  
    
47. case WAIT\_TIMEOUT:  
    
48. // This is a good time to do some background work.  
    
49. break;  
    
50.   
    
51. default:  
    
52. // Error in the WaitForSingleObject; abort.  
    
53. // This indicates a problem with the OVERLAPPED structure's  
    
54. // event handle.  
    
55. break;  
    
56. \}  
    
57. \}  
    
58. \}  
    
59. else  
    
60. // WriteFile completed immediately.  
    
61. fRes = true;  
    
62.   
    
63. CloseHandle(osWrite.hEvent);  
    
64. return fRes;  
    
65. \}  
    
66.   
    
67.   
    
68. bool read(HANDLE hComm)  
    
69. \{  
    
70. DWORD dwRead;  
    
71. BOOL fWaitingOnRead = FALSE;  
    
72. OVERLAPPED osReader = \{0\};  
    
73. memset(lpBuf, 0, 8);//数组清零  
    
74. // Create the overlapped event. Must be closed before exiting  
    
75. // to avoid a handle leak.  
    
76. osReader.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);  
    
77.   
    
78. if (osReader.hEvent == NULL)  
    
79. \{  
    
80. // Error creating overlapped event; abort.  
    
81. return false;  
    
82. \}  
    
83.   
    
84. if (!fWaitingOnRead)  
    
85. \{  
    
86. // Issue read operation.  
    
87. if (!ReadFile(hComm, lpBuf, 8, &dwRead, &osReader))  
    
88. \{  
    
89. // error;//错误查询  
    
90. if (GetLastError() != ERROR\_IO\_PENDING) // read not delayed?  
    
91. \{  
    
92. // Error in communications; report it.  
    
93. \}  
    
94. else  
    
95. \{  
    
96. fWaitingOnRead = TRUE;  
    
97. \}  
    
98. \}  
    
99. else  
    
100. \{  
    
101. // read completed immediately  
    
102. // HandleASuccessfulRead(lpBuf, dwRead);  
    
103. \}  
    
104. \}  
    
105.   
    
106. if (fWaitingOnRead)  
    
107. \{  
    
108. \#define READ\_TIMEOUT 500 // milliseconds  
    
109. DWORD dwRes = WaitForSingleObject(osReader.hEvent, READ\_TIMEOUT);  
    
110. switch(dwRes)  
    
111. \{  
    
112. // Read completed.  
    
113. case WAIT\_OBJECT\_0:  
    
114. if (!GetOverlappedResult(hComm, &osReader, &dwRead, FALSE))  
    
115. \{  
    
116. // Error in communications; report it.  
    
117. \}  
    
118. else  
    
119. \{  
    
120. // Read completed successfully.  
    
121. //HandleASuccessfulRead(lpBuf, dwRead);  
    
122. \}  
    
123. // Reset flag so that another opertion can be issued.  
    
124. fWaitingOnRead = false;  
    
125. break;  
    
126.   
    
127. case WAIT\_TIMEOUT:  
    
128. // Operation isn't complete yet. fWaitingOnRead flag isn't  
    
129. // changed since I'll loop back around, and I don't want  
    
130. // to issue another read until the first one finishes.  
    
131. //  
    
132. // This is a good time to do some background work.  
    
133. break;  
    
134.   
    
135. default:  
    
136. // Error in the WaitForSingleObject; abort.  
    
137. // This indicates a problem with the OVERLAPPED structure's  
    
138. // event handle.  
    
139. break;  
    
140. \}  
    
141. \}  
    
142. return true;  
    
143. \}  
    
144. void HIDSampleFunc()  
    
145. \{  
    
146. HANDLE hDev;  
    
147.   
    
148.   
    
149.   
    
150. hDev = OpenMyHIDDevice(1); //打开设备，使用重叠（异步）方式;  
    
151. printf("传递设备句柄:%x\\n",hDev);  
    
152. if (hDev == INVALID\_HANDLE\_VALUE)  
    
153. return;  
    
154. /\*//不使用异步方式的时候的代码  
    
155. // BYTE recvDataBuf\[8\];  
    
156. // BYTE reportBuf\[8\];  
    
157. // DWORD bytes;  
    
158. memset(reportBuf, 0, 8);//数组清零  
    
159. reportBuf\[0\] = 4; //输出报告的报告ID是4  
    
160. reportBuf\[1\] = 1;  
    
161. if (!WriteFile(hDev,// 设备句柄，即 CreateFile 的返回值  
    
162. reportBuf,// 存有待发送数据的 buffer  
    
163. 8, // 待发送数据的长度  
    
164. &bytes, // 实际收到的数据的字节数  
    
165. 0// 异步模式  
    
166. )) //写入数据到设备  
    
167. \{  
    
168.   
    
169. return;\}  
    
170. // Sleep(1500);  
    
171. printf("开始接收");  
    
172. ReadFile(hDev, recvDataBuf, 8, &bytes, NULL); //读取设备发给主机的数  
    
173. printf("结束");  
    
174. \*/  
    
175.   
    
176.   
    
177. for(int i=0;i<8;i++)  
    
178. \{  
    
179. printf("开始写入\\n");  
    
180. write(hDev);  
    
181. printf("开始接收\\n");  
    
182. read(hDev);//error;//错误查询  
    
183. for(int i=0;i<8;i++)\{printf("%x ",lpBuf\[i\]);\}printf("结束\\n");\}  
    
184.   
    
185.   
    
186. \}  
    
187.   
    
188.   
    
189. HANDLE OpenMyHIDDevice(int overlapped)  
    
190. \{  
    
191. HANDLE hidHandle;  
    
192. GUID hidGuid;  
    
193. HidD\_GetHidGuid(&hidGuid);  
    
194.   
    
195. HDEVINFO hDevInfo = SetupDiGetClassDevs(  
    
196. &hidGuid,  
    
197. NULL,  
    
198. NULL,  
    
199. (DIGCF\_PRESENT | DIGCF\_DEVICEINTERFACE));  
    
200. if (hDevInfo == INVALID\_HANDLE\_VALUE)  
    
201. \{  
    
202. return INVALID\_HANDLE\_VALUE;  
    
203. \}  
    
204.   
    
205. SP\_DEVICE\_INTERFACE\_DATA devInfoData;  
    
206. devInfoData.cbSize = sizeof (SP\_DEVICE\_INTERFACE\_DATA);  
    
207. int deviceNo = 0;  
    
208.   
    
209. SetLastError(NO\_ERROR);  
    
210.   
    
211. while (GetLastError() != ERROR\_NO\_MORE\_ITEMS)  
    
212. \{  
    
213. if (SetupDiEnumInterfaceDevice (hDevInfo,  
    
214. 0,  
    
215. &hidGuid,  
    
216. deviceNo,  
    
217. &devInfoData))  
    
218. \{  
    
219. ULONG requiredLength = 0;  
    
220. SetupDiGetInterfaceDeviceDetail(hDevInfo,  
    
221. &devInfoData,  
    
222. NULL,  
    
223. 0,  
    
224. &requiredLength,  
    
225. NULL);  
    
226.   
    
227. PSP\_INTERFACE\_DEVICE\_DETAIL\_DATA devDetail =  
    
228. (SP\_INTERFACE\_DEVICE\_DETAIL\_DATA\*) malloc (requiredLength);  
    
229. devDetail->cbSize = sizeof(SP\_INTERFACE\_DEVICE\_DETAIL\_DATA);  
    
230.   
    
231. if(!SetupDiGetInterfaceDeviceDetail(hDevInfo,  
    
232. &devInfoData,  
    
233. devDetail,  
    
234. requiredLength,  
    
235. NULL,  
    
236. NULL))  
    
237. \{  
    
238.   
    
239. free(devDetail);  
    
240. SetupDiDestroyDeviceInfoList(hDevInfo);  
    
241. return INVALID\_HANDLE\_VALUE;  
    
242. \}  
    
243. /\*----------------------该处为vid-pid-guid的比较后作出标志位------------\*/  
    
244. char vidpidguid\[30\];  
    
245. sprintf(vidpidguid,"%s","\\\\\\\\?\\\\hid\#vid\_16c0&pid\_05e1\#");//“\\\\”为转移字符，要改成这样  
    
246. int hidcheck=0;  
    
247. for(int i=0 ;i<25;i++)\{  
    
248. if(devDetail->DevicePath\[i\] == vidpidguid\[i\])\{hidcheck++;\}  
    
249. printf("%c",devDetail->DevicePath\[i\]);  
    
250. \}  
    
251. printf("======%d\\n",hidcheck);  
    
252. /\*-------------------------------------------------------------------\*/  
    
253. if (overlapped)  
    
254. \{  
    
255.   
    
256. if(hidcheck == 25)//vid-pid-guid的比较正确，则使用GENERIC\_READ | GENERIC\_WRITE访问  
    
257. \{  
    
258. hidHandle = CreateFile(devDetail->DevicePath,  
    
259. GENERIC\_READ | GENERIC\_WRITE,  
    
260. FILE\_SHARE\_READ | FILE\_SHARE\_WRITE,  
    
261. (LPSECURITY\_ATTRIBUTES)NULL,  
    
262. OPEN\_EXISTING,  
    
263. FILE\_FLAG\_OVERLAPPED,  
    
264. NULL);  
    
265. printf("使用读写方式打开\\n");  
    
266. \}  
    
267. else  
    
268. \{//否则作为独占方式访问  
    
269. hidHandle = CreateFile(devDetail->DevicePath,  
    
270. 0,  
    
271. FILE\_SHARE\_READ | FILE\_SHARE\_WRITE,  
    
272. (LPSECURITY\_ATTRIBUTES)NULL,  
    
273. OPEN\_EXISTING,  
    
274. FILE\_FLAG\_OVERLAPPED,  
    
275. NULL);  
    
276. printf("系统独占方式打开\\n");  
    
277. \}  
    
278.   
    
279. \}  
    
280. else  
    
281. \{  
    
282. if(hidcheck == 25)//vid-pid-guid的比较正确，则使用GENERIC\_READ | GENERIC\_WRITE访问  
    
283. \{  
    
284. hidHandle = CreateFile(devDetail->DevicePath, //访问路径  
    
285. GENERIC\_READ | GENERIC\_WRITE, //访问方式必须为零，由于鼠标键盘HID是系统独占，所以会出错  
    
286. FILE\_SHARE\_READ | FILE\_SHARE\_WRITE, //共享模式  
    
287. (LPSECURITY\_ATTRIBUTES)NULL,  
    
288. OPEN\_EXISTING, //文件不存在是返回失败  
    
289. 0, //若为FILE\_FLAG\_OVERLAPPED以重叠（异步）模式打开  
    
290. NULL  
    
291. );  
    
292. printf("使用读写方式打开\\n");  
    
293. \}  
    
294. else  
    
295. \{//否则作为独占方式访问  
    
296. hidHandle = CreateFile(devDetail->DevicePath, //访问路径  
    
297. 0, //访问方式必须为零，由于鼠标键盘HID是系统独占，所以会出错  
    
298. FILE\_SHARE\_READ | FILE\_SHARE\_WRITE, //共享模式  
    
299. (LPSECURITY\_ATTRIBUTES)NULL,  
    
300. OPEN\_EXISTING, //文件不存在是返回失败  
    
301. 0, //若为FILE\_FLAG\_OVERLAPPED以重叠（异步）模式打开  
    
302. NULL  
    
303. );  
    
304. printf("系统独占方式打开\\n");  
    
305. \}  
    
306. \}  
    
307.   
    
308. free(devDetail);  
    
309.   
    
310. if (hidHandle==INVALID\_HANDLE\_VALUE)  
    
311. \{  
    
312. SetupDiDestroyDeviceInfoList(hDevInfo);  
    
313. free(devDetail);  
    
314. return INVALID\_HANDLE\_VALUE;  
    
315. \}  
    
316. printf("打开成功\\n");  
    
317. \_HIDD\_ATTRIBUTES hidAttributes;  
    
318. if(!HidD\_GetAttributes(hidHandle, &hidAttributes))  
    
319. \{  
    
320. CloseHandle(hidHandle);  
    
321. SetupDiDestroyDeviceInfoList(hDevInfo);  
    
322.   
    
323.   
    
324. return INVALID\_HANDLE\_VALUE;  
    
325. \}  
    
326.   
    
327. if (USB\_VID == hidAttributes.VendorID  
    
328. && USB\_PID == hidAttributes.ProductID)  
    
329. \{  
    
330. printf("找到设备!\\n");  
    
331. break;  
    
332. \}  
    
333. else  
    
334. \{  
    
335. CloseHandle(hidHandle);  
    
336. \++deviceNo;  
    
337. \}  
    
338. \}  
    
339. \}  
    
340.   
    
341. SetupDiDestroyDeviceInfoList(hDevInfo);  
    
342.   
    
343. return hidHandle;  
    
344. \}  
    
345.   
    
346.   
    
347.   
    
348. int \_tmain(int argc, \_TCHAR\* argv\[\])  
    
349. \{  
    
350. HIDSampleFunc();  
    
351.   
    
352.   
    
353. // MessageBox(NULL,(LPCTSTR)lpMsgBuf, \_T("Error"), MB\_OK | MB\_ICONINFORMATION );  
    
354. // Free the buffer.  
    
355. // LocalFree( lpMsgBuf );  
    
356. system("PAUSE");  
    
357. return 0;  
    
358. \}

*复制代码*

自己解决了，原来writefile和readfile的缓冲去不能共用

[http_bbs.csdn.net_topics_390691197]: http://bbs.csdn.net/topics/390691197
[http_bbs.csdn.net_topics_390511409]: http://bbs.csdn.net/topics/390511409
[http_blog.10jqka.com.cn_103723137_6082311.shtml]: http://blog.10jqka.com.cn/103723137/6082311.shtml
[http_bbs.21ic.com_icview-455726-1-1.html]: http://bbs.21ic.com/icview-455726-1-1.html