HID-USB设备读写开发测试

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

打开HID例程程序

 

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

HID 数据传输上位机READFILE不到数据的问题

一个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的缓冲去不能共用