devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

手撸 串口交互命令行 及 AT应用层协议解析框架_串口at解析框架

作者：Li_阴宅 | 2024-07-31 03:55:31

赞

踩

串口at解析框架

        在嵌入式系统开发中，命令行接口（CLI）和AT命令解析是常见的需求。CLI提供了方便的调试接口，而AT命令则常用于模块间的通信控制。本文将介绍如何手动实现一个串口交互的命令行及AT应用层协议解析框架，适用于FreeRTOS系统。

流程图：

        这个回调函数 HAL_UART_RxCpltCallback 是用于处理 UART（通用异步收发传输器）接收到的数据。在接收数据的过程中会首先对接收到的字符进行判断，并且判断接收缓冲区是否还有空间，如果已满，则调用 ProcessReceivedFrame 处理数据，并在每次接受满之后重启UART中断。

  1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
  2. {
  3.     // 用于检查当前触发中断的 UART 实例是否是我们期望处理的那个实例 xPort。
  4.     if (huart->Instance == xPort.Instance)
  5.     {
  6.         // 如果这是接收到的第一个字节，清空接收缓冲区
  7.         if (rx_index == 0)
  8.         {
  9.             //如果当前接收到的数据是本次接收的第一个字节（rx_index 为 0），
  10.             //则将接收缓冲区清空。
  11.             memset(rx_buffer, '\0', xPort_RX_BUFFER_SIZE);
  12.         }
  13.  
  14.         // 如果接收到回车符 '\r'，目前没有处理逻辑
  15.         if (received_char == '\r') // || cRxedChar == '\r'
  16.         {
  17.             // 这里可以添加处理回车符的逻辑
  18.         }
  19.         // 如果接收到换行符 '\n'
  20.         else if (received_char == '\n') // || cRxedChar == '\r'
  21.         {
  22.             if (rx_index != 0)
  23.             {
  24.                 // 处理接收到的一帧数据
  25.                 // 在此处添加处理逻辑，例如将数据复制到另一个缓冲区或进行解析
  26.                 ProcessReceivedFrame(rx_buffer, &rx_index);
  27.             }
  28.         }
  29.         else
  30.         {
  31.             // 将接收到的字符存储到接收缓冲区
  32.             rx_buffer[rx_index++] = (char)received_char;
  33.  
  34.             // 检查接收缓冲区是否已满
  35.             if (rx_index >= xPort_RX_BUFFER_SIZE)
  36.             {
  37.                 // 处理接收到的一帧数据
  38.                 ProcessReceivedFrame(rx_buffer, &rx_index);
  39.             }
  40.         }
  41.  
  42.         // 重新启动 UART 接收中断，以接收下一个字节
  43.         HAL_UART_Receive_IT(&xPort, &received_char, 1);
  44.     }
  45. }

        结合之前对 HAL_UART_RxCpltCallback 函数的理解，现在我们详细解释如何通过ProcessReceivedFrame 函数处理接收到的数据：

        首先通过 osPoolAlloc 从内存池中分配内存，以存储接收到的数据，接着使用 memset 函数将分配的内存初始化为零。然后将当前帧数据的长度存储到 message->len 中，并使用 strncpy 函数将缓冲区的数据拷贝到 message->buff 中，最后将拷贝的数据放入消息队列中，等待处理。重置缓冲区长度指针 plength 为 0，表示缓冲区已处理完毕。使用 memset 函数将缓冲区清空，以准备接收新的数据。

  1. void ProcessReceivedFrame(char *buffer, uint8_t* plength)
  2. {
  3.     // // 处理接收到的一帧数据
  4.     // // 例如，打印接收到的数据
  5.     // buffer[length - 2] = '\0'; // 替换 "\r\n" 为字符串终止符
  6.     // printf("Received frame: %s\n", buffer);
  7.     // osMessagePut(uartQueueHandle, (uint32_t)buffer, osWaitForever);
  8.  
  9.     USART_Msg_Def *message;
  10.     message = (USART_Msg_Def *)osPoolAlloc(uartmsgPoolHandle); // 申请内存
  11.     //osPoolAlloc There is dirt in this memory pool
  12.     memset(message->buff, '\0', xPort_RX_BUFFER_SIZE);
  13.     message->len = *plength;
  14.     strncpy(message->buff, buffer, message->len);                     // 数据拷贝
  15.     osMessagePut(uartQueueHandle, (uint32_t)message, osWaitForever); // 写入队列
  16.     *plength = 0;
  17.     memset(buffer, '\0', xPort_RX_BUFFER_SIZE);
  18. }

vUARTCommandConsoleStart 函数通过以下步骤来启动 UART 命令控制台任务：

  • 注册 CLI 命令：调用 vRegisterSampleCLICommands 函数，注册一些示例 CLI 命令，这些命令将在命令控制台任务中使用。
  • 创建一个互斥量 xTxMutex，用于保护对 UART 发送操作的访问，确保线程安全。使用 configASSERT 确保互斥量创建成功。如果创建失败，程序将进入断言。
  • 使用 xTaskCreate 创建一个新的任务，该任务将实现 UART 命令控制台。
  • 启动 UART 接收功能，以便命令控制台可以接收来自 UART 的数据。
  1. void vUARTCommandConsoleStart(void)
  2. {
  3.     uint16_t usStackSize = 512;
  4.     UBaseType_t uxPriority = 0;
  5.  
  6.     // 注册示例 CLI 命令
  7.     vRegisterSampleCLICommands();
  8.  
  9.     // 创建用于访问 UART Tx 的信号量（互斥量）
  10.     xTxMutex = xSemaphoreCreateMutex();
  11.     configASSERT(xTxMutex);
  12.  
  13.     // 创建处理命令控制台的任务
  14.     xTaskCreate(prvUARTCommandConsoleTask, // 实现命令控制台的任务函数
  15.                 "CLI",                     // 任务名称，用于调试
  16.                 usStackSize,               // 分配给任务的堆栈大小
  17.                 NULL,                      // 任务参数，这里未使用，传递 NULL
  18.                 uxPriority,                // 任务优先级
  19.                 NULL);                     // 任务句柄，这里未使用，传递 NULL
  20.  
  21.     // 启动 UART 接收
  22.     StartUARTReception();
  23. }

 prvUARTCommandConsoleTask 函数是一个 FreeRTOS 任务，用于处理 UART 命令控制台。这个任务从消息队列中读取接收到的 UART 数据，并将其传递给命令解释器进行处理。

  1. static void prvUARTCommandConsoleTask(void *pvParameters)
  2. {
  3.     char *pcOutputString;
  4.     BaseType_t xReturned;
  5.  
  6.     (void)pvParameters;
  7.  
  8.     /* Obtain the address of the output buffer. Note there is no mutual
  9.     exclusion on this buffer as it is assumed only one command console interface
  10.     will be used at any one time. */
  11.     pcOutputString = FreeRTOS_CLIGetOutputBuffer();
  12.  
  13.     /* Send the welcome message. */
  14.     vSerialPutString(pcWelcomeMessage, (uint16_t)strlen((char*)pcWelcomeMessage));
  15.     
  16.     for (;;)
  17.     {
  18.         osEvent eEventTmp;
  19.         USART_Msg_Def *message;
  20.         
  21.         // 等待从消息队列中接收消息
  22.         eEventTmp = osMessageGet(uartQueueHandle, 0);
  23.         if (eEventTmp.status == osEventMessage)
  24.         {
  25.             // 处理接收到的数据帧
  26.             message = (USART_Msg_Def *)eEventTmp.value.p;
  27.  
  28.             char cInputString[cmdMAX_INPUT_SIZE];
  29.             memcpy(cInputString, message->buff, cmdMAX_INPUT_SIZE);
  30.             int8_t cInputLen = message->len;
  31.             
  32.             osPoolFree(uartmsgPoolHandle, message); // 释放内存
  33.             
  34. #if debug
  35.             char tmp[50];
  36.             sprintf(tmp, "len=%d,strlen=%d\n", cInputLen, strlen(cInputString));
  37.             HAL_UART_Transmit(&xPort, (const uint8_t *)tmp, strlen(tmp), portMAX_DELAY);
  38. #endif
  39.             if (xSemaphoreTake(xTxMutex, cmdMAX_MUTEX_WAIT) == pdPASS)
  40.             {
  41.                 vSerialPutString(cInputString, cInputLen);
  42.                 
  43.                 vSerialPutString(pcNewLine, (uint16_t)strlen((char*)pcNewLine));
  44.  
  45.                 do
  46.                 {
  47.                     /* Get the next output string from the command interpreter. */
  48.                     xReturned = FreeRTOS_CLIProcessCommand(cInputString, pcOutputString, configCOMMAND_INT_MAX_OUTPUT_SIZE);
  49.  
  50.                     /* Write the generated string to the UART. */
  51.                     vSerialPutString(pcOutputString, (uint16_t)strlen((char*)pcOutputString));
  52.  
  53.                 } while (xReturned != pdFALSE);
  54.  
  55.                 vSerialPutString("\r\n>", 3);
  56.                 memset(cInputString, 0x00, cmdMAX_INPUT_SIZE);
  57.                 
  58.                 /* Must ensure to give the mutex back. */
  59.                 xSemaphoreGive(xTxMutex);
  60.             }
  61.         }
  62.         osDelay(1);
  63.     }
  64. }

这个任务实现了一个简单的 UART 命令控制台，通过消息队列接收 UART 输入数据，使用命令解释器处理输入命令，并将结果输出到 UART。任务使用互斥量确保对 UART 发送操作的线程安全。通过这种方式，系统可以处理并执行来自 UART 的命令，同时确保并发访问的安全性。

 

下面这段代码注册了两个CLI（命令行接口）命令：Echo 和 AT。

  1. /* FreeRTOS includes. */
  2. #include "FreeRTOS.h"
  3. #include "task.h"
  4.  
  5. /* Standard includes. */
  6. #include <stdint.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10.  
  11. /* FreeRTOS+CLI includes. */
  12. #include "FreeRTOS_CLI.h"
  13.  
  14. #include "CLI.h"
  15.  
  16. static BaseType_t prvATCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString);
  17. static const CLI_Command_Definition_t xATCommand =
  18. 	{
  19. 		"AT",
  20. 		"\r\nATcmd:\r\n +RST +MODE=0/1 +M=1/2,0~180\r\n",
  21. 		prvATCommand, /* The function to run. */
  22. 		0			  /* The user can enter any number of commands. */
  23. };
  24. static BaseType_t prvATCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString)
  25. {
  26. 	BaseType_t xReturn;
  27. 	char *p = pcCommandString+2;
  28.  
  29. 	ATcmdAnalyse(p);
  30.  
  31. 	strncat(pcWriteBuffer, "\r\nOK", strlen("\r\nOK"));
  32. 	// strncpy( pcWriteBuffer, "what can i say, man!!!\r\n", xWriteBufferLen );
  33. 	xReturn = pdFALSE;
  34. 	return xReturn;
  35. }
  36.  
  37. /*-----------------------------------------------------------*/
  38.  
  39. /*
  40.  * Implements the task-stats command.
  41.  */
  42. static BaseType_t prvParameterEchoCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString);
  43.  
  44. /* Structure that defines the "echo_parameters" command line command.  This
  45. takes a variable number of parameters that the command simply echos back one at
  46. a time. */
  47. static const CLI_Command_Definition_t xParameterEcho =
  48. 	{
  49. 		"Echo",
  50. 		"\r\nEcho <...>:\r\n Take variable number of parameters, echos each in turn\r\n",
  51. 		prvParameterEchoCommand, /* The function to run. */
  52. 		-1						 /* The user can enter any number of commands. */
  53. };
  54.  
  55. static BaseType_t prvParameterEchoCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString)
  56. {
  57. 	const char *pcParameter;
  58. 	BaseType_t xParameterStringLength, xReturn;
  59. 	static UBaseType_t uxParameterNumber = 0;
  60.  
  61. 	/* Remove compile time warnings about unused parameters, and check the
  62. 	write buffer is not NULL.  NOTE - for simplicity, this example assumes the
  63. 	write buffer length is adequate, so does not check for buffer overflows. */
  64. 	(void)pcCommandString;
  65. 	(void)xWriteBufferLen;
  66. 	configASSERT(pcWriteBuffer);
  67.  
  68. 	if (uxParameterNumber == 0)
  69. 	{
  70. 		/* The first time the function is called after the command has been
  71. 		entered just a header string is returned. */
  72. 		sprintf(pcWriteBuffer, "The parameters were:\r\n");
  73.  
  74. 		/* Next time the function is called the first parameter will be echoed
  75. 		back. */
  76. 		uxParameterNumber = 1U;
  77.  
  78. 		/* There is more data to be returned as no parameters have been echoed
  79. 		back yet. */
  80. 		xReturn = pdPASS;
  81. 	}
  82. 	else
  83. 	{
  84. 		/* Obtain the parameter string. */
  85. 		pcParameter = FreeRTOS_CLIGetParameter(
  86. 			pcCommandString,		/* The command string itself. */
  87. 			uxParameterNumber,		/* Return the next parameter. */
  88. 			&xParameterStringLength /* Store the parameter string length. */
  89. 		);
  90.  
  91. 		if (pcParameter != NULL)
  92. 		{
  93. 			/* Return the parameter string. */
  94. 			memset(pcWriteBuffer, 0x00, xWriteBufferLen);
  95. 			sprintf(pcWriteBuffer, "%d: ", (int)uxParameterNumber);
  96. 			strncat(pcWriteBuffer, (char *)pcParameter, (size_t)xParameterStringLength);
  97. 			strncat(pcWriteBuffer, "\r\n", strlen("\r\n"));
  98.  
  99. 			/* There might be more parameters to return after this one. */
  100. 			xReturn = pdTRUE;
  101. 			uxParameterNumber++;
  102. 		}
  103. 		else
  104. 		{
  105. 			/* No more parameters were found.  Make sure the write buffer does
  106. 			not contain a valid string. */
  107. 			pcWriteBuffer[0] = 0x00;
  108.  
  109. 			/* No more data to return. */
  110. 			xReturn = pdFALSE;
  111.  
  112. 			/* Start over the next time this command is executed. */
  113. 			uxParameterNumber = 0;
  114. 		}
  115. 	}
  116.  
  117. 	return xReturn;
  118. }
  119. /*-----------------------------------------------------------*/
  120.  
  121. void vRegisterSampleCLICommands(void)
  122. {
  123. 	/* Register all the command line commands defined immediately above. */
  124. 	FreeRTOS_CLIRegisterCommand(&xParameterEcho);
  125. 	FreeRTOS_CLIRegisterCommand(&xATCommand);
  126.  
  127. }

1. AT 命令

  1. static BaseType_t prvATCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString);
  2. static const CLI_Command_Definition_t xATCommand =
  3. {
  4.     "AT",
  5.     "\r\nATcmd:\r\n +RST +MODE=0/1 +M=1/2,0~180\r\n",
  6.     prvATCommand, /* The function to run. */
  7.     0              /* The user can enter any number of commands. */
  8. };
  • xATCommand 是一个 CLI_Command_Definition_t 结构体，定义了一个名为 AT 的命令。
  • 第一个参数是命令名称 "AT"。
  • 第二个参数是该命令的帮助信息，用于显示在命令行上。
  • 第三个参数是该命令的处理函数 prvATCommand。
  • 第四个参数表示用户可以输入任意数量的该命令。

2. AT 命令处理函数

  1. static BaseType_t prvATCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString)
  2. {
  3.     BaseType_t xReturn;
  4.     char *p = pcCommandString[2];
  5.  
  6.     ATcmdAnalyse(p);
  7.  
  8.     strncat(pcWriteBuffer, "\r\nOK", strlen("\r\nOK"));
  9.     xReturn = pdFALSE;
  10.     return xReturn;
  11. }
  • prvATCommand 是处理 AT 命令的函数。
  • 它接收三个参数：pcWriteBuffer（写缓冲区），xWriteBufferLen（写缓冲区长度）和 pcCommandString（命令字符串）。
  • 函数将命令字符串的第三个字符传递给 ATcmdAnalyse 函数进行分析处理。
  • 处理完毕后，将字符串 "\r\nOK" 追加到写缓冲区中，并返回 pdFALSE。

 3. Echo 命令

  1. static BaseType_t prvParameterEchoCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString);
  2.  
  3. static const CLI_Command_Definition_t xParameterEcho =
  4. {
  5.     "Echo",
  6.     "\r\nEcho <...>:\r\n Take variable number of parameters, echos each in turn\r\n",
  7.     prvParameterEchoCommand, /* The function to run. */
  8.     -1                        /* The user can enter any number of commands. */
  9. };
  • xParameterEcho 是一个 CLI_Command_Definition_t 结构体，定义了一个名为 Echo 的命令。
  • 第一个参数是命令名称 "Echo"。
  • 第二个参数是该命令的帮助信息，用于显示在命令行上。
  • 第三个参数是该命令的处理函数 prvParameterEchoCommand。
  • 第四个参数表示用户可以输入任意数量的该命令。

4. Echo 命令处理函数 

  1. static BaseType_t prvParameterEchoCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString)
  2. {
  3.     const char *pcParameter;
  4.     BaseType_t xParameterStringLength, xReturn;
  5.     static UBaseType_t uxParameterNumber = 0;
  6.  
  7.     // 省略部分代码...
  8.  
  9.     return xReturn;
  10. }
  • prvParameterEchoCommand 是处理 Echo 命令的函数。
  • 它接收三个参数：pcWriteBuffer（写缓冲区），xWriteBufferLen（写缓冲区长度）和 pcCommandString（命令字符串）。
  • 函数通过调用 FreeRTOS_CLIGetParameter 逐个获取命令参数，并将其逐个写入写缓冲区中。
  • 如果没有更多参数，返回 pdFALSE。

5. 注册命令函数

  1. void vRegisterSampleCLICommands(void)
  2. {
  3.     FreeRTOS_CLIRegisterCommand(&xParameterEcho);
  4.     FreeRTOS_CLIRegisterCommand(&xATCommand);
  5. }
  • vRegisterSampleCLICommands 函数用于注册以上定义的两个命令。
  • 调用 FreeRTOS_CLIRegisterCommand 函数注册 Echo 和 AT 命令。

这些命令通过 FreeRTOS 的 CLI 模块注册，可以在命令行界面中使用。

这段代码实现了一个简单的命令行接口（CLI），允许通过注册命令的方式来扩展功能。主要包括命令注册、命令处理和帮助命令的实现。

  1. /* Standard includes. */
  2. #include <string.h>
  3. #include <stdint.h>
  4.  
  5. /* FreeRTOS includes. */
  6. #include "FreeRTOS.h"
  7. #include "task.h"
  8.  
  9. /* Utils includes. */
  10. #include "FreeRTOS_CLI.h"
  11.  
  12. typedef struct xCOMMAND_INPUT_LIST
  13. {
  14. 	const CLI_Command_Definition_t *pxCommandLineDefinition;
  15. 	struct xCOMMAND_INPUT_LIST *pxNext;
  16. } CLI_Definition_List_Item_t;
  17.  
  18. /*
  19.  * The callback function that is executed when "help" is entered.  This is the
  20.  * only default command that is always present.
  21.  */
  22. static BaseType_t prvHelpCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString);
  23.  
  24. /*
  25.  * Return the number of parameters that follow the command name.
  26.  */
  27. static int8_t prvGetNumberOfParameters(const char *pcCommandString);
  28.  
  29. /* The definition of the "help" command.  This command is always at the front
  30. of the list of registered commands. */
  31. static const CLI_Command_Definition_t xHelpCommand =
  32. 	{
  33. 		"Help",
  34. 		"\r\nHelp:\r\n Lists all the registered commands\r\n",
  35. 		prvHelpCommand,
  36. 		0};
  37.  
  38. /* The definition of the list of commands.  Commands that are registered are
  39. added to this list. */
  40. static CLI_Definition_List_Item_t xRegisteredCommands =
  41. 	{
  42. 		&xHelpCommand, /* The first command in the list is always the help command, defined in this file. */
  43. 		NULL		   /* The next pointer is initialised to NULL, as there are no other registered commands yet. */
  44. };
  45.  
  46. /* A buffer into which command outputs can be written is declared here, rather
  47. than in the command console implementation, to allow multiple command consoles
  48. to share the same buffer.  For example, an application may allow access to the
  49. command interpreter by UART and by Ethernet.  Sharing a buffer is done purely
  50. to save RAM.  Note, however, that the command console itself is not re-entrant,
  51. so only one command interpreter interface can be used at any one time.  For that
  52. reason, no attempt at providing mutual exclusion to the cOutputBuffer array is
  53. attempted.
  55. configAPPLICATION_PROVIDES_cOutputBuffer is provided to allow the application
  56. writer to provide their own cOutputBuffer declaration in cases where the
  57. buffer needs to be placed at a fixed address (rather than by the linker). */
  58. static char cOutputBuffer[configCOMMAND_INT_MAX_OUTPUT_SIZE];
  59.  
  60. /*-----------------------------------------------------------*/
  61.  
  62. BaseType_t FreeRTOS_CLIRegisterCommand(const CLI_Command_Definition_t *const pxCommandToRegister)
  63. {
  64. 	static CLI_Definition_List_Item_t *pxLastCommandInList = &xRegisteredCommands;
  65. 	CLI_Definition_List_Item_t *pxNewListItem;
  66. 	BaseType_t xReturn = pdFAIL;
  67.  
  68. 	/* Check the parameter is not NULL. */
  69. 	configASSERT(pxCommandToRegister);
  70.  
  71. 	/* Create a new list item that will reference the command being registered. */
  72. 	pxNewListItem = (CLI_Definition_List_Item_t *)pvPortMalloc(sizeof(CLI_Definition_List_Item_t));
  73. 	configASSERT(pxNewListItem);
  74.  
  75. 	if (pxNewListItem != NULL)
  76. 	{
  77. 		taskENTER_CRITICAL();
  78. 		{
  79. 			/* Reference the command being registered from the newly created
  80. 			list item. */
  81. 			pxNewListItem->pxCommandLineDefinition = pxCommandToRegister;
  82.  
  83. 			/* The new list item will get added to the end of the list, so
  84. 			pxNext has nowhere to point. */
  85. 			pxNewListItem->pxNext = NULL;
  86.  
  87. 			/* Add the newly created list item to the end of the already existing
  88. 			list. */
  89. 			pxLastCommandInList->pxNext = pxNewListItem;
  90.  
  91. 			/* Set the end of list marker to the new list item. */
  92. 			pxLastCommandInList = pxNewListItem;
  93. 		}
  94. 		taskEXIT_CRITICAL();
  95.  
  96. 		xReturn = pdPASS;
  97. 	}
  98.  
  99. 	return xReturn;
  100. }
  101. /*-----------------------------------------------------------*/
  102.  
  103. BaseType_t FreeRTOS_CLIProcessCommand(const char *const pcCommandInput, char *pcWriteBuffer, size_t xWriteBufferLen)
  104. {
  105. 	static const CLI_Definition_List_Item_t *pxCommand = NULL;
  106. 	BaseType_t xReturn = pdTRUE;
  107. 	const char *pcRegisteredCommandString;
  108. 	size_t xCommandStringLength;
  109.  
  110. 	/* Note:  This function is not re-entrant.  It must not be called from more
  111. 	thank one task. */
  112.  
  113. 	if (pxCommand == NULL)
  114. 	{
  115. 		/* Search for the command string in the list of registered commands. */
  116. 		for (pxCommand = &xRegisteredCommands; pxCommand != NULL; pxCommand = pxCommand->pxNext)
  117. 		{
  118. 			pcRegisteredCommandString = pxCommand->pxCommandLineDefinition->pcCommand;
  119. 			xCommandStringLength = strlen(pcRegisteredCommandString);
  120.  
  121. 			/* To ensure the string lengths match exactly, so as not to pick up
  122. 			a sub-string of a longer command, check the byte after the expected
  123. 			end of the string is either the end of the string or a space before
  124. 			a parameter. */
  125. 			if ((pcCommandInput[xCommandStringLength] == ' ') || (pcCommandInput[xCommandStringLength] == 0x00))
  126. 			{
  127. 				if (strncmp(pcCommandInput, pcRegisteredCommandString, xCommandStringLength) == 0)
  128. 				{
  129. 					/* The command has been found.  Check it has the expected
  130. 					number of parameters.  If cExpectedNumberOfParameters is -1,
  131. 					then there could be a variable number of parameters and no
  132. 					check is made. */
  133. 					if (pxCommand->pxCommandLineDefinition->cExpectedNumberOfParameters >= 0)
  134. 					{
  135. 						if (prvGetNumberOfParameters(pcCommandInput) != pxCommand->pxCommandLineDefinition->cExpectedNumberOfParameters)
  136. 						{
  137. 							xReturn = pdFALSE;
  138. 						}
  139. 					}
  140.  
  141. 					break;
  142. 				}
  143. 			}
  144. 			else if ((strncmp("AT", pcRegisteredCommandString, 2) == 0) && (strncmp("AT", pcCommandInput, 2) == 0))
  145. 			{
  146. 				break;
  147. 			}
  148. 		}
  149. 	}
  150.  
  151. 	if ((pxCommand != NULL) && (xReturn == pdFALSE))
  152. 	{
  153. 		/* The command was found, but the number of parameters with the command
  154. 		was incorrect. */
  155. 		strncpy(pcWriteBuffer, "error cmd para(s).  Enter \"Help\".\r\n\r\n", xWriteBufferLen);
  156. 		pxCommand = NULL;
  157. 	}
  158. 	else if (pxCommand != NULL)
  159. 	{
  160. 		/* Call the callback function that is registered to this command. */
  161. 		xReturn = pxCommand->pxCommandLineDefinition->pxCommandInterpreter(pcWriteBuffer, xWriteBufferLen, pcCommandInput);
  162.  
  163. 		/* If xReturn is pdFALSE, then no further strings will be returned
  164. 		after this one, and	pxCommand can be reset to NULL ready to search
  165. 		for the next entered command. */
  166. 		if (xReturn == pdFALSE)
  167. 		{
  168. 			pxCommand = NULL;
  169. 		}
  170. 	}
  171. 	else
  172. 	{
  173. 		/* pxCommand was NULL, the command was not found. */
  174. 		strncpy(pcWriteBuffer, "Command not recognised.  Enter 'help' to view a list of available commands.\r\n\r\n", xWriteBufferLen);
  175. 		xReturn = pdFALSE;
  176. 	}
  177.  
  178. 	return xReturn;
  179. }
  180. /*-----------------------------------------------------------*/
  181.  
  182. char *FreeRTOS_CLIGetOutputBuffer(void)
  183. {
  184. 	return cOutputBuffer;
  185. }
  186. /*-----------------------------------------------------------*/
  187.  
  188. const char *FreeRTOS_CLIGetParameter(const char *pcCommandString, UBaseType_t uxWantedParameter, BaseType_t *pxParameterStringLength)
  189. {
  190. 	UBaseType_t uxParametersFound = 0;
  191. 	const char *pcReturn = NULL;
  192.  
  193. 	*pxParameterStringLength = 0;
  194.  
  195. 	while (uxParametersFound < uxWantedParameter)
  196. 	{
  197. 		/* Index the character pointer past the current word.  If this is the start
  198. 		of the command string then the first word is the command itself. */
  199. 		while (((*pcCommandString) != 0x00) && ((*pcCommandString) != ' '))
  200. 		{
  201. 			pcCommandString++;
  202. 		}
  203.  
  204. 		/* Find the start of the next string. */
  205. 		while (((*pcCommandString) != 0x00) && ((*pcCommandString) == ' '))
  206. 		{
  207. 			pcCommandString++;
  208. 		}
  209.  
  210. 		/* Was a string found? */
  211. 		if (*pcCommandString != 0x00)
  212. 		{
  213. 			/* Is this the start of the required parameter? */
  214. 			uxParametersFound++;
  215.  
  216. 			if (uxParametersFound == uxWantedParameter)
  217. 			{
  218. 				/* How long is the parameter? */
  219. 				pcReturn = pcCommandString;
  220. 				while (((*pcCommandString) != 0x00) && ((*pcCommandString) != ' '))
  221. 				{
  222. 					(*pxParameterStringLength)++;
  223. 					pcCommandString++;
  224. 				}
  225.  
  226. 				if (*pxParameterStringLength == 0)
  227. 				{
  228. 					pcReturn = NULL;
  229. 				}
  230.  
  231. 				break;
  232. 			}
  233. 		}
  234. 		else
  235. 		{
  236. 			break;
  237. 		}
  238. 	}
  239.  
  240. 	return pcReturn;
  241. }
  242. /*-----------------------------------------------------------*/
  243.  
  244. static BaseType_t prvHelpCommand(char *pcWriteBuffer, size_t xWriteBufferLen, const char *pcCommandString)
  245. {
  246. 	static const CLI_Definition_List_Item_t *pxCommand = NULL;
  247. 	BaseType_t xReturn;
  248.  
  249. 	(void)pcCommandString;
  250.  
  251. 	if (pxCommand == NULL)
  252. 	{
  253. 		/* Reset the pxCommand pointer back to the start of the list. */
  254. 		pxCommand = &xRegisteredCommands;
  255. 	}
  256.  
  257. 	/* Return the next command help string, before moving the pointer on to
  258. 	the next command in the list. */
  259. 	strncpy(pcWriteBuffer, pxCommand->pxCommandLineDefinition->pcHelpString, xWriteBufferLen);
  260. 	pxCommand = pxCommand->pxNext;
  261.  
  262. 	if (pxCommand == NULL)
  263. 	{
  264. 		/* There are no more commands in the list, so there will be no more
  265. 		strings to return after this one and pdFALSE should be returned. */
  266. 		xReturn = pdFALSE;
  267. 	}
  268. 	else
  269. 	{
  270. 		xReturn = pdTRUE;
  271. 	}
  272.  
  273. 	return xReturn;
  274. }
  275. /*-----------------------------------------------------------*/
  276.  
  277. static int8_t prvGetNumberOfParameters(const char *pcCommandString)
  278. {
  279. 	int8_t cParameters = 0;
  280. 	BaseType_t xLastCharacterWasSpace = pdFALSE;
  281.  
  282. 	/* Count the number of space delimited words in pcCommandString. */
  283. 	while (*pcCommandString != 0x00)
  284. 	{
  285. 		if ((*pcCommandString) == ' ')
  286. 		{
  287. 			if (xLastCharacterWasSpace != pdTRUE)
  288. 			{
  289. 				cParameters++;
  290. 				xLastCharacterWasSpace = pdTRUE;
  291. 			}
  292. 		}
  293. 		else
  294. 		{
  295. 			xLastCharacterWasSpace = pdFALSE;
  296. 		}
  297.  
  298. 		pcCommandString++;
  299. 	}
  300.  
  301. 	/* If the command string ended with spaces, then there will have been too
  302. 	many parameters counted. */
  303. 	if (xLastCharacterWasSpace == pdTRUE)
  304. 	{
  305. 		cParameters--;
  306. 	}
  307.  
  308. 	/* The value returned is one less than the number of space delimited words,
  309. 	as the first word should be the command itself. */
  310. 	return cParameters;
  311. }

  • 注册命令

    调用 FreeRTOS_CLIRegisterCommand 函数注册新的命令。这个函数会将新的命令节点添加到链表末尾。

  • 处理命令

    调用 FreeRTOS_CLIProcessCommand 函数处理输入的命令字符串。这个函数会遍历注册的命令链表，找到匹配的命令，并调用相应的回调函数处理。

  • 帮助命令

    当输入 Help 命令时，prvHelpCommand 回调函数会被调用，输出所有注册命令的帮助信息。

 

这段代码实现了一个简单的 AT 指令解析器。

  1. #include "CLI.h"
  2. #include "string.h"
  3. // "\r\nATcmd:\r\n +RST +MODE=0/1 +M=1/2,0~180\r\n",
  4. typedef enum
  5. {
  6.     AT = 0,
  7.     MODE,
  8.     M,
  9.     RST,
  10.     /**将指令添加到上面**/
  11.     MAXCMDNUM
  12. } ATCommand;
  13.  
  14. typedef enum 
  15. {
  16. 	ATERROR = 0, 
  17. 	ATSUCCESS ,
  18. 	ATERRORCODE1,
  19. }ATStatus;
  20.  
  21. typedef ATStatus (*pFuncCallback)(char *str);
  22.  
  23. typedef struct
  24. {
  25.     ATCommand ATCommandName;
  26.     char *ATStr;                    // 发送的AT指令
  27.     pFuncCallback ATCallback; // AT指令接收完成，指令处理回调函数
  28. } ATCommandConfig;
  29.  
  30. ATStatus MODE_Callback(char *str);
  31. ATStatus M_Callback(char *str);
  32. ATStatus RST_Callback(char *str);
  33.  
  34. static const ATCommandConfig ATCommandList[] =
  35.     {
  36.         {MODE, "MODE", MODE_Callback},
  37.         {M, "M", M_Callback},
  38.         {RST, "RST", RST_Callback},
  39.         NULL,
  40. };
  41.  
  42. static void ATcmdGetRun(pATcmd, pATcmdLen, pATvalue)
  43. {
  44.     ATCommandConfig *pxCommand;
  45.     const char *pcRegisteredCommandString;
  46.     for (pxCommand = &ATCommandList[0]; pxCommand != NULL; pxCommand++)
  47.     {
  48.         pcRegisteredCommandString = pxCommand->ATStr;
  49.         if (strncmp(pATcmd, pcRegisteredCommandString, pATcmdLen) == 0)
  50.         {
  51.             pxCommand->ATCallback(pATvalue);
  52.         }
  53.     }
  54. }
  55.  
  56. void ATcmdAnalyse(char *pATcmd)
  57. {
  58.     if ('+' == pATcmd[0])
  59.     {
  60.         pATcmd++;
  61.         char *pATvalue;
  62.         uint8_t pATcmdLen = 0; // ATcmd lenth
  63.         pATvalue = strstr(pATcmd, "=");
  64.         if (pATvalue)
  65.         {
  66.             pATcmdLen = pATvalue - pATcmd; // ATcmd lenth
  67.             pATvalue++;
  68.         }
  69.         else
  70.         {
  71.             pATvalue = NULL;
  72.             pATcmdLen = strlen(pATcmd);
  73.         }
  74.         ATcmdGetRun(pATcmd, pATcmdLen, pATvalue);
  75.     }
  76. }
  77.  
  78.  
  79. /*--------------------------------------------------
  80. In fact, the last step callback function of 
  81. the at instruction cannot directly control the hardware. 
  82. There should be a third intermediate layer SDK
  83. --------------------------------------------------*/
  84. ATStatus MODE_Callback(char *str)
  85. {
  86.     //挂起舵机的任务
  87. }
  88. ATStatus M_Callback(char *str)
  89. {
  90.     //Sg90MotorCtl(舵机1/2  , 舵机角度) 
  91.     //控制舵机运行到具体角度
  92.     //内部需要对舵机能够转动的最大角度进行限位
  93. }
  94. ATStatus RST_Callback(char *str)
  95. {
  96.     //重启 mcu
  97. }

让我们逐步解释它的功能和结构：

  1. 枚举类型定义：

    • ATCommand 枚举定义了一组 AT 指令的名称，包括 AT、MODE、M 和 RST，以及一个特殊的枚举 MAXCMDNUM，用于表示指令数量上限。

  2. AT 状态枚举：

    • ATStatus 枚举定义了一组 AT 操作的状态，包括成功、失败以及可能的其他错误码。

  3. 函数指针定义：

    • pFuncCallback 是一个函数指针类型，指向一个接受 char* 参数并返回 ATStatus 类型的函数。

  4. AT 指令配置结构体：

    • ATCommandConfig 结构体定义了一个 AT 指令的配置，包括指令名称、发送的指令字符串以及指令完成时的回调函数。

  5. AT 指令配置列表：

    • ATCommandList 是一个数组，存储了所有 AT 指令的配置信息，包括指令名称、发送的指令字符串和回调函数。列表以 NULL 结尾。

  6. AT 指令解析函数：

    • ATcmdAnalyse 函数用于解析接收到的 AT 指令。它接收一个指向 AT 指令字符串的指针，并根据指令名称调用相应的回调函数。

  7. AT 指令回调函数：

    • MODE_Callback、M_Callback 和 RST_Callback 是对应于不同指令的回调函数，用于执行具体的操作。这些函数会根据指令参数进行不同的处理。

  8. AT 指令执行函数：

    • ATcmdGetRun 函数根据接收到的 AT 指令名称，在配置列表中查找对应的配置，并调用相应的回调函数执行操作。

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/906893
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号