21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › UC240 UART接口驱动ESP8266
返回列表 发新帖我要提问

[DemoCode下载] UC240 UART接口驱动ESP8266

[复制链接]
762|1
 楼主| xinxianshi 发表于 2023-2-12 19:52 | 显示全部楼层 |阅读模式
ESP8266, UART, UART接口, esp826, 接口
EC_NUC240_UART_ESP8266_V1.00.zip (1.28 MB, 下载次数: 1)
ESP-01S是Espressif公司生产的一种基于ESP8266的小型模块。
ESP-01S ESP8266 Wi-Fi模块是一个独立的SOC，具有集成的TCP/IP协议栈，可以让任何微控制器访问Wi-Fi网络。ESP8266能够独立运行应用程序，或者从另一个应用程序处理器分担所有Wi-Fi网络功能。每个ESP-01S ESP8266模块都预置有AT命令集软件。
TCP传输控制协议是Internet协议套件的主要协议之一。它起源于最初的网络实现，它补充了互联网协议（IP）。因此，整个套件通常称为TCP/IP。TCP在通过IP网络通信的主机上运行的应用程序之间提供可靠的、有序的和经过错误检查的八位字节流。主要的internet应用程序，如万维网、电子邮件、远程管理和文件传输都依赖于TCP。不需要可靠数据流服务的应用程序可以使用用户数据报协议（UDP），该协议提供无连接数据报服务，强调降低延迟而不是可靠性。
本范例代码使用NUC240系列芯片，通过UART0接口驱动ESP-01S模组，利用ESP8266内置的TCP协议栈实现TCP服务器的功能。当电脑通过Wi-Fi连接ESP8266模块后，用户可以使用电脑工具串口及网络助手工具查看执行结果。
将ESP8266设置为TCP服务器，使能多IP连接，因为可能有多个客户端连接到ESP8266。
如下展示了当ESP8266在softAP模式下工作时如何实现TCP服务器。

397763e8d2d6f10cc.png
6449763e8d2e1f04b1.png
回复

收藏 举报

相关帖子
 楼主| xinxianshi 发表于 2023-2-12 19:52 | 显示全部楼层
复制

  1. 

  2. /**************************************************************************//**
    

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

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

  5. * $Date: 8/20/19 5:36p $
    

  6. * [url=home.php?mod=space&uid=247401]@brief[/url] Use UART to drive ESP8266 wifi chip and communication.
    

  7. *
    

  8. * @note
    

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

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

  11. #include <stdio.h>
    

  12. #include "NUC230_240.h"
    

  13. #include <string.h>                     //because using memset function
    

  14. /*---------------------------------------------------------------------------*/
    

  15. /* Define                                                                    */
    

  16. /*---------------------------------------------------------------------------*/
    

  17. #define PLL_CLOCK           50000000
    

  18. #define SYSTICK_TIMER       10000       // 10ms
    


  19. 

  20. #define KEY1 PA0
    

  21. #define KEY2 PA1
    

  22. #define KEY3 PA2
    

  23. #define KEY4 PA3
    


  24. 

  25. #define KEY_NONE 0
    

  26. #define KEY_SW1 1
    

  27. #define KEY_SW2 2
    

  28. #define KEY_SW3 3
    

  29. #define KEY_SW4 4
    


  30. 

  31. #define RECEIVE_MAX_CHAR_NUMBER 100
    

  32. #define RECEIVE_MAX_STRING  10
    

  33. #define RECEIVE_MAX_VALIDCHAR_NUMBER 80
    


  34. 

  35. typedef struct
    

  36. {
    

  37.     uint8_t  u8CharNum;
    

  38.     uint8_t *pu8string;
    

  39. } ATCMD_Type;
    


  40. 

  41. typedef struct
    

  42. {
    

  43.     uint8_t  u8String[RECEIVE_MAX_CHAR_NUMBER];
    

  44. } ATREVSTRING_Type;
    


  45. 

  46. /*---------------------------------------------------------------------------*/
    

  47. /* Global variables                                                          */
    

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

  49. uint32_t u32SysTimerCounter = 0;
    

  50. uint32_t u32TimerOutCounter = 0;
    

  51. uint32_t u32SysTimerKeyCounter = 0;
    

  52. uint8_t u8KeyScan;
    

  53. uint8_t u8KeyScanPrev = KEY_NONE;
    

  54. uint8_t u8KeyGet;
    


  55. 

  56. uint8_t AT_StringCmdRst[] = {"AT+RST\r\n"};
    

  57. uint8_t AT_StringCmdCwmode1[] = {"AT+CWMODE=1\r\n"};
    

  58. uint8_t AT_StringCmdCwmode2[] = {"AT+CWMODE=2\r\n"};
    

  59. uint8_t AT_StringCmdCwmode3[] = {"AT+CWMODE=3\r\n"};
    

  60. uint8_t AT_StringCmdCipMux0[] = {"AT+CIPMUX=0\r\n"};
    

  61. uint8_t AT_StringCmdCipMux1[] = {"AT+CIPMUX=1\r\n"};
    

  62. uint8_t AT_StringCmdCipServer0[] = {"AT+CIPSERVER=0\r\n"};
    

  63. uint8_t AT_StringCmdCipServer1[] = {"AT+CIPSERVER=1,8080\r\n"};
    

  64. uint8_t AT_StringCmdAP[] = {"AT+CWSAP_CUR="Nuvoton_AP","",5,0,4,0\r\n"};
    

  65. uint8_t AT_StringIPD[] = {"\n+IPD,0,"};
    


  66. 

  67. ATCMD_Type atCmdRst = {sizeof(AT_StringCmdRst) / sizeof(uint8_t), AT_StringCmdRst};
    

  68. ATCMD_Type atCmdCwmode1 = {sizeof(AT_StringCmdCwmode1) / sizeof(uint8_t), AT_StringCmdCwmode1};
    

  69. ATCMD_Type atCmdCwmode2 = {sizeof(AT_StringCmdCwmode2) / sizeof(uint8_t), AT_StringCmdCwmode2};
    

  70. ATCMD_Type atCmdCwmode3 = {sizeof(AT_StringCmdCwmode3) / sizeof(uint8_t), AT_StringCmdCwmode3};
    

  71. ATCMD_Type atCmdCipmux0 = {sizeof(AT_StringCmdCipMux0) / sizeof(uint8_t), AT_StringCmdCipMux0};
    

  72. ATCMD_Type atCmdCipmux1 = {sizeof(AT_StringCmdCipMux1) / sizeof(uint8_t), AT_StringCmdCipMux1};
    

  73. ATCMD_Type atCmdCipserver0 = {sizeof(AT_StringCmdCipServer0) / sizeof(uint8_t), AT_StringCmdCipServer0};
    

  74. ATCMD_Type atCmdCipserver1 = {sizeof(AT_StringCmdCipServer1) / sizeof(uint8_t), AT_StringCmdCipServer1};
    

  75. ATCMD_Type atCmdAp = {sizeof(AT_StringCmdAP) / sizeof(uint8_t), AT_StringCmdAP};
    


  76. 

  77. ATREVSTRING_Type ReceiveArray[RECEIVE_MAX_STRING];
    

  78. uint8_t u8ReceiveStringArrayHeader;
    

  79. uint8_t u8ReceiveStringArrayTail;
    

  80. uint8_t u8StringIndex;
    

  81. uint8_t u8ReceiveData[RECEIVE_MAX_VALIDCHAR_NUMBER];
    

  82. uint8_t u8ReceiveDataLength;
    

  83. /*---------------------------------------------------------------------------*/
    

  84. /* Functions                                                                 */
    

  85. /*---------------------------------------------------------------------------*/
    

  86. __STATIC_INLINE void CLK_SysTickInit(uint32_t u32us)
    

  87. {
    

  88.     SysTick->LOAD = u32us * CyclesPerUs;
    

  89.     SysTick->VAL  = (0x00);
    

  90.     SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk | SysTick_CTRL_TICKINT_Msk | SysTick_CTRL_ENABLE_Msk;
    

  91. }
    


  92. 

  93. void SysTick_Handler(void)
    

  94. {
    

  95.     u32SysTimerCounter++;
    


  96. 

  97.     if (u32TimerOutCounter > 0)
    

  98.     {
    

  99.         u32TimerOutCounter --;
    

  100.     }
    

  101. }
    

  102. /*---------------------------------------------------------------------------------------------------------*/
    

  103. /* ISR to handle UART Channel 0 interrupt event                                                            */
    

  104. /*---------------------------------------------------------------------------------------------------------*/
    

  105. void UART02_IRQHandler(void)
    

  106. {
    

  107.     uint32_t u32IntSts = UART0->ISR;
    

  108.     uint8_t u8Data;
    


  109. 

  110.     if (u32IntSts & UART_ISR_RDA_INT_Msk)
    

  111.     {
    

  112.         u8Data = UART_READ(UART0);
    


  113. 

  114.         while (UART1->FSR & UART_FSR_TX_FULL_Msk);
    


  115. 

  116.         UART_WRITE(UART1, u8Data);
    


  117. 

  118.         if (u8Data == '\r')
    

  119.         {
    

  120.             ReceiveArray[u8ReceiveStringArrayTail].u8String[u8StringIndex++] = u8Data;
    

  121.             u8ReceiveStringArrayTail++;
    

  122.             u8StringIndex = 0;
    


  123. 

  124.             if (u8ReceiveStringArrayTail >= RECEIVE_MAX_STRING)
    

  125.             {
    

  126.                 if (u8ReceiveStringArrayHeader == 0)
    

  127.                 {
    

  128.                     u8ReceiveStringArrayTail = 0;
    

  129.                     u8ReceiveStringArrayHeader++;
    

  130.                 }
    

  131.                 else
    

  132.                 {
    

  133.                     u8ReceiveStringArrayTail = 0;
    

  134.                 }
    

  135.             }
    

  136.             else if (u8ReceiveStringArrayTail == u8ReceiveStringArrayHeader)
    

  137.             {
    

  138.                 u8ReceiveStringArrayHeader++;
    


  139. 

  140.                 if (u8ReceiveStringArrayHeader >= RECEIVE_MAX_STRING)
    

  141.                 {
    

  142.                     u8ReceiveStringArrayHeader = 0;
    

  143.                 }
    

  144.             }
    

  145.         }
    

  146.         else
    

  147.         {
    

  148.             ReceiveArray[u8ReceiveStringArrayTail].u8String[u8StringIndex++] = u8Data;
    


  149. 

  150.             if (u8StringIndex >= RECEIVE_MAX_CHAR_NUMBER)
    

  151.             {
    

  152.                 u8StringIndex--;
    

  153.             }
    

  154.         }
    

  155.     }
    

  156.     else
    

  157.     {
    

  158.         UART0->FSR |= UART_FSR_BIF_Msk | UART_FSR_FEF_Msk | UART_FSR_PEF_Msk;
    

  159.         u8Data = UART_READ(UART0);
    

  160.     }
    

  161. }
    

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

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

  164. /*---------------------------------------------------------------------------------------------------------*/
    

  165. void UART1_IRQHandler(void)
    

  166. {
    

  167.     uint32_t u32IntSts = UART1->ISR;
    

  168.     uint8_t u8Data;
    


  169. 

  170.     if (u32IntSts & UART_ISR_RDA_INT_Msk)
    

  171.     {
    

  172.         u8Data = UART_READ(UART1);
    


  173. 

  174.         while (UART0->FSR & UART_FSR_TX_FULL_Msk);
    


  175. 

  176.         UART_WRITE(UART0, u8Data);
    

  177.     }
    

  178.     else
    

  179.     {
    

  180.         UART1->FSR |= UART_FSR_BIF_Msk | UART_FSR_FEF_Msk | UART_FSR_PEF_Msk;
    

  181.         u8Data = UART_READ(UART0);
    

  182.     }
    


  183. 

  184. }
    


  185. 

  186. void SYS_Init(void)
    

  187. {
    

  188.     /*---------------------------------------------------------------------------------------------------------*/
    

  189.     /* Init System Clock                                                                                       */
    

  190.     /*---------------------------------------------------------------------------------------------------------*/
    


  191. 

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

  193.     CLK_EnableXtalRC(CLK_PWRCON_OSC22M_EN_Msk);
    


  194. 

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

  196.     CLK_WaitClockReady(CLK_CLKSTATUS_OSC22M_STB_Msk);
    


  197. 

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

  199.     CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_CLKDIV_HCLK(1));
    


  200. 

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

  202.     CLK_EnableXtalRC(CLK_PWRCON_XTL12M_EN_Msk);
    


  203. 

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

  205.     CLK_WaitClockReady(CLK_CLKSTATUS_XTL12M_STB_Msk);
    


  206. 

  207.     /* Set core clock as PLL_CLOCK from PLL */
    

  208.     CLK_SetCoreClock(PLL_CLOCK);
    


  209. 

  210.     /* Enable UART module clock */
    

  211.     CLK_EnableModuleClock(UART0_MODULE);
    

  212.     CLK_EnableModuleClock(UART1_MODULE);
    


  213. 

  214.     /* Select UART module clock source */
    

  215.     CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));
    

  216.     CLK_SetModuleClock(UART1_MODULE, CLK_CLKSEL1_UART_S_HXT, CLK_CLKDIV_UART(1));
    


  217. 

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

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

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


  221. 

  222.     /* Set GPB multi-function pins for UART0 RXD and TXD */
    

  223.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB0_Msk | SYS_GPB_MFP_PB1_Msk);
    

  224.     SYS->GPB_MFP |= SYS_GPB_MFP_PB0_UART0_RXD | SYS_GPB_MFP_PB1_UART0_TXD;
    


  225. 

  226.     /* Set GPB multi-function pins for UART1 RXD and TXD */
    

  227.     SYS->GPB_MFP &= ~(SYS_GPB_MFP_PB4_Msk | SYS_GPB_MFP_PB5_Msk);
    

  228.     SYS->GPB_MFP |= SYS_GPB_MFP_PB4_UART1_RXD | SYS_GPB_MFP_PB5_UART1_TXD;
    

  229. }
    


  230. 

  231. void UART_Init()
    

  232. {
    

  233.     /*---------------------------------------------------------------------------------------------------------*/
    

  234.     /* Init UART                                                                                               */
    

  235.     /*---------------------------------------------------------------------------------------------------------*/
    

  236.     /* Reset IP */
    

  237.     SYS_ResetModule(UART0_RST);
    

  238.     SYS_ResetModule(UART1_RST);
    


  239. 

  240.     /* Configure UART0/UART1 and set UART0/UART1 Baudrate */
    

  241.     UART_Open(UART0, 115200);
    

  242.     UART_Open(UART1, 115200);
    


  243. 

  244.     /* Enable Interrupt and install the call back function */
    

  245.     //set RX FIFO INT TRIGGER LEVEL
    

  246.     UART0->FCR &= ~(UART_FCR_RFITL_Msk | UART_FCR_RTS_TRI_LEV_Msk);
    

  247.     UART0->FCR |= ((0x0ul << UART_FCR_RFITL_Pos));
    

  248.     UART_DisableInt(UART0, (UART_IER_RDA_IEN_Msk | UART_IER_THRE_IEN_Msk | UART_IER_RLS_IEN_Msk));
    

  249.     UART_EnableInt(UART0, (UART_IER_RDA_IEN_Msk | UART_IER_RLS_IEN_Msk));
    


  250. 

  251.     UART1->FCR &= ~(UART_FCR_RFITL_Msk | UART_FCR_RTS_TRI_LEV_Msk);
    

  252.     UART1->FCR |= ((0x0ul << UART_FCR_RFITL_Pos));
    

  253.     UART_DisableInt(UART1, (UART_IER_RDA_IEN_Msk | UART_IER_THRE_IEN_Msk | UART_IER_RLS_IEN_Msk));
    

  254.     UART_EnableInt(UART1, (UART_IER_RDA_IEN_Msk | UART_IER_RLS_IEN_Msk));
    

  255. }
    


  256. 

  257. void Initial_Key_Input(void)
    

  258. {
    

  259.     GPIO_SetMode(PA, 0, GPIO_PMD_QUASI);
    

  260.     GPIO_SetMode(PA, 1, GPIO_PMD_QUASI);
    

  261.     GPIO_SetMode(PA, 2, GPIO_PMD_QUASI);
    

  262.     GPIO_SetMode(PA, 3, GPIO_PMD_QUASI);
    

  263. }
    


  264. 

  265. uint8_t Get_Key_Input(void)
    

  266. {
    

  267.     uint8_t u8temp = KEY_NONE;
    


  268. 

  269.     if (KEY1 == 0)
    

  270.     {
    

  271.         u8temp = KEY_SW1;
    

  272.     }
    


  273. 

  274.     if (KEY2 == 0)
    

  275.     {
    

  276.         u8temp = KEY_SW2;
    

  277.     }
    


  278. 

  279.     if (KEY3 == 0)
    

  280.     {
    

  281.         u8temp = KEY_SW3;
    

  282.     }
    


  283. 

  284.     if (KEY4 == 0)
    

  285.     {
    

  286.         u8temp = KEY_SW4;
    

  287.     }
    


  288. 

  289.     return u8temp;
    

  290. }
    


  291. 

  292. void Key_Process(uint8_t u8Key)
    

  293. {
    

  294.     uint32_t u32cnt;
    


  295. 

  296.     if (u8Key == KEY_NONE)
    

  297.     {
    

  298.         return;
    

  299.     }
    


  300. 

  301.     switch (u8Key)
    

  302.     {
    

  303.         case KEY_SW1:
    

  304.             UART_Write(UART0, atCmdRst.pu8string, atCmdRst.u8CharNum);            // Reset ESP8266
    

  305.             break;
    


  306. 

  307.         case KEY_SW2:
    

  308.             UART_Write(UART0, atCmdCwmode3.pu8string, atCmdCwmode3.u8CharNum);    // Set ESP8266 STA+AP mode
    


  309. 

  310.             for (u32cnt = 0; u32cnt < 0xffff; u32cnt++);
    


  311. 

  312.             UART_Write(UART0, atCmdCipmux1.pu8string, atCmdCipmux1.u8CharNum);    // Set ESP8266 Multi-connection
    


  313. 

  314.             for (u32cnt = 0; u32cnt < 0xffff; u32cnt++);
    


  315. 

  316.             UART_Write(UART0, atCmdAp.pu8string, atCmdAp.u8CharNum);              // Set ESP8266 AP Name, No Password
    


  317. 

  318.             for (u32cnt = 0; u32cnt < 0xffff; u32cnt++);
    


  319. 

  320.             UART_Write(UART0, atCmdCipserver1.pu8string, atCmdCipserver1.u8CharNum);  // Set ESP8266 TCP Server mode, Port number 8080
    


  321. 

  322.             for (u32cnt = 0; u32cnt < 0xffff; u32cnt++);
    


  323. 

  324.             u8ReceiveStringArrayHeader = u8ReceiveStringArrayTail = 0;
    

  325.             memset(ReceiveArray, 0, sizeof(ReceiveArray));
    


  326. 

  327.         default:
    

  328.             break;
    

  329.     }
    

  330. }
    


  331. 

  332. uint32_t CharConvertToNumber(uint8_t *pu81, uint8_t u8number)
    

  333. {
    

  334.     uint32_t uChar = 0;
    

  335.     uint8_t u8cnt;
    


  336. 

  337.     for (u8cnt = 0; u8cnt < u8number; u8cnt++)
    

  338.     {
    

  339.         if ((*(pu81 + u8cnt) >= '0') && (*(pu81 + u8cnt) <= '9'))
    

  340.         {
    

  341.             uChar = uChar * 10 + (*(pu81 + u8cnt) - '0');
    

  342.         }
    

  343.         else
    

  344.         {
    

  345.             uChar = 0xFFFFFFFF;
    

  346.             break;
    

  347.         }
    

  348.     }
    


  349. 

  350.     return uChar;
    

  351. }
    


  352. 

  353. uint8_t StringCompare(uint8_t *pu81, uint8_t *pu82)
    

  354. {
    

  355.     uint8_t u8cnt = 0, j;
    


  356. 

  357.     uint8_t u8LengthString[4];
    

  358.     uint32_t  u32Length;
    


  359. 

  360.     for (u8cnt = 0;; u8cnt++)
    

  361.     {
    

  362.         if (u8cnt >= RECEIVE_MAX_CHAR_NUMBER)
    

  363.         {
    

  364.             return FALSE;
    

  365.         }
    


  366. 

  367.         if (*(pu82 + u8cnt) == '\0')
    

  368.         {
    

  369.             break;
    

  370.         }
    


  371. 

  372.         if (*(pu81 + u8cnt) != *(pu82 + u8cnt))
    

  373.         {
    

  374.             return FALSE;
    

  375.         }
    

  376.     }
    


  377. 

  378.     for (j = 0; j < 5; j++)
    

  379.     {
    

  380.         if (*(pu81 + u8cnt + j) != ':')
    

  381.         {
    

  382.             u8LengthString[j] = *(pu81 + u8cnt + j);
    

  383.         }
    

  384.         else
    

  385.         {
    

  386.             break;
    

  387.         }
    

  388.     }
    


  389. 

  390.     if (j == 5)
    

  391.     {
    

  392.         return FALSE; //error length
    

  393.     }
    

  394.     else
    

  395.     {
    

  396.         u32Length = CharConvertToNumber(u8LengthString, j);
    

  397.     }
    


  398. 

  399.     u8cnt = u8cnt + j + 1; //+1 to filter ':'
    


  400. 

  401.     if ((u8cnt + u32Length) >= RECEIVE_MAX_CHAR_NUMBER)
    

  402.     {
    

  403.         return FALSE;
    

  404.     }
    


  405. 

  406.     for (j = 0; j < u32Length; j++)
    

  407.     {
    

  408.         u8ReceiveData[j] = *(pu81 + u8cnt + j);
    

  409.     }
    


  410. 

  411.     u8ReceiveData[j] = '\0';
    

  412.     u8ReceiveDataLength = u32Length;
    


  413. 

  414.     return TRUE;
    


  415. 

  416. }
    


  417. 

  418. int main(void)
    

  419. {
    

  420.     /* Unlock protected registers */
    

  421.     SYS_UnlockReg();
    

  422.     /* Init System, IP clock and multi-function I/O */
    

  423.     SYS_Init();
    

  424.     /* Lock protected registers */
    

  425.     SYS_LockReg();
    


  426. 

  427.     /* Init uart */
    

  428.     UART_Init();
    


  429. 

  430.     /* Config systick */
    

  431.     CLK_SysTickInit(SYSTICK_TIMER);
    


  432. 

  433.     while (1)
    

  434.     {
    

  435.         if ((u32SysTimerCounter - u32SysTimerKeyCounter) >= 20) //20*SYSTICK_TIMER
    

  436.         {
    

  437.             u32SysTimerKeyCounter = u32SysTimerCounter;
    

  438.             u8KeyScan = Get_Key_Input();
    


  439. 

  440.             if (u8KeyScan == KEY_NONE)
    

  441.             {
    

  442.                 u8KeyGet = u8KeyScanPrev;
    

  443.             }
    


  444. 

  445.             u8KeyScanPrev = u8KeyScan;
    


  446. 

  447.             if (u8KeyGet != KEY_NONE)
    

  448.             {
    

  449.                 Key_Process(u8KeyGet);
    

  450.                 u8KeyGet = KEY_NONE;
    

  451.             }
    

  452.         }
    


  453. 

  454.         if (u8ReceiveStringArrayHeader != u8ReceiveStringArrayTail)
    

  455.         {
    

  456.             if (StringCompare(ReceiveArray[u8ReceiveStringArrayHeader].u8String, AT_StringIPD))
    

  457.             {
    

  458.                 printf("\n %s", u8ReceiveData);
    

  459.             }
    


  460. 

  461.             u8ReceiveStringArrayHeader++;
    


  462. 

  463.             if (u8ReceiveStringArrayHeader >= RECEIVE_MAX_STRING)
    

  464.             {
    

  465.                 u8ReceiveStringArrayHeader = 0;
    

  466.             }
    

  467.         }
    

  468.     }
    


  469. 

  470. }
    

  471. /*** (C) COPYRIGHT 2019 Nuvoton Technology Corp. ***/
回复

收藏 举报

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

本版积分规则

xinxianshi

102

主题

1019

帖子

1

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