Arduino 控制USB设备（4）解析描述符

zoologist

前面一篇介绍了如何获得USB Descriptor，更麻烦的是这个数据的解读。在【参考1】给出了一个直接解析 Descriptor的例子。美中不足的是，这个例子只能在老版本的Arduino上工作（我估计是 0.22），在新版本 1.6.x 的IDE上会出现很多报错。

经过努力修改，终于可以编译通过(需要选择 Arduno Uno)，程序如下：

1. /* MAX3421E USB Host controller configuration descriptor parser */
   
2. //#include "Spi.h"
   
3. #include "Max3421e.h"
   
4. #include "Usb.h"
   
5. #include "descriptor_parser.h"
   
6. 
   
7. #define LOBYTE(x) ((char*)(&(x)))[0]
   
8. #define HIBYTE(x) ((char*)(&(x)))[1]
   
9. #define BUFSIZE 256    //buffer size
   
10. #define DEVADDR 1
    
11. 
    
12. #define getReportDescr( addr, ep, nbytes, parse_func, nak_limit ) ctrlXfer( addr, ep, bmREQ_HIDREPORT, USB_REQUEST_GET_DESCRIPTOR, 0x00, HID_DESCRIPTOR_REPORT, 0x0000, nbytes, parse_func, nak_limit )
    
13. #define getReport( addr, ep, nbytes, interface, report_type, report_id, parse_func, nak_limit ) ctrlXfer( addr, ep, bmREQ_HIDIN, HID_REQUEST_GET_REPORT, report_id, report_type, interface, nbytes, parse_func, nak_limit )
    
14. 
    
15. /* Foeward declarations */
    
16. void setup();
    
17. void loop();
    
18. byte ctrlXfer( byte addr, byte ep, byte bmReqType, byte bRequest, byte wValLo, byte wValHi, unsigned int wInd, uint16_t nbytes, PARSE parse_func, uint16_t nak_limit );
    
19. void HIDreport_parse( uint8_t* buf, uint8_t* head, uint8_t* tail);
    
20. 
    
21. typedef struct {
    
22.   uint8_t bDescriptorType;
    
23.   uint16_t wDescriptorLength;
    
24. } HID_CLASS_DESCRIPTOR;
    
25. 
    
26. 
    
27. //typedef void (*PARSE)( int8_t*, int8_t*, int8_t );
    
28. 
    
29. MAX3421E Max;
    
30. USB Usb;
    
31. 
    
32. void setup()
    
33. {
    
34.   Serial.begin( 115200 );
    
35.   printProgStr(PSTR("\r\nStart"));
    
36.   Max.powerOn();
    
37.   delay( 200 );
    
38. }
    
39. 
    
40. void loop()
    
41. {
    
42.   uint8_t rcode;
    
43.   uint8_t tmpbyte = 0;
    
44. 
    
45.   //PARSE pf = &HIDreport_parse;
    
46.   /**/
    
47.   Max.Task();
    
48.   Usb.Task();
    
49.   if( Usb.getUsbTaskState() >= USB_STATE_CONFIGURING ) {  //state configuring or higher
    
50.   /* printing device descriptor */
    
51.     printProgStr(PSTR("\r\nDevice addressed... "));
    
52.     printProgStr(PSTR("Requesting device descriptor."));
    
53.     tmpbyte = getdevdescr( DEVADDR );                           //number of configurations, 0 if error   
    
54.     if( tmpbyte == 0 ) {
    
55.       printProgStr(PSTR("\r\nDevice descriptor cannot be retrieved. Program Halted\r\n"));
    
56.       while( 1 );           //stop
    
57.      }//if( tmpbyte
    
58.      /* print configuration descriptors for all configurations */
    
59.      for( uint8_t i = 0; i < tmpbyte; i++ ) {
    
60.        getconfdescr( DEVADDR, i );
    
61.      }   
    
62.   /* Stop */
    
63.       while( 1 );                          //stop
    
64.   }   
    
65. }
    
66. 
    
67. /* Prints device descriptor. Returns number of configurations or zero if request error occured */
    
68. byte getdevdescr( byte addr )
    
69. {
    
70.   USB_DEVICE_DESCRIPTOR buf;
    
71.   byte rcode;
    
72.   //Max.toggle( BPNT_0 );
    
73.   rcode = Usb.getDevDescr( addr, 0, 0x12, ( char *)&buf );
    
74.   if( rcode ) {
    
75.     printProgStr( rcode_error_msg );
    
76.     print_hex( rcode, 8 );
    
77.     return( 0 );
    
78.   }
    
79.   printProgStr(PSTR("\r\nDevice descriptor: \r\n"));
    
80.   //Descriptor length
    
81.   printProgStr( descr_len );
    
82.   print_hex( buf.bLength, 8 );
    
83.   //Descriptor type
    
84. //  printProgStr( descr_type );
    
85. //  print_hex( buf.bDescriptorType, 8 );
    
86. //  printProgStr( descrtype_parse( buf.bDescriptorType ));
    
87.   //USB Version
    
88.   printProgStr(PSTR("\r\nUSB version:\t\t"));
    
89.   Serial.print(( HIBYTE( buf.bcdUSB )), HEX );
    
90.   Serial.print(".");
    
91.   Serial.print(( LOBYTE( buf.bcdUSB )), HEX );
    
92.   //Device class
    
93.   printProgStr( class_str );
    
94.   print_hex( buf.bDeviceClass, 8 );
    
95.   printProgStr( classname_parse( buf.bDeviceClass ));
    
96.   //Device Subclass
    
97.   printProgStr( subclass_str );
    
98.   print_hex( buf.bDeviceSubClass, 8 );
    
99.   //Device Protocol
    
100.   printProgStr( protocol_str );
     
101.   print_hex( buf.bDeviceProtocol, 8 );
     
102.   //Max.packet size
     
103.   printProgStr( maxpktsize_str );
     
104.   print_hex( buf.bMaxPacketSize0, 8 );
     
105.   //VID
     
106.   printProgStr(PSTR("\r\nVendor  ID:\t\t"));
     
107.   print_hex( buf.idVendor, 16 );
     
108.   //PID
     
109.   printProgStr(PSTR("\r\nProduct ID:\t\t"));
     
110.   print_hex( buf.idProduct, 16 );
     
111.   //Revision
     
112.   printProgStr(PSTR("\r\nRevision ID:\t\t"));
     
113.   print_hex( buf.bcdDevice, 16 );
     
114.   //Mfg.string
     
115.   printProgStr (PSTR("\r\nMfg.string index:\t"));
     
116.   print_hex( buf.iManufacturer, 8 );
     
117.   getstrdescr( addr, buf.iManufacturer );
     
118.   //Prod.string
     
119.   printProgStr(PSTR("\r\nProd.string index:\t"));
     
120.   print_hex( buf.iProduct, 8 );
     
121.   //printProgStr( str_cont );
     
122.   getstrdescr( addr, buf.iProduct );
     
123.   //Serial number string
     
124.   printProgStr(PSTR("\r\nSerial number index:\t"));
     
125.   print_hex( buf.iSerialNumber, 8 );
     
126.   //printProgStr( str_cont );
     
127.   getstrdescr( addr, buf.iSerialNumber );
     
128.   //Number of configurations
     
129.   printProgStr(PSTR("\r\nNumber of conf.:\t"));
     
130.   print_hex( buf.bNumConfigurations, 8 );
     
131.   return( buf.bNumConfigurations );
     
132. }
     
133. /* Get string descriptor. Takes device address and string index */
     
134. byte getstrdescr( byte addr, byte idx )
     
135. {
     
136.   char buf[ BUFSIZE ];
     
137.   byte rcode;
     
138.   byte length;
     
139.   byte i;
     
140.   unsigned int langid;
     
141.   if( idx == 0 ) {  //don't try to get index zero
     
142.     return( 0 );
     
143.   }
     
144.   rcode = Usb.getStrDescr( addr, 0, 1, 0, 0, buf );  //get language table length
     
145.   if( rcode ) {
     
146.     printProgStr(PSTR("\r\nError retrieving LangID table length"));
     
147.     return( rcode );
     
148.   }
     
149.   length = buf[ 0 ];      //length is the first byte
     
150.   rcode = Usb.getStrDescr( addr, 0, length, 0, 0, buf );  //get language table
     
151.   if( rcode ) {
     
152.     printProgStr(PSTR("\r\nError retrieving LangID table"));
     
153.     return( rcode );
     
154.   }
     
155.   HIBYTE( langid ) = buf[ 3 ];                            //get first langid  
     
156.   LOBYTE( langid ) = buf[ 2 ];                            //bytes are swapped to account for endiannes
     
157.   //printProgStr(PSTR("\r\nLanguage ID: "));
     
158.   //print_hex( langid, 16 );
     
159.   rcode = Usb.getStrDescr( addr, 0, 1, idx, langid, buf );
     
160.   if( rcode ) {
     
161.     printProgStr(PSTR("\r\nError retrieving string length"));
     
162.     return( rcode );
     
163.   }
     
164.   length = ( buf[ 0 ] < 254 ? buf[ 0 ] : 254 );
     
165.   printProgStr(PSTR(" Length: "));
     
166.   Serial.print( length, DEC );
     
167.   rcode = Usb.getStrDescr( addr, 0, length, idx, langid, buf );
     
168.   if( rcode ) {
     
169.     printProgStr(PSTR("\r\nError retrieveing string"));
     
170.     return( rcode );
     
171.   }
     
172.   printProgStr(PSTR(" Contents: "));
     
173.   for( i = 2; i < length; i+=2 ) {
     
174.     Serial.print( buf[ i ] );
     
175.   }
     
176.   return( idx );
     
177. }
     
178. /* Returns string to class name */
     
179. const char* classname_parse( byte class_number )
     
180. {
     
181.   switch( class_number ) {
     
182.     case 0x00:
     
183.       return PSTR(" Use class information in the Interface Descriptor");
     
184.     case 0x01:
     
185.       return PSTR(" Audio");
     
186.     case 0x02:
     
187.       return PSTR(" Communications and CDC Control");
     
188.     case 0x03:
     
189.       return PSTR(" HID (Human Interface Device)");
     
190.     case 0x05:
     
191.       return PSTR(" Physical");
     
192.     case 0x06:
     
193.       return PSTR(" Image");
     
194.     case 0x07:
     
195.       return PSTR(" Printer");
     
196.     case 0x08:
     
197.       return PSTR(" Mass Storage");
     
198.     case 0x09:
     
199.       return PSTR(" Hub");
     
200.     case 0x0a:
     
201.       return PSTR(" CDC-Data");
     
202.     case 0x0b:
     
203.       return PSTR(" Smart Card");
     
204.     case 0x0d:
     
205.       return PSTR(" Content Security");
     
206.     case 0x0e:
     
207.       return PSTR(" Video");
     
208.     case 0x0f:
     
209.       return PSTR(" Personal Healthcare");
     
210.     case 0xdc:
     
211.       return PSTR("Diagnostic Device");
     
212.     case 0xe0:
     
213.       return PSTR(" Wireless Controller");
     
214.     case 0xef:
     
215.       return PSTR(" Miscellaneous");
     
216.     case 0xfe:
     
217.       return PSTR(" Application Specific");
     
218.     case 0xff:
     
219.       return PSTR(" Vendor Specific");
     
220.     default:
     
221.       return unk_msg;
     
222.   }//switch( class_number
     
223. }            
     
224. /* Getting configuration descriptor */
     
225. byte getconfdescr( byte addr, byte conf )
     
226. {
     
227.   char buf[ BUFSIZE ];
     
228.   char* buf_ptr = buf;
     
229.   byte rcode;
     
230.   byte descr_length;
     
231.   byte descr_type;
     
232.   unsigned int total_length;
     
233.   printProgStr(PSTR("\r\n\nConfiguration number "));
     
234.   Serial.print( conf, HEX );
     
235.   rcode = Usb.getConfDescr( addr, 0, 4, conf, buf );  //get total length
     
236.   if( rcode ) {
     
237.     printProgStr(PSTR("Error retrieving configuration length. Error code "));
     
238.     Serial.println( rcode, HEX );
     
239.     return( 0 );
     
240.   }//if( rcode
     
241.   LOBYTE( total_length ) = buf[ 2 ];
     
242.   HIBYTE( total_length ) = buf[ 3 ];
     
243.   printProgStr(PSTR("\r\nTotal configuration length: "));
     
244.   Serial.print( total_length, DEC );
     
245.   printProgStr(PSTR(" bytes"));
     
246.   if( total_length > BUFSIZE ) {    //check if total length is larger than buffer
     
247.     printProgStr(PSTR("Total length truncated to "));
     
248.     Serial.print( BUFSIZE, DEC);
     
249.     printProgStr(PSTR("bytes"));
     
250.     total_length = BUFSIZE;
     
251.   }
     
252.   rcode = Usb.getConfDescr( addr, 0, total_length, conf, buf ); //get the whole descriptor
     
253.   while( buf_ptr < buf + total_length ) {  //parsing descriptors
     
254.     descr_length = *( buf_ptr );
     
255.     descr_type = *( buf_ptr + 1 );
     
256.     switch( descr_type ) {
     
257.       case( USB_DESCRIPTOR_CONFIGURATION ):
     
258.         printconfdescr( buf_ptr );
     
259.         break;
     
260.       case( USB_DESCRIPTOR_INTERFACE ):
     
261.         printintfdescr( buf_ptr );
     
262.         break;
     
263.       case( USB_DESCRIPTOR_ENDPOINT ):
     
264.         printepdescr( buf_ptr );
     
265.         break;
     
266.       case( HID_DESCRIPTOR_HID ):
     
267.         printhid_descr( buf_ptr );
     
268.         break;
     
269.       default:
     
270.         printunkdescr( buf_ptr );
     
271.         break;
     
272.         }//switch( descr_type
     
273.     Serial.println("");   
     
274.     buf_ptr = ( buf_ptr + descr_length );    //advance buffer pointer
     
275.   }//while( buf_ptr <=...
     
276.   return( 0 );
     
277. }
     
278. /* function to print configuration descriptor */
     
279. void printconfdescr( char* descr_ptr )
     
280. {
     
281. USB_CONFIGURATION_DESCRIPTOR* conf_ptr = ( USB_CONFIGURATION_DESCRIPTOR* )descr_ptr;
     
282. uint8_t tmpbyte;
     
283.   printProgStr(PSTR("\r\n\nConfiguration descriptor:"));
     
284.   printProgStr(PSTR("\r\nTotal length:\t\t"));
     
285.   print_hex( conf_ptr->wTotalLength, 16 );
     
286.   printProgStr(PSTR("\r\nNumber of interfaces:\t"));
     
287.   print_hex( conf_ptr->bNumInterfaces, 8 );
     
288.   printProgStr(PSTR("\r\nConfiguration value:\t"));
     
289.   print_hex( conf_ptr->bConfigurationValue, 8 );
     
290.   printProgStr(PSTR("\r\nConfiguration string:\t"));
     
291.   tmpbyte = conf_ptr->iConfiguration;
     
292.   print_hex( tmpbyte, 8 );
     
293.   getstrdescr( DEVADDR, tmpbyte );
     
294.   printProgStr(PSTR("\r\nAttributes:\t\t"));
     
295.   tmpbyte = conf_ptr->bmAttributes;
     
296.   print_hex( tmpbyte, 8 );
     
297.   if( tmpbyte & 0x40 ) {  //D6
     
298.     printProgStr(PSTR(" Self-powered"));
     
299.   }
     
300.   if( tmpbyte & 0x20 ) { //D5
     
301.     printProgStr(PSTR(" Remote Wakeup"));
     
302.   }
     
303.   printProgStr(PSTR("\r\nMax.power:\t\t"));
     
304.   tmpbyte = conf_ptr->bMaxPower;
     
305.   print_hex( tmpbyte, 8 );
     
306.   printProgStr(PSTR(" "));
     
307.   Serial.print(( tmpbyte * 2 ), DEC);
     
308.   printProgStr(PSTR("ma"));
     
309.   return;
     
310. }
     
311. /* function to print interface descriptor */
     
312. void printintfdescr( char* descr_ptr )
     
313. {
     
314. USB_INTERFACE_DESCRIPTOR* intf_ptr = ( USB_INTERFACE_DESCRIPTOR* )descr_ptr;
     
315. uint8_t tmpbyte;
     
316.   printProgStr(PSTR("\r\nInterface descriptor:"));
     
317.   printProgStr(PSTR("\r\nInterface number:\t"));
     
318.   print_hex( intf_ptr->bInterfaceNumber, 8 );
     
319.   printProgStr(PSTR("\r\nAlternate setting:\t"));
     
320.   print_hex( intf_ptr->bAlternateSetting, 8 );
     
321.   printProgStr(PSTR("\r\nEndpoints:\t\t"));
     
322.   print_hex( intf_ptr->bNumEndpoints, 8 );
     
323.   printProgStr( class_str );
     
324.   tmpbyte = intf_ptr->bInterfaceClass;
     
325.   print_hex( tmpbyte, 8 );
     
326.   printProgStr(classname_parse( tmpbyte ));
     
327.   printProgStr( subclass_str );
     
328.   print_hex( intf_ptr->bInterfaceSubClass, 8 );
     
329.   printProgStr( protocol_str );
     
330.   print_hex( intf_ptr->bInterfaceProtocol, 8 );
     
331.   printProgStr(PSTR("\r\nInterface string:\t"));
     
332.   tmpbyte = intf_ptr->iInterface;
     
333.   print_hex( tmpbyte, 8 );
     
334.   getstrdescr( DEVADDR, tmpbyte );
     
335.   return;
     
336. }
     
337. /* function to print endpoint descriptor */
     
338. void printepdescr( char* descr_ptr )
     
339. {
     
340. USB_ENDPOINT_DESCRIPTOR* ep_ptr = ( USB_ENDPOINT_DESCRIPTOR* )descr_ptr;
     
341. uint8_t tmpbyte;
     
342.   printProgStr(PSTR("\r\nEndpoint descriptor:"));
     
343.   printProgStr(PSTR("\r\nEndpoint address:\t"));
     
344.   tmpbyte = ep_ptr->bEndpointAddress;
     
345.   print_hex( tmpbyte & 0x0f, 8 );
     
346.   printProgStr(PSTR(" Direction: "));
     
347.   ( tmpbyte & 0x80 ) ? printProgStr(PSTR("IN")) : printProgStr(PSTR("OUT"));
     
348.   printProgStr(PSTR("\r\nAttributes:\t\t"));
     
349.   tmpbyte = ep_ptr->bmAttributes;
     
350.   print_hex( tmpbyte, 8 );
     
351.   printProgStr(PSTR(" Transfer type: "));
     
352.   printProgStr((char*)pgm_read_word(&transfer_types[(tmpbyte & 0x03)]));
     
353.   if(( tmpbyte & 0x03 ) == 1 ) {  //Isochronous Transfer
     
354.     printProgStr(PSTR(", Sync Type: "));
     
355.     printProgStr((char*)pgm_read_word(&sync_types[(tmpbyte & 0x0c)]));
     
356.     printProgStr(PSTR(", Usage Type: "));
     
357.     printProgStr((char*)pgm_read_word(&usage_types[(tmpbyte & 0x30)]));
     
358.   }//if( tmpbyte & 0x01
     
359.   printProgStr( maxpktsize_str );
     
360.   print_hex( ep_ptr->wMaxPacketSize, 16 );
     
361.   printProgStr(PSTR("\r\nPolling interval:\t"));
     
362.   tmpbyte = ep_ptr->bInterval;
     
363.   print_hex( tmpbyte, 8 );
     
364.   printProgStr(PSTR(" "));
     
365.   Serial.print( tmpbyte, DEC );
     
366.   printProgStr(PSTR(" ms"));
     
367.   return;
     
368. }
     
369. /* function to print HID descriptor */
     
370. void printhid_descr( char* descr_ptr )
     
371. {
     
372. PARSE pf = &HIDreport_parse;
     
373. USB_HID_DESCRIPTOR* hid_ptr = ( USB_HID_DESCRIPTOR* )descr_ptr;
     
374. uint8_t tmpbyte;
     
375.   /**/
     
376.   printProgStr(PSTR("\r\nHID descriptor:"));
     
377.   printProgStr(PSTR("\r\nDescriptor length:\t"));
     
378.   tmpbyte = hid_ptr->bLength;
     
379.   print_hex( tmpbyte, 8 );
     
380.   printProgStr(PSTR(" "));
     
381.   Serial.print( tmpbyte, DEC );
     
382.   printProgStr(PSTR(" bytes"));
     
383.   printProgStr(PSTR("\r\nHID version:\t\t"));
     
384.   Serial.print(( HIBYTE( hid_ptr->bcdHID )), HEX );
     
385.   Serial.print(".");
     
386.   Serial.print(( LOBYTE( hid_ptr->bcdHID )), HEX );
     
387.   tmpbyte = hid_ptr->bCountryCode;
     
388.   printProgStr(PSTR("\r\nCountry Code:\t\t"));
     
389.   Serial.print( tmpbyte, DEC );
     
390.   printProgStr(PSTR(" "));
     
391.   ( tmpbyte > 35 ) ? printProgStr(PSTR("Reserved")) : printProgStr((char*)pgm_read_word(&HID_Country_Codes[ tmpbyte ]));
     
392.   tmpbyte = hid_ptr->bNumDescriptors;
     
393.   printProgStr(PSTR("\r\nClass Descriptors:\t"));
     
394.   Serial.print( tmpbyte, DEC );
     
395.   //Printing class descriptors
     
396.   descr_ptr += 6; //advance buffer pointer
     
397.   for( uint8_t i = 0; i < tmpbyte; i++ ) {
     
398.     uint8_t tmpdata;
     
399.     HID_CLASS_DESCRIPTOR* hidclass_ptr = ( HID_CLASS_DESCRIPTOR* )descr_ptr;
     
400.     tmpdata = hidclass_ptr->bDescriptorType;
     
401.     printProgStr(PSTR("\r\nClass Descriptor Type:\t"));
     
402.     Serial.print( tmpdata, HEX );
     
403.     if(( tmpdata < 0x21 ) || ( tmpdata > 0x2f )) {
     
404.      printProgStr(PSTR(" Invalid"));
     
405.     }
     
406.     switch( tmpdata ) {
     
407.       case 0x21:
     
408.         printProgStr(PSTR(" HID"));
     
409.         break;
     
410.       case 0x22:
     
411.         printProgStr(PSTR(" Report"));
     
412.         break;
     
413.       case 0x23:
     
414.         printProgStr(PSTR(" Physical"));
     
415.         break;
     
416.       default:
     
417.         printProgStr(PSTR(" Reserved"));
     
418.         break;
     
419.     }//switch( tmpdata
     
420.     printProgStr(PSTR("\r\nClass Descriptor Length:"));
     
421.     Serial.print( hidclass_ptr->wDescriptorLength );
     
422.     printProgStr(PSTR(" bytes"));
     
423.     printProgStr(PSTR("\r\n\nHID report descriptor:\r\n"));
     
424.     getReportDescr( DEVADDR, 0 , hidclass_ptr->wDescriptorLength, pf, USB_NAK_LIMIT );
     
425.     descr_ptr += 3; //advance to the next record
     
426.   }//for( uint8_t i=...
     
427.   return;
     
428. }
     
429. /*function to print unknown descriptor */
     
430. void printunkdescr( char* descr_ptr )
     
431. {
     
432.   byte length = *descr_ptr;
     
433.   byte i;
     
434.   printProgStr(PSTR("\r\nUnknown descriptor:"));
     
435.   printProgStr(PSTR("Length:\t\t"));
     
436.   print_hex( *descr_ptr, 8 );
     
437.   printProgStr(PSTR("\r\nType:\t\t"));
     
438.   print_hex( *(descr_ptr + 1 ), 8 );
     
439.   printProgStr(PSTR("\r\nContents:\t"));
     
440.   descr_ptr += 2;
     
441.   for( i = 0; i < length; i++ ) {
     
442.     print_hex( *descr_ptr, 8 );
     
443.     descr_ptr++;
     
444.   }
     
445. }
     
446. /* Control-IN transfer with callback. Sets address, endpoint, fills control packet with necessary data, dispatches control packet, and initiates bulk IN transfer   */
     
447. /* Control, data, and setup stages combined from standard USB library to be able to read large data blocks. Restricted to control-IN transfers with data stage   */
     
448. /* data read and MAX3421E RECV FIFO buffer release shall be performed by parse_func callback */
     
449. /* return codes:                */
     
450. /* 00       =   success         */
     
451. /* 01-0f    =   non-zero HRSLT  */
     
452. byte ctrlXfer( byte addr, byte ep, byte bmReqType, byte bRequest, byte wValLo, byte wValHi, unsigned int wInd, uint16_t nbytes, PARSE parse_func, uint16_t nak_limit = USB_NAK_LIMIT )
     
453. {
     
454. byte rcode;   
     
455. SETUP_PKT sp;
     
456. EP_RECORD* ep_rec = Usb.getDevTableEntry( addr, ep );
     
457. byte pktsize;
     
458. byte maxpktsize = ep_rec->MaxPktSize;
     
459. unsigned int xfrlen = 0;
     
460.   /**/
     
461.   Max.regWr( rPERADDR, addr );                    //set peripheral address
     
462.   /* fill in setup packet */
     
463.   sp.ReqType_u.bmRequestType = bmReqType;
     
464.   sp.bRequest = bRequest;
     
465.   sp.wVal_u.wValueLo = wValLo;
     
466.   sp.wVal_u.wValueHi = wValHi;
     
467.   sp.wIndex = wInd;
     
468.   sp.wLength = nbytes;
     
469.   Max.bytesWr( rSUDFIFO, 8, ( char *)&sp );    //transfer to setup packet FIFO
     
470.   rcode = Usb.dispatchPkt( tokSETUP, ep, nak_limit );            //dispatch packet
     
471.   //Serial.println("Setup packet");   //DEBUG
     
472.   if( rcode ) {                                   //return HRSLT if not zero
     
473.       printProgStr(PSTR("\r\nSetup packet error: "));
     
474.       Serial.print( rcode, HEX );                                          
     
475.       return( rcode );
     
476.   }
     
477.   /* Data stage */
     
478.   //ep_rec->rcvToggle = bmRCVTOG1;
     
479.   Max.regWr( rHCTL, bmRCVTOG1 );  //set toggle
     
480.   while( 1 ) {                    //exited by break
     
481.     /* request data */
     
482.     rcode = Usb.dispatchPkt( tokIN, ep, nak_limit );
     
483.     if( rcode ) {
     
484.       printProgStr(PSTR("\r\nData Stage Error: "));
     
485.       Serial.print( rcode, HEX );
     
486.       return( rcode );
     
487.     }
     
488.     /* check for RCVDAVIRQ and generate error if not present */
     
489.     /* the only case when absense of RCVDAVIRQ makes sense is when toggle error occured. Need to add handling for that */
     
490.     if(( Max.regRd( rHIRQ ) & bmRCVDAVIRQ ) == 0 ) {
     
491.       printProgStr(PSTR("\r\nData Toggle error."));
     
492.       return ( 0xf0 );                           
     
493.     }   
     
494.     pktsize = Max.regRd( rRCVBC );  //get received bytes count
     
495.     parse_func( pktsize );          //call parse function. Parse is expected to read the FIFO completely
     
496.     Max.regWr( rHIRQ, bmRCVDAVIRQ );                    // Clear the IRQ & free the buffer
     
497.     xfrlen += pktsize;                              // add this packet's byte count to total transfer length
     
498.     /* The transfer is complete under two conditions:           */
     
499.     /* 1. The device sent a short packet (L.T. maxPacketSize)   */
     
500.     /* 2. 'nbytes' have been transferred.                       */
     
501.     if (( pktsize < maxpktsize ) || (xfrlen >= nbytes )) {      // have we transferred 'nbytes' bytes?
     
502.       break;
     
503.     }
     
504.   }//while( 1 )
     
505.   rcode = Usb.dispatchPkt( tokOUTHS, ep, nak_limit );
     
506.   if( rcode ) {   //return error
     
507.     printProgStr(PSTR("Status packet error: "));
     
508.     Serial.print( rcode, HEX );                                          
     
509.   }
     
510.   return( rcode );
     
511. }
     
512. /* Parses bitfields in main items */
     
513. void print_mainbitfield( uint8_t byte_toparse )
     
514. {
     
515.   ( byte_toparse & 0x01 ) ? printProgStr(PSTR("Constant,")) : printProgStr(PSTR("Data,"));  //bit 0
     
516.   ( byte_toparse & 0x02 ) ? printProgStr(PSTR("Variable,")) : printProgStr(PSTR("Array,"));  //bit 1
     
517.   ( byte_toparse & 0x04 ) ? printProgStr(PSTR("Relative,")) : printProgStr(PSTR("Absolute,"));  //...
     
518.   ( byte_toparse & 0x08 ) ? printProgStr(PSTR("Wrap,")) : printProgStr(PSTR("No Wrap,"));
     
519.   ( byte_toparse & 0x10 ) ? printProgStr(PSTR("Non Linear,")) : printProgStr(PSTR("Linear,"));
     
520.   ( byte_toparse & 0x20 ) ? printProgStr(PSTR("No preferred,")) : printProgStr(PSTR("Preferred State,"));
     
521.   ( byte_toparse & 0x40 ) ? printProgStr(PSTR("Null State,")) : printProgStr(PSTR("No Null Position,"));  //bit 6
     
522.   ( byte_toparse & 0x40 ) ? printProgStr(PSTR("Volatile( ignore for Input),")) : printProgStr(PSTR("Non-volatile(Ignore for Input),"));  //bit 7
     
523. }
     
524. /* HID Report Desriptor Parser Callback             */
     
525. /* called repeatedly from Control transfer function */
     
526. void HIDreport_parse( uint8_t pkt_size )
     
527. {
     
528. #define B_SIZE 0x03        //bSize bitmask
     
529. #define B_TYPE 0x0c        //bType bitmask
     
530. #define B_TAG  0xf0        //bTag bitmask
     
531. /* parser states */
     
532. enum STATE { ITEM_START, DATA_PARSE };
     
533. static STATE state = ITEM_START;
     
534. static uint8_t databytes_left = 0;
     
535. static uint8_t prefix;              //item prefix - type and tag
     
536. uint8_t byte_toparse;
     
537. uint8_t bType;
     
538. uint8_t tmpbyte;
     
539. /**/
     
540.   while( 1 ) {
     
541.      if( pkt_size ) {
     
542.        byte_toparse = Max.regRd( rRCVFIFO );  //read a byte from FIFO
     
543.        pkt_size--;
     
544.      }
     
545.      else {
     
546.        return;                                //all bytes read
     
547.      }
     
548.      switch( state ) {
     
549.       case ITEM_START:  //start of the record
     
550.         prefix = byte_toparse >>2;        //store prefix for databyte parsing
     
551.         tmpbyte = byte_toparse & B_SIZE;
     
552.         /* get item length */
     
553.         ( tmpbyte == 0x03 ) ? databytes_left = 4 : databytes_left = tmpbyte;
     
554.          if( databytes_left ) {
     
555.            state = DATA_PARSE;    //read bytes after prefix
     
556.          }
     
557.          printProgStr(PSTR("\r\nLength: "));
     
558.          Serial.print( databytes_left, DEC );
     
559.          /* get item type */
     
560.          bType = ( byte_toparse & B_TYPE ) >>2;
     
561.          printProgStr(PSTR("  Type: "));
     
562.          printProgStr((char*)pgm_read_word(&btypes[ bType ]));
     
563.          /* get item tag */
     
564.          printProgStr(PSTR("\t\tTag: "));
     
565.          tmpbyte = ( byte_toparse & B_TAG ) >>4 ;
     
566.          switch( bType ) {
     
567.            case 0:  //Main
     
568.              if( tmpbyte < 0x08 ) {
     
569.                printProgStr(PSTR("Invalid Tag"));
     
570.              }
     
571.              else if( tmpbyte > 0x0c ) {
     
572.                printProgStr( reserved_msg );
     
573.              }
     
574.              else {
     
575.                printProgStr((char*)pgm_read_word(&maintags[ tmpbyte - 8 /* & 0x03 */]));
     
576.                //Serial.print("Byte: ");
     
577.                //Serial.println( tmpbyte, HEX );
     
578.              }
     
579.              break;//case 0 Main
     
580.            case 1:  //Global
     
581.              ( tmpbyte > 0x0b ) ? printProgStr( reserved_msg ) : printProgStr((char*)pgm_read_word(&globaltags[ tmpbyte ]));
     
582.              break;//case 1 Global
     
583.            case 2:  //Local
     
584.              ( tmpbyte > 0x0a ) ? printProgStr( reserved_msg ) : printProgStr((char*)pgm_read_word(&localtags[ tmpbyte ]));
     
585.              break;//case 2 Local
     
586.            default:
     
587.              break;  
     
588.          }//switch( bType...        
     
589.          break;//case ITEM_START
     
590.        case DATA_PARSE:
     
591.          switch( prefix ) {
     
592.            case 0x20:  //Main Input
     
593.            case 0x24:  //Main Output
     
594.            case 0x2c:  //Main Feature
     
595.              /* todo: add parsing 8th bit */
     
596.              print_mainbitfield( byte_toparse );
     
597.              break;
     
598.            case 0x28:    //Main Collection
     
599.              if(( byte_toparse > 0x06 ) && ( byte_toparse < 0x80 )) {
     
600.                printProgStr( reserved_msg );
     
601.              }
     
602.              else if(( byte_toparse > 0x7f ) && ( byte_toparse <= 0xff )) {
     
603.                printProgStr(PSTR("Vendor-defined"));
     
604.              }
     
605.              else {
     
606.                printProgStr((char*)pgm_read_word(&collections[ byte_toparse ]));
     
607.              }
     
608.              break;//case 0x28 Main Collection           
     
609.            //case 0x30: //Main End Collection
     
610.            case 0x01:    //Global Usage Page
     
611.              switch( byte_toparse ) {  //see HID Usage Tables doc v.1.12 page 14
     
612.                case 0x00:              
     
613.                case 0x01:
     
614.                case 0x02:
     
615.                case 0x03:
     
616.                case 0x04:
     
617.                case 0x05:
     
618.                case 0x06:
     
619.                case 0x07:
     
620.                case 0x08:
     
621.                case 0x09:
     
622.                case 0x0a:
     
623.                case 0x0b:
     
624.                case 0x0c:
     
625.                case 0x0d:
     
626.                case 0x0e:
     
627.                case 0x0f:
     
628.                case 0x10:
     
629.                  printProgStr((char*)pgm_read_word(&usage_pages[ byte_toparse ]));
     
630.                  break;
     
631.                case 0x14:
     
632.                  printProgStr(PSTR("Alphanumeric Display"));
     
633.                  break;
     
634.                case 0x40:
     
635.                  printProgStr(PSTR("Medical Instruments"));
     
636.                  break;
     
637.                case 0x80:
     
638.                case 0x81:
     
639.                case 0x82:
     
640.                case 0x83:
     
641.                  printProgStr(PSTR("Monitor page"));
     
642.                  break;
     
643.                case 0x84:
     
644.                case 0x85:
     
645.                case 0x86:
     
646.                case 0x87:
     
647.                  printProgStr(PSTR("Power page"));
     
648.                  break;
     
649.                case 0x8c:
     
650.                  printProgStr(PSTR("Bar Code Scanner page"));
     
651.                  break;
     
652.                case 0x8d:
     
653.                  printProgStr(PSTR("Scale page"));
     
654.                  break;
     
655.                case 0x8e:
     
656.                  printProgStr(PSTR("Magnetic Stripe Reading (MSR) Devices"));
     
657.                  break;
     
658.                case 0x8f:
     
659.                  printProgStr(PSTR("Reserved Point of Sale pages"));
     
660.                  break;
     
661.                case 0x90:
     
662.                  printProgStr(PSTR("Camera Control Page"));
     
663.                  break;
     
664.                case 0x91:
     
665.                  printProgStr(PSTR("Arcade Page"));
     
666.                  break;               
     
667.              default:
     
668. //               printProgStr(PSTR("Data: "));
     
669. //               print_hex( byte_toparse, 8 );
     
670.                //databytes_left--;
     
671.                break;           
     
672.              }//switch case 0x01:    //Global Usage Page
     
673.          }//switch( prefix ...         
     
674.          printProgStr(PSTR("  Data: "));
     
675.          print_hex( byte_toparse, 8 );
     
676.          databytes_left--;
     
677.          if( !databytes_left ) {
     
678.            state = ITEM_START;
     
679.          }
     
680.          break;
     
681.      }//switch( state...
     
682.    }//while( 1 ...
     
683. }
     
684. /* prints hex numbers with leading zeroes */
     
685. // copyright, Peter H Anderson, Baltimore, MD, Nov, '07
     
686. // source: [url]http://www.phanderson.com/arduino/arduino_display.html[/url]
     
687. void print_hex(int v, int num_places)
     
688. {
     
689.   int mask=0, n, num_nibbles, digit;
     
690. 
     
691.   for (n=1; n<=num_places; n++) {
     
692.     mask = (mask << 1) | 0x0001;
     
693.   }
     
694.   v = v & mask; // truncate v to specified number of places
     
695. 
     
696.   num_nibbles = num_places / 4;
     
697.   if ((num_places % 4) != 0) {
     
698.     ++num_nibbles;
     
699.   }
     
700.   do {
     
701.     digit = ((v >> (num_nibbles-1) * 4)) & 0x0f;
     
702.     Serial.print(digit, HEX);
     
703.   }
     
704.   while(--num_nibbles);
     
705. }
     
706. 
     
707. /* given a PROGMEM string, use Serial.print() to send it out       */
     
708. /* Some non-intuitive casting necessary:                           */
     
709. /* printProgStr(PSTR("Func.Mode:\t0x"));                           */
     
710. /* printProgStr((char*)pgm_read_word(&mtpopNames[(op & 0xFF)]));   */
     
711. void printProgStr(const char* str)
     
712. {
     
713.   if(!str) {
     
714.     return;
     
715.   }
     
716.   char c;
     
717.   while((c = pgm_read_byte(str++))) {
     
718.     Serial.write(c);
     
719.   }
     
720.   return;
     
721. }
     

复制代码

工作的照片：

我用USB Shield挂接了一个USB小键盘，获得的结果如下：

Start
Device addressed... Requesting device descriptor.
Device descriptor:

Descriptor Length:        12
USB version:        1.10
Class:        00 Use class information in the Interface Descriptor
Subclass:        00
Protocol:        00
Max.packet size:        08
Vendor ID:        13BA
Product ID:        0001
Revision ID:        0100
Mfg.string index:        00
Prod.string index:        00
Serial number index:        00
Number of conf.:        01

Configuration number 0
Total configuration length: 34 bytes

Configuration descriptor:
Total length:        0022
Number of interfaces:        01
Configuration value:        01
Configuration string:        00
Attributes:        A0 Remote Wakeup
Max.power:        32 100ma

Interface descriptor:
Interface number:        00
Alternate setting:        00
Endpoints:        01
Class:        03 HID (Human Interface Device)
Subclass:        01
Protocol:        01
Interface string:        00

HID descriptor:
Descriptor length:        09 9 bytes
HID version:        1.10
Country Code:        0 Not Supported
Class Descriptors:        1
Class Descriptor Type:        22 Report
Class Descriptor Length:54 bytes

HID report descriptor:

Length: 1 Type: Global        Tag: Usage Page        Generic Desktop Controls Data: 01
Length: 1 Type: Local        Tag: Usage        Data: 06
Length: 1 Type: Main        Tag: Collection        Application (mouse, keyboard) Data: 01
Length: 1 Type: Global        Tag: Usage Page        LEDs Data: 08
Length: 1 Type: Local        Tag: Usage Minimum        Data: 01
Length: 1 Type: Local        Tag: Usage Maximum        Data: 03
Length: 1 Type: Global        Tag: Logical Minimum        Data: 00
Length: 1 Type: Global        Tag: Logical Maximum        Data: 01
Length: 1 Type: Global        Tag: Report Size        Data: 01
Length: 1 Type: Global        Tag: Report Count        Data: 03
Length: 1 Type: Main        Tag: Output        Data,Variable,Absolute,No Wrap,Linear,Preferred State,No Null Position,Non-volatile(Ignore for Input), Data: 02
Length: 1 Type: Global        Tag: Report Count        Data: 05
Length: 1 Type: Main        Tag: Output        Constant,Array,Absolute,No Wrap,Linear,Preferred State,No Null Position,Non-volatile(Ignore for Input), Data: 01
Length: 1 Type: Global        Tag: Usage Page        Keyboard/Keypad Data: 07
Length: 1 Type: Local        Tag: Usage Minimum        Data: E0
Length: 1 Type: Local        Tag: Usage Maximum        Data: E7
Length: 1 Type: Global        Tag: Report Count        Data: 08
Length: 1 Type: Main        Tag: Input        Data,Variable,Absolute,No Wrap,Linear,Preferred State,No Null Position,Non-volatile(Ignore for Input), Data: 02
Length: 1 Type: Global        Tag: Report Size        Data: 08
Length: 1 Type: Global        Tag: Report Count        Data: 01
Length: 1 Type: Main        Tag: Input        Constant,Array,Absolute,No Wrap,Linear,Preferred State,No Null Position,Non-volatile(Ignore for Input), Data: 01
Length: 1 Type: Local        Tag: Usage Minimum        Data: 00
Length: 1 Type: Local        Tag: Usage Maximum        Data: 91
Length: 2 Type: Global        Tag: Logical Maximum        Data: FF Data: 00
Length: 1 Type: Global        Tag: Report Count        Data: 06
Length: 1 Type: Main        Tag: Input        Data,Array,Absolute,No Wrap,Linear,Preferred State,No Null Position,Non-volatile(Ignore for Input), Data: 00
Length: 0 Type: Main        Tag: End Collection

Endpoint descriptor:
Endpoint address:        01 Direction: IN
Attributes:        03 Transfer type: Interrupt
Max.packet size:        0008
Polling interval:        0A 10 ms

修改后的可以正常编译的代码下载



参考：

1. https://github.com/felis/USB_Hos ... s/descriptor_parser USB_Host_Shield/examples/descriptor_parser/

zjhyhky

很厉害啊，看起来很麻烦！

wetnt

精华啊，正在找这个呢！