21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › USBD_HID_Keyboard，最新例程
返回列表 发新帖我要提问

[DemoCode下载] USBD_HID_Keyboard，最新例程

[复制链接]
1197|10
 楼主| 天灵灵地灵灵 发表于 2020-7-4 23:04 | 显示全部楼层 |阅读模式
USB, HID, keyboard, rc
复制
  1. /******************************************************************************
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]     main.c
    

  3.  * @brief
    

  4.  *           Demonstrate how to implement a USB keyboard device.
    

  5.  *           It supports to use GPIO to simulate key input.
    

  6.  * @note
    

  7.  * Copyright (C) 2016 Nuvoton Technology Corp. All rights reserved.
    

  8.  ******************************************************************************/
    

  9. #include <stdio.h>
    

  10. #include "NUC029xGE.h"
    

  11. #include "hid_kb.h"
    


  12. 

  13. /* If crystal-less is enabled, system won't use any crystal as clock source
    

  14.    If using crystal-less, system will be 48MHz, otherwise, system is 72MHz
    

  15. */
    

  16. #define CRYSTAL_LESS        1
    

  17. #define HIRC48_AUTO_TRIM    0x412   /* Use USB signal to fine tune HIRC 48MHz */
    

  18. #define TRIM_INIT           (SYS_BASE+0x118)
    


  19. 

  20. /*--------------------------------------------------------------------------*/
    

  21. uint8_t volatile g_u8EP2Ready = 0;
    

  22. int IsDebugFifoEmpty(void);
    


  23. 


  24. 

  25. void SYS_Init(void)
    

  26. {
    


  27. 

  28.     /*---------------------------------------------------------------------------------------------------------*/
    

  29.     /* Init System Clock                                                                                       */
    

  30.     /*---------------------------------------------------------------------------------------------------------*/
    


  31. 

  32.     /* Enable Internal RC 22.1184 MHz clock */
    

  33.     CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk);
    


  34. 

  35.     /* Waiting for Internal RC clock ready */
    

  36.     CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk);
    


  37. 

  38.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
    

  39.     CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_HIRC, CLK_CLKDIV0_HCLK(1));
    


  40. 

  41. #if (!CRYSTAL_LESS)
    

  42.     /* Enable external XTAL 12 MHz clock */
    

  43.     CLK_EnableXtalRC(CLK_PWRCTL_HXTEN_Msk);
    


  44. 

  45.     /* Waiting for external XTAL clock ready */
    

  46.     CLK_WaitClockReady(CLK_STATUS_HXTSTB_Msk);
    


  47. 

  48.     /* Set core clock */
    

  49.     CLK_SetCoreClock(72000000);
    


  50. 

  51.     /* Use HIRC as UART clock source */
    

  52.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UARTSEL_HIRC, CLK_CLKDIV0_UART(1));
    


  53. 

  54.     /* Use PLL as USB clock source */
    

  55.     CLK_SetModuleClock(USBD_MODULE, CLK_CLKSEL3_USBDSEL_PLL, CLK_CLKDIV0_USB(3));
    


  56. 

  57. #else
    

  58.     /* Enable Internal RC 48MHz clock */
    

  59.     CLK_EnableXtalRC(CLK_PWRCTL_HIRC48EN_Msk);
    


  60. 

  61.     /* Waiting for Internal RC clock ready */
    

  62.     CLK_WaitClockReady(CLK_STATUS_HIRC48STB_Msk);
    


  63. 

  64.     /* Switch HCLK clock source to Internal RC and HCLK source divide 1 */
    

  65.     CLK_SetHCLK(CLK_CLKSEL0_HCLKSEL_HIRC48, CLK_CLKDIV0_HCLK(1));
    


  66. 

  67.     /* Use HIRC as UART clock source */
    

  68.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UARTSEL_HIRC, CLK_CLKDIV0_UART(1));
    


  69. 

  70.     /* Use HIRC48 as USB clock source */
    

  71.     CLK_SetModuleClock(USBD_MODULE, CLK_CLKSEL3_USBDSEL_HIRC48, CLK_CLKDIV0_USB(1));
    

  72. #endif
    


  73. 

  74.     /* Enable module clock */
    

  75.     CLK_EnableModuleClock(UART0_MODULE);
    

  76.     CLK_EnableModuleClock(USBD_MODULE);
    


  77. 


  78. 

  79.     /*---------------------------------------------------------------------------------------------------------*/
    

  80.     /* Init I/O Multi-function                                                                                 */
    

  81.     /*---------------------------------------------------------------------------------------------------------*/
    


  82. 

  83.     /* Set PA multi-function pins for UART0 RXD and TXD */
    

  84.     SYS->GPA_MFPL &= ~(SYS_GPA_MFPL_PA3MFP_Msk | SYS_GPA_MFPL_PA2MFP_Msk);
    

  85.     SYS->GPA_MFPL |= (SYS_GPA_MFPL_PA3MFP_UART0_RXD | SYS_GPA_MFPL_PA2MFP_UART0_TXD);
    

  86. }
    


  87. 


  88. 

  89. void UART0_Init(void)
    

  90. {
    

  91.     /*---------------------------------------------------------------------------------------------------------*/
    

  92.     /* Init UART                                                                                               */
    

  93.     /*---------------------------------------------------------------------------------------------------------*/
    

  94.     /* Reset IP */
    

  95.     SYS->IPRST1 |=  SYS_IPRST1_UART0RST_Msk;
    

  96.     SYS->IPRST1 &= ~SYS_IPRST1_UART0RST_Msk;
    


  97. 

  98.     /* Configure UART0 and set UART0 Baudrate */
    

  99.     UART0->BAUD = UART_BAUD_MODE2 | UART_BAUD_MODE2_DIVIDER(__HIRC, 115200);
    

  100.     UART0->LINE = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;
    

  101. }
    


  102. 


  103. 

  104. void HID_UpdateKbData(void)
    

  105. {
    

  106.     int32_t i;
    

  107.     uint8_t *buf;
    

  108.     uint32_t key = 0xF;
    

  109.     static uint32_t preKey;
    


  110. 

  111.     if(g_u8EP2Ready)
    

  112.     {
    

  113.         buf = (uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP2));
    


  114. 

  115.         /* If PB15 = 0, just report it is key 'a' */
    

  116.         key = (PB->PIN & (1 << 15)) ? 0 : 1;
    


  117. 

  118.         if(key == 0)
    

  119.         {
    

  120.             for(i = 0; i < 8; i++)
    

  121.             {
    

  122.                 buf[i] = 0;
    

  123.             }
    


  124. 

  125.             if(key != preKey)
    

  126.             {
    

  127.                 /* Trigger to note key release */
    

  128.                 USBD_SET_PAYLOAD_LEN(EP2, 8);
    

  129.             }
    

  130.         }
    

  131.         else
    

  132.         {
    

  133.             preKey = key;
    

  134.             buf[2] = 0x04; /* Key A */
    

  135.             USBD_SET_PAYLOAD_LEN(EP2, 8);
    

  136.         }
    

  137.     }
    

  138. }
    


  139. 

  140. void PowerDown()
    

  141. {
    

  142.     /* Unlock protected registers */
    

  143.     SYS_UnlockReg();
    


  144. 

  145.     printf("Enter power down ...\n");
    

  146.     while(!IsDebugFifoEmpty());
    


  147. 

  148.     /* Wakeup Enable */
    

  149.     USBD_ENABLE_INT(USBD_INTEN_WKEN_Msk);
    


  150. 

  151.     CLK_PowerDown();
    


  152. 

  153.     /* Clear PWR_DOWN_EN if it is not clear by itself */
    

  154.     if(CLK->PWRCTL & CLK_PWRCTL_PDEN_Msk)
    

  155.         CLK->PWRCTL ^= CLK_PWRCTL_PDEN_Msk;
    


  156. 

  157.     printf("device wakeup!\n");
    


  158. 

  159.     /* Lock protected registers */
    

  160.     SYS_LockReg();
    

  161. }
    


  162. 

  163. /*---------------------------------------------------------------------------------------------------------*/
    

  164. /*  Main Function                                                                                          */
    

  165. /*---------------------------------------------------------------------------------------------------------*/
    

  166. int32_t main(void)
    

  167. {
    

  168. #if CRYSTAL_LESS
    

  169.     uint32_t u32TrimInit;
    

  170. #endif
    


  171. 

  172.     /* Unlock protected registers */
    

  173.     SYS_UnlockReg();
    


  174. 

  175.     SYS_Init();
    

  176.     UART0_Init();
    


  177. 

  178.     printf("\n");
    

  179.     printf("+--------------------------------------------------------+\n");
    

  180.     printf("|          NuMicro USB HID Keyboard Sample Code          |\n");
    

  181.     printf("+--------------------------------------------------------+\n");
    

  182.     printf("If PB15 = 0, just report it is key 'a'.\n");
    


  183. 

  184.     USBD_Open(&gsInfo, HID_ClassRequest, NULL);
    


  185. 

  186.     /* Endpoint configuration */
    

  187.     HID_Init();
    

  188.     USBD_Start();
    


  189. 

  190.     /* Enable USB device interrupt */
    

  191.     NVIC_EnableIRQ(USBD_IRQn);
    


  192. 

  193. #if CRYSTAL_LESS
    

  194.     /* Backup default trim */
    

  195.     u32TrimInit = M32(TRIM_INIT);
    

  196. #endif
    


  197. 

  198.     /* Clear SOF */
    

  199.     USBD->INTSTS = USBD_INTSTS_SOFIF_Msk;
    


  200. 

  201.     /* start to IN data */
    

  202.     g_u8EP2Ready = 1;
    


  203. 

  204.     while(1)
    

  205.     {
    

  206. #if CRYSTAL_LESS
    

  207.         /* Start USB trim if it is not enabled. */
    

  208.         if((SYS->IRCTCTL1 & SYS_IRCTCTL1_FREQSEL_Msk) != 2)
    

  209.         {
    

  210.             /* Start USB trim only when SOF */
    

  211.             if(USBD->INTSTS & USBD_INTSTS_SOFIF_Msk)
    

  212.             {
    

  213.                 /* Clear SOF */
    

  214.                 USBD->INTSTS = USBD_INTSTS_SOFIF_Msk;
    


  215. 

  216.                 /* Re-enable crystal-less */
    

  217.                 SYS->IRCTCTL1 = HIRC48_AUTO_TRIM;
    

  218.             }
    

  219.         }
    


  220. 

  221.         /* Disable USB Trim when error */
    

  222.         if(SYS->IRCTISTS & (SYS_IRCTISTS_CLKERRIF1_Msk | SYS_IRCTISTS_TFAILIF1_Msk))
    

  223.         {
    

  224.             /* Init TRIM */
    

  225.             M32(TRIM_INIT) = u32TrimInit;
    


  226. 

  227.             /* Disable crystal-less */
    

  228.             SYS->IRCTCTL1 = 0;
    


  229. 

  230.             /* Clear error flags */
    

  231.             SYS->IRCTISTS = SYS_IRCTISTS_CLKERRIF1_Msk | SYS_IRCTISTS_TFAILIF1_Msk;
    


  232. 

  233.             /* Clear SOF */
    

  234.             USBD->INTSTS = USBD_INTSTS_SOFIF_Msk;
    

  235.         }
    

  236. #endif
    


  237. 

  238.         /* Enter power down when USB suspend */
    

  239.         if(g_u8Suspend)
    

  240.             PowerDown();
    


  241. 

  242.         HID_UpdateKbData();
    

  243.     }
    

  244. }
    


  245. 


  246. 


  247. 

  248. /*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
    


  249.


回复

收藏 举报

相关帖子
 楼主| 天灵灵地灵灵 发表于 2020-7-4 23:05 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * @file     hid_kb.h
    

  3.  * @brief    NUC029xGE series USB HID keyboard header file
    

  4.  *
    

  5.  * @note
    

  6.  * Copyright (C) 2016 Nuvoton Technology Corp. All rights reserved.
    

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

  8. #ifndef __USBD_HID_H__
    

  9. #define __USBD_HID_H__
    


  10. 

  11. /* Define the vendor id and product id */
    

  12. #define USBD_VID        0x0416
    

  13. #define USBD_PID        0x0123
    


  14. 

  15. /*!<Define HID Class Specific Request */
    

  16. #define GET_REPORT          0x01
    

  17. #define GET_IDLE            0x02
    

  18. #define GET_PROTOCOL        0x03
    

  19. #define SET_REPORT          0x09
    

  20. #define SET_IDLE            0x0A
    

  21. #define SET_PROTOCOL        0x0B
    


  22. 

  23. /*!<USB HID Interface Class protocol */
    

  24. #define HID_NONE            0x00
    

  25. #define HID_KEYBOARD        0x01
    

  26. #define HID_MOUSE           0x02
    


  27. 

  28. /*!<USB HID Class Report Type */
    

  29. #define HID_RPT_TYPE_INPUT      0x01
    

  30. #define HID_RPT_TYPE_OUTPUT     0x02
    

  31. #define HID_RPT_TYPE_FEATURE    0x03
    


  32. 

  33. /*-------------------------------------------------------------*/
    

  34. /* Define EP maximum packet size */
    

  35. #define EP0_MAX_PKT_SIZE    8
    

  36. #define EP1_MAX_PKT_SIZE    EP0_MAX_PKT_SIZE
    

  37. #define EP2_MAX_PKT_SIZE    8
    


  38. 

  39. #define SETUP_BUF_BASE  0
    

  40. #define SETUP_BUF_LEN   8
    

  41. #define EP0_BUF_BASE    (SETUP_BUF_BASE + SETUP_BUF_LEN)
    

  42. #define EP0_BUF_LEN     EP0_MAX_PKT_SIZE
    

  43. #define EP1_BUF_BASE    (SETUP_BUF_BASE + SETUP_BUF_LEN)
    

  44. #define EP1_BUF_LEN     EP1_MAX_PKT_SIZE
    

  45. #define EP2_BUF_BASE    (EP1_BUF_BASE + EP1_BUF_LEN)
    

  46. #define EP2_BUF_LEN     EP2_MAX_PKT_SIZE
    


  47. 

  48. /* Define the interrupt In EP number */
    

  49. #define INT_IN_EP_NUM   0x01
    


  50. 

  51. /* Define Descriptor information */
    

  52. #define HID_DEFAULT_INT_IN_INTERVAL     20
    

  53. #define USBD_SELF_POWERED               0
    

  54. #define USBD_REMOTE_WAKEUP              0
    

  55. #define USBD_MAX_POWER                  50  /* The unit is in 2mA. ex: 50 * 2mA = 100mA */
    


  56. 

  57. #define LEN_CONFIG_AND_SUBORDINATE      (LEN_CONFIG+LEN_INTERFACE+LEN_HID+LEN_ENDPOINT)
    


  58. 


  59. 

  60. /*-------------------------------------------------------------*/
    

  61. extern uint8_t volatile g_u8EP2Ready;
    

  62. extern uint8_t volatile g_u8Suspend;
    


  63. 

  64. /*-------------------------------------------------------------*/
    

  65. void HID_Init(void);
    

  66. void HID_ClassRequest(void);
    

  67. void EP2_Handler(void);
    


  68. 

  69. #endif  /* __USBD_HID_H_ */
    


  70. 

  71. /*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
回复

收藏 举报

 楼主| 天灵灵地灵灵 发表于 2020-7-4 23:05 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * @file     hid_kb.c
    

  3.  * @brief    NUC029xGE series USBD HID keyboard sample file
    

  4.  *
    

  5.  * @note
    

  6.  * Copyright (C) 2016 Nuvoton Technology Corp. All rights reserved.
    

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


  8. 

  9. /*!<Includes */
    

  10. #include <string.h>
    

  11. #include "NUC029xGE.h"
    

  12. #include "usbd.h"
    

  13. #include "hid_kb.h"
    


  14. 

  15. uint8_t volatile g_u8Suspend = 0;
    

  16. uint8_t g_u8Idle = 0, g_u8Protocol = 0;
    


  17. 

  18. void USBD_IRQHandler(void)
    

  19. {
    

  20.     uint32_t u32IntSts = USBD_GET_INT_FLAG();
    

  21.     uint32_t u32State = USBD_GET_BUS_STATE();
    


  22. 

  23. //------------------------------------------------------------------
    

  24.     if(u32IntSts & USBD_INTSTS_FLDET)
    

  25.     {
    

  26.         // Floating detect
    

  27.         USBD_CLR_INT_FLAG(USBD_INTSTS_FLDET);
    


  28. 

  29.         if(USBD_IS_ATTACHED())
    

  30.         {
    

  31.             /* USB Plug In */
    

  32.             USBD_ENABLE_USB();
    

  33.         }
    

  34.         else
    

  35.         {
    

  36.             /* USB Un-plug */
    

  37.             USBD_DISABLE_USB();
    

  38.         }
    

  39.     }
    


  40. 

  41. //------------------------------------------------------------------
    

  42.     if(u32IntSts & USBD_INTSTS_WAKEUP)
    

  43.     {
    

  44.         /* Clear event flag */
    

  45.         USBD_CLR_INT_FLAG(USBD_INTSTS_WAKEUP);
    

  46.     }
    


  47. 

  48. //------------------------------------------------------------------
    

  49.     if(u32IntSts & USBD_INTSTS_BUS)
    

  50.     {
    

  51.         /* Clear event flag */
    

  52.         USBD_CLR_INT_FLAG(USBD_INTSTS_BUS);
    


  53. 

  54.         if(u32State & USBD_STATE_USBRST)
    

  55.         {
    

  56.             /* Bus reset */
    

  57.             USBD_ENABLE_USB();
    

  58.             USBD_SwReset();
    

  59.             g_u8Suspend = 0;
    

  60.         }
    

  61.         if(u32State & USBD_STATE_SUSPEND)
    

  62.         {
    

  63.             /* Enter power down to wait USB attached */
    

  64.             g_u8Suspend = 1;
    


  65. 

  66.             /* Enable USB but disable PHY */
    

  67.             USBD_DISABLE_PHY();
    

  68.         }
    

  69.         if(u32State & USBD_STATE_RESUME)
    

  70.         {
    

  71.             /* Enable USB and enable PHY */
    

  72.             USBD_ENABLE_USB();
    

  73.             g_u8Suspend = 0;
    

  74.         }
    

  75.     }
    


  76. 

  77. //------------------------------------------------------------------
    

  78.     if(u32IntSts & USBD_INTSTS_USB)
    

  79.     {
    

  80.         // USB event
    

  81.         if(u32IntSts & USBD_INTSTS_SETUP)
    

  82.         {
    

  83.             // Setup packet
    

  84.             /* Clear event flag */
    

  85.             USBD_CLR_INT_FLAG(USBD_INTSTS_SETUP);
    


  86. 

  87.             /* Clear the data IN/OUT ready flag of control end-points */
    

  88.             USBD_STOP_TRANSACTION(EP0);
    

  89.             USBD_STOP_TRANSACTION(EP1);
    


  90. 

  91.             USBD_ProcessSetupPacket();
    

  92.         }
    


  93. 

  94.         // EP events
    

  95.         if(u32IntSts & USBD_INTSTS_EP0)
    

  96.         {
    

  97.             /* Clear event flag */
    

  98.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP0);
    

  99.             // control IN
    

  100.             USBD_CtrlIn();
    

  101.         }
    


  102. 

  103.         if(u32IntSts & USBD_INTSTS_EP1)
    

  104.         {
    

  105.             /* Clear event flag */
    

  106.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP1);
    


  107. 

  108.             // control OUT
    

  109.             USBD_CtrlOut();
    

  110.         }
    


  111. 

  112.         if(u32IntSts & USBD_INTSTS_EP2)
    

  113.         {
    

  114.             /* Clear event flag */
    

  115.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP2);
    

  116.             // Interrupt IN
    

  117.             EP2_Handler();
    

  118.         }
    


  119. 

  120.         if(u32IntSts & USBD_INTSTS_EP3)
    

  121.         {
    

  122.             /* Clear event flag */
    

  123.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP3);
    

  124.         }
    


  125. 

  126.         if(u32IntSts & USBD_INTSTS_EP4)
    

  127.         {
    

  128.             /* Clear event flag */
    

  129.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP4);
    

  130.         }
    


  131. 

  132.         if(u32IntSts & USBD_INTSTS_EP5)
    

  133.         {
    

  134.             /* Clear event flag */
    

  135.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP5);
    

  136.         }
    


  137. 

  138.         if(u32IntSts & USBD_INTSTS_EP6)
    

  139.         {
    

  140.             /* Clear event flag */
    

  141.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP6);
    

  142.         }
    


  143. 

  144.         if(u32IntSts & USBD_INTSTS_EP7)
    

  145.         {
    

  146.             /* Clear event flag */
    

  147.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP7);
    

  148.         }
    

  149.     }
    

  150. }
    


  151. 

  152. void EP2_Handler(void)  /* Interrupt IN handler */
    

  153. {
    

  154.     g_u8EP2Ready = 1;
    

  155. }
    


  156. 


  157. 

  158. /*--------------------------------------------------------------------------*/
    

  159. /**
    

  160.   * @brief  USBD Endpoint Config.
    

  161.   * @param  None.
    

  162.   * @retval None.
    

  163.   */
    

  164. void HID_Init(void)
    

  165. {
    

  166.     /* Init setup packet buffer */
    

  167.     /* Buffer range for setup packet -> [0 ~ 0x7] */
    

  168.     USBD->STBUFSEG = SETUP_BUF_BASE;
    


  169. 

  170.     /*****************************************************/
    

  171.     /* EP0 ==> control IN endpoint, address 0 */
    

  172.     USBD_CONFIG_EP(EP0, USBD_CFG_CSTALL | USBD_CFG_EPMODE_IN | 0);
    

  173.     /* Buffer range for EP0 */
    

  174.     USBD_SET_EP_BUF_ADDR(EP0, EP0_BUF_BASE);
    


  175. 

  176.     /* EP1 ==> control OUT endpoint, address 0 */
    

  177.     USBD_CONFIG_EP(EP1, USBD_CFG_CSTALL | USBD_CFG_EPMODE_OUT | 0);
    

  178.     /* Buffer range for EP1 */
    

  179.     USBD_SET_EP_BUF_ADDR(EP1, EP1_BUF_BASE);
    


  180. 

  181.     /*****************************************************/
    

  182.     /* EP2 ==> Interrupt IN endpoint, address 1 */
    

  183.     USBD_CONFIG_EP(EP2, USBD_CFG_EPMODE_IN | INT_IN_EP_NUM);
    

  184.     /* Buffer range for EP2 */
    

  185.     USBD_SET_EP_BUF_ADDR(EP2, EP2_BUF_BASE);
    


  186. 

  187. }
    


  188. 

  189. void HID_ClassRequest(void)
    

  190. {
    

  191.     uint8_t buf[8];
    


  192. 

  193.     USBD_GetSetupPacket(buf);
    


  194. 

  195.     if(buf[0] & 0x80)    /* request data transfer direction */
    

  196.     {
    

  197.         // Device to host
    

  198.         switch(buf[1])
    

  199.         {
    

  200.             case GET_REPORT:
    

  201. //            {
    

  202. //                break;
    

  203. //            }
    

  204.             case GET_IDLE:
    

  205.             {
    

  206.                 USBD_SET_PAYLOAD_LEN(EP1, buf[6]);
    

  207.                 /* Data stage */
    

  208.                 USBD_PrepareCtrlIn(&g_u8Idle, buf[6]);
    

  209.                 /* Status stage */
    

  210.                 USBD_PrepareCtrlOut(0, 0);
    

  211.                 break;
    

  212.             }
    

  213.             case GET_PROTOCOL:
    

  214.             {
    

  215.                 USBD_SET_PAYLOAD_LEN(EP1, buf[6]);
    

  216.                 /* Data stage */
    

  217.                 USBD_PrepareCtrlIn(&g_u8Protocol, buf[6]);
    

  218.                 /* Status stage */
    

  219.                 USBD_PrepareCtrlOut(0, 0);
    

  220.                 break;
    

  221.             }
    

  222.             default:
    

  223.             {
    

  224.                 /* Setup error, stall the device */
    

  225.                 USBD_SetStall(EP0);
    

  226.                 USBD_SetStall(EP1);
    

  227.                 break;
    

  228.             }
    

  229.         }
    

  230.     }
    

  231.     else
    

  232.     {
    

  233.         // Host to device
    

  234.         switch(buf[1])
    

  235.         {
    

  236.             case SET_REPORT:
    

  237.             {
    

  238.                 if(buf[3] == 2)
    

  239.                 {
    

  240.                     /* Request Type = Output */
    

  241.                     USBD_SET_DATA1(EP1);
    

  242.                     USBD_SET_PAYLOAD_LEN(EP1, buf[6]);
    


  243. 

  244.                     /* Status stage */
    

  245.                     USBD_PrepareCtrlIn(0, 0);
    

  246.                 }
    

  247.                 break;
    

  248.             }
    

  249.             case SET_IDLE:
    

  250.             {
    

  251.                 g_u8Idle = buf[3];
    

  252.                 /* Status stage */
    

  253.                 USBD_SET_DATA1(EP0);
    

  254.                 USBD_SET_PAYLOAD_LEN(EP0, 0);
    

  255.                 break;
    

  256.             }
    

  257.             case SET_PROTOCOL:
    

  258.             {
    

  259.                 g_u8Protocol = buf[2];
    

  260.                 /* Status stage */
    

  261.                 USBD_SET_DATA1(EP0);
    

  262.                 USBD_SET_PAYLOAD_LEN(EP0, 0);
    

  263.                 break;
    

  264.             }
    

  265.             default:
    

  266.             {
    

  267.                 // Stall
    

  268.                 /* Setup error, stall the device */
    

  269.                 USBD_SetStall(EP0);
    

  270.                 USBD_SetStall(EP1);
    

  271.                 break;
    

  272.             }
    

  273.         }
    

  274.     }
    

  275. }
    


  276. 

  277. /*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
    


  278.
回复

收藏 举报

 楼主| 天灵灵地灵灵 发表于 2020-7-4 23:06 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * @file     hid_kb.c
    

  3.  * @brief    NUC029xGE series USBD HID keyboard sample file
    

  4.  *
    

  5.  * @note
    

  6.  * Copyright (C) 2016 Nuvoton Technology Corp. All rights reserved.
    

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


  8. 

  9. /*!<Includes */
    

  10. #include <string.h>
    

  11. #include "NUC029xGE.h"
    

  12. #include "usbd.h"
    

  13. #include "hid_kb.h"
    


  14. 

  15. uint8_t volatile g_u8Suspend = 0;
    

  16. uint8_t g_u8Idle = 0, g_u8Protocol = 0;
    


  17. 

  18. void USBD_IRQHandler(void)
    

  19. {
    

  20.     uint32_t u32IntSts = USBD_GET_INT_FLAG();
    

  21.     uint32_t u32State = USBD_GET_BUS_STATE();
    


  22. 

  23. //------------------------------------------------------------------
    

  24.     if(u32IntSts & USBD_INTSTS_FLDET)
    

  25.     {
    

  26.         // Floating detect
    

  27.         USBD_CLR_INT_FLAG(USBD_INTSTS_FLDET);
    


  28. 

  29.         if(USBD_IS_ATTACHED())
    

  30.         {
    

  31.             /* USB Plug In */
    

  32.             USBD_ENABLE_USB();
    

  33.         }
    

  34.         else
    

  35.         {
    

  36.             /* USB Un-plug */
    

  37.             USBD_DISABLE_USB();
    

  38.         }
    

  39.     }
    


  40. 

  41. //------------------------------------------------------------------
    

  42.     if(u32IntSts & USBD_INTSTS_WAKEUP)
    

  43.     {
    

  44.         /* Clear event flag */
    

  45.         USBD_CLR_INT_FLAG(USBD_INTSTS_WAKEUP);
    

  46.     }
    


  47. 

  48. //------------------------------------------------------------------
    

  49.     if(u32IntSts & USBD_INTSTS_BUS)
    

  50.     {
    

  51.         /* Clear event flag */
    

  52.         USBD_CLR_INT_FLAG(USBD_INTSTS_BUS);
    


  53. 

  54.         if(u32State & USBD_STATE_USBRST)
    

  55.         {
    

  56.             /* Bus reset */
    

  57.             USBD_ENABLE_USB();
    

  58.             USBD_SwReset();
    

  59.             g_u8Suspend = 0;
    

  60.         }
    

  61.         if(u32State & USBD_STATE_SUSPEND)
    

  62.         {
    

  63.             /* Enter power down to wait USB attached */
    

  64.             g_u8Suspend = 1;
    


  65. 

  66.             /* Enable USB but disable PHY */
    

  67.             USBD_DISABLE_PHY();
    

  68.         }
    

  69.         if(u32State & USBD_STATE_RESUME)
    

  70.         {
    

  71.             /* Enable USB and enable PHY */
    

  72.             USBD_ENABLE_USB();
    

  73.             g_u8Suspend = 0;
    

  74.         }
    

  75.     }
    


  76. 

  77. //------------------------------------------------------------------
    

  78.     if(u32IntSts & USBD_INTSTS_USB)
    

  79.     {
    

  80.         // USB event
    

  81.         if(u32IntSts & USBD_INTSTS_SETUP)
    

  82.         {
    

  83.             // Setup packet
    

  84.             /* Clear event flag */
    

  85.             USBD_CLR_INT_FLAG(USBD_INTSTS_SETUP);
    


  86. 

  87.             /* Clear the data IN/OUT ready flag of control end-points */
    

  88.             USBD_STOP_TRANSACTION(EP0);
    

  89.             USBD_STOP_TRANSACTION(EP1);
    


  90. 

  91.             USBD_ProcessSetupPacket();
    

  92.         }
    


  93. 

  94.         // EP events
    

  95.         if(u32IntSts & USBD_INTSTS_EP0)
    

  96.         {
    

  97.             /* Clear event flag */
    

  98.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP0);
    

  99.             // control IN
    

  100.             USBD_CtrlIn();
    

  101.         }
    


  102. 

  103.         if(u32IntSts & USBD_INTSTS_EP1)
    

  104.         {
    

  105.             /* Clear event flag */
    

  106.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP1);
    


  107. 

  108.             // control OUT
    

  109.             USBD_CtrlOut();
    

  110.         }
    


  111. 

  112.         if(u32IntSts & USBD_INTSTS_EP2)
    

  113.         {
    

  114.             /* Clear event flag */
    

  115.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP2);
    

  116.             // Interrupt IN
    

  117.             EP2_Handler();
    

  118.         }
    


  119. 

  120.         if(u32IntSts & USBD_INTSTS_EP3)
    

  121.         {
    

  122.             /* Clear event flag */
    

  123.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP3);
    

  124.         }
    


  125. 

  126.         if(u32IntSts & USBD_INTSTS_EP4)
    

  127.         {
    

  128.             /* Clear event flag */
    

  129.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP4);
    

  130.         }
    


  131. 

  132.         if(u32IntSts & USBD_INTSTS_EP5)
    

  133.         {
    

  134.             /* Clear event flag */
    

  135.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP5);
    

  136.         }
    


  137. 

  138.         if(u32IntSts & USBD_INTSTS_EP6)
    

  139.         {
    

  140.             /* Clear event flag */
    

  141.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP6);
    

  142.         }
    


  143. 

  144.         if(u32IntSts & USBD_INTSTS_EP7)
    

  145.         {
    

  146.             /* Clear event flag */
    

  147.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP7);
    

  148.         }
    

  149.     }
    

  150. }
    


  151. 

  152. void EP2_Handler(void)  /* Interrupt IN handler */
    

  153. {
    

  154.     g_u8EP2Ready = 1;
    

  155. }
    


  156. 


  157. 

  158. /*--------------------------------------------------------------------------*/
    

  159. /**
    

  160.   * @brief  USBD Endpoint Config.
    

  161.   * @param  None.
    

  162.   * @retval None.
    

  163.   */
    

  164. void HID_Init(void)
    

  165. {
    

  166.     /* Init setup packet buffer */
    

  167.     /* Buffer range for setup packet -> [0 ~ 0x7] */
    

  168.     USBD->STBUFSEG = SETUP_BUF_BASE;
    


  169. 

  170.     /*****************************************************/
    

  171.     /* EP0 ==> control IN endpoint, address 0 */
    

  172.     USBD_CONFIG_EP(EP0, USBD_CFG_CSTALL | USBD_CFG_EPMODE_IN | 0);
    

  173.     /* Buffer range for EP0 */
    

  174.     USBD_SET_EP_BUF_ADDR(EP0, EP0_BUF_BASE);
    


  175. 

  176.     /* EP1 ==> control OUT endpoint, address 0 */
    

  177.     USBD_CONFIG_EP(EP1, USBD_CFG_CSTALL | USBD_CFG_EPMODE_OUT | 0);
    

  178.     /* Buffer range for EP1 */
    

  179.     USBD_SET_EP_BUF_ADDR(EP1, EP1_BUF_BASE);
    


  180. 

  181.     /*****************************************************/
    

  182.     /* EP2 ==> Interrupt IN endpoint, address 1 */
    

  183.     USBD_CONFIG_EP(EP2, USBD_CFG_EPMODE_IN | INT_IN_EP_NUM);
    

  184.     /* Buffer range for EP2 */
    

  185.     USBD_SET_EP_BUF_ADDR(EP2, EP2_BUF_BASE);
    


  186. 

  187. }
    


  188. 

  189. void HID_ClassRequest(void)
    

  190. {
    

  191.     uint8_t buf[8];
    


  192. 

  193.     USBD_GetSetupPacket(buf);
    


  194. 

  195.     if(buf[0] & 0x80)    /* request data transfer direction */
    

  196.     {
    

  197.         // Device to host
    

  198.         switch(buf[1])
    

  199.         {
    

  200.             case GET_REPORT:
    

  201. //            {
    

  202. //                break;
    

  203. //            }
    

  204.             case GET_IDLE:
    

  205.             {
    

  206.                 USBD_SET_PAYLOAD_LEN(EP1, buf[6]);
    

  207.                 /* Data stage */
    

  208.                 USBD_PrepareCtrlIn(&g_u8Idle, buf[6]);
    

  209.                 /* Status stage */
    

  210.                 USBD_PrepareCtrlOut(0, 0);
    

  211.                 break;
    

  212.             }
    

  213.             case GET_PROTOCOL:
    

  214.             {
    

  215.                 USBD_SET_PAYLOAD_LEN(EP1, buf[6]);
    

  216.                 /* Data stage */
    

  217.                 USBD_PrepareCtrlIn(&g_u8Protocol, buf[6]);
    

  218.                 /* Status stage */
    

  219.                 USBD_PrepareCtrlOut(0, 0);
    

  220.                 break;
    

  221.             }
    

  222.             default:
    

  223.             {
    

  224.                 /* Setup error, stall the device */
    

  225.                 USBD_SetStall(EP0);
    

  226.                 USBD_SetStall(EP1);
    

  227.                 break;
    

  228.             }
    

  229.         }
    

  230.     }
    

  231.     else
    

  232.     {
    

  233.         // Host to device
    

  234.         switch(buf[1])
    

  235.         {
    

  236.             case SET_REPORT:
    

  237.             {
    

  238.                 if(buf[3] == 2)
    

  239.                 {
    

  240.                     /* Request Type = Output */
    

  241.                     USBD_SET_DATA1(EP1);
    

  242.                     USBD_SET_PAYLOAD_LEN(EP1, buf[6]);
    


  243. 

  244.                     /* Status stage */
    

  245.                     USBD_PrepareCtrlIn(0, 0);
    

  246.                 }
    

  247.                 break;
    

  248.             }
    

  249.             case SET_IDLE:
    

  250.             {
    

  251.                 g_u8Idle = buf[3];
    

  252.                 /* Status stage */
    

  253.                 USBD_SET_DATA1(EP0);
    

  254.                 USBD_SET_PAYLOAD_LEN(EP0, 0);
    

  255.                 break;
    

  256.             }
    

  257.             case SET_PROTOCOL:
    

  258.             {
    

  259.                 g_u8Protocol = buf[2];
    

  260.                 /* Status stage */
    

  261.                 USBD_SET_DATA1(EP0);
    

  262.                 USBD_SET_PAYLOAD_LEN(EP0, 0);
    

  263.                 break;
    

  264.             }
    

  265.             default:
    

  266.             {
    

  267.                 // Stall
    

  268.                 /* Setup error, stall the device */
    

  269.                 USBD_SetStall(EP0);
    

  270.                 USBD_SetStall(EP1);
    

  271.                 break;
    

  272.             }
    

  273.         }
    

  274.     }
    

  275. }
    


  276. 

  277. /*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
    


  278.
回复

收藏 举报

 楼主| 天灵灵地灵灵 发表于 2020-7-4 23:06 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * @file     descriptors.c
    

  3.  * @brief    NUC029xGE series USBD descriptor
    

  4.  *
    

  5.  * @note
    

  6.  * Copyright (C) 2016 Nuvoton Technology Corp. All rights reserved.
    

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

  8. #ifndef __DESCRIPTORS_C__
    

  9. #define __DESCRIPTORS_C__
    


  10. 

  11. /*!<Includes */
    

  12. #include "NUC029xGE.h"
    

  13. #include "usbd.h"
    

  14. #include "hid_kb.h"
    


  15. 

  16. /*!<USB HID Report Descriptor */
    

  17. const uint8_t HID_KeyboardReportDescriptor[] =
    

  18. {
    

  19.     0x05, 0x01,     /* Usage Page(Generic Desktop Controls) */
    

  20.     0x09, 0x06,     /* Usage(Keyboard) */
    

  21.     0xA1, 0x01,     /* Collection(Application) */
    

  22.     0x05, 0x07,         /* Usage Page(Keyboard/Keypad) */
    

  23.     0x19, 0xE0,         /* Usage Minimum(0xE0) */
    

  24.     0x29, 0xE7,         /* Usage Maximum(0xE7) */
    

  25.     0x15, 0x00,         /* Logical Minimum(0x0) */
    

  26.     0x25, 0x01,         /* Logical Maximum(0x1) */
    

  27.     0x75, 0x01,         /* Report Size(0x1) */
    

  28.     0x95, 0x08,         /* Report Count(0x8) */
    

  29.     0x81, 0x02,         /* Input (Data) => Modifier byte */
    

  30.     0x95, 0x01,         /* Report Count(0x1) */
    

  31.     0x75, 0x08,         /* Report Size(0x8) */
    

  32.     0x81, 0x01,         /* Input (Constant) => Reserved byte */
    

  33.     0x95, 0x05,         /* Report Count(0x5) */
    

  34.     0x75, 0x01,         /* Report Size(0x1) */
    

  35.     0x05, 0x08,         /* Usage Page(LEDs) */
    

  36.     0x19, 0x01,         /* Usage Minimum(0x1) */
    

  37.     0x29, 0x05,         /* Usage Maximum(0x5) */
    

  38.     0x91, 0x02,         /* Output (Data) => LED report */
    

  39.     0x95, 0x01,         /* Report Count(0x1) */
    

  40.     0x75, 0x03,         /* Report Size(0x3) */
    

  41.     0x91, 0x01,         /* Output (Constant) => LED report padding */
    

  42.     0x95, 0x06,         /* Report Count(0x6) */
    

  43.     0x75, 0x08,         /* Report Size(0x8) */
    

  44.     0x15, 0x00,         /* Logical Minimum(0x0) */
    

  45.     0x25, 0x65,         /* Logical Maximum(0x65) */
    

  46.     0x05, 0x07,         /* Usage Page(Keyboard/Keypad) */
    

  47.     0x19, 0x00,         /* Usage Minimum(0x0) */
    

  48.     0x29, 0x65,         /* Usage Maximum(0x65) */
    

  49.     0x81, 0x00,         /* Input (Data) */
    

  50.     0xC0,           /* End Collection */
    

  51. };
    


  52. 


  53. 


  54. 


  55. 

  56. /*----------------------------------------------------------------------------*/
    

  57. /*!<USB Device Descriptor */
    

  58. const uint8_t gu8DeviceDescriptor[] =
    

  59. {
    

  60.     LEN_DEVICE,     /* bLength */
    

  61.     DESC_DEVICE,    /* bDescriptorType */
    

  62. #ifdef SUPPORT_LPM
    

  63.     0x01, 0x02,     /* bcdUSB >= 0x0201 to support LPM */
    

  64. #else
    

  65.     0x10, 0x01,     /* bcdUSB */
    

  66. #endif
    

  67.     0x00,           /* bDeviceClass */
    

  68.     0x00,           /* bDeviceSubClass */
    

  69.     0x00,           /* bDeviceProtocol */
    

  70.     EP0_MAX_PKT_SIZE,   /* bMaxPacketSize0 */
    

  71.     /* idVendor */
    

  72.     USBD_VID & 0x00FF,
    

  73.     (USBD_VID & 0xFF00) >> 8,
    

  74.     /* idProduct */
    

  75.     USBD_PID & 0x00FF,
    

  76.     (USBD_PID & 0xFF00) >> 8,
    

  77.     0x00, 0x00,     /* bcdDevice */
    

  78.     0x01,           /* iManufacture */
    

  79.     0x02,           /* iProduct */
    

  80.     0x03,           /* iSerialNumber - no serial */
    

  81.     0x01            /* bNumConfigurations */
    

  82. };
    


  83. 

  84. /*!<USB Configure Descriptor */
    

  85. const uint8_t gu8ConfigDescriptor[] =
    

  86. {
    

  87.     LEN_CONFIG,     /* bLength */
    

  88.     DESC_CONFIG,    /* bDescriptorType */
    

  89.     /* wTotalLength */
    

  90.     LEN_CONFIG_AND_SUBORDINATE & 0x00FF,
    

  91.     (LEN_CONFIG_AND_SUBORDINATE & 0xFF00) >> 8,
    

  92.     0x01,           /* bNumInterfaces */
    

  93.     0x01,           /* bConfigurationValue */
    

  94.     0x00,           /* iConfiguration */
    

  95.     0x80 | (USBD_SELF_POWERED << 6) | (USBD_REMOTE_WAKEUP << 5),/* bmAttributes */
    

  96.     USBD_MAX_POWER,         /* MaxPower */
    


  97. 

  98.     /* I/F descr: HID */
    

  99.     LEN_INTERFACE,  /* bLength */
    

  100.     DESC_INTERFACE, /* bDescriptorType */
    

  101.     0x00,           /* bInterfaceNumber */
    

  102.     0x00,           /* bAlternateSetting */
    

  103.     0x01,           /* bNumEndpoints */
    

  104.     0x03,           /* bInterfaceClass */
    

  105.     0x01,           /* bInterfaceSubClass */
    

  106.     HID_KEYBOARD,   /* bInterfaceProtocol */
    

  107.     0x00,           /* iInterface */
    


  108. 

  109.     /* HID Descriptor */
    

  110.     LEN_HID,        /* Size of this descriptor in UINT8s. */
    

  111.     DESC_HID,       /* HID descriptor type. */
    

  112.     0x10, 0x01,     /* HID Class Spec. release number. */
    

  113.     0x00,           /* H/W target country. */
    

  114.     0x01,           /* Number of HID class descriptors to follow. */
    

  115.     DESC_HID_RPT,   /* Descriptor type. */
    

  116.     /* Total length of report descriptor. */
    

  117.     sizeof(HID_KeyboardReportDescriptor) & 0x00FF,
    

  118.     (sizeof(HID_KeyboardReportDescriptor) & 0xFF00) >> 8,
    


  119. 

  120.     /* EP Descriptor: interrupt in. */
    

  121.     LEN_ENDPOINT,   /* bLength */
    

  122.     DESC_ENDPOINT,  /* bDescriptorType */
    

  123.     (INT_IN_EP_NUM | EP_INPUT), /* bEndpointAddress */
    

  124.     EP_INT,         /* bmAttributes */
    

  125.     /* wMaxPacketSize */
    

  126.     EP2_MAX_PKT_SIZE & 0x00FF,
    

  127.     (EP2_MAX_PKT_SIZE & 0xFF00) >> 8,
    

  128.     HID_DEFAULT_INT_IN_INTERVAL     /* bInterval */
    

  129. };
    


  130. 

  131. /*!<USB Language String Descriptor */
    

  132. const uint8_t gu8StringLang[4] =
    

  133. {
    

  134.     4,              /* bLength */
    

  135.     DESC_STRING,    /* bDescriptorType */
    

  136.     0x09, 0x04
    

  137. };
    


  138. 

  139. /*!<USB Vendor String Descriptor */
    

  140. const uint8_t gu8VendorStringDesc[] =
    

  141. {
    

  142.     16,
    

  143.     DESC_STRING,
    

  144.     'N', 0, 'u', 0, 'v', 0, 'o', 0, 't', 0, 'o', 0, 'n', 0
    

  145. };
    


  146. 

  147. /*!<USB Product String Descriptor */
    

  148. const uint8_t gu8ProductStringDesc[] =
    

  149. {
    

  150.     26,
    

  151.     DESC_STRING,
    

  152.     'H', 0, 'I', 0, 'D', 0, ' ', 0, 'K', 0, 'e', 0, 'y', 0, 'b', 0, 'o', 0, 'a', 0, 'r', 0, 'd', 0
    

  153. };
    


  154. 


  155. 

  156. const uint8_t gu8StringSerial[26] =
    

  157. {
    

  158.     26,             // bLength
    

  159.     DESC_STRING,    // bDescriptorType
    

  160.     'A', 0, '0', 0, '2', 0, '0', 0, '1', 0, '4', 0, '0', 0, '9', 0, '0', 0, '3', 0, '0', 0, '2', 0
    

  161. };
    


  162. 

  163. const uint8_t *gpu8UsbString[4] =
    

  164. {
    

  165.     gu8StringLang,
    

  166.     gu8VendorStringDesc,
    

  167.     gu8ProductStringDesc,
    

  168.     gu8StringSerial
    

  169. };
    


  170. 

  171. const uint8_t *gpu8UsbHidReport[3] =
    

  172. {
    

  173.     HID_KeyboardReportDescriptor,
    

  174.     NULL,
    

  175.     NULL
    

  176. };
    


  177. 

  178. const uint32_t gu32UsbHidReportLen[3] =
    

  179. {
    

  180.     sizeof(HID_KeyboardReportDescriptor),
    

  181.     0,
    

  182.     0
    

  183. };
    


  184. 

  185. const uint32_t gu32ConfigHidDescIdx[3] =
    

  186. {
    

  187.     (LEN_CONFIG + LEN_INTERFACE),
    

  188.     0,
    

  189.     0
    

  190. };
    


  191. 

  192. #ifdef SUPPORT_LPM
    

  193. const uint8_t gu8BosDescriptor[] =
    

  194. {
    

  195.     LEN_BOS,        /* bLength */
    

  196.     DESC_BOS,       /* bDescriptorType */
    

  197.     /* wTotalLength */
    

  198.     0x0C & 0x00FF,
    

  199.     (0x0C & 0xFF00) >> 8,
    

  200.     0x01,           /* bNumDeviceCaps */
    


  201. 

  202.     /* Device Capability */
    

  203.     LEN_DEVCAP,     /* bLength */
    

  204.     DESC_DEVCAP,/* bDescriptorType */
    

  205.     0x02,  /* bDevCapabilityType, 0x02 is USB 2.0 Extension */
    

  206.     0x06, 0x04, 0x00, 0x00  /* bmAttributes, 32 bits */
    

  207.                             /* bit 0 : Reserved. Must 0. */
    

  208.                             /* bit 1 : 1 to support LPM. */
    

  209.                             /* bit 2 : 1 to support BSL & Alternat HIRD. */
    

  210.                             /* bit 3 : 1 to recommend Baseline BESL. */
    

  211.                             /* bit 4 : 1 to recommand Deep BESL. */
    

  212.                             /* bit 11:8 : Recommend Baseline BESL value. Ignore by bit3 is zero. */
    

  213.                             /* bit 15:12 : Recommend Deep BESL value. Ignore by bit4 is zero. */
    

  214.                             /* bit 31:16 : Reserved. Must 0. */
    

  215. };
    

  216. #endif
    


  217. 

  218. const S_USBD_INFO_T gsInfo =
    

  219. {
    

  220.     gu8DeviceDescriptor,
    

  221.     gu8ConfigDescriptor,
    

  222.     gpu8UsbString,
    

  223.     gpu8UsbHidReport,
    

  224.     gu32UsbHidReportLen,
    

  225.     gu32ConfigHidDescIdx,
    

  226. #ifdef SUPPORT_LPM
    

  227.     gu8BosDescriptor
    

  228. #else
    

  229.     NULL
    

  230. #endif
    

  231. };
    


  232. 


  233. 

  234. #endif  /* __DESCRIPTORS_C__ */
    


  235. 

  236. /*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
回复

收藏 举报

aoyi 发表于 2020-8-3 17:40 | 显示全部楼层
非常感谢楼主分享
回复

收藏 举报

drer 发表于 2020-8-3 17:41 | 显示全部楼层
真的是最新的
回复

收藏 举报

gwsan 发表于 2020-8-3 17:41 | 显示全部楼层
感谢楼主热心发代码
回复

收藏 举报

kxsi 发表于 2020-8-3 17:41 | 显示全部楼层
支持楼主 干货啊
回复

收藏 举报

nawu 发表于 2020-8-3 17:41 | 显示全部楼层
路过 学习了
回复

收藏 举报

yiy 发表于 2020-8-3 21:12 | 显示全部楼层
还带USB接口，真是帅呆了。
回复

收藏 举报

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

本版积分规则

天灵灵地灵灵

183

主题

3475

帖子

13

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