21ic电子技术开发论坛 › 综合技术交流 › RISC-V › 第八十三章、CH32V103应用教程——USB模拟鼠标键盘设备 ...
返回列表 发新帖我要提问

[RISC-V MCU 应用开发] 第八十三章、CH32V103应用教程——USB模拟鼠标键盘设备

[复制链接]
 楼主| RISCVLAR 发表于 2021-3-16 15:14 | 显示全部楼层 |阅读模式
USB, 模拟, 键盘, se, ui
本帖最后由 RISCVLAR 于 2021-3-16 15:13 编辑

CH32V103应用教程——USB模拟鼠标键盘设备

本章教程主要使用CH32V103 USB模拟鼠标键盘设备。

1、USB简介及相关函数介绍
关于USB具体介绍，可参考前面章节。

2、硬件设计
本章教程主要进行USB模拟鼠标键盘实验，仅需用到开发板USB口。

3、软件设计
本章程序全在主函数中进行，具体程序如下：
main.c文件
复制
  1. /********************************** (C) COPYRIGHT *******************************
    

  2. * File Name          : main.c
    

  3. * Author             : WCH
    

  4. * Version            : V1.0.0
    

  5. * Date               : 2019/10/15
    

  6. * Description        : Main program body.
    

  7. *******************************************************************************/
    

  8. #include "debug.h"
    

  9. #include "usart.h"
    

  10. #include "string.h"
    


  11. 

  12. #define   DevEP0SIZE   0x40
    


  13. 

  14. /* Device Descriptor */
    

  15. const UINT8  MyDevDescr[] =
    

  16. {
    

  17.         0x12,              //设备描述符长度，18字节
    

  18.         0x01,              //描述符类型，0x01为设备描述符
    

  19.         0x10, 0x01,        //本设备所使用USB版本协议，因为是小端结构，所以低字节在前，即USB1.1版本为0x10,0x01，USB2.0为0x00,0x02
    

  20.         0x00,              //类代码,此处不在设备描述符中定义设备类，而在接口描述符中定义设备类。对于大多数标准的USB设备类，该字段通常设置为0，而在接口描述符中的bInterfaceClass中指定接口所实现的功能
    

  21.         0x00,              //子类代码，当类代码bDeviceClass为0时，下面的子类代码bDeviceSubClass也必须为0。
    

  22.         0x00,              //设备所使用的协议，协议代码由USB协会规定。当该字段为0时，表示设备不使用类所定义的协议。
    

  23.         DevEP0SIZE,        //端点0的最大包长，可以取值8、16、32、64，此处为64字节
    

  24.         0x86, 0x1A,        //厂商ID
    

  25.         0xe1, 0xe6,        //产品设备ID
    

  26.         0x00, 0x01,        //设备版本号
    

  27.         0x01,              //描述厂商的字符串索引值。当该值为0时，表示没有厂商字符串
    

  28.         0x02,              //描述产品的字符串索引值。当该值为0时，表示没有产品字符串
    

  29.         0x03,              //描述设备的序列号字符串索引值。当该值为0时，表示没有序列号字符串
    

  30.         0x01,              //可能的配置数，通常为1
    

  31. };
    


  32. 

  33. const UINT8 KeyRepDesc[] =
    

  34. {
    

  35.         0x05, 0x01,         // Usage page Generatic Desktop
    

  36.         0x09, 0x06,         // Usage keyboard
    

  37.         0xa1, 0x01,         // Collation Application
    

  38.         0x05, 0x07,         // Usafe page (key code)
    

  39.         0x19, 0xe0,         // Usage Min ( E0 -->  L_CTL)
    

  40.         0x29, 0xe7,         // Usage MAX ( E7 --> R_GUI )
    

  41.         0x15, 0x00,         // Logical min
    

  42.         0x25, 0x01,         // Logical max
    

  43.         0x95, 0x08,         // Report count ( 8 )
    

  44.         0x75, 0x01,         // Report size  ( 1 )
    

  45.         0x81, 0x02,         // Input ( Data, Variable, Absolute )
    

  46.         0x95, 0x08,         // Report count ( 8 )
    

  47.         0x75, 0x01,         // Report size  ( 1 )
    

  48.         0x81, 0x01,         // Input ( const )
    

  49.         0x05, 0x08,         // Usage page( LED )
    

  50.         0x19, 0x01,         // Usage min ( 1 )
    

  51.         0x29, 0x03,         // Usage max ( 3 )
    

  52.         0x95, 0x03,         // Report count ( 3 )
    

  53.         0x75, 0x01,         // Report size ( 1 )
    

  54.         0x91, 0x02,         // Output ( Data, Variable, Absolute )
    

  55.         0x95, 0x01,         // Report count ( 1 )
    

  56.         0x75, 0x05,         // Report size ( 5 )
    

  57.         0x91, 0x01,         // Output ( const )
    

  58.         0x05, 0x07,         // Usage page ( key code )
    

  59.         0x19, 0x00,         // Usage min ( 0H )
    

  60.         0x2a, 0xff, 0x00,   // Usage max ( FFH )
    

  61.         0x15, 0x00,         // Logical min ( 0H )
    

  62.         0x26, 0xff, 0x00,   // Logical max ( FFH )
    

  63.         0x95, 0x06,         // Report count ( 6 )
    

  64.         0x75, 0x08,         // Report size ( 8 )
    

  65.         0x81, 0x00,         // Input ( Data, Array, Absolute )
    

  66.         0xc0                // End collection
    

  67. };
    


  68. 

  69. const UINT8  MouseRepDesc[]=
    

  70. {
    

  71.         0x05,0x01,
    

  72.         0x09,0x02,
    

  73.         0xA1,0x01,
    

  74.         0x09,0x01,
    

  75.         0xA1,0x00,
    

  76.         0x05,0x09,
    

  77.         0x19,0x01,
    

  78.         0x29,0x03,
    

  79.         0x15,0x00,
    

  80.         0x25,0x01,
    

  81.         0x95,0x03,
    

  82.         0x75,0x01,
    

  83.         0x81,0x02,
    

  84.         0x95,0x01,
    

  85.         0x75,0x05,
    

  86.         0x81,0x03,
    

  87.         0x05,0x01,
    

  88.         0x09,0x30,
    

  89.         0x09,0x31,
    

  90.         0x09,0x38,
    

  91.         0x15,0x81,
    

  92.         0x25,0x7f,
    

  93.         0x75,0x08,
    

  94.         0x95,0x03,
    

  95.         0x81,0x06,
    

  96.         0xC0,
    

  97.         0xC0
    

  98. };
    


  99. 

  100. /* Configration Descriptor */
    

  101. const UINT8  MyCfgDescr[] =
    

  102. {
    

  103.         //配置描述符
    

  104.         0x09,              //配置描述符长度，标准USB配置描述符长度为9字节
    

  105.         0x02,              //描述符类型，配置描述符为0x02
    

  106.         0x3b, 0x00,        //配置描述符集合总长度，59字节
    

  107.         0x02,              //该配置所支持的接口数，2个接口
    

  108.         0x01,              //表示该配置的值
    

  109.         0x00,              //描述该配置的字符串的索引值，0x00表示没有字符串
    

  110.         0xA0,              //描述设备的一些属性，如供电方式和唤醒等，0xA0表示设备总线供电且支持远程唤醒
    

  111.         0x32,              //设备需要从总线获取的最大电流量，0x32表示最大电流100ma
    


  112. 

  113.         //键盘
    

  114.         //接口描述符,接口描述符不能单独返回，必须附着在配置描述符后一并返回
    

  115.         0x09,              //接口描述符长度，标准的USB接口描述符长度为9字节
    

  116.         0x04,              //描述符类型，接口描述符为0x04
    

  117.         0x00,              //该接口的编号，从0开始，此处为0x00
    

  118.         0x00,              //该接口的备用编号,通常设置为0
    

  119.         0x01,              //该接口所使用的端点数，0x01表示使用1个端点。如果该字段为0，则表示没有非0端点，只使用默认的控制端点
    

  120.         0x03,              //该接口所使用的类，0x03为HID类
    

  121.         0x01,              //该接口所使用的子类
    

  122.         0x01,              //该接口所使用的协议
    

  123.         0x00,              //该接口的字符串的索引值，0x00表示没有字符串
    


  124. 

  125.         //HID类描述符，它是一个类描述符，应该跟在接口描述符后面
    

  126.         0x09,              //该描述符长度，它的大小与该描述符中下级描述符的个数有关。例如只有一个下级描述符时，总长度为9
    

  127.         0x21,              //描述符类型，HID描述符为0x21
    

  128.         0x10,0x01,         //HID协议的版本号，这里参看的HID协议是USB HID1.1协议，因此这里为0x0110
    

  129.         0x00,              //国家代码,是设备所适用的国家。通常我们的键盘是美式键盘，代码为33，即0x21，但此处设置为0x00
    

  130.         0x01,              //下级描述符的数量，该值至少为1，即至少要有一个报告描述符。下级描述符可以是报告描述符或物理描述符
    

  131.         0x22,              //下级描述符的类型，报告描述符的编号为0x22，物理描述符编号为0x23
    

  132.         sizeof(KeyRepDesc)&0xFF, 0x00, //下级描述符的长度
    


  133. 

  134.         //端点描述符，端点描述符不能单独返回，必须附着在配置描述符后一并返回
    

  135.         0x07,              //端点描述符长度，标准的USB端点描述符长度为7字节
    

  136.         0x05,              //描述符类型，端点描述符为0x05
    

  137.         0x81,              //该端点的地址，0x81表示端点1作为输入，最高位D7为该端点的传输方向，1为输入，0为输出。D3-D0为端点号，可设置为0-7，D6-4保留，设为0.
    

  138.         //关于端点属性，最低两位D1-0表示该端点的传输类型，0为控制传输，1为等时传输，2为批量传输，3为中断传输。
    

  139.         0x03,              //该端点的属性，此处为中断传输方式
    

  140.         DevEP0SIZE, 0x00,  //该端点支持的最大包长度，此处设置为64字节
    

  141.         0x0a,              //端点的查询时间。对于中断端点，表示查询的帧间隔数
    


  142. 

  143.         //鼠标
    

  144.         //接口描述符
    

  145.         0x09,              //接口描述符长度，9字节
    

  146.         0x04,              //描述符类型，接口描述符为0x04
    

  147.         0x01,              //该接口的编号，从0开始，此处为0x01
    

  148.         0x00,              //该接口的备用编号
    

  149.         0x01,              //该接口所使用的端点数，0x01表示使用1个端点
    

  150.         0x03,              //该接口所使用的类，0x03为HID类
    

  151.         0x01,              //该接口所使用的子类
    

  152.         0x02,              //该接口所使用的协议
    

  153.         0x00,              //该接口的字符串的索引值，0x00表示没有字符串
    


  154. 

  155.         //HID类描述符
    

  156.         0x09,              //该描述符长度，它的大小与该描述符中下级描述符的个数有关。例如只有一个下级描述符时，总长度为9
    

  157.         0x21,              //描述符类型，HID描述符为0x21
    

  158.         0x10,0x01,         //HID协议的版本号，这里参看的HID协议是USB HID1.1协议，因此这里为0x0110
    

  159.         0x00,              //国家代码,是设备所适用的国家。通常我们的键盘是美式键盘，代码为33，即0x21，但此处设置为0x00
    

  160.         0x01,              //下级描述符的数量，该值至少为1，即至少要有一个报告描述符。下级描述符可以是报告描述符或物理描述符
    

  161.         0x22,              //下级描述符的类型，报告描述符的编号为0x22，物理描述符编号为0x23
    

  162.         sizeof(MouseRepDesc)&0xFF,0x00,  //下级描述符的长度
    


  163. 

  164.         //端点描述符
    

  165.         0x07,              //端点描述符长度，7字节
    

  166.         0x05,              //描述符类型，端点描述符为0x05
    

  167.         0x82,              //该端点的地址，0x82表示端点2作为输入
    

  168.         0x03,              //该端点的属性
    

  169.         DevEP0SIZE, 0x00,  //该端点支持的最大包长度，64字节
    

  170.         0x0a,              //端点的查询时间
    

  171. };
    


  172. 

  173. const UINT8  MyProductIDInfo[] = {0x0E,0x03,'K',0,'&',0,'M',0,'1',0,'0',0,'3',0};
    


  174. 

  175. /* Language Descriptor */
    

  176. const UINT8  MyLangDescr[] = { 0x04, 0x03, 0x09, 0x04 };
    


  177. 

  178. /* Manufactor Descriptor */
    

  179. const UINT8  MyManuInfo[] = { 0x0E, 0x03, 'w', 0, 'c', 0, 'h', 0, '.', 0, 'c', 0, 'n', 0 };
    


  180. 

  181. /* Product Information */
    

  182. const UINT8  MyProdInfo[] = { 0x0C, 0x03, 'C', 0, 'H', 0, '5', 0, '5', 0, '9', 0 };
    


  183. 

  184. /**********************************************************/
    

  185. volatile UINT8   Ready = 0;
    

  186. volatile UINT8   Endp1Busy = 0;  //传输完成控制标志位
    

  187. volatile UINT8   Endp2Busy = 0;
    

  188. UINT8   DevConfig;
    

  189. UINT8   SetupReqCode;
    

  190. UINT16  SetupReqLen;
    

  191. UINT8   HIDKey[8];
    

  192. UINT8   HIDMouse[4];
    

  193. const   UINT8 *pDescr;
    


  194. 

  195. /* Endpoint Buffer */
    

  196. __attribute__ ((aligned(4))) UINT8 EP0_Databuf[64];     //ep0(64)
    

  197. __attribute__ ((aligned(4))) UINT8 EP1_Databuf[64+64];  //ep1_out(64)+ep1_in(64)
    

  198. __attribute__ ((aligned(4))) UINT8 EP2_Databuf[64+64];  //ep2_out(64)+ep2_in(64)
    


  199. 

  200. void USBHD_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast")));
    


  201. 

  202. /*******************************************************************************
    

  203. * Function Name  : USB_DevTransProcess
    

  204. * Description    : USB device transfer process.
    

  205. * Input          : None
    

  206. * Return         : None
    

  207. *******************************************************************************/
    

  208. void USB_DevTransProcess( void )
    

  209. {
    

  210.     UINT8  len, chtype;
    

  211.     UINT8  intflag, errflag = 0;
    


  212. 

  213.     intflag = R8_USB_INT_FG;
    


  214. 

  215.     if( intflag & RB_UIF_TRANSFER )
    

  216.     {
    

  217.         switch ( R8_USB_INT_ST & ( MASK_UIS_TOKEN | MASK_UIS_ENDP ) )
    

  218.         {
    

  219.             case UIS_TOKEN_SETUP:
    

  220.                 R8_UEP0_CTRL = RB_UEP_R_TOG | RB_UEP_T_TOG | UEP_R_RES_ACK | UEP_T_RES_NAK;
    

  221.                 len = R8_USB_RX_LEN;
    


  222. 

  223.                 if ( len == sizeof( USB_SETUP_REQ ) )
    

  224.                 {
    

  225.                     SetupReqLen = pSetupReqPak->wLength;
    

  226.                     SetupReqCode = pSetupReqPak->bRequest;
    

  227.                     chtype = pSetupReqPak->bRequestType;
    


  228. 

  229.                     len = 0;
    

  230.                     errflag = 0;
    


  231. 

  232.                     if ( ( pSetupReqPak->bRequestType & USB_REQ_TYP_MASK ) != USB_REQ_TYP_STANDARD )
    

  233.                     {
    

  234.                         switch(SetupReqCode)
    

  235.                         {
    

  236.                             case 0x01:    //GetReport
    

  237.                                 len = 1;
    

  238.                                 pEP0_DataBuf[0] = 0xaa;
    

  239.                                 break;
    

  240.                             case 0x0a:
    

  241.                                 R8_UEP0_T_LEN = 0;
    

  242.                                 break;    //这个一定要有
    

  243.                             case 0x09:
    

  244.                                 Ready = 1;
    

  245.                                 break;
    

  246.                             default:
    

  247.                                 errflag = 0xFF;
    

  248.                         }
    

  249.                     }
    

  250.                     else
    

  251.                     {
    

  252.                         switch( SetupReqCode )
    

  253.                         {
    

  254.                             case USB_GET_DESCRIPTOR:
    

  255.                             {
    

  256.                                 switch( ((pSetupReqPak->wValue)>>8) )
    

  257.                                 {
    

  258.                                     case USB_DESCR_TYP_DEVICE:
    

  259.                                         pDescr = MyDevDescr;
    

  260.                                         len = MyDevDescr[0];
    

  261.                                         break;
    


  262. 

  263.                                     case USB_DESCR_TYP_CONFIG:
    

  264.                                         pDescr = MyCfgDescr;
    

  265.                                         len = MyCfgDescr[2];
    

  266.                                         break;
    


  267. 

  268.                                     case USB_DESCR_TYP_STRING:
    

  269.                                         switch( (pSetupReqPak->wValue)&0xff )
    

  270.                                         {
    

  271.                                             case 0:
    

  272.                                                 pDescr = MyLangDescr;
    

  273.                                                 len = MyLangDescr[0];
    

  274.                                                 break;
    


  275. 

  276.                                             case 1:
    

  277.                                                 pDescr = MyManuInfo;
    

  278.                                                 len = MyManuInfo[0];
    

  279.                                                 break;
    


  280. 

  281.                                             case 2:
    

  282.                                                 pDescr = MyProdInfo;
    

  283.                                                 len = MyProdInfo[0];
    

  284.                                                 break;
    


  285. 

  286.                                             case 3:
    

  287.                                                 pDescr = MyProductIDInfo;
    

  288.                                                 len = MyProductIDInfo[0];
    

  289.                                                 break;
    


  290. 

  291.                                             default:
    

  292.                                                 errflag = 0xFF;
    

  293.                                                 break;
    

  294.                                         }
    

  295.                                         break;
    


  296. 

  297.                                     case USB_DESCR_TYP_REPORT:
    

  298.                                         if(((pSetupReqPak->wIndex)&0xff) == 0)          //接口0报表描述符
    

  299.                                         {
    

  300.                                             pDescr = KeyRepDesc;                        //数据准备上传
    

  301.                                             len = sizeof(KeyRepDesc);
    

  302.                                         }
    

  303.                                         else if(((pSetupReqPak->wIndex)&0xff) == 1)     //接口1报表描述符
    

  304.                                         {
    

  305.                                             pDescr = MouseRepDesc;                      //数据准备上传
    

  306.                                             len = sizeof(MouseRepDesc);
    

  307.                                             Ready = 1;                                  //如果有更多接口，该标准位应该在最后一个接口配置完成后有效
    

  308.                                         }
    

  309.                                         else len = 0xff;                                //本程序只有2个接口，这句话正常不可能执行
    

  310.                                         break;
    


  311. 

  312.                                     default :
    

  313.                                         errflag = 0xff;
    

  314.                                         break;
    

  315.                                 }
    


  316. 

  317.                                 if( SetupReqLen>len )   SetupReqLen = len;
    

  318.                                 len = (SetupReqLen >= DevEP0SIZE) ? DevEP0SIZE : SetupReqLen;
    

  319.                                 memcpy( pEP0_DataBuf, pDescr, len );
    

  320.                                 pDescr += len;
    

  321.                             }
    

  322.                                 break;
    


  323. 

  324.                             case USB_SET_ADDRESS:
    

  325.                                 SetupReqLen = (pSetupReqPak->wValue)&0xff;
    

  326.                                 break;
    


  327. 

  328.                             case USB_GET_CONFIGURATION:
    

  329.                                 pEP0_DataBuf[0] = DevConfig;
    

  330.                                 if ( SetupReqLen > 1 ) SetupReqLen = 1;
    

  331.                                 break;
    


  332. 

  333.                             case USB_SET_CONFIGURATION:
    

  334.                                 DevConfig = (pSetupReqPak->wValue)&0xff;
    

  335.                                 break;
    


  336. 

  337.                             case USB_CLEAR_FEATURE:
    

  338.                                 if ( ( pSetupReqPak->bRequestType & USB_REQ_RECIP_MASK ) == USB_REQ_RECIP_ENDP )
    

  339.                                 {
    

  340.                                     switch( (pSetupReqPak->wIndex)&0xff )
    

  341.                                     {
    

  342.                                     case 0x82:
    

  343.                                         R8_UEP2_CTRL = (R8_UEP2_CTRL & ~( RB_UEP_T_TOG|MASK_UEP_T_RES )) | UEP_T_RES_NAK;
    

  344.                                         break;
    


  345. 

  346.                                     case 0x02:
    

  347.                                         R8_UEP2_CTRL = (R8_UEP2_CTRL & ~( RB_UEP_R_TOG|MASK_UEP_R_RES )) | UEP_R_RES_ACK;
    

  348.                                         break;
    


  349. 

  350.                                     case 0x81:
    

  351.                                         R8_UEP1_CTRL = (R8_UEP1_CTRL & ~( RB_UEP_T_TOG|MASK_UEP_T_RES )) | UEP_T_RES_NAK;
    

  352.                                         break;
    


  353. 

  354.                                     case 0x01:
    

  355.                                         R8_UEP1_CTRL = (R8_UEP1_CTRL & ~( RB_UEP_R_TOG|MASK_UEP_R_RES )) | UEP_R_RES_ACK;
    

  356.                                         break;
    


  357. 

  358.                                     default:
    

  359.                                         errflag = 0xFF;
    

  360.                                         break;
    

  361.                                     }
    

  362.                                 }
    

  363.                                 else    errflag = 0xFF;
    

  364.                                 break;
    


  365. 

  366.                             case USB_GET_INTERFACE:
    

  367.                                 pEP0_DataBuf[0] = 0x00;
    

  368.                                 if ( SetupReqLen > 1 ) SetupReqLen = 1;
    

  369.                                 break;
    


  370. 

  371.                             case USB_GET_STATUS:
    

  372.                                 pEP0_DataBuf[0] = 0x00;
    

  373.                                 pEP0_DataBuf[1] = 0x00;
    

  374.                                 if ( SetupReqLen > 2 ) SetupReqLen = 2;
    

  375.                                 break;
    


  376. 

  377.                             default:
    

  378.                                 errflag = 0xff;
    

  379.                                 break;
    

  380.                         }
    

  381.                     }
    

  382.                 }
    

  383.                 else    errflag = 0xff;
    


  384. 

  385.                 if( errflag == 0xff)
    

  386.                 {
    

  387.                     R8_UEP0_CTRL = RB_UEP_R_TOG | RB_UEP_T_TOG | UEP_R_RES_STALL | UEP_T_RES_STALL;
    

  388.                 }
    

  389.                 else
    

  390.                 {
    

  391.                     if( chtype & 0x80 )
    

  392.                     {
    

  393.                         len = (SetupReqLen>DevEP0SIZE) ? DevEP0SIZE : SetupReqLen;
    

  394.                         SetupReqLen -= len;
    

  395.                     }
    

  396.                     else  len = 0;
    


  397. 

  398.                     R8_UEP0_T_LEN = len;
    

  399.                     R8_UEP0_CTRL = RB_UEP_R_TOG | RB_UEP_T_TOG | UEP_R_RES_ACK | UEP_T_RES_ACK;
    

  400.                 }
    

  401.                 break;
    


  402. 

  403.             case UIS_TOKEN_IN:
    

  404.                 switch( SetupReqCode )
    

  405.                 {
    

  406.                     case USB_GET_DESCRIPTOR:
    

  407.                         len = SetupReqLen >= DevEP0SIZE ? DevEP0SIZE : SetupReqLen;
    

  408.                         memcpy( pEP0_DataBuf, pDescr, len );
    

  409.                         SetupReqLen -= len;
    

  410.                         pDescr += len;
    

  411.                         R8_UEP0_T_LEN = len;
    

  412.                         R8_UEP0_CTRL ^= RB_UEP_T_TOG;
    

  413.                         break;
    


  414. 

  415.                     case USB_SET_ADDRESS:
    

  416.                         R8_USB_DEV_AD = (R8_USB_DEV_AD&RB_UDA_GP_BIT) | SetupReqLen;
    

  417.                         R8_UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
    

  418.                         break;
    


  419. 

  420.                     default:
    

  421.                         R8_UEP0_T_LEN = 0;
    

  422.                         R8_UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
    

  423.                         break;
    

  424.                 }
    

  425.                 break;
    


  426. 

  427.             case UIS_TOKEN_OUT:
    

  428.                 len = R8_USB_RX_LEN;
    

  429.                 break;
    


  430. 

  431.             case UIS_TOKEN_OUT | 1:
    

  432.                 if ( R8_USB_INT_ST & RB_UIS_TOG_OK )
    

  433.                 {
    

  434.                     len = R8_USB_RX_LEN;
    

  435.                     DevEP1_OUT_Deal( len );
    

  436.                 }
    

  437.                 break;
    


  438. 

  439.             case UIS_TOKEN_IN | 1:
    

  440.                 R8_UEP1_T_LEN = 0;
    

  441.                 Endp1Busy = 0;
    

  442.                 R8_UEP1_CTRL = (R8_UEP1_CTRL & ~MASK_UEP_T_RES) | UEP_T_RES_NAK;
    

  443.                 break;
    


  444. 

  445.             case UIS_TOKEN_OUT | 2:
    

  446.                 if ( R8_USB_INT_ST & RB_UIS_TOG_OK )
    

  447.                 {
    

  448.                     len = R8_USB_RX_LEN;
    

  449.                     DevEP2_OUT_Deal( len );
    

  450.                 }
    

  451.                 break;
    


  452. 

  453.             case UIS_TOKEN_IN | 2:
    

  454.                 R8_UEP2_T_LEN = 0;
    

  455.                 Endp2Busy = 0;
    

  456.                 R8_UEP2_CTRL = (R8_UEP2_CTRL & ~MASK_UEP_T_RES) | UEP_T_RES_NAK;
    

  457.                 break;
    


  458. 

  459.             default :
    

  460.                 break;
    

  461.         }
    

  462.         R8_USB_INT_FG = RB_UIF_TRANSFER;
    

  463.     }
    

  464.     else if( intflag & RB_UIF_BUS_RST )
    

  465.     {
    

  466.         R8_USB_DEV_AD = 0;
    

  467.         R8_UEP0_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK;
    

  468.         R8_UEP1_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK | RB_UEP_AUTO_TOG;
    

  469.         R8_UEP2_CTRL = UEP_R_RES_ACK | UEP_T_RES_NAK | RB_UEP_AUTO_TOG;
    

  470.         R8_USB_INT_FG |= RB_UIF_BUS_RST;
    

  471.     }
    

  472.     else if( intflag & RB_UIF_SUSPEND )
    

  473.     {
    

  474.         if ( R8_USB_MIS_ST & RB_UMS_SUSPEND ) {;}
    

  475.         else{;}
    

  476.         R8_USB_INT_FG = RB_UIF_SUSPEND;
    

  477.     }
    

  478.     else
    

  479.     {
    

  480.         R8_USB_INT_FG = intflag;
    

  481.     }
    

  482. }
    


  483. 

  484. void HIDValueHandle()
    

  485. {
    

  486.     UINT8 i;
    

  487.     i = USART_ReceiveData(USART2);
    

  488.     printf( "%c\n", (UINT8)i );
    

  489.     switch(i)
    

  490.     {
    

  491.     //鼠标数据上传示例
    

  492.         case 'L':                                               //左键
    

  493.             HIDMouse[0] = 0x01;
    

  494.             while( Endp2Busy )
    

  495.             {
    

  496.                 ;                                               //如果忙（上一包数据没有传上去），则等待。
    

  497.             }
    

  498.             Endp2Busy = 1;                                      //设置为忙状态
    

  499.             memcpy(pEP2_IN_DataBuf, HIDMouse, 4);
    

  500.             DevEP2_IN_Deal(4);
    

  501.             HIDMouse[0] = 0;                                    //抬起
    

  502.             while( Endp2Busy )
    

  503.             {
    

  504.                 ;                                               //如果忙（上一包数据没有传上去），则等待。
    

  505.             }
    

  506.             Endp2Busy = 1;                                      //设置为忙状态
    

  507.             memcpy(pEP2_IN_DataBuf, HIDMouse, 4);
    

  508.             DevEP2_IN_Deal(4);
    

  509.             break;
    

  510.         case 'R':                                               //右键
    

  511.             HIDMouse[0] = 0x02;
    

  512.             while( Endp2Busy )
    

  513.             {
    

  514.                 ;                                               //如果忙（上一包数据没有传上去），则等待。
    

  515.             }
    

  516.             Endp2Busy = 1;                                      //设置为忙状态
    

  517.             memcpy(pEP2_IN_DataBuf, HIDMouse, 4);
    

  518.             DevEP2_IN_Deal(4);
    

  519.             HIDMouse[0] = 0;                                    //抬起
    

  520.             while( Endp2Busy )
    

  521.             {
    

  522.                 ;                                               //如果忙（上一包数据没有传上去），则等待。
    

  523.             }
    

  524.             Endp2Busy = 1;                                      //设置为忙状态
    

  525.             memcpy(pEP2_IN_DataBuf, HIDMouse, 4);
    

  526.             DevEP2_IN_Deal(4);
    

  527.             break;
    

  528.     //键盘数据上传示例
    

  529.         case 'A':                                               //A键
    

  530.             HIDKey[2] = 0x04;                                   //按键开始
    

  531.             while( Endp1Busy )
    

  532.             {
    

  533.                 ;                                               //如果忙（上一包数据没有传上去），则等待。
    

  534.             }
    

  535.             Endp1Busy = 1;                                      //设置为忙状态
    

  536.             memcpy(pEP1_IN_DataBuf, HIDKey, 8);
    

  537.             DevEP1_IN_Deal(8);
    

  538.             HIDKey[2] = 0;                                      //按键结束
    

  539.             while( Endp1Busy )
    

  540.             {
    

  541.                 ;                                               //如果忙（上一包数据没有传上去），则等待。
    

  542.             }
    

  543.             Endp1Busy = 1;                                      //设置为忙状态
    

  544.             memcpy(pEP1_IN_DataBuf, HIDKey, 8);
    

  545.             DevEP1_IN_Deal(8);
    

  546.             break;
    

  547.         case 'Q':                                               //CAP键
    

  548.             HIDKey[2] = 0x39;
    

  549.             while( Endp1Busy )
    

  550.             {
    

  551.                 ;                                               //如果忙（上一包数据没有传上去），则等待。
    

  552.             }
    

  553.             Endp1Busy = 1;                                      //设置为忙状态
    

  554.             memcpy(pEP1_IN_DataBuf, HIDKey, 8);
    

  555.             DevEP1_IN_Deal(8);
    

  556.             HIDKey[2] = 0;                                      //按键结束
    

  557.             while( Endp1Busy )
    

  558.             {
    

  559.                 ;                                               //如果忙（上一包数据没有传上去），则等待。
    

  560.             }
    

  561.             Endp1Busy = 1;                                      //设置为忙状态
    

  562.             memcpy(pEP1_IN_DataBuf, HIDKey, 8);
    

  563.             DevEP1_IN_Deal(8);
    

  564.             break;
    

  565.         default:                                                //其他
    

  566.             break;
    

  567.     }
    

  568. }
    

  569. /*******************************************************************************
    

  570. * Function Name  : Set_USBConfig
    

  571. * Description    : Set USB clock.
    

  572. * Input          : None
    

  573. * Return         : None
    

  574. *******************************************************************************/
    

  575. void USBHD_ClockCmd(UINT32 RCC_USBCLKSource,FunctionalState NewState)
    

  576. {
    

  577.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, NewState);
    

  578.     EXTEN->EXTEN_CTR |= EXTEN_USBHD_IO_EN;
    

  579.     RCC_USBCLKConfig(RCC_USBCLKSource);                      //USBclk=PLLclk/1.5=48Mhz
    

  580.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_USBHD,NewState);
    

  581. }
    


  582. 

  583. /*******************************************************************************
    

  584. * Function Name  : main
    

  585. * Description    : Main program.
    

  586. * Input          : None
    

  587. * Return         : None
    

  588. *******************************************************************************/
    

  589. int main(void)
    

  590. {
    

  591.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    

  592.     Delay_Init();
    

  593.     USART2_Printf_Init(115200);
    


  594. 

  595.     printf("SystemClk:%d\r\n",SystemCoreClock);
    

  596.     printf("USBHD Device Test\r\n");
    


  597. 

  598.     pEP0_RAM_Addr = EP0_Databuf;
    

  599.     pEP1_RAM_Addr = EP1_Databuf;
    

  600.     pEP2_RAM_Addr = EP2_Databuf;
    


  601. 

  602.     USBHD_ClockCmd(RCC_USBCLKSource_PLLCLK_1Div5,ENABLE);
    

  603.     USB_DeviceInit();
    

  604.     NVIC_EnableIRQ( USBHD_IRQn );
    


  605. 

  606.     while(1)
    

  607.     {
    

  608.         printf("Ready1=%d\n",Ready);
    

  609.         if(Ready)
    

  610.         {
    

  611.             HIDValueHandle();
    

  612.         }
    

  613.         Delay_Ms(500);
    

  614.     }
    

  615. }
    


  616. 

  617. /*******************************************************************************
    

  618. * Function Name  : DevEP1_OUT_Deal
    

  619. * Description    : Deal device Endpoint 1 OUT.
    

  620. * Input          : l: Data length.
    

  621. * Return         : None
    

  622. *******************************************************************************/
    

  623. void DevEP1_OUT_Deal( UINT8 l )
    

  624. {
    

  625.     ;
    

  626. }
    


  627. 

  628. /*******************************************************************************
    

  629. * Function Name  : DevEP2_OUT_Deal
    

  630. * Description    : Deal device Endpoint 2 OUT.
    

  631. * Input          : l: Data length.
    

  632. * Return         : None
    

  633. *******************************************************************************/
    

  634. void DevEP2_OUT_Deal( UINT8 l )
    

  635. {
    

  636.     ;
    

  637. }
    


  638. 

  639. /*******************************************************************************
    

  640. * Function Name  : USB_IRQHandler
    

  641. * Description    : This function handles USB exception.
    

  642. * Input          : None
    

  643. * Return         : None
    

  644. *******************************************************************************/
    

  645. void USBHD_IRQHandler (void)
    

  646. {
    

  647.     USB_DevTransProcess();
    

  648. }
main.c文件中本人对各种描述符都进行了注释，便于大家理解，有不懂地方可以参考《圈圈教你玩USB》。关于USB设备传输过程，可结合应用手册关于USB寄存器介绍进行理解学习。

4、下载验证
将编译好的程序下载到开发板并复位，打开串口调试助手，串口打印如下：
图片1.png
用公对公USB线将开发板与电脑连接起来，打开设备管理器可以看到端口中多了一个键盘设备和鼠标设备，如图所示：
图片2.png 图片3.png
串口调试助手发送L，显示如下：
图片4.png

CH32V103 USB模拟鼠标键盘设备.rar

498.8 KB, 下载次数: 321
回复 赏

举报

相关帖子
zealerlu 发表于 2021-11-20 22:09 | 显示全部楼层
感谢楼主~~
回复 赏

举报

quark 发表于 2022-2-23 12:22 | 显示全部楼层
感谢
回复 赏

举报

probedog 发表于 2022-2-25 10:39 | 显示全部楼层
分享的资料挺全
回复 赏

举报

onlycook 发表于 2022-3-7 15:31 来自手机 | 显示全部楼层
感谢分享
回复 赏

举报

gygp 发表于 2023-2-2 09:31 | 显示全部楼层
普通i/o可以模拟USB键盘吗
回复 赏

举报

wwppd 发表于 2023-2-6 12:41 | 显示全部楼层
用单片机怎么制作电脑USB或者PS/2键盘
回复 赏

举报

mikewalpole 发表于 2023-2-6 16:06 | 显示全部楼层
ch375 模拟HID鼠标吗？              
回复 赏

举报

ingramward 发表于 2023-2-7 20:43 | 显示全部楼层
如何用单片机模拟键盘控制电脑               
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

RISCVLAR

133

主题

296

帖子

44

粉丝
快速回复 在线客服 返回列表 返回顶部