21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › M031的USB打印机
返回列表 发新帖我要提问

[DemoCode下载] M031的USB打印机

[复制链接]
2008|6
 楼主| xuanhuanzi 发表于 2019-6-23 18:51 | 显示全部楼层 |阅读模式
打印机, USB, rc, TE
复制
  1. /******************************************************************************
    

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

  3.  * [url=home.php?mod=space&uid=895143]@version[/url]  V1.00
    

  4.  * $Revision: 10 $
    

  5.  * $Date: 18/07/18 3:37p $
    

  6.  * [url=home.php?mod=space&uid=247401]@brief[/url]    Demonstrate how to implement a composite device.(USB micro printer device and HID Transfer).
    

  7.  *           Transfer data between USB device and PC through USB HID interface.
    

  8.  *           A windows tool is also included in this sample code to connect with a USB device.
    

  9.  *
    

  10.  * @note
    

  11.  *           Windows tool: User need to input the specific PID for the USB HID device connected to PC.
    

  12.  *                         PID format with hexadecimal.
    

  13.  *
    

  14.  *           -> PID is 0xAABB in this sample.
    

  15.  *
    

  16.  * Copyright (C) 2018 Nuvoton Technology Corp. All rights reserved.
    

  17.  *****************************************************************************/
    

  18. #include <stdio.h>
    

  19. #include "M031Series.h"
    

  20. #include "micro_printer_and_hid_transfer.h"
    


  21. 

  22. #define CRYSTAL_LESS        1    /* CRYSTAL_LESS must be 1 if USB clock source is HIRC */
    

  23. #define TRIM_INIT           (SYS_BASE+0x118)
    


  24. 

  25. extern uint8_t volatile g_u8Suspend;
    

  26. int IsDebugFifoEmpty(void);
    


  27. 

  28. void SYS_Init(void)
    

  29. {
    

  30.     /* Unlock protected registers */
    

  31.     SYS_UnlockReg();
    


  32. 

  33.     /* Enable HIRC clock */
    

  34.     CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk);
    


  35. 

  36.     /* Waiting for HIRC clock ready */
    

  37.     CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk);
    


  38. 

  39.     /* Switch HCLK clock source to HIRC and HCLK source divide 1 */
    

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


  41. 

  42.     /* Switch UART0 clock source to HIRC */
    

  43.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART0SEL_HIRC, CLK_CLKDIV0_UART0(1));
    


  44. 

  45.     /* Enable UART0 clock */
    

  46.     CLK_EnableModuleClock(UART0_MODULE);
    


  47. 

  48.     /* Switch USB clock source to HIRC & USB Clock = HIRC / 1 */
    

  49.     CLK_SetModuleClock(USBD_MODULE, CLK_CLKSEL0_USBDSEL_HIRC, CLK_CLKDIV0_USB(1));
    


  50. 

  51.     /* Enable USB clock */
    

  52.     CLK_EnableModuleClock(USBD_MODULE);
    


  53. 

  54.     /* Update System Core Clock */
    

  55.     SystemCoreClockUpdate();
    


  56. 

  57.     /* Set PB multi-function pins for UART0 RXD=PB.12 and TXD=PB.13 */
    

  58.     SYS->GPB_MFPH = (SYS->GPB_MFPH & ~(SYS_GPB_MFPH_PB12MFP_Msk | SYS_GPB_MFPH_PB13MFP_Msk))
    

  59.                     |(SYS_GPB_MFPH_PB12MFP_UART0_RXD | SYS_GPB_MFPH_PB13MFP_UART0_TXD);
    


  60. 

  61.     /* Lock protected registers */
    

  62.     SYS_LockReg();
    

  63. }
    


  64. 

  65. void PowerDown()
    

  66. {
    

  67.     /* Unlock protected registers */
    

  68.     SYS_UnlockReg();
    


  69. 

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

  71.     while(!IsDebugFifoEmpty());
    


  72. 

  73.     /* Wakeup Enable */
    

  74.     USBD_ENABLE_INT(USBD_INTEN_WKEN_Msk);
    


  75. 

  76.     CLK_PowerDown();
    


  77. 

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

  79.     if(CLK->PWRCTL & CLK_PWRCTL_PDEN_Msk)
    

  80.         CLK->PWRCTL ^= CLK_PWRCTL_PDEN_Msk;
    


  81. 

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


  83. 

  84.     /* Lock protected registers */
    

  85.     SYS_LockReg();
    

  86. }
    


  87. 

  88. /*---------------------------------------------------------------------------------------------------------*/
    

  89. /*  Main Function                                                                                          */
    

  90. /*---------------------------------------------------------------------------------------------------------*/
    

  91. int32_t main(void)
    

  92. {
    

  93. #if CRYSTAL_LESS
    

  94.     uint32_t u32TrimInit;
    

  95. #endif
    

  96.     uint8_t Str[9];
    


  97. 

  98.     /* Unlock protected registers */
    

  99.     SYS_UnlockReg();
    


  100. 

  101.     /* Init System, peripheral clock and multi-function I/O */
    

  102.     SYS_Init();
    


  103. 

  104.     /* Init UART0 to 115200-8n1 for print message */
    

  105.     UART_Open(UART0, 115200);
    


  106. 

  107.     printf("\n");
    

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

  109.     printf("|       NuMicro USB Composite Device Sample Code        |\n");
    

  110.     printf("|      USB Micro Printer + HID Transfer (PID:AABB)      |\n");
    

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


  112. 

  113.     /* Open USB controller */
    

  114.     USBD_Open(&gsInfo, PTR_ClassRequest, NULL);
    


  115. 

  116.     /* Endpoint configuration */
    

  117.     PTR_Init();
    


  118. 

  119.     /* Start USB device */
    

  120.     USBD_Start();
    


  121. 

  122. #if CRYSTAL_LESS
    

  123.     /* Backup init trim */
    

  124.     u32TrimInit = M32(TRIM_INIT);
    


  125. 

  126.     /* Waiting for USB bus stable */
    

  127.     USBD_CLR_INT_FLAG(USBD_INTSTS_SOFIF_Msk);
    

  128.     while((USBD_GET_INT_FLAG() & USBD_INTSTS_SOFIF_Msk) == 0);
    


  129. 

  130.     /* Enable USB crystal-less - Set reference clock from USB SOF packet & Enable HIRC auto trim function */
    

  131.     SYS->HIRCTRIMCTL |= (SYS_HIRCTRIMCTL_REFCKSEL_Msk | 0x1);
    

  132. #endif
    


  133. 

  134.     NVIC_EnableIRQ(USBD_IRQn);
    


  135. 

  136.     while(1)
    

  137.     {
    

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

  139.         if(g_u8Suspend)
    

  140.             PowerDown();
    


  141. 

  142.         CLK_SysTickDelay(2000);   // delay
    


  143. 

  144.         if (++Str[1] > 0x39)
    

  145.             Str[1] = 0x30;      // increase 1 to 10 than reset to 0
    


  146. 

  147. #if CRYSTAL_LESS
    

  148.         /* Re-start crystal-less when any error found */
    

  149.         if (SYS->HIRCTRIMSTS & (SYS_HIRCTRIMSTS_TFAILIF_Msk | SYS_HIRCTRIMSTS_CLKERIF_Msk))
    

  150.         {
    

  151.             SYS->HIRCTRIMSTS = SYS_HIRCTRIMSTS_TFAILIF_Msk | SYS_HIRCTRIMSTS_CLKERIF_Msk;
    


  152. 

  153.             /* Init TRIM */
    

  154.             M32(TRIM_INIT) = u32TrimInit;
    


  155. 

  156.             /* Waiting for USB bus stable */
    

  157.             USBD_CLR_INT_FLAG(USBD_INTSTS_SOFIF_Msk);
    

  158.             while((USBD_GET_INT_FLAG() & USBD_INTSTS_SOFIF_Msk) == 0);
    


  159. 

  160.             /* Re-enable crystal-less - Set reference clock from USB SOF packet & Enable HIRC auto trim function */
    

  161.             SYS->HIRCTRIMCTL |= (SYS_HIRCTRIMCTL_REFCKSEL_Msk | 0x1);
    

  162.             //printf("USB trim fail. Just retry. SYS->HIRCTRIMSTS = 0x%x, SYS->HIRCTRIMCTL = 0x%x\n", SYS->HIRCTRIMSTS, SYS->HIRCTRIMCTL);
    

  163.         }
    

  164. #endif
    

  165.     }
    

  166. }
    


  167. 


  168. 


  169. 

  170. /*** (C) COPYRIGHT 2018 Nuvoton Technology Corp. ***/
    


  171.


回复

收藏 举报

相关帖子
 楼主| xuanhuanzi 发表于 2019-6-23 18:52 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * @file     micro_printer_and_hid_transfer.h
    

  3.  * @version  V1.00
    

  4.  * $Revision: 4 $
    

  5.  * $Date: 18/04/03 10:29a $
    

  6.  * @brief    M031 series USB driver header file
    

  7.  *
    

  8.  * @note
    

  9.  * Copyright (C) 2018 Nuvoton Technology Corp. All rights reserved.
    

  10.  *****************************************************************************/
    


  11. 

  12. #ifndef __USBD_PRINTER_H__
    

  13. #define __USBD_PRINTER_H__
    


  14. 

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

  16. #define USBD_VID        0x0416
    

  17. #define USBD_PID        0xAABB
    


  18. 

  19. /*!<Define CDC Class Specific Request */
    

  20. #define SET_LINE_CODE           0x20
    

  21. #define GET_LINE_CODE           0x21
    

  22. #define SET_CONTROL_LINE_STATE  0x22
    


  23. 

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

  25. #define GET_REPORT          0x01
    

  26. #define GET_IDLE            0x02
    

  27. #define GET_PROTOCOL        0x03
    

  28. #define SET_REPORT          0x09
    

  29. #define SET_IDLE            0x0A
    

  30. #define SET_PROTOCOL        0x0B
    


  31. 

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

  33. #define HID_NONE            0x00
    

  34. #define HID_KEYBOARD        0x01
    

  35. #define HID_MOUSE           0x02
    


  36. 

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

  38. #define HID_RPT_TYPE_INPUT      0x01
    

  39. #define HID_RPT_TYPE_OUTPUT     0x02
    

  40. #define HID_RPT_TYPE_FEATURE    0x03
    


  41. 

  42. /*-------------------------------------------------------------*/
    

  43. /* Define EP maximum packet size */
    

  44. #define EP0_MAX_PKT_SIZE    64
    

  45. #define EP1_MAX_PKT_SIZE    EP0_MAX_PKT_SIZE
    

  46. #define EP2_MAX_PKT_SIZE    64
    

  47. #define EP3_MAX_PKT_SIZE    64
    

  48. #define EP4_MAX_PKT_SIZE    8
    

  49. #define EP5_MAX_PKT_SIZE    64
    

  50. #define EP6_MAX_PKT_SIZE    64
    


  51. 

  52. #define SETUP_BUF_BASE      0
    

  53. #define SETUP_BUF_LEN       8
    

  54. #define EP0_BUF_BASE        (SETUP_BUF_BASE + SETUP_BUF_LEN)
    

  55. #define EP0_BUF_LEN         EP0_MAX_PKT_SIZE
    

  56. #define EP1_BUF_BASE        (SETUP_BUF_BASE + SETUP_BUF_LEN)
    

  57. #define EP1_BUF_LEN         EP1_MAX_PKT_SIZE
    

  58. #define EP2_BUF_BASE        (EP1_BUF_BASE + EP1_BUF_LEN)
    

  59. #define EP2_BUF_LEN         EP2_MAX_PKT_SIZE
    

  60. #define EP3_BUF_BASE        (EP2_BUF_BASE + EP2_BUF_LEN)
    

  61. #define EP3_BUF_LEN         EP3_MAX_PKT_SIZE
    

  62. #define EP4_BUF_BASE        (EP3_BUF_BASE + EP3_BUF_LEN)
    

  63. #define EP4_BUF_LEN         EP4_MAX_PKT_SIZE
    

  64. #define EP5_BUF_BASE        (EP4_BUF_BASE + EP4_BUF_LEN)
    

  65. #define EP5_BUF_LEN         EP5_MAX_PKT_SIZE
    

  66. #define EP6_BUF_BASE        (EP5_BUF_BASE + EP5_BUF_LEN)
    

  67. #define EP6_BUF_LEN         EP6_MAX_PKT_SIZE
    


  68. 

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

  70. #define BULK_IN_EP_NUM      0x01
    

  71. #define BULK_OUT_EP_NUM     0x02
    

  72. #define INT_IN_EP_NUM       0x03
    

  73. #define INT_IN_EP_NUM_1     0x04
    

  74. #define INT_OUT_EP_NUM      0x05
    


  75. 

  76. /* Define Descriptor information */
    

  77. #define HID_DEFAULT_INT_IN_INTERVAL     1
    

  78. #define USBD_SELF_POWERED               0
    

  79. #define USBD_REMOTE_WAKEUP              0
    

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


  81. 

  82. /************************************************/
    

  83. #define  GET_PORT_STATUS           0x01
    


  84. 


  85. 

  86. /*-------------------------------------------------------------*/
    

  87. void PTR_Init(void);
    

  88. void PTR_ClassRequest(void);
    

  89. void PTR_Data_Receive(void);
    


  90. 

  91. void EP5_Handler(void);
    

  92. void EP6_Handler(void);
    

  93. void HID_SetInReport(void);
    

  94. void HID_GetOutReport(uint8_t *pu8EpBuf, uint32_t u32Size);
    


  95. 

  96. #endif  /* __USBD_PRINTER_H_ */
    


  97. 

  98. /*** (C) COPYRIGHT 2018 Nuvoton Technology Corp. ***/
回复

收藏 举报

 楼主| xuanhuanzi 发表于 2019-6-23 18:52 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * @file     micro_printer_and_hid_transfer.c
    

  3.  * @version  V1.00
    

  4.  * $Revision: 10 $
    

  5.  * $Date: 18/07/18 4:49p $
    

  6.  * @brief    M031 series USBD driver Sample file
    

  7.  *
    

  8.  * @note
    

  9.  * Copyright (C) 2018 Nuvoton Technology Corp. All rights reserved.
    

  10.  *****************************************************************************/
    

  11. #include <stdio.h>
    

  12. #include <string.h>
    

  13. #include "NuMicro.h"
    

  14. #include "micro_printer_and_hid_transfer.h"
    


  15. 

  16. uint8_t volatile g_u8Suspend = 0;
    


  17. 

  18. /*--------------------------------------------------------------------------*/
    

  19. void USBD_IRQHandler(void)
    

  20. {
    

  21.     uint32_t volatile u32IntSts = USBD_GET_INT_FLAG();
    

  22.     uint32_t volatile u32State = USBD_GET_BUS_STATE();
    


  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.     if (u32IntSts & USBD_INTSTS_BUS)
    

  42.     {
    

  43.         /* Clear event flag */
    

  44.         USBD_CLR_INT_FLAG(USBD_INTSTS_BUS);
    


  45. 

  46.         if (u32State & USBD_STATE_USBRST)
    

  47.         {
    

  48.             /* Bus reset */
    

  49.             USBD_ENABLE_USB();
    

  50.             USBD_SwReset();
    

  51.             g_u8Suspend = 0;
    

  52.         }
    

  53.         if (u32State & USBD_STATE_SUSPEND)
    

  54.         {
    

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

  56.             g_u8Suspend = 1;
    


  57. 

  58.             /* Enable USB but disable PHY */
    

  59.             USBD_DISABLE_PHY();
    

  60.         }
    

  61.         if (u32State & USBD_STATE_RESUME)
    

  62.         {
    

  63.             /* Enable USB and enable PHY */
    

  64.             USBD_ENABLE_USB();
    

  65.             g_u8Suspend = 0;
    

  66.         }
    

  67.     }
    


  68. 

  69.     if(u32IntSts & USBD_INTSTS_SOF)
    

  70.     {
    

  71.         /* Clear SOF flag */
    

  72.         USBD_CLR_INT_FLAG(USBD_INTSTS_SOF);
    

  73.     }
    


  74. 

  75.     if(u32IntSts & USBD_INTSTS_WAKEUP)
    

  76.     {
    

  77.         /* Clear event flag */
    

  78.         USBD_CLR_INT_FLAG(USBD_INTSTS_WAKEUP);
    

  79.     }
    


  80. 

  81.     if (u32IntSts & USBD_INTSTS_USB)
    

  82.     {
    

  83.         /* USB event */
    

  84.         if (u32IntSts & USBD_INTSTS_SETUP)
    

  85.         {
    

  86.             /* Setup packet */
    

  87.             /* Clear event flag */
    

  88.             USBD_CLR_INT_FLAG(USBD_INTSTS_SETUP);
    


  89. 

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

  91.             USBD_STOP_TRANSACTION(EP0);
    

  92.             USBD_STOP_TRANSACTION(EP1);
    


  93. 

  94.             USBD_ProcessSetupPacket();
    

  95.         }
    


  96. 

  97.         /* EP events */
    

  98.         if (u32IntSts & USBD_INTSTS_EP0)
    

  99.         {
    

  100.             /* Clear event flag */
    

  101.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP0);
    

  102.             /* control IN */
    

  103.             USBD_CtrlIn();
    

  104.         }
    


  105. 

  106.         if (u32IntSts & USBD_INTSTS_EP1)
    

  107.         {
    

  108.             /* Clear event flag */
    

  109.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP1);
    

  110.             /* control OUT */
    

  111.             USBD_CtrlOut();
    

  112.         }
    


  113. 

  114.         if (u32IntSts & USBD_INTSTS_EP2)
    

  115.         {
    

  116.             /* Clear event flag */
    

  117.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP2);
    

  118.         }
    


  119. 

  120.         if (u32IntSts & USBD_INTSTS_EP3)
    

  121.         {
    

  122.             /* Clear event flag */
    

  123.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP3);
    

  124.             /* Bulk Out -> receive printer data */
    

  125.             PTR_Data_Receive();
    

  126.         }
    


  127. 

  128.         if (u32IntSts & USBD_INTSTS_EP4)
    

  129.         {
    

  130.             /* Clear event flag */
    

  131.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP4);
    

  132.         }
    


  133. 

  134.         if (u32IntSts & USBD_INTSTS_EP5)
    

  135.         {
    

  136.             /* Clear event flag */
    

  137.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP5);
    

  138.             /* Interrupt IN */
    

  139.             EP5_Handler();
    

  140.         }
    


  141. 

  142.         if (u32IntSts & USBD_INTSTS_EP6)
    

  143.         {
    

  144.             /* Clear event flag */
    

  145.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP6);
    

  146.             /* Interrupt OUT */
    

  147.             EP6_Handler();
    

  148.         }
    


  149. 

  150.         if (u32IntSts & USBD_INTSTS_EP7)
    

  151.         {
    

  152.             /* Clear event flag */
    

  153.             USBD_CLR_INT_FLAG(USBD_INTSTS_EP7);
    

  154.         }
    

  155.     }
    

  156. }
    


  157. 

  158. void EP5_Handler(void)  /* Interrupt IN handler */
    

  159. {
    

  160.     HID_SetInReport();
    

  161. }
    


  162. 

  163. void EP6_Handler(void)  /* Interrupt OUT handler */
    

  164. {
    

  165.     uint8_t *ptr;
    

  166.     /* Interrupt OUT */
    

  167.     ptr = (uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP6));
    

  168.     HID_GetOutReport(ptr, USBD_GET_PAYLOAD_LEN(EP6));
    

  169.     USBD_SET_PAYLOAD_LEN(EP6, EP6_MAX_PKT_SIZE);
    

  170. }
    


  171. 

  172. /*--------------------------------------------------------------------------*/
    

  173. /**
    

  174.   * @brief  USBD Endpoint Config.
    

  175.   * @param  None.
    

  176.   * @retval None.
    

  177.   */
    

  178. void PTR_Init(void)
    

  179. {
    

  180.     /* Init setup packet buffer */
    

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

  182.     USBD->STBUFSEG = SETUP_BUF_BASE;
    


  183. 

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

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

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

  187.     /* Buffer range for EP0 */
    

  188.     USBD_SET_EP_BUF_ADDR(EP0, EP0_BUF_BASE);
    


  189. 

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

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

  192.     /* Buffer range for EP1 */
    

  193.     USBD_SET_EP_BUF_ADDR(EP1, EP1_BUF_BASE);
    


  194. 

  195.     /*****************************************************/
    

  196.     /* EP2 ==> Bulk IN endpoint, address 1 */
    

  197.     USBD_CONFIG_EP(EP2, USBD_CFG_EPMODE_IN | BULK_IN_EP_NUM);
    

  198.     /* Buffer offset for EP2 */
    

  199.     USBD_SET_EP_BUF_ADDR(EP2, EP2_BUF_BASE);
    


  200. 

  201.     /* EP3 ==> Bulk Out endpoint, address 2 */
    

  202.     USBD_CONFIG_EP(EP3, USBD_CFG_EPMODE_OUT | BULK_OUT_EP_NUM);
    

  203.     /* Buffer offset for EP3 */
    

  204.     USBD_SET_EP_BUF_ADDR(EP3, EP3_BUF_BASE);
    

  205.     /* trigger receive OUT data */
    

  206.     USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
    


  207. 

  208.     /* EP4 ==> Interrupt IN endpoint, address 3 */
    

  209.     USBD_CONFIG_EP(EP4, USBD_CFG_EPMODE_IN | INT_IN_EP_NUM);
    

  210.     /* Buffer offset for EP4 ->  */
    

  211.     USBD_SET_EP_BUF_ADDR(EP4, EP4_BUF_BASE);
    


  212. 

  213.     /*****************************************************/
    

  214.     /* EP5 ==> Interrupt IN endpoint, address 4 */
    

  215.     USBD_CONFIG_EP(EP5, USBD_CFG_EPMODE_IN | INT_IN_EP_NUM_1);
    

  216.     /* Buffer range for EP5 */
    

  217.     USBD_SET_EP_BUF_ADDR(EP5, EP5_BUF_BASE);
    


  218. 

  219.     /* EP6 ==> Interrupt OUT endpoint, address 5 */
    

  220.     USBD_CONFIG_EP(EP6, USBD_CFG_EPMODE_OUT | INT_OUT_EP_NUM);
    

  221.     /* Buffer range for EP6 */
    

  222.     USBD_SET_EP_BUF_ADDR(EP6, EP6_BUF_BASE);
    

  223.     /* trigger to receive OUT data */
    

  224.     USBD_SET_PAYLOAD_LEN(EP6, EP6_MAX_PKT_SIZE);
    

  225. }
    


  226. 

  227. void PTR_ClassRequest(void)
    

  228. {
    

  229.     uint8_t buf[8];
    


  230. 

  231.     USBD_GetSetupPacket(buf);
    


  232. 

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

  234.     {
    

  235.         /* Device to host */
    

  236.         switch (buf[1])
    

  237.         {
    

  238.         case GET_PORT_STATUS:
    

  239.         {
    

  240.             /* Data stage */
    

  241.             USBD_SET_DATA1(EP0);
    

  242.             USBD_SET_PAYLOAD_LEN(EP0, 0);
    

  243.             /* Status stage */
    

  244.             USBD_PrepareCtrlOut(0,0);
    

  245.             break;
    

  246.         }
    

  247.         default:
    

  248.         {
    

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

  250.             USBD_SetStall(EP0);
    

  251.             USBD_SetStall(EP1);
    

  252.             break;
    

  253.         }
    

  254.         }
    

  255.     }
    

  256.     else
    

  257.     {
    

  258.         /* Host to device */
    

  259.         switch (buf[1])
    

  260.         {
    

  261.         case SET_REPORT:
    

  262.         {
    

  263.             if (buf[3] == 3)
    

  264.             {
    

  265.                 /* Request Type = Feature */
    

  266.                 USBD_SET_DATA1(EP1);
    

  267.                 USBD_SET_PAYLOAD_LEN(EP1, 0);
    

  268.             }
    

  269.             break;
    

  270.         }
    

  271.         case SET_IDLE:
    

  272.         {
    

  273.             /* Status stage */
    

  274.             USBD_SET_DATA1(EP0);
    

  275.             USBD_SET_PAYLOAD_LEN(EP0, 0);
    

  276.             break;
    

  277.         }
    

  278.         case SET_PROTOCOL:
    

  279. //             {
    

  280. //                 break;
    

  281. //             }
    

  282.         default:
    

  283.         {
    

  284.             /* Stall */
    

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

  286.             USBD_SetStall(EP0);
    

  287.             USBD_SetStall(EP1);
    

  288.             break;
    

  289.         }
    

  290.         }
    

  291.     }
    

  292. }
    


  293. 

  294. /* Receive printer command and data from host */
    

  295. void PTR_Data_Receive(void)
    

  296. {
    

  297.     uint8_t *pu8Buf = (uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP3));
    

  298.     uint32_t u32Size = USBD_GET_PAYLOAD_LEN(EP3);
    


  299. 

  300.     /* trigger next OUT data */
    

  301.     USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
    

  302. }
    


  303. 

  304. /***************************************************************/
    

  305. #define HID_CMD_SIGNATURE   0x43444948
    


  306. 

  307. /* HID Transfer Commands */
    

  308. #define HID_CMD_NONE     0x00
    

  309. #define HID_CMD_ERASE    0x71
    

  310. #define HID_CMD_READ     0xD2
    

  311. #define HID_CMD_WRITE    0xC3
    

  312. #define HID_CMD_TEST     0xB4
    


  313. 

  314. #define PAGE_SIZE        2048
    

  315. #define TEST_PAGES       4
    

  316. #define SECTOR_SIZE      4096
    

  317. #define START_SECTOR     0x10
    


  318. 

  319. #ifdef __ICCARM__
    

  320. typedef __packed struct
    

  321. {
    

  322.     uint8_t u8Cmd;
    

  323.     uint8_t u8Size;
    

  324.     uint32_t u32Arg1;
    

  325.     uint32_t u32Arg2;
    

  326.     uint32_t u32Signature;
    

  327.     uint32_t u32Checksum;
    

  328. } CMD_T;
    


  329. 

  330. #else
    

  331. typedef struct __attribute__((__packed__))
    

  332. {
    

  333.     uint8_t u8Cmd;
    

  334.     uint8_t u8Size;
    

  335.     uint32_t u32Arg1;
    

  336.     uint32_t u32Arg2;
    

  337.     uint32_t u32Signature;
    

  338.     uint32_t u32Checksum;
    

  339. }
    

  340. CMD_T;
    

  341. #endif
    


  342. 

  343. CMD_T gCmd;
    


  344. 

  345. static uint8_t  g_u8PageBuff[PAGE_SIZE] = {0};    /* Page buffer to upload/download through HID report */
    

  346. static uint32_t g_u32BytesInPageBuf = 0;          /* The bytes of data in g_u8PageBuff */
    

  347. static uint8_t  g_u8TestPages[TEST_PAGES * PAGE_SIZE] = {0};    /* Test pages to upload/download through HID report */
    


  348. 

  349. int32_t HID_CmdEraseSectors(CMD_T *pCmd)
    

  350. {
    

  351.     uint32_t u32StartSector;
    

  352.     uint32_t u32Sectors;
    


  353. 

  354.     u32StartSector = pCmd->u32Arg1 - START_SECTOR;
    

  355.     u32Sectors = pCmd->u32Arg2;
    


  356. 

  357.     printf("Erase command - Sector: %d   Sector Cnt: %d\n", u32StartSector, u32Sectors);
    


  358. 

  359.     /* TODO: To erase the sector of storage */
    

  360.     memset(g_u8TestPages + u32StartSector * SECTOR_SIZE, 0xFF, sizeof(uint8_t) * u32Sectors * SECTOR_SIZE);
    


  361. 

  362.     /* To note the command has been done */
    

  363.     pCmd->u8Cmd = HID_CMD_NONE;
    


  364. 

  365.     return 0;
    

  366. }
    


  367. 


  368. 

  369. int32_t HID_CmdReadPages(CMD_T *pCmd)
    

  370. {
    

  371.     uint32_t u32StartPage;
    

  372.     uint32_t u32Pages;
    


  373. 

  374.     u32StartPage = pCmd->u32Arg1;
    

  375.     u32Pages     = pCmd->u32Arg2;
    


  376. 

  377.     printf("Read command - Start page: %d    Pages Numbers: %d\n", u32StartPage, u32Pages);
    


  378. 

  379.     if(u32Pages)
    

  380.     {
    

  381.         /* Update data to page buffer to upload */
    

  382.         /* TODO: We need to update the page data if got a page read command. (0xFF is used in this sample code) */
    

  383.         memcpy(g_u8PageBuff, g_u8TestPages, sizeof(g_u8PageBuff));
    

  384.         g_u32BytesInPageBuf = PAGE_SIZE;
    


  385. 

  386.         /* The signature word is used as page counter */
    

  387.         pCmd->u32Signature = 1;
    


  388. 

  389.         /* Trigger HID IN */
    

  390.         USBD_MemCopy((uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP5)), (void *)g_u8PageBuff, EP5_MAX_PKT_SIZE);
    

  391.         USBD_SET_PAYLOAD_LEN(EP5, EP5_MAX_PKT_SIZE);
    

  392.         g_u32BytesInPageBuf -= EP5_MAX_PKT_SIZE;
    

  393.     }
    


  394. 

  395.     return 0;
    

  396. }
    


  397. 


  398. 

  399. int32_t HID_CmdWritePages(CMD_T *pCmd)
    

  400. {
    

  401.     uint32_t u32StartPage;
    

  402.     uint32_t u32Pages;
    


  403. 

  404.     u32StartPage = pCmd->u32Arg1;
    

  405.     u32Pages     = pCmd->u32Arg2;
    


  406. 

  407.     printf("Write command - Start page: %d    Pages Numbers: %d\n", u32StartPage, u32Pages);
    

  408.     g_u32BytesInPageBuf = 0;
    


  409. 

  410.     /* The signature is used to page counter */
    

  411.     pCmd->u32Signature = 0;
    


  412. 

  413.     return 0;
    

  414. }
    


  415. 


  416. 

  417. int32_t gi32CmdTestCnt = 0;
    

  418. int32_t HID_CmdTest(CMD_T *pCmd)
    

  419. {
    

  420.     int32_t i;
    

  421.     uint8_t *pu8;
    


  422. 

  423.     pu8 = (uint8_t *)pCmd;
    

  424.     printf("Get test command #%d (%d bytes)\n", gi32CmdTestCnt++, pCmd->u8Size);
    

  425.     for(i=0; i<pCmd->u8Size; i++)
    

  426.     {
    

  427.         if((i&0xF) == 0)
    

  428.         {
    

  429.             printf("\n");
    

  430.         }
    

  431.         printf(" %02x", pu8[i]);
    

  432.     }
    


  433. 

  434.     printf("\n");
    


  435. 


  436. 

  437.     /* To note the command has been done */
    

  438.     pCmd->u8Cmd = HID_CMD_NONE;
    


  439. 

  440.     return 0;
    

  441. }
    


  442. 


  443. 

  444. uint32_t CalCheckSum(uint8_t *buf, uint32_t size)
    

  445. {
    

  446.     uint32_t sum;
    

  447.     int32_t i;
    


  448. 

  449.     i = 0;
    

  450.     sum = 0;
    

  451.     while(size--)
    

  452.     {
    

  453.         sum+=buf[i++];
    

  454.     }
    


  455. 

  456.     return sum;
    


  457. 

  458. }
    


  459. 


  460. 

  461. int32_t ProcessCommand(uint8_t *pu8Buffer, uint32_t u32BufferLen)
    

  462. {
    

  463.     uint32_t u32sum;
    


  464. 


  465. 

  466.     USBD_MemCopy((uint8_t *)&gCmd, pu8Buffer, u32BufferLen);
    


  467. 

  468.     /* Check size */
    

  469.     if((gCmd.u8Size > sizeof(gCmd)) || (gCmd.u8Size > u32BufferLen))
    

  470.         return -1;
    


  471. 

  472.     /* Check signature */
    

  473.     if(gCmd.u32Signature != HID_CMD_SIGNATURE)
    

  474.         return -1;
    


  475. 

  476.     /* Calculate checksum & check it*/
    

  477.     u32sum = CalCheckSum((uint8_t *)&gCmd, gCmd.u8Size);
    

  478.     if(u32sum != gCmd.u32Checksum)
    

  479.         return -1;
    


  480. 

  481.     switch(gCmd.u8Cmd)
    

  482.     {
    

  483.     case HID_CMD_ERASE:
    

  484.     {
    

  485.         HID_CmdEraseSectors(&gCmd);
    

  486.         break;
    

  487.     }
    

  488.     case HID_CMD_READ:
    

  489.     {
    

  490.         HID_CmdReadPages(&gCmd);
    

  491.         break;
    

  492.     }
    

  493.     case HID_CMD_WRITE:
    

  494.     {
    

  495.         HID_CmdWritePages(&gCmd);
    

  496.         break;
    

  497.     }
    

  498.     case HID_CMD_TEST:
    

  499.     {
    

  500.         HID_CmdTest(&gCmd);
    

  501.         break;
    

  502.     }
    

  503.     default:
    

  504.         return -1;
    

  505.     }
    


  506. 

  507.     return 0;
    

  508. }
    


  509. 


  510. 

  511. void HID_GetOutReport(uint8_t *pu8EpBuf, uint32_t u32Size)
    

  512. {
    

  513.     uint8_t  u8Cmd;
    

  514.     uint32_t u32StartPage;
    

  515.     uint32_t u32Pages;
    

  516.     uint32_t u32PageCnt;
    


  517. 

  518.     /* Get command information */
    

  519.     u8Cmd        = gCmd.u8Cmd;
    

  520.     u32StartPage = gCmd.u32Arg1;
    

  521.     u32Pages     = gCmd.u32Arg2;
    

  522.     u32PageCnt   = gCmd.u32Signature; /* The signature word is used to count pages */
    


  523. 


  524. 

  525.     /* Check if it is in the data phase of write command */
    

  526.     if((u8Cmd == HID_CMD_WRITE) &&  (u32PageCnt < u32Pages))
    

  527.     {
    

  528.         /* Process the data phase of write command */
    


  529. 

  530.         /* Get data from HID OUT */
    

  531.         USBD_MemCopy(&g_u8PageBuff[g_u32BytesInPageBuf], pu8EpBuf, EP6_MAX_PKT_SIZE);
    

  532.         g_u32BytesInPageBuf += EP6_MAX_PKT_SIZE;
    


  533. 

  534.         /* The HOST must make sure the data is PAGE_SIZE alignment */
    

  535.         if(g_u32BytesInPageBuf >= PAGE_SIZE)
    

  536.         {
    

  537.             printf("Writing page %d\n", u32StartPage + u32PageCnt);
    

  538.             /* TODO: We should program received data to storage here */
    

  539.             memcpy(g_u8TestPages + u32PageCnt * PAGE_SIZE, g_u8PageBuff, sizeof(g_u8PageBuff));
    

  540.             u32PageCnt++;
    


  541. 

  542.             /* Write command complete! */
    

  543.             if(u32PageCnt >= u32Pages)
    

  544.             {
    

  545.                 u8Cmd = HID_CMD_NONE;
    


  546. 

  547.                 printf("Write command complete.\n");
    

  548.             }
    


  549. 

  550.             g_u32BytesInPageBuf = 0;
    

  551.         }
    


  552. 

  553.         /* Update command status */
    

  554.         gCmd.u8Cmd        = u8Cmd;
    

  555.         gCmd.u32Signature = u32PageCnt;
    

  556.     }
    

  557.     else
    

  558.     {
    

  559.         /* Check and process the command packet */
    

  560.         if(ProcessCommand(pu8EpBuf, u32Size))
    

  561.         {
    

  562.             printf("Unknown HID command!\n");
    

  563.         }
    

  564.     }
    

  565. }
    


  566. 

  567. void HID_SetInReport(void)
    

  568. {
    

  569.     uint32_t u32StartPage;
    

  570.     uint32_t u32TotalPages;
    

  571.     uint32_t u32PageCnt;
    

  572.     uint8_t *ptr;
    

  573.     uint8_t u8Cmd;
    


  574. 

  575.     u8Cmd        = gCmd.u8Cmd;
    

  576.     u32StartPage = gCmd.u32Arg1;
    

  577.     u32TotalPages= gCmd.u32Arg2;
    

  578.     u32PageCnt   = gCmd.u32Signature;
    


  579. 

  580.     /* Check if it is in data phase of read command */
    

  581.     if(u8Cmd == HID_CMD_READ)
    

  582.     {
    

  583.         /* Process the data phase of read command */
    

  584.         if((u32PageCnt >= u32TotalPages) && (g_u32BytesInPageBuf == 0))
    

  585.         {
    

  586.             /* The data transfer is complete. */
    

  587.             u8Cmd = HID_CMD_NONE;
    

  588.             printf("Read command complete!\n");
    

  589.         }
    

  590.         else
    

  591.         {
    

  592.             if(g_u32BytesInPageBuf == 0)
    

  593.             {
    

  594.                 /* The previous page has sent out. Read new page to page buffer */
    

  595.                 /* TODO: We should update new page data here. (0xFF is used in this sample code) */
    

  596.                 printf("Reading page %d\n", u32StartPage + u32PageCnt);
    

  597.                 memcpy(g_u8PageBuff, g_u8TestPages + u32PageCnt * PAGE_SIZE, sizeof(g_u8PageBuff));
    


  598. 

  599.                 g_u32BytesInPageBuf = PAGE_SIZE;
    


  600. 

  601.                 /* Update the page counter */
    

  602.                 u32PageCnt++;
    

  603.             }
    


  604. 

  605.             /* Prepare the data for next HID IN transfer */
    

  606.             ptr = (uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP5));
    

  607.             USBD_MemCopy(ptr, (void *)&g_u8PageBuff[PAGE_SIZE - g_u32BytesInPageBuf], EP5_MAX_PKT_SIZE);
    

  608.             USBD_SET_PAYLOAD_LEN(EP5, EP5_MAX_PKT_SIZE);
    

  609.             g_u32BytesInPageBuf -= EP5_MAX_PKT_SIZE;
    

  610.         }
    

  611.     }
    


  612. 

  613.     gCmd.u8Cmd        = u8Cmd;
    

  614.     gCmd.u32Signature = u32PageCnt;
    

  615. }
回复

收藏 举报

 楼主| xuanhuanzi 发表于 2019-6-23 18:52 | 显示全部楼层
复制
  1. /******************************************************************************
    

  2.  * @file     descriptors.c
    

  3.  * @version  V1.00
    

  4.  * $Revision: 6 $
    

  5.  * $Date: 18/04/13 3:44p $
    

  6.  * @brief    M031 series USBD driver source file
    

  7.  *
    

  8.  * @note
    

  9.  * Copyright (C) 2018 Nuvoton Technology Corp. All rights reserved.
    

  10.  *****************************************************************************/
    

  11. /*!<Includes */
    

  12. #include "NuMicro.h"
    

  13. #include "micro_printer_and_hid_transfer.h"
    


  14. 

  15. /*----------------------------------------------------------------------------*/
    

  16. /*!<USB Device Descriptor */
    

  17. uint8_t gu8DeviceDescriptor[] =
    

  18. {
    

  19.     LEN_DEVICE,     /* bLength */
    

  20.     DESC_DEVICE,    /* bDescriptorType */
    

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

  22.     0x00,           /* bDeviceClass */
    

  23.     0x00,           /* bDeviceSubClass */
    

  24.     0x00,           /* bDeviceProtocol */
    

  25.     EP0_MAX_PKT_SIZE,   /* bMaxPacketSize0 */
    

  26.     /* idVendor */
    

  27.     USBD_VID & 0x00FF,
    

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

  29.     /* idProduct */
    

  30.     USBD_PID & 0x00FF,
    

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

  32.     0x00, 0x03,     /* bcdDevice */
    

  33.     0x01,           /* iManufacture */
    

  34.     0x02,           /* iProduct */
    

  35.     0x00,           /* iSerialNumber - no serial */
    

  36.     0x01            /* bNumConfigurations */
    

  37. };
    


  38. 

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

  40. uint8_t HID_DeviceReportDescriptor[] =
    

  41. {
    

  42.     0x06, 0x00, 0xFF,   // Usage Page = 0xFF00 (Vendor Defined Page 1)
    

  43.     0x09, 0x01,         // Usage (Vendor Usage 1)
    

  44.     0xA1, 0x01,         // Collection (Application)
    

  45.     0x19, 0x01,         // Usage Minimum
    

  46.     0x29, 0x40,         // Usage Maximum //64 input usages total (0x01 to 0x40)
    

  47.     0x15, 0x00,         // Logical Minimum (data bytes in the report may have minimum value = 0x00)
    

  48.     0x26, 0xFF, 0x00,   // Logical Maximum (data bytes in the report may have maximum value = 0x00FF = unsigned 255)
    

  49.     0x75, 0x08,         // Report Size: 8-bit field size
    

  50.     0x95, 0x40,         // Report Count: Make sixty-four 8-bit fields (the next time the parser hits
    

  51.     // an "Input", "Output", or "Feature" item)
    

  52.     0x81, 0x00,         // Input (Data, Array, Abs): Instantiates input packet fields based on the
    

  53.     // above report size, count, logical min/max, and usage.
    

  54.     0x19, 0x01,         // Usage Minimum
    

  55.     0x29, 0x40,         // Usage Maximum //64 output usages total (0x01 to 0x40)
    

  56.     0x91, 0x00,         // Output (Data, Array, Abs): Instantiates output packet fields. Uses same
    

  57.     // report size and count as "Input" fields, since nothing new/different was
    

  58.     // specified to the parser since the "Input" item.
    

  59.     0xC0                // End Collection
    

  60. };
    


  61. 


  62. 

  63. /*!<USB Configure Descriptor */
    

  64. uint8_t gu8ConfigDescriptor[] =
    

  65. {
    

  66.     LEN_CONFIG,     /* bLength              */
    

  67.     DESC_CONFIG,    /* bDescriptorType      */
    

  68.     0x6E, 0x00,     /* wTotalLength         */
    

  69.     0x02,           /* bNumInterfaces       */
    

  70.     0x01,           /* bConfigurationValue  */
    

  71.     0x00,           /* iConfiguration       */
    

  72.     0xC0,           /* bmAttributes         */
    

  73.     0x32,           /* MaxPower             */
    


  74. 

  75.     /* INTERFACE descriptor */
    

  76.     LEN_INTERFACE,  /* bLength                        */
    

  77.     DESC_INTERFACE, /* bDescriptorType                */
    

  78.     0x00,           /* bInterfaceNumber               */
    

  79.     0x00,           /* bAlternateSetting              */
    

  80.     0x01,           /* bNumEndpoints                  */
    

  81.     0x07,           /* bInterfaceClass: printer class */
    

  82.     0x01,           /* bInterfaceSubClass             */
    

  83.     0x01,           /* bInterfaceProtocol             */
    

  84.     0x00,           /* iInterface                     */
    


  85. 

  86.     /* ENDPOINT descriptor */
    

  87.     LEN_ENDPOINT,                   /* bLength          */
    

  88.     DESC_ENDPOINT,                  /* bDescriptorType  */
    

  89.     (EP_OUTPUT | BULK_OUT_EP_NUM),  /* bEndpointAddress */
    

  90.     EP_BULK,                        /* bmAttributes     */
    

  91.     EP3_MAX_PKT_SIZE, 0x00,         /* wMaxPacketSize   */
    

  92.     0x00,                           /* bInterval        */
    


  93. 

  94.     /* INTERFACE descriptor */
    

  95.     LEN_INTERFACE,  /* bLength                        */
    

  96.     DESC_INTERFACE, /* bDescriptorType                */
    

  97.     0x00,           /* bInterfaceNumber               */
    

  98.     0x01,           /* bAlternateSetting              */
    

  99.     0x02,           /* bNumEndpoints                  */
    

  100.     0x07,           /* bInterfaceClass: printer class */
    

  101.     0x01,           /* bInterfaceSubClass             */
    

  102.     0x02,           /* bInterfaceProtocol             */
    

  103.     0x00,           /* iInterface                     */
    


  104. 

  105.     /* ENDPOINT descriptor */
    

  106.     LEN_ENDPOINT,                   /* bLength          */
    

  107.     DESC_ENDPOINT,                  /* bDescriptorType  */
    

  108.     (EP_OUTPUT | BULK_OUT_EP_NUM),  /* bEndpointAddress */
    

  109.     EP_BULK,                        /* bmAttributes     */
    

  110.     EP3_MAX_PKT_SIZE, 0x00,         /* wMaxPacketSize   */
    

  111.     0x00,                           /* bInterval        */
    


  112. 

  113.     /* ENDPOINT descriptor */
    

  114.     LEN_ENDPOINT,                   /* bLength          */
    

  115.     DESC_ENDPOINT,                  /* bDescriptorType  */
    

  116.     (EP_INPUT | BULK_IN_EP_NUM),    /* bEndpointAddress */
    

  117.     EP_BULK,                        /* bmAttributes     */
    

  118.     EP2_MAX_PKT_SIZE, 0x00,         /* wMaxPacketSize   */
    

  119.     0x00,                           /* bInterval        */
    


  120. 

  121.     /* INTERFACE descriptor */
    

  122.     LEN_INTERFACE,  /* bLength              */
    

  123.     DESC_INTERFACE, /* bDescriptorType      */
    

  124.     0x00,           /* bInterfaceNumber     */
    

  125.     0x02,           /* bAlternateSetting    */
    

  126.     0x03,           /* bNumEndpoints        */
    

  127.     0xFF,           /* bInterfaceClass      */
    

  128.     0x00,           /* bInterfaceSubClass   */
    

  129.     0xFF,           /* bInterfaceProtocol   */
    

  130.     0x00,           /* iInterface           */
    


  131. 

  132.     /* ENDPOINT descriptor */
    

  133.     LEN_ENDPOINT,                   /* bLength          */
    

  134.     DESC_ENDPOINT,                  /* bDescriptorType  */
    

  135.     (EP_OUTPUT | BULK_OUT_EP_NUM),  /* bEndpointAddress */
    

  136.     EP_BULK,                        /* bmAttributes     */
    

  137.     EP3_MAX_PKT_SIZE, 0x00,         /* wMaxPacketSize   */
    

  138.     0x00,                           /* bInterval        */
    


  139. 

  140.     /* ENDPOINT descriptor */
    

  141.     LEN_ENDPOINT,                   /* bLength          */
    

  142.     DESC_ENDPOINT,                  /* bDescriptorType  */
    

  143.     (EP_INPUT | BULK_IN_EP_NUM),    /* bEndpointAddress */
    

  144.     EP_BULK,                        /* bmAttributes     */
    

  145.     EP2_MAX_PKT_SIZE, 0x00,         /* wMaxPacketSize   */
    

  146.     0x00,                           /* bInterval        */
    


  147. 

  148.     /* ENDPOINT descriptor */
    

  149.     LEN_ENDPOINT,                   /* bLength          */
    

  150.     DESC_ENDPOINT,                  /* bDescriptorType  */
    

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

  152.     EP_INT,                         /* bmAttributes     */
    

  153.     EP4_MAX_PKT_SIZE, 0x00,         /* wMaxPacketSize   */
    

  154.     0x01,                           /* bInterval        */
    


  155. 

  156.     /* I/F descr: HID Transfer */
    

  157.     LEN_INTERFACE,  /* bLength */
    

  158.     DESC_INTERFACE, /* bDescriptorType */
    

  159.     0x01,           /* bInterfaceNumber */
    

  160.     0x00,           /* bAlternateSetting */
    

  161.     0x02,           /* bNumEndpoints */
    

  162.     0x03,           /* bInterfaceClass */
    

  163.     0x00,           /* bInterfaceSubClass */
    

  164.     0x00,           /* bInterfaceProtocol */
    

  165.     0x00,           /* iInterface */
    


  166. 

  167.     /* HID Descriptor */
    

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

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

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

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

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

  173.     DESC_HID_RPT,   /* Descriptor type. */
    

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

  175.     sizeof(HID_DeviceReportDescriptor) & 0x00FF,
    

  176.     ((sizeof(HID_DeviceReportDescriptor) & 0xFF00) >> 8),
    


  177. 

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

  179.     LEN_ENDPOINT,                               /* bLength */
    

  180.     DESC_ENDPOINT,                              /* bDescriptorType */
    

  181.     (INT_IN_EP_NUM_1 | EP_INPUT),               /* bEndpointAddress */
    

  182.     EP_INT,                                     /* bmAttributes */
    

  183.     /* wMaxPacketSize */
    

  184.     EP5_MAX_PKT_SIZE & 0x00FF,
    

  185.     ((EP5_MAX_PKT_SIZE & 0xFF00) >> 8),
    

  186.     HID_DEFAULT_INT_IN_INTERVAL,                /* bInterval */
    


  187. 

  188.     /* EP Descriptor: interrupt out. */
    

  189.     LEN_ENDPOINT,                               /* bLength */
    

  190.     DESC_ENDPOINT,                              /* bDescriptorType */
    

  191.     (INT_OUT_EP_NUM | EP_OUTPUT),               /* bEndpointAddress */
    

  192.     EP_INT,                                     /* bmAttributes */
    

  193.     /* wMaxPacketSize */
    

  194.     EP6_MAX_PKT_SIZE & 0x00FF,
    

  195.     ((EP6_MAX_PKT_SIZE & 0xFF00) >> 8),
    

  196.     HID_DEFAULT_INT_IN_INTERVAL,                /* bInterval */
    

  197. };
    


  198. 

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

  200. uint8_t gu8StringLang[4] =
    

  201. {
    

  202.     4,              /* bLength */
    

  203.     DESC_STRING,    /* bDescriptorType */
    

  204.     0x09, 0x04
    

  205. };
    


  206. 

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

  208. uint8_t gu8VendorStringDesc[] =
    

  209. {
    

  210.     16,
    

  211.     DESC_STRING,
    

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

  213. };
    


  214. 

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

  216. uint8_t gu8ProductStringDesc[] =
    

  217. {
    

  218.     22,             /* bLength          */
    

  219.     DESC_STRING,    /* bDescriptorType  */
    

  220.     'U', 0, 'S', 0, 'B', 0, ' ', 0, 'D', 0, 'e', 0, 'v', 0, 'i', 0, 'c', 0, 'e', 0
    

  221. };
    


  222. 

  223. /*!<USB BOS Descriptor */
    

  224. const uint8_t gu8BOSDescriptor[] =
    

  225. {
    

  226.     LEN_BOS,        /* bLength */
    

  227.     DESC_BOS,       /* bDescriptorType */
    

  228.     /* wTotalLength */
    

  229.     0x0C & 0x00FF,
    

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

  231.     0x01,           /* bNumDeviceCaps */
    


  232. 

  233.     /* Device Capability */
    

  234.     0x7,            /* bLength */
    

  235.     DESC_CAPABILITY,/* bDescriptorType */
    

  236.     CAP_USB20_EXT,  /* bDevCapabilityType */
    

  237.     0x02, 0x00, 0x00, 0x00  /* bmAttributes */
    

  238. };
    


  239. 

  240. uint8_t *gpu8UsbString[4] =
    

  241. {
    

  242.     gu8StringLang,
    

  243.     gu8VendorStringDesc,
    

  244.     gu8ProductStringDesc,
    

  245.     0,
    

  246. };
    


  247. 

  248. uint8_t *gu8UsbHidReport[3] =
    

  249. {
    

  250.     0,
    

  251.     HID_DeviceReportDescriptor,
    

  252.     0,
    

  253. };
    


  254. 

  255. uint32_t gu32UsbHidReportLen[3] =
    

  256. {
    

  257.     0,
    

  258.     sizeof(HID_DeviceReportDescriptor),
    

  259.     0,
    

  260. };
    


  261. 

  262. uint32_t gu32ConfigHidDescIdx[3] =
    

  263. {
    

  264.     0,
    

  265.     (sizeof(gu8ConfigDescriptor) - LEN_HID - (2*LEN_ENDPOINT)),
    

  266.     0,
    

  267. };
    


  268. 

  269. const S_USBD_INFO_T gsInfo =
    

  270. {
    

  271.     (uint8_t *)gu8DeviceDescriptor,
    

  272.     (uint8_t *)gu8ConfigDescriptor,
    

  273.     (uint8_t **)gpu8UsbString,
    

  274.     (uint8_t **)gu8UsbHidReport,
    

  275.     (uint8_t *)gu8BOSDescriptor,
    

  276.     (uint32_t *)gu32UsbHidReportLen,
    

  277.     (uint32_t *)gu32ConfigHidDescIdx
    

  278. };
    


  279.
回复

收藏 举报

 楼主| xuanhuanzi 发表于 2019-6-23 19:05 | 显示全部楼层
这是官方BSP里面的例子，说明这个系列还是非常支持USB的。
回复

收藏 举报

643757107 发表于 2019-6-23 23:29 | 显示全部楼层
多谢分享，一会儿下载看看。
回复

收藏 举报

dongnanxibei 发表于 2019-6-23 23:52 | 显示全部楼层
新唐提供的USB接口的芯片还挺多的。
回复

收藏 举报

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

本版积分规则

xuanhuanzi

183

主题

2331

帖子

3

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