gaoro-xiao/TCP2UART
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

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

Browse Source
This commit is contained in:
😍
2026-03-31 22:28:41 +08:00
parent 0f4f89eae4
commit e5fffaccdf
13 changed files with 448 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files
App/config.c
+81 -30
View File
@@ -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)
App/config.h
+14 -10
View File
@@ -144,21 +144,25 @@ device_config_t *config_get_mutable(void);
*/
at_result_t config_process_at_cmd(const char *cmd, char *response, uint16_t max_len);
/**
* @brief UART1 IDLE interrupt handler for config module
*/
void config_uart_idle_handler(void);
/**
* @brief Start UART1 reception for configuration
*/
void config_start_reception(void);
/**
* @brief Poll configuration UART and process pending AT commands
*/
void config_poll(void);
/**
* @brief Feed one byte received from the config UART.
* @param byte Received byte.
*/
void config_uart_rx_byte(uint8_t byte);
/**
* @brief Try to process one AT command frame from an external UART source.
* @param data Input bytes.
* @param len Input length.
* @return true if the frame was recognized as an AT/config command.
*/
bool config_try_process_frame(const uint8_t *data, uint16_t len);
/**
* @brief Check whether AT+RESET requested a system reset
*/
App/uart_trans.c
+4
View File
@@ -192,6 +192,7 @@ int uart_trans_start(uart_channel_t channel)
ctx->tx_tail = 0u;
ctx->tx_dma_len = 0u;
ctx->tx_busy = false;
memset(&ctx->stats, 0, sizeof(ctx->stats));
__HAL_UART_ENABLE_IT(ctx->huart, UART_IT_IDLE);
if (HAL_UART_Receive_DMA(ctx->huart, ctx->rx_dma_buffer, UART_RX_DMA_BUFFER_SIZE) != HAL_OK) {
@@ -302,6 +303,7 @@ void uart_trans_idle_handler(uart_channel_t channel)
}
huart = g_channels[channel].huart;
g_channels[channel].stats.idle_events++;
dma_write_index = (uint16_t)(UART_RX_DMA_BUFFER_SIZE - __HAL_DMA_GET_COUNTER(huart->hdmarx));
if (dma_write_index >= UART_RX_DMA_BUFFER_SIZE) {
dma_write_index = 0u;
@@ -316,6 +318,7 @@ void uart_trans_rx_half_cplt_handler(uart_channel_t channel)
return;
}
g_channels[channel].stats.rx_half_events++;
process_rx_snapshot(channel, UART_RX_DMA_BUFFER_SIZE / 2u);
}
@@ -325,6 +328,7 @@ void uart_trans_rx_cplt_handler(uart_channel_t channel)
return;
}
g_channels[channel].stats.rx_full_events++;
process_rx_snapshot(channel, 0u);
}
App/uart_trans.h
+3
View File
@@ -41,6 +41,9 @@ typedef struct {
uint32_t tx_bytes;
uint32_t rx_packets;
uint32_t tx_packets;
uint32_t idle_events;
uint32_t rx_half_events;
uint32_t rx_full_events;
uint32_t errors;
} uart_stats_t;