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

[DemoCode下载] USB虚拟串口

[复制链接]
1168|3
 楼主| gaoyang9992006 发表于 2024-4-21 20:39 | 显示全部楼层 |阅读模式
ar, 虚拟串口, 串口, USB
EC_M032_USBD_VCOM_And_HID_MMKey_V1.00.zip (1.63 MB, 下载次数: 3)
USB接口模拟虚拟串口与键盘。
复制
  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: 12 $
    

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

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

  7.  *
    

  8.  * @note
    

  9.  * SPDX-License-Identifier: Apache-2.0
    

  10.  * Copyright (C) 2021 Nuvoton Technology Corp. All rights reserved.
    

  11.  *****************************************************************************/
    

  12. #include <stdio.h>
    

  13. #include "NuMicro.h"
    

  14. #include "VCOM_and_HID_keyboard.h"
    


  15. 

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

  17. #define TRIM_INIT           (SYS_BASE+0x118)
    


  18. 

  19. int IsDebugFifoEmpty(void);
    


  20. 

  21. /*--------------------------------------------------------------------------*/
    

  22. STR_VCOM_LINE_CODING gLineCoding = {115200, 0, 0, 8};   /* Baud rate : 115200    */
    

  23. /* Stop bit     */
    

  24. /* parity       */
    

  25. /* data bits    */
    

  26. uint16_t gCtrlSignal = 0;     /* BIT0: DTR(Data Terminal Ready) , BIT1: RTS(Request To Send) */
    


  27. 

  28. extern uint8_t volatile g_u8Suspend;
    

  29. /*--------------------------------------------------------------------------*/
    

  30. #define RX_BUFSIZE           512 /* RX buffer size */
    

  31. #define TX_BUFSIZE           512 /* RX buffer size */
    

  32. #define TX_FIFO_SIZE         16  /* TX Hardware FIFO size */
    


  33. 

  34. /*---------------------------------------------------------------------------------------------------------*/
    

  35. /* Global variables                                                                                        */
    

  36. /*---------------------------------------------------------------------------------------------------------*/
    

  37. /* UART0 */
    

  38. volatile uint8_t comRbuf[RX_BUFSIZE];
    

  39. volatile uint16_t comRbytes = 0;
    

  40. volatile uint16_t comRhead = 0;
    

  41. volatile uint16_t comRtail = 0;
    


  42. 

  43. volatile uint8_t comTbuf[TX_BUFSIZE];
    

  44. volatile uint16_t comTbytes = 0;
    

  45. volatile uint16_t comThead = 0;
    

  46. volatile uint16_t comTtail = 0;
    


  47. 

  48. uint8_t gRxBuf[64] = {0};
    

  49. uint8_t *gpu8RxBuf = 0;
    

  50. uint32_t gu32RxSize = 0;
    

  51. uint32_t gu32TxSize = 0;
    


  52. 

  53. volatile int8_t gi8BulkOutReady = 0;
    


  54. 

  55. void SYS_Init(void)
    

  56. {
    

  57.     /* Unlock protected registers */
    

  58.     SYS_UnlockReg();
    


  59. 

  60.     /* Enable HIRC clock */
    

  61.     CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk);
    


  62. 

  63.     /* Waiting for HIRC clock ready */
    

  64.     CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk);
    


  65. 

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

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


  68. 

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

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


  71. 

  72.     /* Enable UART0 clock */
    

  73.     CLK_EnableModuleClock(UART0_MODULE);
    


  74. 

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

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


  77. 

  78.     /* Enable USB clock */
    

  79.     CLK_EnableModuleClock(USBD_MODULE);
    


  80. 

  81.     /* Update System Core Clock */
    

  82.     SystemCoreClockUpdate();
    


  83. 

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

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

  86.                     |(SYS_GPB_MFPH_PB12MFP_UART0_RXD | SYS_GPB_MFPH_PB13MFP_UART0_TXD);
    


  87. 

  88.     UART_ENABLE_INT(UART0, (UART_INTEN_RDAIEN_Msk | UART_INTEN_THREIEN_Msk | UART_INTEN_RXTOIEN_Msk));
    


  89. 

  90.     /* Lock protected registers */
    

  91.     SYS_LockReg();
    

  92. }
    


  93. 


  94. 

  95. void PowerDown()
    

  96. {
    

  97.     /* Unlock protected registers */
    

  98.     SYS_UnlockReg();
    


  99. 

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

  101.     while(!IsDebugFifoEmpty());
    


  102. 

  103.     /* Wakeup Enable */
    

  104.     USBD_ENABLE_INT(USBD_INTEN_WKEN_Msk);
    


  105. 

  106.     CLK_PowerDown();
    


  107. 

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

  109.     if(CLK->PWRCTL & CLK_PWRCTL_PDEN_Msk)
    

  110.         CLK->PWRCTL ^= CLK_PWRCTL_PDEN_Msk;
    


  111. 

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


  113. 

  114.     /* Lock protected registers */
    

  115.     SYS_LockReg();
    

  116. }
    


  117. 

  118. /*---------------------------------------------------------------------------------------------------------*/
    

  119. /* UART Callback function                                                                                  */
    

  120. /*---------------------------------------------------------------------------------------------------------*/
    

  121. void UART02_IRQHandler(void)
    

  122. {
    

  123.     uint8_t bInChar;
    

  124.     int32_t size;
    

  125.     uint32_t u32IntStatus;
    


  126. 

  127.     u32IntStatus = UART0->INTSTS;
    


  128. 

  129.     if((u32IntStatus & UART_INTSTS_RDAIF_Msk) || (u32IntStatus & UART_INTSTS_RXTOIF_Msk))
    

  130.     {
    

  131.         /* Receiver FIFO threshold level is reached or Rx time out */
    


  132. 

  133.         /* Get all the input characters */
    

  134.         while (UART_GET_RX_EMPTY(UART0) == 0)
    

  135.         {
    

  136.             /* Get the character from UART Buffer */
    

  137.             bInChar = UART0->DAT;
    


  138. 

  139.             /* Check if buffer full */
    

  140.             if(comRbytes < RX_BUFSIZE)
    

  141.             {
    

  142.                 /* Enqueue the character */
    

  143.                 comRbuf[comRtail++] = bInChar;
    

  144.                 if(comRtail >= RX_BUFSIZE)
    

  145.                     comRtail = 0;
    

  146.                 comRbytes++;
    

  147.             }
    

  148.             else
    

  149.             {
    

  150.                 /* FIFO over run */
    

  151.             }
    

  152.         }
    

  153.     }
    


  154. 

  155.     if(u32IntStatus & UART_INTSTS_THREIF_Msk)
    

  156.     {
    

  157.         if(comTbytes && (UART0->INTEN & UART_INTEN_THREIEN_Msk))
    

  158.         {
    

  159.             /* Fill the Tx FIFO */
    

  160.             size = comTbytes;
    

  161.             if(size >= TX_FIFO_SIZE)
    

  162.             {
    

  163.                 size = TX_FIFO_SIZE;
    

  164.             }
    


  165. 

  166.             while(size)
    

  167.             {
    

  168.                 bInChar = comTbuf[comThead++];
    

  169.                 UART0->DAT = bInChar;
    

  170.                 if(comThead >= TX_BUFSIZE)
    

  171.                     comThead = 0;
    

  172.                 comTbytes--;
    

  173.                 size--;
    

  174.             }
    

  175.         }
    

  176.         else
    

  177.         {
    

  178.             /* No more data, just stop Tx (Stop work) */
    

  179.             UART_DISABLE_INT(UART0, UART_INTEN_THREIEN_Msk);
    

  180.         }
    

  181.     }
    

  182. }
    


  183. 

  184. void VCOM_TransferData(void)
    

  185. {
    

  186.     int32_t i, i32Len;
    


  187. 

  188.     /* Check whether USB is ready for next packet or not*/
    

  189.     if(gu32TxSize == 0)
    

  190.     {
    

  191.         /* Check whether we have new COM Rx data to send to USB or not */
    

  192.         if(comRbytes)
    

  193.         {
    

  194.             i32Len = comRbytes;
    

  195.             if(i32Len > EP2_MAX_PKT_SIZE)
    

  196.                 i32Len = EP2_MAX_PKT_SIZE;
    


  197. 

  198.             for(i = 0; i < i32Len; i++)
    

  199.             {
    

  200.                 gRxBuf[i] = comRbuf[comRhead++];
    

  201.                 if(comRhead >= RX_BUFSIZE)
    

  202.                     comRhead = 0;
    

  203.             }
    


  204. 

  205.             __set_PRIMASK(1);
    

  206.             comRbytes -= i32Len;
    

  207.             __set_PRIMASK(0);
    


  208. 

  209.             gu32TxSize = i32Len;
    

  210.             USBD_MemCopy((uint8_t *)(USBD_BUF_BASE + USBD_GET_EP_BUF_ADDR(EP2)), (uint8_t *)gRxBuf, i32Len);
    

  211.             USBD_SET_PAYLOAD_LEN(EP2, i32Len);
    

  212.         }
    

  213.         else
    

  214.         {
    

  215.             /* Prepare a zero packet if previous packet size is EP2_MAX_PKT_SIZE and
    

  216.                no more data to send at this moment to note Host the transfer has been done */
    

  217.             i32Len = USBD_GET_PAYLOAD_LEN(EP2);
    

  218.             if(i32Len == EP2_MAX_PKT_SIZE)
    

  219.                 USBD_SET_PAYLOAD_LEN(EP2, 0);
    

  220.         }
    

  221.     }
    


  222. 

  223.     /* Process the Bulk out data when bulk out data is ready. */
    

  224.     if(gi8BulkOutReady && (gu32RxSize <= TX_BUFSIZE - comTbytes))
    

  225.     {
    

  226.         for(i = 0; i < gu32RxSize; i++)
    

  227.         {
    

  228.             comTbuf[comTtail++] = gpu8RxBuf[i];
    

  229.             if(comTtail >= TX_BUFSIZE)
    

  230.                 comTtail = 0;
    

  231.         }
    


  232. 

  233.         __set_PRIMASK(1);
    

  234.         comTbytes += gu32RxSize;
    

  235.         __set_PRIMASK(0);
    


  236. 

  237.         gu32RxSize = 0;
    

  238.         gi8BulkOutReady = 0; /* Clear bulk out ready flag */
    


  239. 

  240.         /* Ready to get next BULK out */
    

  241.         USBD_SET_PAYLOAD_LEN(EP3, EP3_MAX_PKT_SIZE);
    

  242.     }
    


  243. 

  244.     /* Process the software Tx FIFO */
    

  245.     if(comTbytes)
    

  246.     {
    

  247.         /* Check if Tx is working */
    

  248.         if((UART0->INTEN & UART_INTEN_THREIEN_Msk) == 0)
    

  249.         {
    

  250.             /* Send one bytes out */
    

  251.             UART0->DAT = comTbuf[comThead++];
    

  252.             if(comThead >= TX_BUFSIZE)
    

  253.                 comThead = 0;
    


  254. 

  255.             comTbytes--;
    


  256. 

  257.             /* Enable Tx Empty Interrupt. (Trigger first one) */
    

  258.             UART_ENABLE_INT(UART0, UART_INTEN_THREIEN_Msk);
    

  259.         }
    

  260.     }
    

  261. }
    


  262. 


  263. 

  264. /*---------------------------------------------------------------------------------------------------------*/
    

  265. /*  Main Function                                                                                          */
    

  266. /*---------------------------------------------------------------------------------------------------------*/
    

  267. int32_t main(void)
    

  268. {
    

  269. #if CRYSTAL_LESS
    

  270.     uint32_t u32TrimInit;
    

  271. #endif
    


  272. 

  273.     /* Unlock protected registers */
    

  274.     SYS_UnlockReg();
    


  275. 

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

  277.     SYS_Init();
    


  278. 

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

  280.     UART_Open(UART0, 115200);
    


  281. 

  282.     printf("\n\n");
    

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

  284.     printf("|     NuMicro USB Virtual COM and HID Media Key Sample Code    |\n");
    

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

  286.     printf("Use PD0 to report key - Brightness + when PD0 = 0\n");
    

  287.     printf("Use PD1 to report key - Brightness - when PD1 = 0\n");
    

  288.     printf("Use PD2 to report key - Volume + when PD2 = 0\n");
    

  289.     printf("Use PD3 to report key - Volume - when PD3 = 0\n");
    

  290.     printf("Use PD4 to report key - Keyboard Brightness + when PD4 = 0\n");
    

  291.     printf("Use PD5 to report key - Keyboard Brightness - when PD5 = 0\n");
    

  292.     printf("Use PD6 to report key - Mute when PD6 = 0\n");
    


  293. 

  294.     /* Set PD.0 ~ PD.6 as Quasi-bidirectional mode */
    

  295.     GPIO_SetMode(PD, (BIT0|BIT1|BIT2|BIT3|BIT4|BIT5|BIT6), GPIO_MODE_QUASI);
    


  296. 

  297.     /* Open USB controller */
    

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


  299. 

  300.     /* Endpoint configuration */
    

  301.     HID_Init();
    


  302. 

  303.     /* Start USB device */
    

  304.     USBD_Start();
    


  305. 

  306.     g_u8EP5Ready=1;
    


  307. 

  308.     NVIC_EnableIRQ(USBD_IRQn);
    


  309. 

  310.     NVIC_EnableIRQ(UART02_IRQn);
    


  311. 

  312. #if CRYSTAL_LESS
    

  313.     /* Backup default trim */
    

  314.     u32TrimInit = M32(TRIM_INIT);
    

  315. #endif
    


  316. 

  317.     /* Clear SOF */
    

  318.     USBD->INTSTS = USBD_INTSTS_SOFIF_Msk;
    


  319. 

  320.     while(1)
    

  321.     {
    

  322. #if CRYSTAL_LESS
    

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

  324.         if((SYS->HIRCTRIMCTL & SYS_HIRCTRIMCTL_FREQSEL_Msk) != 1)
    

  325.         {
    

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

  327.             if(USBD->INTSTS & USBD_INTSTS_SOFIF_Msk)
    

  328.             {
    

  329.                 /* Clear SOF */
    

  330.                 USBD->INTSTS = USBD_INTSTS_SOFIF_Msk;
    


  331. 

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

  333.                 SYS->HIRCTRIMCTL = 0x01;
    

  334.                 SYS->HIRCTRIMCTL |= SYS_HIRCTRIMCTL_REFCKSEL_Msk;
    

  335.             }
    

  336.         }
    


  337. 

  338.         /* Disable USB Trim when error */
    

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

  340.         {
    

  341.             /* Init TRIM */
    

  342.             M32(TRIM_INIT) = u32TrimInit;
    


  343. 

  344.             /* Disable crystal-less */
    

  345.             SYS->HIRCTRIMCTL = 0;
    


  346. 

  347.             /* Clear error flags */
    

  348.             SYS->HIRCTRIMSTS = SYS_HIRCTRIMSTS_CLKERIF_Msk | SYS_HIRCTRIMSTS_TFAILIF_Msk;
    


  349. 

  350.             /* Clear SOF */
    

  351.             USBD->INTSTS = USBD_INTSTS_SOFIF_Msk;
    

  352.         }
    

  353. #endif
    

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

  355.         if(g_u8Suspend)
    

  356.             PowerDown();
    


  357. 

  358.         VCOM_TransferData();
    


  359. 

  360.         HID_UpdateKbData();
    

  361.     }
    

  362. }
    


  363. 


  364. 


  365. 

  366. /*** (C) COPYRIGHT 2021 Nuvoton Technology Corp. ***/
    


  367.


回复

收藏 举报

相关帖子
 楼主| gaoyang9992006 发表于 2024-4-21 20:40 | 显示全部楼层
123266250923e24c7.png
这个应用很不错，可以做很多电脑外设的应用。
回复

收藏 举报

LLGTR 发表于 2024-4-24 23:11 | 显示全部楼层
是同时模拟了虚拟串口和键盘吗？
回复

收藏 举报

lidi911 发表于 2024-4-24 23:53 来自手机 | 显示全部楼层
可以做个游戏模拟器玩玩
回复

收藏 举报

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

本版积分规则

gaoyang9992006 Image
个人签名：如果你觉得我的分享或者答复还可以，请给我点赞，谢谢。

2053

主题

16420

帖子

222

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