21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 如何使用UART的接收超时功能来接收未知数据长度的数据包 ...
返回列表 发新帖我要提问

[DemoCode下载] 如何使用UART的接收超时功能来接收未知数据长度的数据包

[复制链接]
1256|4
 楼主| 643757107 发表于 2024-2-19 21:25 | 显示全部楼层 |阅读模式
UART, 使用, 数据包, 接收, 串口接收, 串口
复制
  1. /******************************************************************************
    

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

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

  4.  * $Revision: 3 $
    

  5.  * $Date: 18/05/30 3:53p $
    

  6.  * [url=home.php?mod=space&uid=247401]@brief[/url]    Show how to use the UART Rx timeout function for receiving unknown data length package.
    

  7.  *
    

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

  9.  * [url=home.php?mod=space&uid=17282]@CopyRight[/url] (C) 2018 Nuvoton Technology Corp. All rights reserved.
    

  10.  *
    

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

  12. #include <stdio.h>
    

  13. #include "NuMicro.h"
    


  14. 

  15. #define FIFO_THRESHOLD 4
    

  16. #define RX_BUFFER_SIZE 128
    

  17. #define RX_TIMEOUT_CNT 60 //40~255
    


  18. 

  19. enum
    

  20. {
    

  21.     eUART_RX_Received_Data_Finish = 0,
    

  22.     eUART_RX_Received_Data_NOT_Finish
    

  23. };
    


  24. 

  25. volatile uint8_t g_au8UART_RX_Buffer[RX_BUFFER_SIZE] = {0}; // UART Rx received data Buffer (RAM)
    

  26. volatile uint8_t g_bUART_RX_Received_Data_State = eUART_RX_Received_Data_NOT_Finish;
    

  27. volatile uint8_t g_u8UART_RDA_Trigger_Cnt = 0; // UART RDA interrupt trigger times counter
    

  28. volatile uint8_t g_u8UART_RXTO_Trigger_Cnt = 0; // UART RXTO interrupt trigger times counter
    


  29. 

  30. void UART02_IRQHandler(void)
    

  31. {
    

  32.     uint8_t i;
    

  33.     static uint16_t u16UART_RX_Buffer_Index = 0;
    


  34. 

  35.     if(UART_GET_INT_FLAG(UART0, UART_INTSTS_RDAINT_Msk))
    

  36.     {
    

  37.         /* UART receive data available flag */
    


  38. 

  39.         /* Record RDA interrupt trigger times */
    

  40.         g_u8UART_RDA_Trigger_Cnt++;
    


  41. 

  42.         /* Move the data from Rx FIFO to sw buffer (RAM). */
    

  43.         /* Every time leave 1 byte data in FIFO for Rx timeout */
    

  44.         for(i = 0 ; i < (FIFO_THRESHOLD - 1) ; i++)
    

  45.         {
    

  46.             g_au8UART_RX_Buffer[u16UART_RX_Buffer_Index] = UART_READ(UART0);
    

  47.             u16UART_RX_Buffer_Index ++;
    


  48. 

  49.             if (u16UART_RX_Buffer_Index >= RX_BUFFER_SIZE)
    

  50.                 u16UART_RX_Buffer_Index = 0;
    

  51.         }
    

  52.     }
    

  53.     else if(UART_GET_INT_FLAG(UART0, UART_INTSTS_RXTOINT_Msk))
    

  54.     {
    

  55.         /* When Rx timeout flag is set to 1, it means there is no data needs to be transmitted. */
    


  56. 

  57.         /* Record Timeout times */
    

  58.         g_u8UART_RXTO_Trigger_Cnt++;
    


  59. 

  60.         /* Move the last data from Rx FIFO to sw buffer. */
    

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

  62.         {
    

  63.             g_au8UART_RX_Buffer[u16UART_RX_Buffer_Index] = UART_READ(UART0);
    

  64.             u16UART_RX_Buffer_Index ++;
    

  65.         }
    


  66. 

  67.         /* Clear UART RX parameter */
    


  68. 

  69.         UART_DISABLE_INT(UART0, UART_INTEN_RDAIEN_Msk | UART_INTEN_RXTOIEN_Msk);
    

  70.         u16UART_RX_Buffer_Index = 0;
    

  71.         g_bUART_RX_Received_Data_State = eUART_RX_Received_Data_Finish;
    

  72.     }
    

  73. }
    


  74. 

  75. void SYS_Init(void)
    

  76. {
    

  77.     /* Unlock protected registers */
    

  78.     SYS_UnlockReg();
    


  79. 

  80.     /*---------------------------------------------------------------------------------------------------------*/
    

  81.     /* Init System Clock                                                                                       */
    

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


  83. 

  84.     /* Enable HIRC and LIRC clock */
    

  85.     CLK_EnableXtalRC(CLK_PWRCTL_LIRCEN_Msk);
    

  86.     CLK_EnableXtalRC(CLK_PWRCTL_HIRCEN_Msk);
    


  87. 

  88.     /* Wait for HIRC and LIRC clock ready */
    

  89.     CLK_WaitClockReady(CLK_STATUS_LIRCSTB_Msk);
    

  90.     CLK_WaitClockReady(CLK_STATUS_HIRCSTB_Msk);
    


  91. 

  92.     /* Select HCLK clock source as HIRC and HCLK clock divider as 1 */
    

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


  94. 

  95.     /* Enable UART module clock */
    

  96.     CLK_EnableModuleClock(UART0_MODULE);
    


  97. 

  98.     /* Select UART module clock source as HIRC and UART module clock divider as 1 */
    

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


  100. 

  101.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  103.     /*---------------------------------------------------------------------------------------------------------*/
    


  104. 

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

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

  107.                      | (SYS_GPB_MFPH_PB12MFP_UART0_RXD | SYS_GPB_MFPH_PB13MFP_UART0_TXD));
    


  108. 

  109.     /* Lock protected registers */
    

  110.     SYS_LockReg();
    

  111. }
    


  112. 

  113. void UART0_Init(void)
    

  114. {
    

  115.     /*---------------------------------------------------------------------------------------------------------*/
    

  116.     /* Init UART                                                                                               */
    

  117.     /*---------------------------------------------------------------------------------------------------------*/
    

  118.     /* Reset UART0 */
    

  119.     SYS_ResetModule(UART0_RST);
    


  120. 

  121.     /* Configure UART0 and set UART0 baud rate */
    

  122.     UART_Open(UART0, 115200);
    


  123. 

  124.     /* Enable UART RDA and RX timeout interrupt */
    

  125.     UART_EnableInt(UART0, UART_INTEN_RDAIEN_Msk | UART_INTEN_RXTOIEN_Msk);
    

  126.     NVIC_EnableIRQ(UART02_IRQn);
    


  127. 

  128.     /* Set RX Trigger Level as 4 bytes */
    

  129.     UART0->FIFO = ((UART0->FIFO & (~UART_FIFO_RFITL_Msk)) | UART_FIFO_RFITL_4BYTES);
    


  130. 

  131.     /* Set Timeout time counter in 60 bit-time and enable time-out counter */
    

  132.     UART_SetTimeoutCnt(UART0, RX_TIMEOUT_CNT);
    

  133. }
    


  134. 

  135. void DescriptionMessage(void)
    

  136. {
    

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

  138.     printf("|  This sample code performs how to receive unknow data length package.|\n");
    

  139.     printf("|                                                                      |\n");
    

  140.     printf("|   (1) Please send data to UART0 Rx(PB.12)                            |\n");
    

  141.     printf("|   (2) UART will receive data by UART Rx RDA and RXTO interrupt.      |\n");
    

  142.     printf("|   (3) User can modify the Rx Timeout counter RX_TIMEOUT_CNT for      |\n");
    

  143.     printf("|       diffirent timeout period.                                      |\n");
    

  144.     printf("|                                                                      |\n");
    

  145.     printf("|   Description for RX_TIMEOUT_CNT :                                   |\n");
    

  146.     printf("|   -UART data = 8 bits                                                |\n");
    

  147.     printf("|   -UART Parity = None                                                |\n");
    

  148.     printf("|   -RX_TIMEOUT_CNT = 60                                               |\n");
    

  149.     printf("|     If there is no data comes in 60 baudrate clock,                  |\n");
    

  150.     printf("|     the UART Rx timeout interrupt flag will be set to 1.             |\n");
    

  151.     printf("|     RX_TIMEOUT_CNT = 60 = 6 * ( 1 start + 8 data bits + 1 stop bit ) |\n");
    

  152.     printf("|                         = 6 bytes data transmittion times            |\n");
    

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


  154. 

  155.     UART_WAIT_TX_EMPTY(UART0);
    

  156. }
    


  157. 

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

  159. /*  Main Function                                                                                          */
    

  160. /*---------------------------------------------------------------------------------------------------------*/
    

  161. int32_t main(void)
    

  162. {
    

  163.     uint32_t u32ResetBufferIndex;
    

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

  165.     SYS_Init();
    


  166. 

  167.     /* Init UART */
    

  168.     UART0_Init();
    


  169. 

  170.     /* Print description message */
    

  171.     DescriptionMessage();
    


  172. 

  173.     while(1)
    

  174.     {
    

  175.         /* Wait to receive UART data */
    

  176.         while(UART_RX_IDLE(UART0));
    


  177. 

  178.         /* Start to received UART data */
    

  179.         g_bUART_RX_Received_Data_State = eUART_RX_Received_Data_NOT_Finish;
    

  180.         /* Wait for receiving UART message finished */
    

  181.         while(g_bUART_RX_Received_Data_State != eUART_RX_Received_Data_Finish);
    


  182. 

  183.         printf("\nUART0 Rx Received Data : %s\n",g_au8UART_RX_Buffer);
    

  184.         printf("UART0 Rx RDA (Fifofull) interrupt times : %d\n",g_u8UART_RDA_Trigger_Cnt);
    

  185.         printf("UART0 Rx RXTO (Timeout) interrupt times : %d\n",g_u8UART_RXTO_Trigger_Cnt);
    


  186. 

  187.         /* Reset SRAM Buffer */
    

  188.         u32ResetBufferIndex = 0;
    

  189.         while(g_au8UART_RX_Buffer[u32ResetBufferIndex] != '\0')
    

  190.             g_au8UART_RX_Buffer[u32ResetBufferIndex++] = '\0';
    

  191.         /* Reset UART interrupt parameter */
    

  192.         UART_EnableInt(UART0, UART_INTEN_RDAIEN_Msk | UART_INTEN_RXTOIEN_Msk);
    

  193.         g_u8UART_RDA_Trigger_Cnt = 0; // UART RDA interrupt times
    

  194.         g_u8UART_RXTO_Trigger_Cnt = 0; // UART RXTO interrupt times
    

  195.     }
    

  196. }


回复

收藏 举报

相关帖子
 楼主| 643757107 发表于 2024-2-19 21:25 | 显示全部楼层
#define FIFO_THRESHOLD 4
#define RX_BUFFER_SIZE 128
#define RX_TIMEOUT_CNT 60 //40~255
复制
  1. 这些宏定义了FIFO的阈值、接收缓冲区的大小和接收超时计数器的值。

回复

收藏 举报

 楼主| 643757107 发表于 2024-2-19 21:26 | 显示全部楼层
复制
  1. volatile uint8_t g_au8UART_RX_Buffer[RX_BUFFER_SIZE] = {0}; // UART Rx received data Buffer (RAM)
    

  2. volatile uint8_t g_bUART_RX_Received_Data_State = eUART_RX_Received_Data_NOT_Finish;
    

  3. volatile uint8_t g_u8UART_RDA_Trigger_Cnt = 0; // UART RDA interrupt trigger times counter
    

  4. volatile uint8_t g_u8UART_RXTO_Trigger_Cnt = 0; // UART RXTO interrupt trigger times counter

这些全局变量用于存储接收到的数据、接收状态以及接收中断触发次数。
回复

收藏 举报

 楼主| 643757107 发表于 2024-2-19 21:26 | 显示全部楼层
UART02_IRQHandler()函数：
这是UART0的中断服务程序。当接收到数据或者发生接收超时时会触发相应的中断，进行相应的处理。

SYS_Init()函数：
这个函数用于初始化系统时钟和UART0模块。

UART0_Init()函数：
这个函数用于初始化UART0模块，包括设置波特率、启用接收中断和接收超时中断等。

DescriptionMessage()函数：
这个函数用于打印描述信息，说明了代码的作用以及如何使用。
回复

收藏 举报

可怜的小弗朗士 发表于 2024-3-8 15:16 | 显示全部楼层
超时中断和空闲中断哪个好用
回复

收藏 举报

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

本版积分规则

643757107

223

主题

3972

帖子

11

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