标题: 用51单片机模拟USB键盘源程序及原理图 [打印本页]

---

作者: FTB1021    时间: 2017-4-26 11:26
标题: 用51单片机模拟USB键盘源程序及原理图
使用51单片机模拟USB键盘原理图（附件里面可以下载清晰版的电路图及完整源码）：



单片机源程序：

1. /******************************************************************
   
2.    本程序只供学习使用，未经作者许可，不得用于其它任何用途
   
3.       我的邮箱：computer-lov@tom.com
   
4. 
   
5. USBKeyBoard.C  file
   
6. 
   
7. 作者：Computer-lov
   
8. 建立日期: 2007.03.20
   
9. 修改日期: 2007.03.23
   
10. 版本：V1.1
    
11. 版权所有，盗版必究。
    
12. Copyright(C) Computer-lov 2007-2017
    
13. All rights reserved            
    
14. *******************************************************************/
    
15. 
    
16. #include <AT89x52.H>
    
17. #include "USB.H"
    
18. #include "PDIUSBD12.H"
    
19. #include "My_type.h"
    
20. #include "UART.H"
    
21. #include "key.h"
    
22. #include "keyboard.h"
    
23. 
    
24. #define USB_COMMAND_ADD           1
    
25. #define USB_DATA_ADD              0
    
26. 
    
27. //USB芯片连接引脚
    
28. #define USB_DATA                  P0
    
29. #define USB_A0                    P3_5
    
30. #define USB_WR                    P3_6
    
31. #define USB_RD                    P3_7
    
32. #define USB_INT                   P3_2
    
33. 
    
34. 
    
35. #define ENDPOINT_NUMBER           2
    
36. #define MAX_CONTROL_DATA_SIZE     16
    
37. 
    
38. 
    
39. //控制传输时保存数据
    
40. CONTROL_DATA_BUFF Control_Data;
    
41. 
    
42. //缓冲
    
43. uint8 idata buffer[64];
    
44. 
    
45. //交换数据时用的指针
    
46. uint8 *pData;
    
47. 
    
48. uint8 idle;     //空闲状态
    
49. uint8 protocol; //当前协议
    
50. 
    
51. //高低字节交换
    
52. 
    
53. #define SWAP16(x)  ((((uint16)(x))<<8)|(((uint16)(x))>>8))
    
54. 
    
55. //取一个整数的低字节
    
56. #define LSB(x) ((uint8)(x))
    
57. 
    
58. //取一个整数的高字节
    
59. #define MSB(x) ((uint8)(((uint16)(x))>>8))                              
    
60. 
    
61. //字符串描述符所用的语言种类
    
62. code uint8 LANGUAGE_ID[4]={0x04,0x03,0x09,0x04};                  
    
63. 
    
64. //设备序列号                                                                                
    
65. code uint8 device_serial_number[]=
    
66. {22,STRING_DESCRIPTOR,'2',0,'0',0,'0',0,'7',0,'-',0,'0',0,'3',0,'-',0,'2',0,'3',0};
    
67. 
    
68. //厂商字符串
    
69. code uint8 ManufacturerString[80]=
    
70. {80,STRING_DESCRIPTOR,0x35,0x75,0x11,0x81,0x08,0x57,0x08,0x57,0x84,0x76,0xB6,0x5B,
    
71. 0x53,0x5F,'-',0x00,'-',0x00,'-',0x00,'-',0x00,'@',0,0x20,0x00,'H',0,'t',0,'t',0,
    
72. 'p',0,':',0,'/',0,'/',0,'C',0,'o',0,'m',0,'p',0,'u',0,'t',0,'e',0,'r',0,'0',0,
    
73. '0',0,'.',0,'2',0,'1',0,'i',0,'c',0,'.',0,'o',0,'r',0,'g',0};
    
74. 
    
75. //产品字符串
    
76. code uint8 ProducterString[80]=
    
77. {80,STRING_DESCRIPTOR,0x35,0x75,0x11,0x81,0x08,0x57,0x08,0x57,0x5A,0x50,0x84,0x76,
    
78. 'U',0,'S',0,'B',0,0x2E,0x95,0xD8,0x76,'@',0,0x20,0x00,'H',0,'t',0,'t',0,
    
79. 'p',0,':',0,'/',0,'/',0,'C',0,'o',0,'m',0,'p',0,'u',0,'t',0,'e',0,'r',0,'0',0,
    
80. '0',0,'.',0,'2',0,'1',0,'i',0,'c',0,'.',0,'o',0,'r',0,'g',0};
    
81. 
    
82. 
    
83. code DEVICE_DESCRIPTOR_STRUCT device_descriptor=     //设备描述符
    
84. {
    
85. sizeof(DEVICE_DESCRIPTOR_STRUCT),                   //设备描述符的字节数大小
    
86. DEVICE_DESCRIPTOR,                                         //设备描述符类型编号
    
87. 0x1001,                                             //USB版本号
    
88. 0x00,                                               //USB分配的设备类代码
    
89. 0x00,                                               //USB分配的子类代码
    
90. 0x00,                                               //USB分配的设备协议代码
    
91. 0x10,                                               //端点0的最大包大小
    
92. 0x3412,                                             //厂商编号VID，这里只是作为测试用，请使用自己的VID
    
93. 0x7856,                                             //产品编号PID，这里只是作为测试用，请使用自己的PID
    
94. 0x0100,                                             //设备出厂编号
    
95. 0x01,                                               //设备厂商字符串的索引
    
96. 0x02,                                               //描述产品字符串的索引
    
97. 0x03,                                               //描述设备序列号字符串的索引
    
98. 0x01                                                //可能的配置数量
    
99. };
    
100. 
     
101. //定义配置，接口，端点等描述符结构体，因为它们是随配置描述符一起返回的
     
102. typedef struct _CON_INT_ENDP_DESCRIPTOR_STRUCT
     
103. {
     
104. CONFIGURATION_DESCRIPTOR_STRUCT configuration_descriptor;
     
105. INTERFACE_DESCRIPTOR_STRUCT  interface_descriptor;
     
106. HID_DESCRIPTOR_STRUCT hid_descriptor;
     
107. ENDPOINT_DESCRIPTOR_STRUCT  endpoint_descriptor[ENDPOINT_NUMBER];
     
108. }CON_INT_ENDP_DESCRIPTOR_STRUCT;
     
109. 
     
110. code CON_INT_ENDP_DESCRIPTOR_STRUCT con_int_endp_descriptor=
     
111. {
     
112. //configuration_descriptor                                          //配置描述符
     
113. {
     
114. sizeof(CONFIGURATION_DESCRIPTOR_STRUCT),                           //配置描述符的字节数大小
     
115. CONFIGURATION_DESCRIPTOR,                                          //配置描述符类型编号
     
116. SWAP16(sizeof(CON_INT_ENDP_DESCRIPTOR_STRUCT)),
     
117. 0x01,                                                            //只包含一个接口
     
118. 0x01,                                                            //该配置的编号
     
119. 0x00,                                                            //iConfiguration字段
     
120. 0xA0,                                                            //采用总线供电，支持远程唤醒
     
121. 0xC8                                                            //从总线获取最大电流400mA
     
122. },
     
123. //interface_descritor                                             //接口描述符
     
124. {
     
125. sizeof(INTERFACE_DESCRIPTOR_STRUCT),                             //接口描述符的字节数大小
     
126. INTERFACE_DESCRIPTOR,                                            //接口描述符类型编号
     
127. 0x00,                                                            //接口编号为0
     
128. 0x00,                                                            //该接口描述符的编号
     
129. ENDPOINT_NUMBER,                                                 //非0端点数量为2，只使用端点主端点输入和输出
     
130. 0x03,                                                            //人机接口设备（HID）类
     
131. 0x01,                                                            //使用的子类：支持BIOS根启动Boot的子类
     
132. 0x01,                                                            //使用的协议：键盘
     
133. 0x00                                                             //接口描述符字符串索引
     
134. },
     
135. //hid_descriptor
     
136. {
     
137. sizeof(HID_DESCRIPTOR_STRUCT),                                   //HID描述符的字节数大小
     
138. HID_DESCRIPTOR,                                                  //HID描述符类型编号
     
139. 0x1001,                                                          //HID类协议版本号，为1.1
     
140. 0x21,                                                            //固件的国家地区代号，0x21为美国
     
141. NUM_SUB_DESCRIPTORS,                                             //下级描述符的数量
     
142. {
     
143.   {
     
144.    REPORT_DESCRIPTOR,                                             //下级描述符为报告描述符
     
145.    SWAP16(sizeof(KeyBoardReportDescriptor))                       //下级描述符的长度
     
146.   }
     
147. },
     
148. },
     
149. //endpoint_descriptor[]
     
150. {
     
151. {                                                                //主端点输入描述
     
152.   sizeof(ENDPOINT_DESCRIPTOR_STRUCT),                             //端点描述符的字节数大小
     
153.   ENDPOINT_DESCRIPTOR,                                            //端点描述符类型编号
     
154.   MAIN_POINT_IN,                                                  //端点号，主输入端点
     
155.   ENDPOINT_TYPE_INTERRUPT,                                        //使用的传输类型：中断传输
     
156.   0x4000,                                                         //该端点支持的最大包尺寸，64字节
     
157.   0x0A                                                            //中断扫描时间：设置为10ms
     
158. },
     
159.   
     
160. {                                                                //主端点输出描述
     
161.   sizeof(ENDPOINT_DESCRIPTOR_STRUCT),                             //端点描述符的字节数大小
     
162.   ENDPOINT_DESCRIPTOR,                                            //端点描述符类型编号
     
163.   MAIN_POINT_OUT,                                                 //端点号，主输出端点
     
164.   ENDPOINT_TYPE_INTERRUPT,                                        //使用的传输类型：中断传输
     
165.   0x4000,                                                         //该端点支持的最大包尺寸，64字节
     
166.   0x0A                                                            //中断扫描时间：设置为10ms
     
167. }
     
168. }
     
169. };
     
170. 
     
171. union                                          //程序标志位
     
172. {
     
173. uint16 Register;
     
174. struct
     
175. {
     
176. uint8 bus_reset        :1;
     
177. uint8 suspend          :1;
     
178. uint8 remote_wakeup    :1;
     
179. uint8 int_isr          :1;
     
180. uint8 not_end          :1;
     
181. uint8 usb_idle         :1;
     
182. uint8 usb_busy         :1;
     
183. uint8 setup_packet_in  :1;
     
184. uint8 setup_packet_out :1;
     
185. uint8 set_addr         :1;
     
186. uint8 usb_endp0_in     :1;
     
187. uint8 usb_endp2_in     :1;
     
188. uint8 usb_endp2_out    :1;
     
189. }flags;
     
190. }usb_flags;
     
191. 
     
192. union                                         //中断寄存器
     
193. {
     
194. uint8 Register[2];
     
195. struct
     
196.   {
     
197.    uint8 control_out_port  :1;
     
198.    uint8 control_in_port   :1;
     
199.    uint8 port_out_1        :1;
     
200.    uint8 port_in_1         :1;
     
201.    uint8 main_out_port     :1;
     
202.    uint8 main_in_port      :1;
     
203.    uint8 bus_reset         :1;
     
204.    uint8 suspend_change    :1;
     
205.    uint8 DMA_EOT           :1;
     
206.    uint8 not_use           :7;
     
207.   }Interrupt;
     
208. }Interrupt_Register;
     
209. 
     
210. 
     
211. union                                    //端点最后处理状态
     
212. {
     
213. uint8 Register;
     
214. struct
     
215. {
     
216.   uint8 successful          :1;
     
217.   uint8 error_code          :4;
     
218.   uint8 setup_packet        :1;
     
219.   uint8 data_1              :1;
     
220.   uint8 prestatus_not_read  :1;
     
221. }Status;
     
222. }Last_Status;
     
223. 
     
224. 
     
225. /*****************   延时x毫秒函数 ***********/
     
226. void delay(uint16 x)               
     
227. {
     
228. uint16 i;
     
229. uint16 j;
     
230. for(i=0;i<x;i++)
     
231. for(j=0;j<230;j++);
     
232. }
     
233. /********************************************/
     
234. 
     
235. /*******************************写USB命令******************************************/
     
236. void write_usb_command(uint8 usb_command)
     
237. {
     
238. USB_A0=USB_COMMAND_ADD;
     
239. USB_DATA=usb_command;
     
240. USB_WR=0;
     
241. USB_WR=1;
     
242. USB_DATA=0xFF;
     
243. }
     
244. /******************************************************************************/
     
245. 
     
246. /*********************写一字节USB数据*******************************************/
     
247. void write_a_usb_data(uint8 usb_data)      
     
248. {
     
249. USB_A0=USB_DATA_ADD;
     
250. USB_DATA=usb_data;
     
251. USB_WR=0;
     
252. USB_WR=1;
     
253. USB_DATA=0XFF;
     
254. }
     
255. /******************************************************************************/
     
256. 
     
257. /****************************读一字节USB数据************************************/
     
258. uint8 read_a_usb_data(void)
     
259. {
     
260. uint8 temp;
     
261. USB_A0=USB_DATA_ADD;
     
262. USB_RD=0;
     
263. temp=USB_DATA;
     
264. USB_RD=1;
     
265. return temp;
     
266. }
     
267. /******************************************************************************/
     
268. 
     
269. /************************读USB中断寄存器**************************************/
     
270. void read_interrupt_register(void)
     
271. {
     
272. write_usb_command(Read_Interrupt_Register);
     
273. Interrupt_Register.Register[0]=read_a_usb_data();
     
274. Interrupt_Register.Register[1]=read_a_usb_data();
     
275. }
     
276. /******************************************************************************/
     
277. 
     
278. /************************设置USB地址*******************************************/
     
279. void set_usb_addr(uint8 addr)
     
280. {
     
281. 
     
282. write_usb_command(Set_Address);
     
283. write_a_usb_data(0x80|addr);
     
284. Prints("   设置地址.....................",1);
     
285. Prints("       地址为：  ",0);
     
286. PrintLongInt(addr);
     
287. Prints("",1);
     
288. }
     
289. /******************************************************************************/
     
290. 
     
291. /*************************端点使能******************************************/
     
292. void set_endpoint_enable(void)
     
293. {
     
294. write_usb_command(Set_Endpoint_Enable);
     
295. write_a_usb_data(0x01);
     
296. }
     
297. /******************************************************************************/
     
298. 
     
299. /****************************选择终端点*************************************/
     
300. uint8 select_endpoint(uint8 endp)
     
301. {
     
302. write_usb_command(Select_EndPoint+endp);
     
303. return read_a_usb_data();
     
304. }
     
305. /******************************************************************************/
     
306. 
     
307. /****************************读端点最后状态**********************************/
     
308. uint8  read_last_status(uint8 endp)
     
309. {
     
310. write_usb_command(Read_Last_Status+endp);
     
311. return read_a_usb_data();
     
312. }
     
313. /******************************************************************************/
     
314. 
     
315. /****************************设置端点状态**************************************/
     
316. void set_endpoint_status(uint8 endp,uint8 status)  
     
317. {
     
318. write_usb_command(0x40+endp);
     
319. write_a_usb_data(!status);
     
320. }
     
321. /******************************************************************************/
     
322. 
     
323. /*****************************读端点状态**************************************/
     
324. uint8 read_endpoint_status(uint8 endp)
     
325. {
     
326. write_usb_command(0x80+endp);
     
327. return read_a_usb_data();
     
328. }
     
329. /******************************************************************************/
     
330. 
     
331. /************************清缓冲，在读取缓冲数据后调用**************************/
     
332. void clear_buffer(void)
     
333. {
     
334. write_usb_command(Clear_Buffer);
     
335. }
     
336. /******************************************************************************/
     
337. 
     
338. /***********************缓冲区数据有效，在写缓冲后调用**************************/
     
339. void validate_buffer(void)
     
340. {
     
341. write_usb_command(Validate_Buffer);
     
342. }
     
343. /******************************************************************************/
     
344. 
     
345. /***************************应答建立包************************************/
     
346. void ack_setup(uint8 endp)
     
347. {
     
348. select_endpoint(endp);
     
349. write_usb_command(Ack_Setup);
     
350. }
     
351. /******************************************************************************/
     
352. 
     
353. /***********************出错处理******************************************/
     
354. void error(uint8 number)
     
355. {
     
356. Prints("有错误发生！！！",1);
     
357. number=0;
     
358. }
     
359. /******************************************************************************/
     
360. 
     
361. /*************************读终端点缓冲****************************************/
     
362. uint8 read_endpoint_buff(uint8 endp,uint8 len,uint8 * buff)
     
363. {
     
364. uint8 i,j;
     
365. read_last_status(endp);
     
366. if(!(select_endpoint(endp))&0x01){error(0); return 0;}
     
367. read_endpoint_status(endp);
     
368. write_usb_command(Read_Buffer);
     
369. read_a_usb_data();
     
370. j=read_a_usb_data();
     
371. if(j>len)
     
372.   j=len;
     
373. for(i=0;i<j;i++)
     
374.   {
     
375.    USB_RD=0;
     
376.    *(buff+i)=USB_DATA;
     
377.    USB_RD=1;
     
378.   }
     
379. clear_buffer();
     
380. return j;
     
381. }
     
382. /******************************************************************************/
     
383. 
     
384. /*************************写终端点缓冲*****************************************/
     
385. uint8 write_endpoint_buff(uint8 endp,uint8 len,uint8 * buff)
     
386. {
     
387. uint8 i;
     
388. read_last_status(endp);
     
389. select_endpoint(endp);
     
390. write_usb_command(Write_Buffer);
     
391. write_a_usb_data(0);
     
392. write_a_usb_data(len);
     
393. for(i=0;i<len;i++)
     
394.   {
     
395.    USB_DATA=*(buff+i);
     
396.    USB_WR=0;
     
397.    USB_WR=1;
     
398.   }
     
399. USB_DATA=0XFF;
     
400. validate_buffer();
     
401. return len;
     
402. }
     
403. /******************************************************************************/
     
404. 
     
405. /***************************断开USB连接****************************************/
     
406. void disconnect_usb(void)
     
407. {
     
408. Prints("断开USB连接........................",1);
     
409. write_usb_command(0xf3);
     
410. write_a_usb_data(0x0e);
     
411. write_a_usb_data(0x47);
     
412. delay(100);
     
413. }
     
414. /******************************************************************************/
     
415. 
     
416. /*******************************连接USB**************************************/
     
417. void connect_usb(void)
     
418. {
     
419. Prints("连接USB...............",1);
     
420. write_usb_command(0xf3);                         //初始化USBD12
     
421. write_a_usb_data(0x1e);                          //连接USB
     
422. write_a_usb_data(0x47);                          //设置频率
     
423. }
     
424. /******************************************************************************/
     
425. 
     
426. /***************************初始化USB***************************************************/
     
427. void init_usb(void)               
     
428. {
     
429. Prints("USBD12芯片初始化",1);
     
430. set_usb_addr(0);
     
431. set_endpoint_enable();
     
432. }
     
433. /******************************************************************************/
     
434. 
     
435. /****************************USB总线复位处理***********************************/
     
436. void usb_bus_reset(void)
     
437. {
     
438. Prints("USB总线复位................................",1);
     
439. usb_flags.Register=0;
     
440. set_endpoint_enable();
     
441. }
     
442. /******************************************************************************/
     
443. 
     
444. /*****************************USB总线挂起处理**********************************/
     
445. void usb_bus_suspend(void)
     
446. {
     
447. Prints("USB总线挂起................................",1);
     
448. }
     
449. /******************************************************************************/
     
450. 
     
451. /***************************设置地址***************************************/
     
452. void set_usb_address(void)
     
453. {
     
454. usb_flags.flags.set_addr=1;
     
455. while(select_endpoint(1)&0x01);
     
456. write_endpoint_buff(1,0,0);
     
457. set_usb_addr(Control_Data.DeviceRequest.wValue);
     
458. usb_flags.flags.usb_endp0_in=0;
     
459. usb_flags.flags.setup_packet_out=0;
     
460. }
     
461. /******************************************************************************/
     
462. 
     
463. /**************************获取状态响应*****************************************/
     
464. void get_status(uint8 receiver)
     
465. {
     
466. uint8 status[2];
     
467. switch (receiver)
     
468.   {
     
469.    case 0:                        //获取设备状态
     
470.     status[0]=0x00;
     
471.     status[1]=0x00;
     
472.     break;
     
473.    case 1:                        //获取接口状态
     
474.     status[0]=0x00;
     
475.     status[0]=0x00;
     
476.     break;
     
477.    case 2:                        //获取端点状态
     
478.     status[0]=0x00;
     
479.     status[1]=0x00;
     
480.     break;
     
481.    }
     
482.   write_endpoint_buff(1,2,status);
     
483.   usb_flags.flags.usb_endp0_in=0;
     
484. }
     
485. /******************************************************************************/
     
486. 
     
487. /*********************清除特性*******************************************/
     
488. void clear_feature(uint8 receiver)   
     
489. {
     
490. Prints("    清除特性................................",1);
     
491. receiver=0;
     
492. write_endpoint_buff(1,0,0);
     
493. usb_flags.flags.usb_endp0_in=0;
     
494. usb_flags.flags.setup_packet_out=0;
     
495. }
     
496. /******************************************************************************/
     
497. 
     
498. /*******************设置特性**************************************************/
     
499. void set_feature(uint8 receiver)
     
500. {
     
501. Prints("    设置特性................................",1);
     
502. receiver=0;
     
503. write_endpoint_buff(1,0,0);
     
504. usb_flags.flags.usb_endp0_in=0;
     
505. usb_flags.flags.setup_packet_out=0;
     
506. }
     
507. /******************************************************************************/
     
508. 
     
509. /*****************************设置描述*****************************************/
     
510. void set_descriptor(void)
     
511. {
     
512. Prints("    设置描述符................................",1);
     
513. usb_flags.flags.usb_endp0_in=0;
     
514. usb_flags.flags.setup_packet_out=0;
     
515. }
     
516. /******************************************************************************/
     
517. 
     
518. /***************************设置配置*******************************************/
     
519. void set_configuration(void)
     
520. {
     
521. Prints("    设置配置................................",1);
     
522. write_endpoint_buff(1,0,0);
     
523. usb_flags.flags.usb_endp0_in=0;
     
524. usb_flags.flags.setup_packet_out=0;
     
525. }
     
526. /******************************************************************************/
     
527. 
     
528. /************************获取配置状态******************************************/
     
529. void get_configuration(void)
     
530. {
     
531. uint8 value=0x01;
     
532. Prints("    获取配置................................",1);
     
533. write_endpoint_buff(1,1,&value);
     
534. usb_flags.flags.usb_endp0_in=0;
     
535. }
     
536. /******************************************************************************/
     
537. 
     
538. /****************************设置接口************************************/
     
539. void set_interface(void)
     
540. {
     
541. Prints("    设置接口................................",1);
     
542. write_endpoint_buff(1,0,0);
     
543. usb_flags.flags.usb_endp0_in=0;
     
544. usb_flags.flags.setup_packet_out=0;
     
545. }
     
546. /******************************************************************************/
     
547. 
     
548. /***************************获取接口状态***************************************/
     
549. void get_interface(void)
     
550. {
     
551. uint8 value=0x01;
     
552. Prints("    获取接口................................",1);
     
553. write_endpoint_buff(1,1,&value);
     
554. usb_flags.flags.usb_endp0_in=0;
     
555. }
     
556. /******************************************************************************/
     
557. 
     
558. /***********************获取描述符*********************************************/
     
559. void get_descriptor(void)
     
560. {
     
561. Prints("    获取描述符................................",1);
     
562.   if(!usb_flags.flags.not_end)
     
563.      {
     
564.       switch(MSB(Control_Data.DeviceRequest.wValue))
     
565.            {
     
566.         case DEVICE_DESCRIPTOR:
     
567.                      Prints("        获取设备描述符................................",1);
     
568.                  Control_Data.wCount=sizeof(DEVICE_DESCRIPTOR_STRUCT);
     
569.                   Control_Data.pData=(uint8 *)(&device_descriptor);
     
570.              break;
     
571.         case CONFIGURATION_DESCRIPTOR:
     
572.                          Prints("        获取配置描述符................................",1);
     
573.              Control_Data.wCount=SWAP16(con_int_endp_descriptor.configuration_descriptor.wTotalLength);
     
574.                          Control_Data.pData=(uint8 *)(&con_int_endp_descriptor);
     
575.              if(Control_Data.wLength<Control_Data.wCount)Control_Data.wCount=Control_Data.wLength;
     
576.              break;
     
577.                 case STRING_DESCRIPTOR:
     
578.                      Prints("        获取字符串描述符................................",1);
     
579.                          switch(LSB(Control_Data.DeviceRequest.wValue))
     
580.                           {
     
581.                            case 0:
     
582.                             Prints("            获取语言ID................................",1);
     
583.                             Control_Data.wCount=LANGUAGE_ID[0];
     
584.                 Control_Data.pData=LANGUAGE_ID;
     
585.                                break;
     
586. 
     
587.                            case 1:
     
588.                             Prints("            获取厂商字符串................................",1);
     
589.                             Control_Data.wCount=ManufacturerString[0];
     
590.                 Control_Data.pData=ManufacturerString;
     
591.                             break;
     
592. 
     
593.                            case 2:
     
594.                             Prints("            获取产品字符串................................",1);
     
595.                             Control_Data.wCount=ProducterString[0];
     
596.                 Control_Data.pData=ProducterString;
     
597.                             break;
     
598. 
     
599.                            case 3:
     
600.                  Prints("            获取设备序列号................................",1);
     
601.                              Control_Data.wCount=device_serial_number[0];
     
602.                              Control_Data.pData=device_serial_number;
     
603.                            break;
     
604. 
     
605.                            default: break;
     
606.                           }
     
607.                          break;
     
608.                  default:
     
609.                      Prints("       获取其它描述符..................描述符索引为：",0);
     
610.                          PrintLongInt(MSB(Control_Data.DeviceRequest.wValue));
     
611.                          Prints("",1);
     
612.                   break;
     
613.                    }
     
614.       if(Control_Data.wLength<Control_Data.wCount)Control_Data.wCount=Control_Data.wLength;
     
615.          }
     
616.         //写数据到D12输入端点
     
617.     if(Control_Data.wCount>=MAX_CONTROL_DATA_SIZE)
     
618.      {
     
619.           write_endpoint_buff(1,MAX_CONTROL_DATA_SIZE,Control_Data.pData);
     
620.           Control_Data.pData+=MAX_CONTROL_DATA_SIZE;
     
621.       Control_Data.wCount-=MAX_CONTROL_DATA_SIZE;
     
622.           if(usb_flags.flags.set_addr)usb_flags.flags.not_end=1;
     
623.            else usb_flags.flags.usb_endp0_in=0;
     
624.           return;
     
625.          }
     
626.     else
     
627.      {
     
628.           write_endpoint_buff(1,Control_Data.wCount,Control_Data.pData);
     
629.       usb_flags.flags.setup_packet_in=0;
     
630.           usb_flags.flags.usb_endp0_in=0;
     
631.           return;
     
632.          }      
     
633. }
     
634. /******************************************************************************/
     
635. 
     
636. /*********************发到接口的获取描述符**************************************/
     
637. void get_descriptor_interface(void)
     
638. {
     
639. Prints("    获取描述符（从接口）..............................",1);
     
640.   if(!usb_flags.flags.not_end)
     
641.      {
     
642.       switch(MSB(Control_Data.DeviceRequest.wValue))
     
643.            {
     
644.         case HID_DESCRIPTOR:
     
645.                      Prints("        获取HID描述符................................",1);
     
646.                  Control_Data.wCount=sizeof(HID_DESCRIPTOR_STRUCT);
     
647.                   //Control_Data.pData=(uint8 *)(&hid_descriptor);
     
648.              break;
     
649.         case REPORT_DESCRIPTOR:
     
650.                          Prints("        获取报告描述符................................",1);
     
651.              Control_Data.wCount=SWAP16(sizeof(KeyBoardReportDescriptor));
     
652.                          Control_Data.pData=(uint8 *)(KeyBoardReportDescriptor);
     
653.              if(Control_Data.wLength<Control_Data.wCount)Control_Data.wCount=Control_Data.wLength;
     
654.              break;
     
655.                 case PHYSICAL_DESCRIPTOR:
     
656.                      Prints("        获取物理描述符................................",1);
     
657.                          break;
     
658.                  default:
     
659.                      Prints("       获取其它描述符..................描述符索引为：",0);
     
660.                          PrintLongInt(MSB(Control_Data.DeviceRequest.wValue));
     
661.                          Prints("",1);
     
662.                   break;
     
663.                    }
     
664.       if(Control_Data.wLength<Control_Data.wCount)Control_Data.wCount=Control_Data.wLength;
     
665.          }
     
666.         //写数据到D12输入端点
     
667.     if(Control_Data.wCount>=MAX_CONTROL_DATA_SIZE)
     
668.      {
     
669.           write_endpoint_buff(1,MAX_CONTROL_DATA_SIZE,Control_Data.pData);
     
670.           Control_Data.pData+=MAX_CONTROL_DATA_SIZE;
     
671.       Control_Data.wCount-=MAX_CONTROL_DATA_SIZE;
     
672.           if(usb_flags.flags.set_addr)usb_flags.flags.not_end=1;
     
673.            else usb_flags.flags.usb_endp0_in=0;
     
674.           return;
     
675.          }
     
676.     else
     
677.      {
     
678.           write_endpoint_buff(1,Control_Data.wCount,Control_Data.pData);
     
679.       usb_flags.flags.setup_packet_in=0;
     
680.           usb_flags.flags.usb_endp0_in=0;
     
681.           return;
     
682.          }      
     
683. }
     
684. /******************************************************************************/
     
685. 
     
686. /************************终端点0输出中断处理************************************/
     
687. void endp0_out(void)
     
688. {
     
689. Last_Status.Register=read_last_status(0);
     
690. if(Last_Status.Status.setup_packet)
     
691.   {
     
692.    Control_Data.wLength=0;
     
693.    Control_Data.wCount=0;
     
694.    if(read_endpoint_buff(0,sizeof(Control_Data.DeviceRequest),(uint8 *)(&(Control_Data.DeviceRequest)))!=sizeof(REQUESTCMD))
     
695.     {
     
696.          set_endpoint_status(0,0);
     
697.          set_endpoint_status(1,0);
     
698.          return;
     
699.         }
     
700.   Control_Data.DeviceRequest.wValue=SWAP16(Control_Data.DeviceRequest.wValue);
     
701.   Control_Data.DeviceRequest.wIndex=SWAP16(Control_Data.DeviceRequest.wIndex);
     
702.   Control_Data.DeviceRequest.wLength=SWAP16(Control_Data.DeviceRequest.wLength);
     
703. 
     
704.   ack_setup(0);
     
705.   ack_setup(1);
     
706.   Control_Data.wLength=Control_Data.DeviceRequest.wLength;
     
707.   usb_flags.flags.not_end=0;
     
708.   usb_flags.flags.usb_endp0_in=1;
     
709.   usb_flags.flags.setup_packet_in=0;
     
710.   usb_flags.flags.setup_packet_out=0;
     
711.   if(Control_Data.DeviceRequest.bmRequestType&0x80){usb_flags.flags.setup_packet_in=1;return;}
     
712.   else {usb_flags.flags.setup_packet_out=1;return;}
     
713. }
     
714. else
     
715.   {
     
716.    select_endpoint(0);
     
717.    clear_buffer();
     
718.   }
     
719. }
     
720. /******************************************************************************/
     
721. 
     
722. /***********************获取报告*********************************************/
     
723. void get_report(void)
     
724. {
     
725. Prints("        获取报告................................",1);
     
726. }
     
727. /******************************************************************************/
     
728. 
     
729. /**********************获取空闲状态*********************************************/
     
730. void get_idle(void)
     
731. {
     
732. Prints("    获取空闲................................",1);
     
733. write_endpoint_buff(1,1,&idle);
     
734. usb_flags.flags.usb_endp0_in=0;
     
735. }
     
736. /******************************************************************************/
     
737. 
     
738. /*************************获取协议**********************************************/
     
739. void get_protocol(void)
     
740. {
     
741. Prints("    获取协议................................",1);
     
742. write_endpoint_buff(1,1,&protocol);
     
743. usb_flags.flags.usb_endp0_in=0;
     
744. }
     
745. /******************************************************************************/
     
746. 
     
747. /***********************设置报告***********************************************/
     
748. void set_report(void)
     
749. {
     
750. Prints("    设置报告................................",1);
     
751. }
     
752. /******************************************************************************/
     
753. 
     
754. /***********************设置空闲***********************************************/
     
755. void set_idle(void)
     
756. {
     
757. Prints("    设置空闲................................",1);
     
758. while(select_endpoint(1)&0x01);
     
759. write_endpoint_buff(1,0,0);
     
760. idle=Control_Data.DeviceRequest.wValue;
     
761. usb_flags.flags.usb_endp0_in=0;
     
762. usb_flags.flags.setup_packet_out=0;
     
763. }
     
764. /******************************************************************************/
     
765. 
     
766. /**********************设置协议**************************************************/
     
767. void set_protocol(void)
     
768. {
     
769. Prints("    设置协议................................",1);
     
770. while(select_endpoint(1)&0x01);
     
771. write_endpoint_buff(1,0,0);
     
772. protocol=Control_Data.DeviceRequest.wValue;
     
773. usb_flags.flags.usb_endp0_in=0;
     
774. usb_flags.flags.setup_packet_out=0;
     
775. }
     
776. /******************************************************************************/
     
777. 
     
778. /****************************终端点0输入处理**************************************/
     
779. void endp0_in(void)
     
780. {
     
781. read_last_status(1);
     
782. //如果是输入请求包
     
783. if(usb_flags.flags.setup_packet_in||usb_flags.flags.not_end)
     
784.   {
     
785.     switch(Control_Data.DeviceRequest.bmRequestType&0x60)
     
786.          {
     
787.            case 0x00:  //标准请求
     
788.            Prints("USB标准请求................................",1);
     
789.            switch(Control_Data.DeviceRequest.bmRequestType&0x1F)
     
790.             {
     
791.                  case 0: //到设备
     
792.                    switch (Control_Data.DeviceRequest.bRequest)
     
793.                     {
     
794.                      case 0: get_status(0);break;
     
795.                      case 6: get_descriptor();break;
     
796.                      case 8: get_configuration();break;
     
797.                          default:break;
     
798.                     }
     
799.                  break;
     
800. 
     
801.                  case 1:  //到接口
     
802.                    switch (Control_Data.DeviceRequest.bRequest)
     
803.                     {
     
804.                  case  0: get_status(1);break;
     
805.                           case 6: get_descriptor_interface();break;
     
806.                      case 10: get_interface();break;
     
807.                  default: break;
     
808.                         }
     
809.                  break;
     
810. 
     
811.                  case 2:  //到端点
     
812.                   {
     
813.                if(Control_Data.DeviceRequest.bRequest==0)get_status(2);  
     
814.                   }
     
815.                  default: break;
     
816.             }
     
817.            break;
     
818. 
     
819.            case 0x20:  //类请求
     
820.        Prints("USB类请求................................",1);
     
821.            switch(Control_Data.DeviceRequest.bmRequestType&0x1F)
     
822.             {
     
823.                  case 0:  //到设备
     
824.                    switch (Control_Data.DeviceRequest.bRequest)
     
825.                     {
     
826.                          default:break;
     
827.                     }
     
828.                  break;
     
829. 
     
830.                  case 1:  //到接口
     
831.                    switch (Control_Data.DeviceRequest.bRequest)
     
832.                     {
     
833. 
     
834.                            case   GET_REPORT: get_report();   break; //获取报告
     
835.              case     GET_IDLE: get_idle();     break; //获取空闲状态
     
836.              case GET_PROTOCOL: get_protocol(); break; //获取协议
     
837.                  default: break;
     
838.                         }
     
839.                  break;
     
840. 
     
841.                  case 2:  //到端点
     
842.                   {
     
843.                    switch (Control_Data.DeviceRequest.bRequest)
     
844.                     {
     
845.                  default: break;
     
846.                         }  
     
847.                   }
     
848.                  default: break;
     
849.             }
     
850.            break;
     
851. 
     
852.            case 0x40:  //用户请求
     
853.        Prints("USB用户请求................................",1);
     
854.            switch(Control_Data.DeviceRequest.bmRequestType&0x1F)
     
855.             {
     
856.                  case 0:  //到设备
     
857.                    switch (Control_Data.DeviceRequest.bRequest)
     
858.                     {
     
859.                          default: break;
     
860.                     }
     
861.              break;
     
862. 
     
863.                  case 1:   //到接口
     
864.                    switch (Control_Data.DeviceRequest.bRequest)
     
865.                     {
     
866.                  default: break;
     
867.                         }
     
868.          break;
     
869. 
     
870.                  case 2:  //到端点
     
871.                   {
     
872.                    switch (Control_Data.DeviceRequest.bRequest)
     
873.                     {
     
874.                  default: break;
     
875.                         }  
     
876.                   }
     
877.                  default: break;
     
878.             }
     
879.         }
     
880.     return;
     
881.   }
     
882. 
     
883.   //如果是输出请求包
     
884. if(usb_flags.flags.setup_packet_out)
     
885.   {
     
886.     switch(Control_Data.DeviceRequest.bmRequestType&0x60)
     
887.          {
     
888.            case 0x00:  //标准请求
     
889.            Prints("USB标准请求................................",1);
     
890.            switch(Control_Data.DeviceRequest.bmRequestType&0x1F)
     
891.             {
     
892.                  case 0:   //到设备
     
893.              switch (Control_Data.DeviceRequest.bRequest)
     
894.               {
     
895.                    case     CLEAR_FEATURE: clear_feature(0);break;
     
896.                    case       SET_FEATURE: set_feature(0);break;
     
897.                    case       SET_ADDRESS: set_usb_address();break;          //set_address                  
     
898.                    case    SET_DESCRIPTOR: set_descriptor();break;           //set_descriptor
     
899.                    case SET_CONFIGURATION: set_configuration(); break;       //set_configurat                                 
     
900.                      default: break;
     
901.                   }
     
902.                  break;
     
903.                  
     
904.                  case 1:   //到接口
     
905.               switch (Control_Data.DeviceRequest.bRequest)
     
906.                    {
     
907.                     case CLEAR_FEATURE:  clear_feature(1);break;
     
908.                     case   SET_FEATURE:  set_feature(1); break;
     
909.                 case SET_INTERFACE: set_interface();break;
     
910.                     default: break;
     
911.                 }
     
912.                  break;
     
913.                  
     
914.                  case 2:   //到端点
     
915.                   switch (Control_Data.DeviceRequest.bRequest)
     
916.                    {
     
917.                     case CLEAR_FEATURE: clear_feature(2);break;
     
918.                     case   SET_FEATURE: set_feature(2);break;
     
919.                 default: break;      
     
920.                    }
     
921.                  break;
     
922. 
     
923.                  default: break;
     
924.             }
     
925.       break;
     
926. 
     
927.           case 0x20:  //类请求
     
928.       Prints("USB类请求................................",1);
     
929.            switch(Control_Data.DeviceRequest.bmRequestType&0x1F)
     
930.             {
     
931.                  case 0:    //接收者为设备
     
932.              switch (Control_Data.DeviceRequest.bRequest)
     
933.               {                              
     
934.                      default: break;
     
935.                   }
     
936.                  break;
     
937. 
     
938.                  case 1:   //接收者为接口
     
939.               switch (Control_Data.DeviceRequest.bRequest)
     
940.                    {
     
941.             case   SET_REPORT: set_report();   break; //设置报告
     
942.             case     SET_IDLE: set_idle();     break; //设置空闲
     
943.             case SET_PROTOCOL: set_protocol(); break; //设置协议
     
944.                     default: break;
     
945.                 }
     
946.                  
     
947.                  break;
     
948. 
     
949.                  case 2:   //接收者为端点
     
950.                   switch (Control_Data.DeviceRequest.bRequest)
     
951.                    {
     
952.                 default: break;      
     
953.                    }
     
954.                  break;
     
955.                  
     
956.                  case 3: //其它接收者
     
957.                   switch (Control_Data.DeviceRequest.bRequest)
     
958.                    {
     
959.                 default: break;      
     
960.                    }break;
     
961.                                     
     
962.                  default: break;
     
963.             }      
     
964.            break;
     
965. 
     
966.        case 0x40:  //用户请求
     
967.            Prints("USB用户请求................................",1);
     
968.            switch(Control_Data.DeviceRequest.bmRequestType&0x1F)
     
969.             {
     
970.                  case 0:    //接收者为设备
     
971.              switch (Control_Data.DeviceRequest.bRequest)
     
972.               {                              
     
973.                      default: break;
     
974.                   }
     
975.                  break;
     
976.                  
     
977.                  case 1:   //接收者为接口
     
978.               switch (Control_Data.DeviceRequest.bRequest)
     
979.                    {
     
980.                     default: break;
     
981.                 }
     
982.              break;
     
983.                  
     
984.                  case 2:   //接收者为端点
     
985.                   switch (Control_Data.DeviceRequest.bRequest)
     
986.                    {
     
987.                 default: break;      
     
988.                    }
     
989.                  break;
     
990.                  
     
991.                  case 3: //其它接收者
     
992.                   switch (Control_Data.DeviceRequest.bRequest)
     
993.                    {
     
994.                 default: break;      
     
995.                    }                  
     
996.                  break;
     
997.                                     
     
998.                  default: break;
     
999.             }
     
1000.         }
      
1001.   }
      
1002. }
      
1003. /******************************************************************************/
      
1004. 
      
1005. /**********************端点1输出***********************************************/
      
1006. /*void endp1_out(void)
      
1007. {
      
1008. Prints("端点1输出................................",1);
      
1009. }*/
      
1010. /******************************************************************************/
      
1011. 
      
1012. /*************************端点1输入*****************************************/
      
1013. /*void endp1_in(void)
      
1014. {
      
1015. Prints("端点1输入................................",1);
      
1016. }*/
      
1017. /******************************************************************************/
      
1018. 
      
1019. /***************************端点2输出****************************************/
      
1020. void endp2_out(void)
      
1021. {
      
1022. uint8 i,j;
      
1023. 
      
1024. j=read_endpoint_buff(4,64,buffer);
      
1025. P2=~buffer[0];
      
1026. Prints("端点2输出................................",1);
      
1027. Prints("    端点2的数据是  ",0);
      
1028. for(i=0;i<j;i++)
      
1029.   {
      
1030.    PrintHex(buffer[i]);
      
1031.    if(i==16)Prints("",1);
      
1032.   }
      
1033. Prints("",1);
      
1034. }
      
1035. /******************************************************************************/
      
1036. 
      
1037. 
      
1038. //用来返回数据的缓冲
      
1039. uint8 idata InBuffer[64];
      
1040. 
      
1041. /***************************统计x中有多少个bit为1*******************************/
      
1042. uint8 Count1Bits(uint16 x)
      
1043. {
      
1044. uint8 i;
      
1045. 
      
1046. i=0;
      
1047. while(x)
      
1048.   {
      
1049.    if(x&0x8000)i++;
      
1050.    x<<=1;
      
1051.   }
      
1052. return i;
      
1053. }
      
1054. /******************************************************************************/
      
1055. 
      
1056. /****************************主端点输入处理************************************/
      
1057. void endp2_in(void)                                      
      
1058. {
      
1059. uint8 i;
      
1060. // Prints("端点2输入................................",1);
      
1061. KeyMapCanChange=0;  //禁止修改按键值
      
1062. if(KeyMapOk) //如果有按键按下
      
1063.   {
      
1064.    //4*4的键盘，最多能够识别3个键同时按下，
      
1065.    //如果开关上接二极管可以同时识别更多的键
      
1066.    if(Count1Bits(KeyMapOk)>3)
      
1067.     {
      
1068.          for(i=2;i<8;i++)InBuffer[i]=0x01;  //按键过多
      
1069.         }
      
1070.    else
      
1071.     {
      
1072.      if(KeyMapOk&(1<<3)) //左Ctrl键
      
1073.       {
      
1074.        InBuffer[0]|=1;
      
1075.       }
      
1076.      else
      
1077.       {
      
1078.        InBuffer[0]&=~1;
      
1079.       }
      
1080.         
      
1081.      if(KeyMapOk&(1<<7)) //左shift键
      
1082.       {
      
1083.        InBuffer[0]|=1<<1;
      
1084.       }
      
1085.      else
      
1086.       {
      
1087.        InBuffer[0]&=~(1<<1);
      
1088.       }
      
1089.         
      
1090.      if(KeyMapOk&(1<<2)) //左ALT键
      
1091.       {
      
1092.        InBuffer[0]|=1<<2;
      
1093.       }
      
1094.      else
      
1095.       {
      
1096.            InBuffer[0]&=~(1<<2);
      
1097.           }
      
1098.          i=2;
      
1099.          if(KeyMapOk&(1))
      
1100.           {
      
1101.            InBuffer[i++]=0x28;            //回车键
      
1102.           }
      
1103.          if(KeyMapOk&(1<<1))
      
1104.           {
      
1105.            InBuffer[i++]=0x62;            //0键
      
1106.           }
      
1107.          if(KeyMapOk&(1<<4))
      
1108.           {
      
1109.            InBuffer[i++]=0x5B;            //3键
      
1110.           }
      
1111.          if(KeyMapOk&(1<<5))
      
1112.           {
      
1113.            InBuffer[i++]=0x5A;            //2键
      
1114.           }
      
1115.          if(KeyMapOk&(1<<6))
      
1116.           {
      
1117.            InBuffer[i++]=0x59;            //1键
      
1118.           }
      
1119.          if(KeyMapOk&(1<<8))
      
1120.           {
      
1121.            InBuffer[i++]=0x5E;            //6键
      
1122.           }
      
1123.          if(KeyMapOk&(1<<9))
      
1124.           {
      
1125.            InBuffer[i++]=0x5D;            //5键
      
1126.           }
      
1127.          if(KeyMapOk&(1<<10))
      
1128.           {
      
1129.            InBuffer[i++]=0x5C;            //4键
      
1130.           }
      
1131.          if(KeyMapOk&(1<<11))
      
1132.           {
      
1133.            InBuffer[i++]=0x39;            //Caps Lock键
      
1134.           }
      
1135.          if(KeyMapOk&(1<<12))
      
1136.           {
      
1137.            InBuffer[i++]=0x61;            //9键
      
1138.           }
      
1139.          if(KeyMapOk&(1<<13))
      
1140.           {
      
1141.            InBuffer[i++]=0x60;            //8键
      
1142.           }
      
1143.          if(KeyMapOk&(1<<14))
      
1144.           {
      
1145.            InBuffer[i++]=0x5F;            //2键
      
1146.           }
      
1147.          if(KeyMapOk&(1<<15))
      
1148.           {
      
1149.            InBuffer[i++]=0x53;            //Num Lock键
      
1150.           }
      
1151.          for(;i<8;i++)
      
1152.           {
      
1153.            InBuffer[i]=0;  //多余的清0
      
1154.           }
      
1155.         }
      
1156.   }
      
1157. else //如果无按键按下，则返回0
      
1158.   {
      
1159.    for(i=0;i<8;i++)
      
1160.     {
      
1161.          InBuffer[i]=0;
      
1162.         }
      
1163.   }
      
1164. KeyMapCanChange=1; //允许修改按键值
      
1165. //返回8个字节数据
      
1166. write_endpoint_buff(5,8,InBuffer);
      
1167. }
      
1168. /******************************************************************************/
      
1169. 
      
1170. 
      
1171. /***************************主函数**********************************************/
      
1172. void main(void)
      
1173. {
      
1174. InitUART();  //串口初始化
      
1175. Printc(0x0c);  //清屏
      
1176. Printc(0x0c);
      
1177. Prints("系统启动................................",1);
      
1178. delay(1000);         //延迟
      
1179. disconnect_usb();            //断开USB连接
      
1180. init_usb();                   //初始化USB芯片
      
1181. connect_usb();                   //连接USB
      
1182. InitTimer0();  //定时器0初始化，用来做键盘扫描，定时时间大约为5ms
      
1183. 
      
1184. 
      
1185. 
      
1186. …………限于本文篇幅 余下代码请从51黑下载附件…………
      

复制代码

下载：
51单片机模拟一个USB键盘的代码，.rar (322.46 KB, 下载次数: 364)

2017-4-26 11:26 上传

点击文件名下载附件
下载积分: 黑币 -5

---

作者: mycoffees    时间: 2017-5-5 08:38
谢谢分享，感觉很有用

---

作者: djk0125    时间: 2017-9-29 10:32
d12的应用！学习了

---

作者: 越快乐越堕落    时间: 2017-9-29 19:02
上面那个IC是什么型号

---

作者: xiuyueyuan2013    时间: 2017-9-30 15:52
好东西，感谢分享

---

作者: q188654089    时间: 2017-11-3 21:22
好东西，感谢分享

---

作者: faxa1    时间: 2017-11-3 22:37
谢谢分享

---

作者: tanlean123    时间: 2017-11-21 11:57

谢谢分享

---

作者: kentron2011    时间: 2017-12-7 13:46
谢谢分享

---

作者: f74108    时间: 2017-12-10 12:32
谢谢分享

---

作者: 壹勿所知    时间: 2017-12-14 11:28
看一下

---

作者: songyx005    时间: 2017-12-23 14:58
好东西，学习一下

---

作者: 海不里    时间: 2018-1-17 15:43
已经下载学习了，感觉很实用

---

作者: jackwuming    时间: 2018-1-20 14:00
好东西，学习学习

---

作者: allen2016    时间: 2018-3-1 16:33
下来学习学习了，多谢

---

作者: a8629889    时间: 2018-5-2 18:08
正想搞一个~

---

作者: jinmei1314    时间: 2018-5-15 10:18
正在找这个资料，也想做个键盘。

---

作者: jysliang    时间: 2018-5-15 15:02
用不了  

---

作者: daichao89    时间: 2018-6-4 15:01
学习学习。。。。。。

---

作者: Kypotono    时间: 2018-6-24 15:29
感谢楼主分享

---

作者: tianshengcai1    时间: 2018-7-22 09:34
感谢分享，好好学习一下

---

作者: siekoo    时间: 2018-9-17 20:20
数组真的剪啊

---

作者: coulomb    时间: 2018-9-18 09:42
手上剛好有D12 USB芯片;可供參考.感謝分想

---

作者: efengzu    时间: 2018-10-8 10:41
用普通的IO模拟的话，速度跟的上吗？

---

作者: MokNgai    时间: 2018-10-8 15:41
正好需要做一个模拟键盘，先学习学习

---

作者: kiwii    时间: 2018-10-10 23:15
学习了，DIY爱好者，正在做一个键盘模拟器，学习分享。

---

作者: aiyu1688    时间: 2018-10-23 14:22
不错，学习学习

---

作者: authority    时间: 2018-11-1 07:32
不错的，是不是根据书上的例子改编的？

---

作者: authority    时间: 2018-11-1 07:33

不错，学习学习

---

作者: 太黏    时间: 2018-11-1 09:25
厉害，有空弄一下

---

作者: 萌控    时间: 2018-11-8 10:43
太棒了！~感谢

---

作者: gx_ou    时间: 2018-11-17 16:04
谢谢分享，十分有用！

---

作者: Bboylight12    时间: 2018-12-1 15:48
楼主推荐的程序有用，先参考一下，解决我的疑惑

---

作者: pmhker    时间: 2018-12-3 20:57
感谢楼主分享

---

作者: ptlantu    时间: 2018-12-4 10:15
源码编译不过

---

作者: 用面煮虾    时间: 2018-12-10 13:38
谢谢分享   

---

作者: big_zhuang    时间: 2019-2-12 21:55
谢谢分享，感觉很有用

---

作者: buqiao    时间: 2019-2-12 23:19
很实用

---

作者: 风雪残流    时间: 2019-3-27 10:09
感谢分享!!!!!!!!!!!!

---

作者: jokercn    时间: 2019-3-28 19:15
请问下这个的功能是不是通过单片机来控制电脑USB键盘的输入？

---

作者: 洁的电子世界    时间: 2019-4-6 17:53

jokercn 发表于 2019-3-28 19:15
请问下这个的功能是不是通过单片机来控制电脑USB键盘的输入？

此处USB芯片只处理与USB相关的通信工作，而且必须由外部微控制器对其控制才能正常工作。此外，还需要一个中断引脚，当数据收到或发送完，这个中断引脚会向微控制器发出中断请求信号。
有按键按下时，与之相连的MCU的接口状态发生变化，而主机通过不断的扫描MCU接按键管脚状态来知道是否有按键按下，而这个通信过程需要USB支持，可以认为USB起个信息传递功能。

不知道回答正确不，我是一个初学者，多多指教

---

作者: yihuahuahua    时间: 2019-9-1 09:57
厉害厉害

---

作者: tdetde    时间: 2019-10-23 10:12
学习了，谢谢！

---

作者: jen51h    时间: 2020-4-25 18:15
谢谢分享,请问是生成HID设备的吗?

---

作者: allencccice    时间: 2020-9-29 09:07
楼主分享巨有用！如鱼得水！

---

作者: _lshx_    时间: 2021-9-17 10:49
正在找这个资料，也想做个键盘。

---

作者: chenglcd123    时间: 2021-10-8 14:24
这个外围好复杂啊。有简单点的方案吗

---

作者: Foticing    时间: 2022-5-14 14:47
能让单片机向PC发送一些特定的按键值吗？

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1