HID windows readfile writefile

http://blog.10jqka.com.cn/103723137/6082311.shtml

参考代码

点击(此处)折叠或打开

1. #include "xconfig.h"
   
2. 
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. 
   
6. #include <setupapi.h> // Must link in setupapi.lib
   
7. #include <hidsdi.h> // Must link in hid.lib
   
8. #include <string.h>
   
9. 
   
10. #if 1
    
11. #define usVID 0x0416
    
12. #define usPID 0x5020
    
13. #else
    
14. #define usVID 0x1A86
    
15. #define usPID 0x7523
    
16. #endif
    
17. ////////////////////////////////////////////////////////////
    
18. // global Variants /////////////////////////////////////////
    
19.     HANDLE m_hReadHandle;
    
20.     HANDLE m_hWriteHandle;
    
21. 
    
22.     HANDLE m_hReadEvent;
    
23.     HANDLE m_hWriteEvent;
    
24.     HANDLE m_hAbordEvent;
    
25. 
    
26. 
    
27. void CloseDevice(void)
    
28. {
    
29.         if(m_hReadHandle != INVALID_HANDLE_VALUE)
    
30.             CancelIo(m_hReadHandle);
    
31.         if(m_hWriteHandle != INVALID_HANDLE_VALUE)
    
32.             CancelIo(m_hWriteHandle);
    
33.         if(m_hReadHandle != INVALID_HANDLE_VALUE)
    
34.         {
    
35.             CloseHandle(m_hReadHandle);
    
36.             m_hReadHandle = INVALID_HANDLE_VALUE;
    
37.         }
    
38.         if(m_hWriteHandle != INVALID_HANDLE_VALUE)
    
39.         {
    
40.             CloseHandle(m_hWriteHandle);
    
41.             m_hWriteHandle = INVALID_HANDLE_VALUE;
    
42.         }
    
43. }
    
44. 
    
45. void init_HIDIO(void)
    
46. {
    
47.     m_hAbordEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
    
48.     m_hReadEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
    
49.     m_hWriteEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
    
50. }
    
51. 
    
52. void final_HIDIO(void)
    
53. {
    
54.     CloseDevice();
    
55.     CloseHandle(m_hWriteEvent);
    
56.     CloseHandle(m_hReadEvent);
    
57.     CloseHandle(m_hAbordEvent);
    
58. }
    
59. 
    
60. BOOL HID_ReadFile(char *pcBuffer, DWORD szMaxLen, DWORD *pdwLength, DWORD dwMilliseconds)
    
61. {
    
62.     DWORD BytesRead = 0;
    
63.     HANDLE events[2] = {m_hAbordEvent, m_hReadEvent};
    
64. 
    
65.     OVERLAPPED overlapped;
    
66.     memset(&overlapped, 0, sizeof(overlapped));
    
67.     overlapped.hEvent = m_hReadEvent;
    
68. 
    
69.     if(pdwLength != NULL)
    
70.         *pdwLength = 0;
    
71. 
    
72.     if(!ReadFile(m_hReadHandle, pcBuffer, szMaxLen, &BytesRead, &overlapped)) {
    
73.         printf("readfile, GetLastError() = %ld \n", GetLastError());
    
74.         return FALSE;
    
75.     }
    
76. 
    
77.     DWORD dwIndex = WaitForMultipleObjects(2, events, FALSE, dwMilliseconds);
    
78.     if(dwIndex == WAIT_OBJECT_0 || dwIndex == WAIT_OBJECT_0 + 1) {
    
79.         ResetEvent(events[dwIndex - WAIT_OBJECT_0]);
    
80. 
    
81.         if(dwIndex == WAIT_OBJECT_0)
    
82.                 return FALSE;    //Abort event
    
83.         else {
    
84.             DWORD dwLength = 0;
    
85.             //Read OK
    
86.             GetOverlappedResult(m_hReadHandle, &overlapped, &dwLength, TRUE);
    
87.             if(pdwLength != NULL) *pdwLength = dwLength;
    
88.             return TRUE;
    
89.         }
    
90.     }
    
91. 
    
92.     return FALSE;
    
93. }
    
94. 
    
95. BOOL HID_WriteFile(char *pcBuffer, DWORD szLen, DWORD *pdwLength, DWORD dwMilliseconds)
    
96. {
    
97.         HANDLE events[2] = {m_hAbordEvent, m_hWriteEvent};
    
98.         DWORD dwIndex = 0;
    
99.         DWORD dwByteSend = 0;
    
100. 
     
101.         OVERLAPPED overlapped;
     
102.         memset(&overlapped, 0, sizeof(overlapped));
     
103.         overlapped.hEvent = m_hWriteEvent;
     
104. 
     
105.         if(pdwLength != NULL)
     
106.             *pdwLength = 0;
     
107. 
     
108.         if(!WriteFile(m_hWriteHandle, pcBuffer, szLen, &dwByteSend, &overlapped)) {
     
109.             printf("WriteFile, GetLastError() = %ld \n", GetLastError());
     
110.             return FALSE;
     
111.         }
     
112. 
     
113.         dwIndex = WaitForMultipleObjects(2, events, FALSE, dwMilliseconds);
     
114. 
     
115.         if(dwIndex == WAIT_OBJECT_0 || dwIndex == WAIT_OBJECT_0 + 1) {
     
116.             ResetEvent(events[dwIndex - WAIT_OBJECT_0]);
     
117. 
     
118.             if(dwIndex == WAIT_OBJECT_0)
     
119.                 return FALSE;    //Abort event
     
120.             else {
     
121.                 DWORD dwLength = 0;
     
122.                 //Write OK
     
123.                 GetOverlappedResult(m_hWriteHandle, &overlapped, &dwLength, TRUE);
     
124.                 if(pdwLength != NULL)
     
125.                     *pdwLength = dwLength;
     
126.                 return TRUE;
     
127.             }
     
128.         }
     
129. 
     
130.         return FALSE;
     
131. }
     
132. 
     
133. int main()
     
134. {
     
135.     wchar_t MyDevPathName[MAX_PATH];
     
136.     GUID HidGuid;
     
137.     HDEVINFO hDevInfoSet;
     
138.     DWORD MemberIndex=0;
     
139.     SP_DEVICE_INTERFACE_DATA DevInterfaceData;
     
140. 
     
141.     BOOL Result;
     
142.     DWORD RequiredSize;
     
143.     PSP_DEVICE_INTERFACE_DETAIL_DATA    pDevDetailData;
     
144. 
     
145.     PHIDP_PREPARSED_DATA PreparsedData;
     
146.     HIDP_CAPS Capabilities;
     
147. 
     
148.     HANDLE hDevHandle;
     
149.     HIDD_ATTRIBUTES DevAttributes;
     
150. 
     
151.     BOOL MyDevFound=FALSE;
     
152. 
     
153.     //Open Devices.
     
154.     m_hWriteHandle = INVALID_HANDLE_VALUE;
     
155.     m_hReadHandle = INVALID_HANDLE_VALUE;
     
156. 
     
157.     DevInterfaceData.cbSize=sizeof(DevInterfaceData);
     
158.     DevAttributes.Size=sizeof(DevAttributes);
     
159.     HidD_GetHidGuid(&HidGuid);
     
160. 
     
161.     hDevInfoSet=SetupDiGetClassDevs(&HidGuid,
     
162.             NULL,
     
163.             NULL,
     
164.             DIGCF_DEVICEINTERFACE|DIGCF_PRESENT);
     
165. 
     
166.     MemberIndex=0;
     
167.     while(1) {
     
168.         Result=SetupDiEnumDeviceInterfaces(hDevInfoSet,
     
169.                 NULL,
     
170.                 &HidGuid,
     
171.                 MemberIndex,
     
172.                 &DevInterfaceData);
     
173. 
     
174.         if(Result==FALSE) break;
     
175. 
     
176.         MemberIndex++;
     
177. 
     
178.         Result=SetupDiGetDeviceInterfaceDetail(hDevInfoSet,
     
179.                 &DevInterfaceData,
     
180.                 NULL,
     
181.                 0,
     
182.                 &RequiredSize,
     
183.                 NULL);
     
184. 
     
185.         pDevDetailData=(PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(RequiredSize);
     
186.         if(pDevDetailData==NULL) {
     
187.             SetupDiDestroyDeviceInfoList(hDevInfoSet);
     
188.             return FALSE;
     
189.         }
     
190. 
     
191.         pDevDetailData->cbSize=sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
     
192.         Result=SetupDiGetDeviceInterfaceDetail(hDevInfoSet,
     
193.                 &DevInterfaceData,
     
194.                 pDevDetailData,
     
195.                 RequiredSize,
     
196.                 NULL,
     
197.                 NULL);
     
198. 
     
199.         wcscpy(MyDevPathName, (const wchar_t *)pDevDetailData->DevicePath);
     
200.         free(pDevDetailData);
     
201. 
     
202.         if(Result==FALSE) continue;
     
203.         hDevHandle=CreateFile(TEXT((char *)MyDevPathName),
     
204.                 GENERIC_READ | GENERIC_WRITE,
     
205.                 FILE_SHARE_READ|FILE_SHARE_WRITE,
     
206.                 NULL,
     
207.                 OPEN_EXISTING,
     
208.                 FILE_ATTRIBUTE_NORMAL,
     
209.                 NULL);
     
210. 
     
211.         if(hDevHandle!=INVALID_HANDLE_VALUE) {
     
212. #if 1
     
213.             if (TRUE == HidD_GetPreparsedData(hDevHandle, &PreparsedData)) { //获取缓存区长度
     
214.                 HidP_GetCaps(PreparsedData, &Capabilities);
     
215.             }
     
216. #endif
     
217.             Result=HidD_GetAttributes(hDevHandle, &DevAttributes);
     
218.             CloseHandle(hDevHandle);
     
219.             if(Result==FALSE) continue;
     
220.             if(DevAttributes.VendorID == usVID && DevAttributes.ProductID == usPID) {
     
221.                 MyDevFound=TRUE;
     
222. 
     
223.                 m_hReadHandle=CreateFile(TEXT((char *)MyDevPathName),
     
224.                                 GENERIC_READ,
     
225.                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
     
226.                                 NULL,
     
227.                                 OPEN_EXISTING,
     
228.                                 //FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
     
229.                                 FILE_ATTRIBUTE_NORMAL,
     
230.                                 NULL);
     
231. 
     
232.                 m_hWriteHandle=CreateFile(TEXT((char *)MyDevPathName),
     
233.                                 GENERIC_WRITE,
     
234.                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
     
235.                                 NULL,
     
236.                                 OPEN_EXISTING,
     
237.                                 //FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
     
238.                                 FILE_ATTRIBUTE_NORMAL,
     
239.                                 NULL);
     
240. 
     
241.                 break;
     
242.             }
     
243.         }
     
244.         else continue;
     
245.     } //end while
     
246. 
     
247.     char send[255], recv[255];
     
248.     int idx = 0;
     
249.     DWORD iRet, iLen;
     
250. 
     
251.     if (MyDevFound) {
     
252.         init_HIDIO();
     
253. 
     
254.         while (1) {
     
255.             memset(send, 0, sizeof(send));
     
256.             sprintf(&send[1], "[test - %d]", idx++);
     
257.             iLen = Capabilities.InputReportByteLength; //strlen(send);
     
258. 
     
259.             // set event for write
     
260.             //SetEvent(m_hWriteEvent);
     
261.             Result = HID_WriteFile(send, iLen, &iRet, 1000); //reportBuf[0]必须存有待发送报告的ID，并且此报告ID指示的必须是输出报告，否则会返回87号错误
     
262.             //if (Result == FALSE) break;
     
263.             //printf("[%ld] bytes sended. \n", iRet);
     
264. #if 1
     
265.             memset(recv, 0, sizeof(recv));
     
266.             Result = HID_ReadFile(recv, Capabilities.OutputReportByteLength, &iRet, 1000); // recvBytes参数假如设置过大，不会有实质性的错误，会输出实际读到的长度；假如设置过小，即小于报告的长度，会返回1784号错误（用户提供的buffer无效）
     
267.             if (Result == TRUE) {
     
268.                 printf("recved. %s\n", &recv[1]);
     
269.             }
     
270. #endif
     
271.             Sleep(1000);
     
272.         }
     
273. 
     
274.         final_HIDIO();
     
275. 
     
276.     }
     
277. 
     
278. }

调试了好长时间，终于发现这个 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）。为了简化，每个报告都是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; 

}