refactor: 清理UART调试代码并保留RTT诊断

App/config.c

@@ -13,15 +13,20 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define CONFIG_RX_BUFFER_SIZE   128u
+#include "SEGGER_RTT.h"
+
 #define CONFIG_TX_BUFFER_SIZE   256u
 #define CONFIG_CMD_MAX_LEN      128u
 
+#define CONFIG_UART_HANDLE      huart1
+
 static device_config_t g_config;
-static uint8_t g_rx_buffer[CONFIG_RX_BUFFER_SIZE];
-static volatile uint16_t g_rx_index;
-static volatile bool g_rx_complete;
 static volatile bool g_reset_requested;
+static char g_uart_cmd_buffer[CONFIG_CMD_MAX_LEN];
+static uint16_t g_uart_cmd_len;
+static char g_pending_cmd_buffer[CONFIG_CMD_MAX_LEN];
+static volatile uint16_t g_pending_cmd_len;
+static volatile bool g_pending_cmd_ready;
 
 static uint32_t config_calc_crc(const device_config_t *cfg)
 {
@@ -62,6 +67,28 @@ static bool equals_ignore_case(const char *a, const char *b)
     return (*a == '\0' && *b == '\0');
 }
 
+static int parse_baudrate_value(const char *value, uint32_t *baudrate)
+{
+    char *endptr;
+    unsigned long parsed;
+
+    if (value == NULL || baudrate == NULL) {
+        return -1;
+    }
+
+    parsed = strtoul(value, &endptr, 10);
+    if (endptr == value || *skip_whitespace(endptr) != '\0') {
+        return -1;
+    }
+
+    if (parsed < 1200ul || parsed > 921600ul) {
+        return -1;
+    }
+
+    *baudrate = (uint32_t)parsed;
+    return 0;
+}
+
 static at_result_t handle_query(char *response, uint16_t max_len)
 {
     char ip_str[16];
@@ -294,12 +321,18 @@ at_result_t config_process_at_cmd(const char *cmd, char *response, uint16_t max_
         return AT_NEED_REBOOT;
     }
     if (equals_ignore_case(cmd_name, "BAUD1") && value != NULL) {
-        g_config.uart2_baudrate = (uint32_t)atoi(value);
+        if (parse_baudrate_value(value, &g_config.uart2_baudrate) != 0) {
+            snprintf(response, max_len, "ERROR: Invalid baudrate\r\n");
+            return AT_INVALID_PARAM;
+        }
         snprintf(response, max_len, "OK\r\n");
         return AT_NEED_REBOOT;
     }
     if (equals_ignore_case(cmd_name, "BAUD2") && value != NULL) {
-        g_config.uart3_baudrate = (uint32_t)atoi(value);
+        if (parse_baudrate_value(value, &g_config.uart3_baudrate) != 0) {
+            snprintf(response, max_len, "ERROR: Invalid baudrate\r\n");
+            return AT_INVALID_PARAM;
+        }
         snprintf(response, max_len, "OK\r\n");
         return AT_NEED_REBOOT;
     }
@@ -369,54 +402,72 @@ int config_str_to_mac(const char *str, uint8_t *mac)
     return 0;
 }
 
-void config_uart_idle_handler(void)
+void config_poll(void)
 {
-    uint16_t dma_counter = __HAL_DMA_GET_COUNTER(huart1.hdmarx);
-    uint16_t len = (uint16_t)(CONFIG_RX_BUFFER_SIZE - dma_counter);
+    if (g_pending_cmd_ready) {
+        uint16_t len = g_pending_cmd_len;
 
-    if (len > 0u) {
-        g_rx_index = len;
-        g_rx_complete = true;
+        g_pending_cmd_ready = false;
+        g_pending_cmd_len = 0u;
+        (void)config_try_process_frame((const uint8_t *)g_pending_cmd_buffer, len);
+    }
+}
+
+void config_uart_rx_byte(uint8_t byte)
+{
+    if (byte == '\r' || byte == '\n') {
+        if (g_uart_cmd_len > 0u) {
+            if (!g_pending_cmd_ready) {
+                memcpy(g_pending_cmd_buffer, g_uart_cmd_buffer, g_uart_cmd_len);
+                g_pending_cmd_buffer[g_uart_cmd_len] = '\0';
+                g_pending_cmd_len = g_uart_cmd_len;
+                g_pending_cmd_ready = true;
+            }
+            g_uart_cmd_len = 0u;
+        }
+        return;
     }
 
-    HAL_UART_DMAStop(&huart1);
-    HAL_UART_Receive_DMA(&huart1, g_rx_buffer, CONFIG_RX_BUFFER_SIZE);
+    if (g_uart_cmd_len < (CONFIG_CMD_MAX_LEN - 1u)) {
+        g_uart_cmd_buffer[g_uart_cmd_len++] = (char)byte;
+        g_uart_cmd_buffer[g_uart_cmd_len] = '\0';
+    } else {
+        g_uart_cmd_len = 0u;
+    }
 }
 
-void config_start_reception(void)
-{
-    __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
-    HAL_UART_Receive_DMA(&huart1, g_rx_buffer, CONFIG_RX_BUFFER_SIZE);
-}
-
-void config_poll(void)
+bool config_try_process_frame(const uint8_t *data, uint16_t len)
 {
     char response[CONFIG_TX_BUFFER_SIZE];
     char cmd_buffer[CONFIG_CMD_MAX_LEN];
     at_result_t result;
-    uint16_t len;
+    HAL_StatusTypeDef tx_status;
 
-    if (!g_rx_complete) {
-        return;
+    if (data == NULL || len < 2u) {
+        return false;
     }
 
-    len = g_rx_index;
     if (len >= CONFIG_CMD_MAX_LEN) {
         len = CONFIG_CMD_MAX_LEN - 1u;
     }
 
-    memcpy(cmd_buffer, g_rx_buffer, len);
+    memcpy(cmd_buffer, data, len);
     cmd_buffer[len] = '\0';
-    g_rx_complete = false;
-    g_rx_index = 0u;
+
+    if (((cmd_buffer[0] != 'A') && (cmd_buffer[0] != 'a')) ||
+        ((cmd_buffer[1] != 'T') && (cmd_buffer[1] != 't'))) {
+        return false;
+    }
 
     result = config_process_at_cmd(cmd_buffer, response, sizeof(response));
-    HAL_UART_Transmit(&huart1, (uint8_t *)response, (uint16_t)strlen(response), 1000u);
+    tx_status = HAL_UART_Transmit(&CONFIG_UART_HANDLE, (uint8_t *)response, (uint16_t)strlen(response), 1000u);
 
     if (result == AT_NEED_REBOOT) {
         static const char hint[] = "Note: Use AT+SAVE then AT+RESET to apply changes\r\n";
-        HAL_UART_Transmit(&huart1, (uint8_t *)hint, sizeof(hint) - 1u, 1000u);
+        tx_status = HAL_UART_Transmit(&CONFIG_UART_HANDLE, (uint8_t *)hint, sizeof(hint) - 1u, 1000u);
     }
+
+    return true;
 }
 
 bool config_is_reset_requested(void)