Arduino 控制USB设备（5）解析USB键盘的例子-

zoologist

下面是一个获得 USB 键盘数据的例子【参考1】。原理上说，是将键盘切换为 Boot Protocol 这样就避免了需要具体解析HID的麻烦。

1. /* MAX3421E USB Host controller LCD/keyboard demonstration */
   
2. //#include <Spi.h>
   
3. #include "Max3421e.h"
   
4. #include "Usb.h"
   
5. 
   
6. /* keyboard data taken from configuration descriptor */
   
7. #define KBD_ADDR        1
   
8. #define KBD_EP          1
   
9. #define KBD_IF          0
   
10. #define EP_MAXPKTSIZE   8
    
11. #define EP_POLL         0x0a
    
12. /**/
    
13. //******************************************************************************
    
14. //  macros to identify special charaters(other than Digits and Alphabets)
    
15. //******************************************************************************
    
16. #define BANG        (0x1E)
    
17. #define AT          (0x1F)
    
18. #define POUND       (0x20)
    
19. #define DOLLAR      (0x21)
    
20. #define PERCENT     (0x22)
    
21. #define CAP         (0x23)
    
22. #define AND         (0x24)
    
23. #define STAR        (0x25)
    
24. #define OPENBKT     (0x26)
    
25. #define CLOSEBKT    (0x27)
    
26. 
    
27. #define RETURN      (0x28)
    
28. #define ESCAPE      (0x29)
    
29. #define BACKSPACE   (0x2A)
    
30. #define TAB         (0x2B)
    
31. #define SPACE       (0x2C)
    
32. #define HYPHEN      (0x2D)
    
33. #define EQUAL       (0x2E)
    
34. #define SQBKTOPEN   (0x2F)
    
35. #define SQBKTCLOSE  (0x30)
    
36. #define BACKSLASH   (0x31)
    
37. #define SEMICOLON   (0x33)
    
38. #define INVCOMMA    (0x34)
    
39. #define TILDE       (0x35)
    
40. #define COMMA       (0x36)
    
41. #define PERIOD      (0x37)
    
42. #define FRONTSLASH  (0x38)
    
43. #define DELETE      (0x4c)
    
44. /**/
    
45. /* Modifier masks. One for both modifiers */
    
46. #define SHIFT       0x22
    
47. #define CTRL        0x11
    
48. #define ALT         0x44
    
49. #define GUI         0x88
    
50. /**/
    
51. /* "Sticky keys */
    
52. #define CAPSLOCK    (0x39)
    
53. #define NUMLOCK     (0x53)
    
54. #define SCROLLLOCK  (0x47)
    
55. /* Sticky keys output report bitmasks */
    
56. #define bmNUMLOCK       0x01
    
57. #define bmCAPSLOCK      0x02
    
58. #define bmSCROLLLOCK    0x04
    
59. /**/
    
60. EP_RECORD ep_record[ 2 ];  //endpoint record structure for the keyboard
    
61. 
    
62. char buf[ 8 ] = { 0 };      //keyboard buffer
    
63. char old_buf[ 8 ] = { 0 };  //last poll
    
64. /* Sticky key state */
    
65. bool numLock = false;
    
66. bool capsLock = false;
    
67. bool scrollLock = false;
    
68. bool line = false;
    
69. 
    
70. void setup();
    
71. void loop();
    
72. 
    
73. MAX3421E Max;
    
74. USB Usb;
    
75. 
    
76. void setup() {
    
77.   Serial.begin( 9600 );
    
78.   Serial.println("Start");
    
79.   Max.powerOn();
    
80.   delay( 200 );
    
81. }
    
82. 
    
83. void loop() {
    
84.     Max.Task();
    
85.     Usb.Task();
    
86.     if( Usb.getUsbTaskState() == USB_STATE_CONFIGURING ) {
    
87. //wait for addressing state
    
88.         kbd_init();
    
89.         Usb.setUsbTaskState( USB_STATE_RUNNING );
    
90.     }
    
91.     if( Usb.getUsbTaskState() == USB_STATE_RUNNING ) {  
    
92. //poll the keyboard  
    
93.         kbd_poll();
    
94.     }
    
95. }
    
96. /* Initialize keyboard */
    
97. void kbd_init( void )
    
98. {
    
99. byte rcode = 0;  //return code
    
100. /**/
     
101.     /* Initialize data structures */
     
102.     ep_record[ 0 ] = *( Usb.getDevTableEntry( 0,0 ));  
     
103.                            //copy endpoint 0 parameters
     
104.     ep_record[ 1 ].MaxPktSize = EP_MAXPKTSIZE;
     
105.     ep_record[ 1 ].Interval  = EP_POLL;
     
106.     ep_record[ 1 ].sndToggle = bmSNDTOG0;
     
107.     ep_record[ 1 ].rcvToggle = bmRCVTOG0;
     
108.     Usb.setDevTableEntry( 1, ep_record );              
     
109.                            //plug kbd.endpoint parameters to devtable
     
110.     /* Configure device */
     
111.     rcode = Usb.setConf( KBD_ADDR, 0, 1 );                    
     
112.     if( rcode ) {
     
113.         Serial.print("Error attempting to configure keyboard. Return code :");
     
114.         Serial.println( rcode, HEX );
     
115.         while(1);  //stop
     
116.     }
     
117.     /* Set boot protocol */
     
118.     rcode = Usb.setProto( KBD_ADDR, 0, 0, 0 );
     
119.     if( rcode ) {
     
120.         Serial.print("Error attempting to configure boot protocol. Return code :");
     
121.         Serial.println( rcode, HEX );
     
122.         while( 1 );  //stop
     
123.     }
     
124.     delay(2000);
     
125.     Serial.println("Keyboard initialized");
     
126. }
     
127. 
     
128. /* Poll keyboard and print result */
     
129. /* buffer starts at position 2, 0 is modifier key state and 1 is irrelevant */
     
130. void kbd_poll( void )
     
131. {
     
132. char i;
     
133. static char leds = 0;
     
134. byte rcode = 0;     //return code
     
135.     /* poll keyboard */
     
136.     rcode = Usb.inTransfer( KBD_ADDR, KBD_EP, 8, buf );
     
137.     if( rcode != 0 ) {
     
138.         return;
     
139.     }//if ( rcode..
     
140.     for( i = 2; i < 8; i++ ) {
     
141.      if( buf[ i ] == 0 ) {  //end of non-empty space
     
142.         break;
     
143.      }
     
144.       if( buf_compare( buf[ i ] ) == false ) {   //if new key
     
145.         switch( buf[ i ] ) {
     
146.           case CAPSLOCK:
     
147.             capsLock =! capsLock;
     
148.             leds = ( capsLock ) ? leds |= bmCAPSLOCK : leds &= ~bmCAPSLOCK;   
     
149.                       // set or clear bit 1 of LED report byte
     
150.             break;
     
151.           case NUMLOCK:
     
152.             numLock =! numLock;
     
153.             leds = ( numLock ) ? leds |= bmNUMLOCK : leds &= ~bmNUMLOCK;      
     
154.                                   // set or clear bit 0 of LED report byte
     
155.             break;
     
156.           case SCROLLLOCK:
     
157.             scrollLock =! scrollLock;
     
158.             leds = ( scrollLock ) ? leds |= bmSCROLLLOCK : leds &= ~bmSCROLLLOCK;
     
159.                                   // set or clear bit 2 of LED report byte
     
160.             break;
     
161.           case DELETE:
     
162.             line = false;
     
163.             break;
     
164.           case RETURN:
     
165.             line =! line;
     
166.             break;  
     
167.           default:
     
168.             //Serial.print(HIDtoA( buf[ i ], buf[ 0 ] ));
     
169.             break;
     
170.         }//switch( buf[ i ...
     
171.         Serial.print(buf[ i ],HEX);
     
172.         Serial.print(' ');        
     
173.         Serial.println(buf[ 0 ],HEX);        
     
174.         rcode = Usb.setReport( KBD_ADDR, 0, 1, KBD_IF, 0x02, 0, &leds );
     
175.         if( rcode ) {
     
176.           Serial.print("Set report error: ");
     
177.           Serial.println( rcode, HEX );
     
178.         }//if( rcode ...
     
179.      }//if( buf_compare( buf[ i ] ) == false ...
     
180.     }//for( i = 2...
     
181.     for( i = 2; i < 8; i++ ) {                    //copy new buffer to old
     
182.       old_buf[ i ] = buf[ i ];
     
183.     }
     
184. }
     
185. /* compare byte against bytes in old buffer */
     
186. bool buf_compare( byte data )
     
187. {
     
188. char i;
     
189. for( i = 2; i < 8; i++ ) {
     
190.    if( old_buf[ i ] == data ) {
     
191.      return( true );
     
192.    }
     
193. }
     
194. return( false );
     
195. }
     
196. 
     
197. /* HID to ASCII converter. Takes HID keyboard scancode, returns ASCII code */
     
198. byte HIDtoA( byte HIDbyte, byte mod )
     
199. {
     
200.   /* upper row of the keyboard, numbers and special symbols */
     
201.   if( HIDbyte >= 0x1e && HIDbyte <= 0x27 ) {
     
202.     if(( mod & SHIFT ) || numLock ) {    //shift key pressed
     
203.       switch( HIDbyte ) {
     
204.         case BANG:  return( 0x21 );
     
205.         case AT:    return( 0x40 );
     
206.         case POUND: return( 0x23 );
     
207.         case DOLLAR: return( 0x24 );
     
208.         case PERCENT: return( 0x25 );
     
209.         case CAP: return( 0x5e );
     
210.         case AND: return( 0x26 );
     
211.         case STAR: return( 0x2a );
     
212.         case OPENBKT: return( 0x28 );
     
213.         case CLOSEBKT: return( 0x29 );
     
214.       }//switch( HIDbyte...
     
215.     }
     
216.     else {                  //numbers
     
217.       if( HIDbyte == 0x27 ) {  //zero
     
218.         return( 0x30 );
     
219.       }
     
220.       else {
     
221.         return( HIDbyte + 0x13 );
     
222.       }
     
223.     }//numbers
     
224.   }//if( HIDbyte >= 0x1e && HIDbyte <= 0x27
     
225.   /**/
     
226.   /* number pad. Arrows are not supported */
     
227.   if(( HIDbyte >= 0x59 && HIDbyte <= 0x61 ) &&
     
228.                    ( numLock == true )) {  // numbers 1-9
     
229.     return( HIDbyte - 0x28 );
     
230.   }
     
231.   if(( HIDbyte == 0x62 ) && ( numLock == true )) {  //zero
     
232.     return( 0x30 );
     
233.   }
     
234.   /* Letters a-z */
     
235.   if( HIDbyte >= 0x04 && HIDbyte <= 0x1d ) {
     
236.     if((( capsLock == true ) && ( mod & SHIFT ) == 0 )
     
237.           || (( capsLock == false ) && ( mod & SHIFT ))) {  
     
238.                      //upper case
     
239.       return( HIDbyte + 0x3d );
     
240.     }
     
241.     else {  //lower case
     
242.       return( HIDbyte + 0x5d );
     
243.     }
     
244.   }//if( HIDbyte >= 0x04 && HIDbyte <= 0x1d...
     
245.   /* Other special symbols */
     
246.   if( HIDbyte >= 0x2c && HIDbyte <= 0x38 ) {
     
247.     switch( HIDbyte ) {
     
248.       case SPACE: return( 0x20 );
     
249.       case HYPHEN:
     
250.         if(( mod & SHIFT ) == false ) {
     
251.          return( 0x2d );
     
252.         }
     
253.         else {
     
254.           return( 0x5f );
     
255.         }
     
256.       case EQUAL:
     
257.        if(( mod & SHIFT ) == false ) {
     
258.         return( 0x3d );
     
259.        }
     
260.        else {
     
261.         return( 0x2b );
     
262.        }
     
263.        case SQBKTOPEN:
     
264.          if(( mod & SHIFT ) == false ) {
     
265.           return( 0x5b );
     
266.          }
     
267.          else {
     
268.           return( 0x7b );
     
269.          }
     
270.        case SQBKTCLOSE:
     
271.          if(( mod & SHIFT ) == false ) {
     
272.           return( 0x5d );
     
273.          }
     
274.          else {
     
275.           return( 0x7d );
     
276.          }
     
277.        case BACKSLASH:
     
278.          if(( mod & SHIFT ) == false ) {
     
279.            return( 0x5c );
     
280.          }
     
281.          else {
     
282.            return( 0x7c );
     
283.          }
     
284.        case SEMICOLON:
     
285.          if(( mod & SHIFT ) == false ) {
     
286.            return( 0x3b );
     
287.          }
     
288.          else {
     
289.            return( 0x3a );
     
290.          }
     
291.       case INVCOMMA:
     
292.         if(( mod & SHIFT ) == false ) {
     
293.           return( 0x27 );
     
294.         }
     
295.         else {
     
296.           return( 0x22 );
     
297.         }
     
298.       case TILDE:  
     
299.         if(( mod & SHIFT ) == false ) {
     
300.           return( 0x60 );
     
301.         }
     
302.         else {
     
303.           return( 0x7e );
     
304.         }
     
305.       case COMMA:   
     
306.         if(( mod & SHIFT ) == false ) {
     
307.           return( 0x2c );
     
308.         }
     
309.         else {
     
310.           return( 0x3c );
     
311.         }
     
312.       case PERIOD:
     
313.         if(( mod & SHIFT ) == false ) {
     
314.           return( 0x2e );
     
315.         }
     
316.         else {
     
317.           return( 0x3e );
     
318.         }
     
319.       case FRONTSLASH:
     
320.         if(( mod & SHIFT ) == false ) {
     
321.           return( 0x2f );
     
322.         }
     
323.         else {
     
324.           return( 0x3f );
     
325.         }
     
326.       default:
     
327.         break;
     
328.     }//switch( HIDbyte..
     
329.   }//if( HIDbye >= 0x2d && HIDbyte <= 0x38..
     
330.   return( 0 );
     
331. }

复制代码

实验依然使用上一次的USB小键盘。上面的按键分布如下：



关于键值的介绍可以在【参考2】找到

NumLock OFF的情况下，各输出键值：


*输出三次62,相当于输出3个0

NumLock ON的情况下，各输出键值：


*输出三次62外加一个53

运行结果



本文完整代码下载 LCDkbd


参考：
1. https://github.com/felis/USB_Hos ... s/descriptor_parser USB_Host_Shield/examples/LCDkbd/
2. http://www.quadibloc.com/comp/scan.htm

本文首发 http://www.lab-z.com/usbkb/

nick_zm

我看过有用32u4做键盘记录器，可以记录输入，并转发给电脑，很强的黑客工具

zoologist

nick_zm 发表于 2015-8-7 00:52
我看过有用32u4做键盘记录器，可以记录输入，并转发给电脑，很强的黑客工具

记录只是记录 ps2 的数据吧？

http://www.lab-z.com/ps2a/

不搭配硬件，直接解析不可能，性能不够

maxims

请问：
1、这个只能针对usb键盘吗？其他的，比方usb鼠标？usb手柄（游戏手柄之类）？
2、键盘切换为 Boot Protocol，关于这点，能否详细一点？我百度了，出来的好像都和你说的没多大关系。

谢谢

zoologist

maxims 发表于 2015-8-8 08:41
请问：
1、这个只能针对usb键盘吗？其他的，比方usb鼠标？usb手柄（游戏手柄之类）？
2、键盘切换为 Boot ...

1.其他的HID设备也可以，但是需要额外的程序解析
2.国内基本上没有介绍Boot Protocol 的资料，这种情况很常见......这个 Protocol 最初的设计目的是给BIOS之类使用的。基本上所有的键盘鼠标都会支持。

maxims

zoologist 发表于 2015-8-8 09:12
1.其他的HID设备也可以，但是需要额外的程序解析
2.国内基本上没有介绍Boot Protocol 的资料，这种情况很 ...

好的，我再继续找找资料看看

nick_zm

zoologist 发表于 2015-8-7 09:38
记录只是记录 ps2 的数据吧？

http://www.lab-z.com/ps2a/

https://github.com/tmk/tmk_keyboard/tree/master/converter/usb_usb

happy1991

不好意思，我是新手，想请教
如果我需要直接读取hid讯号
(我有个rfid读卡器，目前是直接透过hid-usb接到电脑上读取卡号)
想改成用arduino，请问有没有建议做法，或参考资料，
非常感谢。

zoologist

happy1991 发表于 2016-6-19 08:41
不好意思，我是新手，想请教
如果我需要直接读取hid讯号
(我有个rfid读卡器，目前是直接透过hid-usb接到电 ...

不知道你的读卡器是不是 hid 键盘设备，如果是的话，直接按照键盘解析，如果不是的话，

那恐怕必须慢慢研究如何解析了。

ps:hid协议的话，windows可以直接解析，但是 arduino 还做不到

lyly

nick_zm 发表于 2015-8-7 00:52
我看过有用32u4做键盘记录器，可以记录输入，并转发给电脑，很强的黑客工具

可以请教下吗 大侠

ming3834436

请教一下如何把键值输出一样（输入A，输出也是A）