21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 单线串口回环数据传输
返回列表 发新帖我要提问

[DemoCode下载] 单线串口回环数据传输

[复制链接]
1267|6
 楼主| xuanhuanzi 发表于 2024-2-19 22:53 | 显示全部楼层 |阅读模式
TE, UART, RT, ar, 串口, 数据传输
复制
  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.  * @brief
    

  5.  *           Two Single-Wire Loopback data test.
    

  6.  *
    

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

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

  9.  *
    

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

  11. #include "stdio.h"
    

  12. #include "string.h"
    

  13. #include "NuMicro.h"
    


  14. 


  15. 

  16. #define PLL_CLOCK   FREQ_96MHZ
    

  17. #define BUFSIZE   128
    


  18. 

  19. /*---------------------------------------------------------------------------------------------------------*/
    

  20. /* Global variables                                                                                        */
    

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

  22. uint8_t g_u8RecData[BUFSIZE] = {0};
    

  23. uint8_t g_u8TxData [BUFSIZE] = {0};
    

  24. volatile uint32_t g_u32RecLen  =  0;
    

  25. volatile int32_t  g_i32RecOK  = FALSE;
    


  26. 


  27. 

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

  29. /* Define functions prototype                                                                              */
    

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

  31. int32_t main(void);
    

  32. void UART1_TEST_HANDLE(void);
    

  33. void UART02_TEST_HANDLE(void);
    

  34. void UART_FunctionTest(void);
    


  35. 


  36. 

  37. void SYS_Init(void)
    

  38. {
    


  39. 

  40.     /*---------------------------------------------------------------------------------------------------------*/
    

  41.     /* Init System Clock                                                                                       */
    

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

  43.     /* Unlock protected registers */
    

  44.     SYS_UnlockReg();
    


  45. 

  46.     /* Enable HIRC clock (Internal RC 48MHz) */
    

  47.     CLK->PWRCTL |= CLK_PWRCTL_HIRCEN_Msk;
    


  48. 

  49.     /* Wait for HIRC clock ready */
    

  50.     while(!(CLK->STATUS & CLK_STATUS_HIRCSTB_Msk));
    


  51. 

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

  53.     CLK->CLKSEL0 = (CLK->CLKSEL0 & (~CLK_CLKSEL0_HCLKSEL_Msk)) | CLK_CLKSEL0_HCLKSEL_HIRC;
    

  54.     CLK->CLKDIV0 = (CLK->CLKDIV0 & (~CLK_CLKDIV0_HCLKDIV_Msk)) | CLK_CLKDIV0_HCLK(1);
    


  55. 

  56.     /* Enable UART0/1/2 peripheral clock */
    

  57.     CLK->APBCLK0 |= (CLK_APBCLK0_UART0CKEN_Msk | CLK_APBCLK0_UART1CKEN_Msk | CLK_APBCLK0_UART2CKEN_Msk);
    


  58. 

  59.     /* Select IP clock source */
    

  60.     /* Select UART0 clock source is HIRC */
    

  61.     CLK->CLKSEL1 = (CLK->CLKSEL1 & (~CLK_CLKSEL1_UART0SEL_Msk)) | CLK_CLKSEL1_UART0SEL_HIRC;
    

  62.     CLK->CLKDIV0 = (CLK->CLKDIV0 & (~CLK_CLKDIV0_UART0DIV_Msk)) | CLK_CLKDIV0_UART0(1);
    


  63. 

  64.     /* Select UART1 clock source is HIRC */
    

  65.     CLK->CLKSEL1 = (CLK->CLKSEL1 & (~CLK_CLKSEL1_UART1SEL_Msk)) | CLK_CLKSEL1_UART1SEL_HIRC;
    

  66.     CLK->CLKDIV0 = (CLK->CLKDIV0 & (~CLK_CLKDIV0_UART1DIV_Msk)) | CLK_CLKDIV0_UART1(1);
    


  67. 

  68.     /* Select UART2 clock source is HIRC */
    

  69.     CLK->CLKSEL3 = (CLK->CLKSEL3 & (~CLK_CLKSEL3_UART2SEL_Msk)) | CLK_CLKSEL3_UART2SEL_HIRC;
    

  70.     CLK->CLKDIV4 = (CLK->CLKDIV4 & (~CLK_CLKDIV4_UART2DIV_Msk)) | CLK_CLKDIV4_UART2(1);
    


  71. 

  72.     /* Update System Core Clock */
    

  73.     /* User can use SystemCoreClockUpdate() to calculate PllClock, SystemCoreClock and CycylesPerUs automatically. */
    

  74.     SystemCoreClockUpdate();
    


  75. 

  76.     /*---------------------------------------------------------------------------------------------------------*/
    

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

  78.     /*---------------------------------------------------------------------------------------------------------*/
    

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

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

  81.                     (SYS_GPB_MFPH_PB12MFP_UART0_RXD | SYS_GPB_MFPH_PB13MFP_UART0_TXD);
    


  82. 

  83.     /* Set PA multi-function pins for UART1 RXD */
    

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


  85. 

  86.     /* Set PB multi-function pins for UART2 RXD */
    

  87.     SYS->GPB_MFPL = (SYS->GPB_MFPL & ~(SYS_GPB_MFPL_PB0MFP_Msk)) | SYS_GPB_MFPL_PB0MFP_UART2_RXD;
    


  88. 

  89.     /* The RX pin needs to pull-high for single-wire */
    

  90.     /* If the external circuit doesn't pull-high, set GPIO pin as Quasi-directional mode for this purpose here */
    

  91.     PA->MODE &= (PA->MODE & ~GPIO_MODE_MODE2_Msk) | (GPIO_MODE_QUASI << GPIO_MODE_MODE2_Pos);
    


  92. 

  93.     PB->MODE = (PB->MODE & ~GPIO_MODE_MODE0_Msk) | (GPIO_MODE_QUASI << GPIO_MODE_MODE0_Pos);
    


  94. 

  95.     /* Lock protected registers */
    

  96.     SYS_LockReg();
    


  97. 

  98. }
    

  99. /*---------------------------------------------------------------------------------------------------------*/
    

  100. /*                                     Init UART0                                                          */
    

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

  102. void UART0_Init()
    

  103. {
    


  104. 

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

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

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


  108. 

  109. }
    

  110. /*---------------------------------------------------------------------------------------------------------*/
    

  111. /*                               Init Single Wire(UART1)                                                   */
    

  112. /*---------------------------------------------------------------------------------------------------------*/
    


  113. 

  114. void UART1_Init()
    

  115. {
    

  116.     /* Configure Single Wire(UART1) and set Single Wire(UART1) baud rate */
    

  117.     UART1->BAUD = UART_BAUD_MODE2 | UART_BAUD_MODE2_DIVIDER(__HIRC, 115200);
    

  118.     UART1->LINE = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;
    


  119. 

  120.     UART1->FUNCSEL = ((UART1->FUNCSEL & (~UART_FUNCSEL_FUNCSEL_Msk)) | UART_FUNCSEL_SINGLE_WIRE);
    

  121. }
    


  122. 


  123. 

  124. /*---------------------------------------------------------------------------------------------------------*/
    

  125. /*                               Init Single Wire(UART2)                                                   */
    

  126. /*---------------------------------------------------------------------------------------------------------*/
    


  127. 

  128. void UART2_Init()
    

  129. {
    

  130.     /* Configure Single Wire(UART2) and set Single Wire(UART2) baud rate */
    

  131.     UART2->BAUD = UART_BAUD_MODE2 | UART_BAUD_MODE2_DIVIDER(__HIRC, 115200);
    

  132.     UART2->LINE = UART_WORD_LEN_8 | UART_PARITY_NONE | UART_STOP_BIT_1;
    


  133. 

  134.     UART2->FUNCSEL = ((UART2->FUNCSEL & (~UART_FUNCSEL_FUNCSEL_Msk)) | UART_FUNCSEL_SINGLE_WIRE);
    


  135. 

  136. }
    


  137. 

  138. /*---------------------------------------------------------------------------------------------------------*/
    

  139. /* UART Test Sample                                                                                        */
    

  140. /* Test Item                                                                                               */
    

  141. /* Debug port control the Single wire 1(UART1) send data to Single wire 2(UART2) or Single wire 2(UART1)   */
    

  142. /* send data to Single wire 1(UART1)                                                                       */
    

  143. /*---------------------------------------------------------------------------------------------------------*/
    


  144. 

  145. /*---------------------------------------------------------------------------------------------------------*/
    

  146. /*                                         Main Function                                                   */
    

  147. /*---------------------------------------------------------------------------------------------------------*/
    

  148. int32_t main(void)
    

  149. {
    


  150. 

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

  152.     SYS_Init();
    


  153. 

  154.     /* Init UART0 for printf */
    

  155.     UART0_Init();
    

  156.     /* Init UART1 and UART2 for Single Wire Test*/
    

  157.     UART1_Init();
    

  158.     UART2_Init();
    


  159. 

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

  161.     /*                                           SAMPLE CODE                                                   */
    

  162.     /*---------------------------------------------------------------------------------------------------------*/
    


  163. 

  164.     printf("\n\nCPU [url=home.php?mod=space&uid=72445]@[/url] %d Hz\n", SystemCoreClock);
    

  165.     printf("\nUART Sample Program\n");
    


  166. 

  167.     /* UART sample function */
    

  168.     UART_FunctionTest();
    


  169. 

  170.     while (1);
    


  171. 

  172. }
    


  173. 

  174. /*---------------------------------------------------------------------------------------------------------*/
    

  175. /*                       ISR to handle UART Channel 1 interrupt event                                      */
    

  176. /*---------------------------------------------------------------------------------------------------------*/
    

  177. void UART13_IRQHandler(void)
    

  178. {
    

  179.     UART1_TEST_HANDLE();
    

  180. }
    


  181. 

  182. /*---------------------------------------------------------------------------------------------------------*/
    

  183. /*                                  UART1 Callback function                                                */
    

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

  185. void UART1_TEST_HANDLE()
    

  186. {
    


  187. 

  188.     uint32_t u32IntSts = UART1->INTSTS;
    


  189. 

  190.     if (u32IntSts & UART_INTSTS_RDAIF_Msk)
    

  191.     {
    

  192.         /* Get all the input characters */
    

  193.         while (UART_IS_RX_READY(UART1))
    

  194.         {
    

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

  196.             g_u8RecData[g_u32RecLen] = UART_READ(UART1);
    


  197. 

  198.             if (g_u32RecLen == BUFSIZE - 1)
    

  199.             {
    

  200.                 g_i32RecOK = TRUE;
    

  201.                 g_u32RecLen = 0;
    

  202.             }
    

  203.             else
    

  204.             {
    

  205.                 g_u32RecLen++;
    

  206.             }
    

  207.         }
    

  208.     }
    


  209. 

  210.     if (u32IntSts & UART_INTSTS_SWBEIF_Msk)
    

  211.     {
    

  212.         printf("Single-wire Bit Error Detection \n");
    

  213.         UART1->INTSTS = UART_INTSTS_SWBEIF_Msk;
    

  214.     }
    

  215. }
    


  216. 


  217. 

  218. /*---------------------------------------------------------------------------------------------------------*/
    

  219. /* ISR to handle UART Channel 0/2 interrupt event                                                            */
    

  220. /*---------------------------------------------------------------------------------------------------------*/
    

  221. void UART02_IRQHandler(void)
    

  222. {
    

  223.     UART02_TEST_HANDLE();
    

  224. }
    


  225. 

  226. /*---------------------------------------------------------------------------------------------------------*/
    

  227. /* UART0/2 Callback function                                                                                  */
    

  228. /*---------------------------------------------------------------------------------------------------------*/
    

  229. void UART02_TEST_HANDLE()
    

  230. {
    


  231. 

  232.     uint32_t u32IntSts = UART2->INTSTS;
    


  233. 

  234.     if (u32IntSts & UART_INTSTS_RDAIF_Msk)
    

  235.     {
    

  236.         /* Get all the input characters */
    

  237.         while (UART_IS_RX_READY(UART2))
    

  238.         {
    

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

  240.             g_u8RecData[g_u32RecLen] = UART_READ(UART2);
    


  241. 

  242.             if (g_u32RecLen == BUFSIZE - 1)
    

  243.             {
    

  244.                 g_i32RecOK = TRUE;
    

  245.                 g_u32RecLen = 0;
    

  246.             }
    

  247.             else
    

  248.             {
    

  249.                 g_u32RecLen++;
    

  250.             }
    

  251.         }
    

  252.     }
    


  253. 

  254.     if (u32IntSts & UART_INTSTS_SWBEIF_Msk)
    

  255.     {
    

  256.         printf("Single-wire Bit Error Detection \n");
    

  257.         UART2->INTSTS = UART_INTSTS_SWBEIF_Msk;
    


  258. 

  259.     }
    

  260. }
    

  261. /*---------------------------------------------------------------------------------------------------------*/
    

  262. /*                              Bulid Source Pattern function                                              */
    

  263. /*---------------------------------------------------------------------------------------------------------*/
    

  264. void Build_Src_Pattern(uint32_t u32Addr, uint8_t type, uint32_t u32Length)
    

  265. {
    

  266.     uint32_t i = 0, pattern = 0;
    

  267.     uint8_t *pAddr;
    

  268.     pAddr = (uint8_t *)u32Addr;
    


  269. 

  270.     if (type == 0)      pattern = 0x1f;
    

  271.     else if (type == 1) pattern = 0x3f;
    

  272.     else if (type == 2) pattern = 0x7f;
    

  273.     else if (type == 3) pattern = 0xff;
    

  274.     else  pattern = 0xff;
    


  275. 

  276.     for (i = 0; i < u32Length ; i++)
    

  277.         pAddr[i] = (i & pattern);
    


  278. 

  279. }
    


  280. 

  281. /*---------------------------------------------------------------------------------------------------------*/
    

  282. /*                    Verify that the received data is correct                                             */
    

  283. /*---------------------------------------------------------------------------------------------------------*/
    

  284. uint8_t Check_Pattern(uint32_t u32Addr0, uint32_t u32Addr1, uint32_t u32Length)
    

  285. {
    

  286.     uint32_t i = 0;
    

  287.     uint8_t result = 1;
    

  288.     uint8_t *pAddr0;
    

  289.     uint8_t *pAddr1;
    

  290.     pAddr0 = (uint8_t *)u32Addr0;
    

  291.     pAddr1 = (uint8_t *)u32Addr1;
    


  292. 

  293.     for (i = 0; i < u32Length ; i++)
    

  294.     {
    

  295.         if (pAddr0[i] != pAddr1[i])
    

  296.         {
    

  297.             printf("Data Error Idex=%d,tx =%d,rx=%d\n", i, pAddr0[i], pAddr1[i]) ;
    

  298.             result = 0;
    

  299.         }
    

  300.     }
    


  301. 

  302.     return result;
    

  303. }
    


  304. 


  305. 

  306. /*---------------------------------------------------------------------------------------------------------*/
    

  307. /*  UART Function Test                                                                                     */
    

  308. /*---------------------------------------------------------------------------------------------------------*/
    

  309. void UART_FunctionTest()
    

  310. {
    

  311.     char cmmd ;
    

  312.     uint32_t  u32i;
    


  313. 

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

  315.     printf("|            UART Single Wire Function Test                 |\n");
    

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

  317.     printf("|  Description :                                            |\n");
    

  318.     printf("|    The sample code will print input char on terminal      |\n");
    

  319.     printf("|    The user must connect the UART1 RX pin(PA2) to         |\n");
    

  320.     printf("|    UART_Rx Pin(PB0).                                      |\n");
    

  321.     printf("|    Single Wire 1(PA2)send data to Single Wire 2(PB0).     |\n");
    

  322.     printf("|    Single Wire 2(PB0)send data to Single Wire 1(PA2).     |\n");
    

  323.     printf("|    Please enter any to start    (Press '0' to exit)       |\n");
    

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


  325. 

  326.     /*
    

  327.         Using a RS232 cable to connect UART0 and PC.UART0 is set to debug port.
    

  328.           UART1 and UART2 is enable RDA and RLS interrupt.
    

  329.           The user can use URT0 to control the transmission or reception of UART1(Single Wire mode)
    

  330.         When UART1(Single Wire 1)transfers data to UART2(Single Wire 2), if data is valid,
    

  331.           it will enter the interrupt and receive the data.And then check the received data.
    

  332.         When UART2(Single Wire 2)transfers data to UART1(Single Wire 1), if data is valid,
    

  333.           it will enter the interrupt and receive the data.And then check the received data.
    

  334.       */
    


  335. 

  336.     /* Enable UART1 RDA/Time-out/Single-wire Bit Error Detection interrupt */
    

  337.     NVIC_EnableIRQ(UART13_IRQn);
    

  338.     UART1->INTEN |= (UART_INTEN_RDAIEN_Msk | UART_INTEN_RXTOIEN_Msk | UART_INTEN_SWBEIEN_Msk);
    

  339.     /* Enable UART2 RDA/Time-out/Single-wire Bit Error Detection interrupt */
    

  340.     NVIC_EnableIRQ(UART02_IRQn);
    

  341.     UART2->INTEN |= (UART_INTEN_RDAIEN_Msk | UART_INTEN_RXTOIEN_Msk | UART_INTEN_SWBEIEN_Msk);
    


  342. 

  343.     do
    

  344.     {
    

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

  346.         printf("|                UART Single Wire Test Item                    |\n");
    

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

  348.         printf("|    (1)Single Wire 1(PA2)send data to Single Wire 2(PB0).     |\n");
    

  349.         printf("|    (2)Single Wire 2(PB0)send data to Single Wire 1(PA2).     |\n");
    

  350.         printf("|    (E)Exit                                                   |\n");
    

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


  352. 

  353.         cmmd = getchar();
    


  354. 

  355.         switch (cmmd)
    

  356.         {
    

  357.         case '1':
    

  358.         {
    

  359.             printf("SW1(UART1) --> SW2(UART2)Test :");
    

  360.             g_i32RecOK  = FALSE;
    

  361.             Build_Src_Pattern((uint32_t)g_u8TxData, UART_WORD_LEN_8, BUFSIZE);
    


  362. 

  363.             /* Check the Rx status is Idel */
    

  364.             while (!UART_RX_IDLE(UART1)) {};
    


  365. 

  366.             /* Send data */
    

  367.             for(u32i = 0; u32i < BUFSIZE; u32i++)
    

  368.             {
    

  369.                 /* Send 1 byte data */
    

  370.                 UART1->DAT = g_u8TxData[u32i];
    


  371. 

  372.                 /* Wait if Tx FIFO is full */
    

  373.                 while((UART1->FIFOSTS & UART_FIFOSTS_TXEMPTYF_Msk)==0);
    

  374.             }
    


  375. 

  376.             while (g_i32RecOK != TRUE) {}
    


  377. 

  378.             Check_Pattern((uint32_t)g_u8TxData, (uint32_t)g_u8RecData, BUFSIZE) ? printf(" Pass\n") : printf(" Fail\n");
    

  379.             /* Clear the Tx and Rx data buffer */
    

  380.             memset((uint8_t *)g_u8TxData, 0, BUFSIZE);
    

  381.             memset((uint8_t *)g_u8RecData, 0, BUFSIZE);
    

  382.         }
    

  383.         break;
    


  384. 

  385.         case '2':
    

  386.         {
    

  387.             printf("SW2(UART2) --> SW1(UART1)Test :");
    

  388.             g_i32RecOK  = FALSE;
    

  389.             Build_Src_Pattern((uint32_t)g_u8TxData, UART_WORD_LEN_8, BUFSIZE);
    


  390. 

  391.             /* Check the Rx status is Idel */
    

  392.             while (!UART_RX_IDLE(UART2)) {};
    


  393. 

  394.             /* Send data */
    

  395.             for(u32i = 0; u32i < BUFSIZE; u32i++)
    

  396.             {
    

  397.                 /* Send 1 byte data */
    

  398.                 UART2->DAT = g_u8TxData[u32i];
    


  399. 

  400.                 /* Wait if Tx FIFO is full */
    

  401.                 while((UART2->FIFOSTS & UART_FIFOSTS_TXEMPTYF_Msk)==0);
    

  402.             }
    


  403. 

  404.             while (g_i32RecOK != TRUE) {};
    


  405. 

  406.             Check_Pattern((uint32_t)g_u8TxData, (uint32_t)g_u8RecData, BUFSIZE) ? printf(" Pass\n") :   printf(" Fail\n");
    


  407. 

  408.             /* Clear the Tx and Rx data buffer */
    

  409.             memset((uint8_t *)g_u8TxData, 0, BUFSIZE);
    


  410. 

  411.             memset((uint8_t *)g_u8RecData, 0, BUFSIZE);
    

  412.         }
    

  413.         break;
    


  414. 

  415.         default:
    

  416.             break;
    

  417.         }
    


  418. 

  419.     }
    

  420.     while ((cmmd != 'E') && (cmmd != 'e'));
    


  421. 

  422.     /* Disable UART1 RDA/Time-out interrupt */
    

  423.     UART1->INTEN &= ~(UART_INTEN_RDAIEN_Msk | UART_INTEN_RXTOIEN_Msk | UART_INTEN_SWBEIEN_Msk);
    

  424.     /* Disable UART2 RDA/Time-out interrupt */
    

  425.     UART2->INTEN &= ~(UART_INTEN_RDAIEN_Msk | UART_INTEN_RXTOIEN_Msk | UART_INTEN_SWBEIEN_Msk);
    

  426.     printf("\nUART Sample Demo End.\n");
    


  427. 

  428. }
    


  429. 

  430. /*** (C) COPYRIGHT 2017 Nuvoton Technology Corp. ***/
    


  431. 


  432.


回复

收藏 举报

相关帖子
 楼主| xuanhuanzi 发表于 2024-2-19 22:54 | 显示全部楼层
导入必要的库文件，包括<stdio.h>、<string.h>和"Nuvoton.h"。
定义了一些全局变量，包括接收数据缓冲区、发送数据缓冲区以及接收数据长度等。
进行系统初始化，包括时钟设置和串口引脚配置。
分别初始化了三个串口，其中UART0用于调试打印，UART1和UART2用于单线串口的测试。
在主函数中进行了串口功能测试。
定义了UART1和UART2的中断处理函数，用于处理数据接收和单线模式的错误检测。
定义了一些辅助函数，如构建源模式和检查接收数据是否正确。
在串口功能测试函数中，首先打印测试项目的描述信息，然后通过用户输入选择测试项目，分别是单线1发送数据到单线2和单线2发送数据到单线1。
测试过程中，通过循环发送数据，并等待数据接收完成，然后检查接收到的数据是否正确。
最后，根据用户输入决定是否退出测试，并禁用串口中断。
整体思路是通过配置单线串口，实现两个串口之间的数据传输和回环测试，通过中断处理函数处理数据接收和单线模式的错误检测，最终进行数据正确性验证。
回复

收藏 举报

小明的同学 发表于 2024-2-27 11:52 | 显示全部楼层
这个主要用于测试，单个芯片就可以完成收发验证。
回复

收藏 举报

21mengnan 发表于 2024-2-27 21:34 | 显示全部楼层
常用的测试方法。
回复

收藏 举报

21mengnan 发表于 2024-2-27 21:34 | 显示全部楼层
串口还可以用DMA方法使用更好。
回复

收藏 举报

LEDyyds 发表于 2024-2-28 20:30 | 显示全部楼层
这就是为了测试吧
回复

收藏 举报

黑心单片机 发表于 2024-2-28 20:47 | 显示全部楼层
这玩意只有测试有用吧
回复

收藏 举报

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

本版积分规则

xuanhuanzi

183

主题

2331

帖子

3

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