From 3763e699dc7719e89c693a4c9f1bd92cae8a6193 Mon Sep 17 00:00:00 2001 From: Wanderingss <1624155937@qq.com> Date: Thu, 24 Sep 2026 23:47:23 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8E=A7=E5=88=B6=E5=8F=B0=E6=94=B9=E5=8D=95?= =?UTF-8?q?=E5=86=99=E8=80=85=E5=8F=91=E9=80=81=EF=BC=9AdefaultTask?= =?UTF-8?q?=E5=94=AF=E4=B8=80=E5=8F=91=E4=B8=B2=E5=8F=A3=E5=85=B6=E4=BD=99?= =?UTF-8?q?=E4=BB=BB=E5=8A=A1=E5=86=99=E7=8E=AF=E5=BD=A2=E7=BC=93=E5=86=B2?= =?UTF-8?q?=EF=BC=8C=E6=9D=9C=E7=BB=9D=E6=97=A5=E5=BF=97=E4=BA=A4=E9=94=99?= =?UTF-8?q?=E4=B8=8E=E8=84=8F=E6=8C=87=E9=92=88=E5=85=A5UART=EF=BC=9B?= =?UTF-8?q?=E6=BA=A2=E5=87=BA=E9=92=A9=E5=AD=90=E5=8A=A0=E6=8C=87=E9=92=88?= =?UTF-8?q?=E7=AA=97=E5=8F=A3=E6=A0=A1=E9=AA=8C=E3=80=81=E5=B4=A9=E6=BA=83?= =?UTF-8?q?=E4=B8=8A=E6=8A=A5=E6=94=B9=E6=98=BE=E5=BC=8F=E9=95=BF=E5=BA=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- App/sys_events.h | 2 + Drivers/BSP/NET/lftpd/lftpd_log.c | 11 +- Drivers/BSP/RS485/rs485.c | 6 + Drivers/BSP/RS485/rs485.h | 1 + Drivers/BSP/dbg_log.h | 35 ++++- Src/freertos.c | 70 ++++++++-- Src/stm32f4xx_it.c | 40 +++--- Src/usart.c | 215 +++++++++++++++++++++++++++++- 8 files changed, 346 insertions(+), 34 deletions(-) diff --git a/App/sys_events.h b/App/sys_events.h index 76b565ac..b8f257c3 100644 --- a/App/sys_events.h +++ b/App/sys_events.h @@ -29,6 +29,8 @@ extern osEventFlagsId_t sys_evtHandle; #define SYS_EVT_TIMESYNC_READY (1u << 3) /* timeSyncTask：首次时间同步完成 */ #define SYS_EVT_NET_RECONFIG (1u << 4) /* UI：请求立即应用新网口配置（netTask 消费后重建网络） */ #define SYS_EVT_CFG_SAVE (1u << 5) /* UI：网口配置保存请求（defaultTask = 配置引擎属主，消费并写盘） */ +#define SYS_EVT_CONSOLE_TX (1u << 6) /* 控制台单写者：生产者入环形缓冲后置位，defaultTask 消费并发送 + * （消费型命令位，非就绪位——就绪位必须 osFlagsNoClear） */ #ifdef __cplusplus } diff --git a/Drivers/BSP/NET/lftpd/lftpd_log.c b/Drivers/BSP/NET/lftpd/lftpd_log.c index 6918590a..de8aced1 100644 --- a/Drivers/BSP/NET/lftpd/lftpd_log.c +++ b/Drivers/BSP/NET/lftpd/lftpd_log.c @@ -3,10 +3,12 @@ #include #include #include +#include "dbg_log.h" void lftpd_log_internal(const char* level, const char* format, ...) { static char buffer[256]; /* static: called at depth in ftpTask, keep off-stack */ + static char line[288]; /* static: 组装含前缀的整行，交给控制台单写者 */ va_list args; va_start(args, format); int err = vsnprintf(buffer, sizeof(buffer), format, args); @@ -14,5 +16,12 @@ void lftpd_log_internal(const char* level, const char* format, ...) { if (err >= sizeof(buffer)) { return; } - printf("%s %s\n", level, buffer); + /* 走控制台单写者（Src/usart.c）：整行一次入缓冲，避免逐字符 fputc 交错 */ + int n = snprintf(line, sizeof(line), "%s %s\r\n", level, buffer); + if (n > 0) { + if (n > (int)sizeof(line) - 1) { + n = (int)sizeof(line) - 1; + } + (void)dbg_console_write_line(line, (unsigned)n); + } } diff --git a/Drivers/BSP/RS485/rs485.c b/Drivers/BSP/RS485/rs485.c index 304ea8f3..30f7f464 100644 --- a/Drivers/BSP/RS485/rs485.c +++ b/Drivers/BSP/RS485/rs485.c @@ -77,6 +77,12 @@ HAL_StatusTypeDef rs485_transmit(rs485_handle_t *p_handle, timeout = RS485_TIMEOUT_DEFAULT; } + /* 防御性边界（2026-09-24，UART 缓冲遍历类 HardFault 加固）： + * 长度必须非零且不超过收发缓冲上限——脏长度交给 HAL 会变成"按长度遍历整片内存" */ + if ((p_data == NULL) || (len == 0U) || (len > RS485_TX_MAX_LEN)) { + return HAL_ERROR; + } + RS485_DIR_TX(p_handle); /* DE 建立延时：HAL 时基为 1ms 粒度，1ms 已充分覆盖收发器驱动使能稳定时间 */ diff --git a/Drivers/BSP/RS485/rs485.h b/Drivers/BSP/RS485/rs485.h index dbff9088..c43e3ab9 100644 --- a/Drivers/BSP/RS485/rs485.h +++ b/Drivers/BSP/RS485/rs485.h @@ -25,6 +25,7 @@ extern "C" { */ #define RS485_TIMEOUT_DEFAULT 1000U /* 默认发送超时（ms） */ #define RS485_RX_BUF_SIZE 256U /* 接收缓冲区大小 */ +#define RS485_TX_MAX_LEN 256U /* 单帧发送长度上限（防御脏长度进 UART，2026-09-24 加固） */ /* * RS-485 句柄结构体 diff --git a/Drivers/BSP/dbg_log.h b/Drivers/BSP/dbg_log.h index 1b51e5bf..1c409e39 100644 --- a/Drivers/BSP/dbg_log.h +++ b/Drivers/BSP/dbg_log.h @@ -23,12 +23,30 @@ extern "C" { #include #include +#include #include "dbg_cfg.h" #ifdef APP_TIMESTAMP_ENABLE #include "sys_clock.h" #endif +/* + * 单写者控制台 API（实现见 Src/usart.c；与 DBG_ENABLE 无关，任何构建都必须可见）： + * dbg_console_write_line - 生产者入口：调用方已格式化好的整行文本一次入环形缓冲 + * （刻意**不用**自研可变参数函数——规范 S12 7.6 禁止；格式化在 + * DBG_PRINT 宏内用库 snprintf 完成） + * dbg_console_write_raw - 异常/早期路径：有界单次直发（不加锁） + * dbg_console_writer_attach- 写者任务（defaultTask）注册自己为唯一发送者 + * dbg_console_drain - 写者任务排空缓冲并发送 + * dbg_console_dropped - 因缓冲满丢弃的行数（诊断） + */ +#define DBG_CON_LINE_MAX 192U /* 单行文本上限（与 Src/usart.c 内部口径一致） */ +int dbg_console_write_line(const char *line, unsigned len); +void dbg_console_write_raw(const char *buf, unsigned len); +void dbg_console_writer_attach(void); +void dbg_console_drain(void); +uint32_t dbg_console_dropped(void); + /* * 总开关：DBG_ENABLE * 定义 → 输出 DBG_ERROR / DBG_INFO；若 DBG_DEBUG_ENABLE 也定义则输出 DBG_DEBUG @@ -40,9 +58,24 @@ extern "C" { /* * 可重定向的打印函数，用户可在编译选项或 net_config.h 中预定义 * #define DBG_PRINT(...) my_printf(__VA_ARGS__) + * + * 默认走单写者控制台（Src/usart.c）： + * DBG_PRINT 在调用点用库 snprintf 有界格式化整行，再一次性交给 dbg_console_write_line + * 入环形缓冲，由 defaultTask 唯一发送—— + * ① 行与行不会字符级交错（旧 printf→fputc 每字符一次 HAL_UART_Transmit 会交错）； + * ② 进 UART 的缓冲恒为控制台内部缓冲，调用方脏指针到不了 UART + * （2026-09-24 HardFault：BFAR=CCM 末尾+1 即在 UART 缓冲读取处）。 */ #ifndef DBG_PRINT -#define DBG_PRINT(...) printf(__VA_ARGS__) +#define DBG_PRINT(...) do { \ + char __con_line[DBG_CON_LINE_MAX]; \ + int __con_n = snprintf(__con_line, sizeof(__con_line), __VA_ARGS__); \ + if (__con_n > 0) { \ + unsigned __con_len = (__con_n >= (int)sizeof(__con_line)) \ + ? (unsigned)(sizeof(__con_line) - 1u) : (unsigned)__con_n; \ + (void)dbg_console_write_line(__con_line, __con_len); \ + } \ +} while (0) #endif /* diff --git a/Src/freertos.c b/Src/freertos.c index 8ed84859..ba97a248 100644 --- a/Src/freertos.c +++ b/Src/freertos.c @@ -269,12 +269,21 @@ void StartDefaultTask(void *argument) /* 配置 poll 周期计数（每 4 次循环 = 2s 轮询一次，与引擎文档/模拟器一致） */ uint32_t cfg_poll_cnt = 0u; + /* 注册控制台写者：本任务此后是串口唯一发送者（其余任务只写环形缓冲）。 + * 见 Src/usart.c "控制台单写者日志"——消除并发写造成的日志逐字符交错， + * 并让脏指针无法再进入 HAL_UART_Transmit 的缓冲遍历。 */ + dbg_console_writer_attach(); + for (;;) { - /* 等待"保存网络配置"请求：有请求立即唤醒；无请求 500ms 后返回 - * （取代原 osDelay(500)：循环节奏不变，保存响应零空转） */ + /* 等待"保存网络配置"或"控制台待发"：任一即醒；无事件 500ms 后返回 + * （取代原 osDelay(500)：循环节奏不变，保存/日志响应零空转） */ if (sys_evtHandle != NULL) { - (void)osEventFlagsWait(sys_evtHandle, SYS_EVT_CFG_SAVE, osFlagsWaitAny, 500u); + (void)osEventFlagsWait(sys_evtHandle, + SYS_EVT_CFG_SAVE | SYS_EVT_CONSOLE_TX, + osFlagsWaitAny, 500u); } + /* 控制台唯一发送点：把环形缓冲中的日志按块发出（无待发时立即返回） */ + dbg_console_drain(); /* 执行待处理保存（配置引擎属主：写盘 + 成功后立即应用）；无请求 = 空操作 */ #if !defined(TEST_SUITE_STORAGE) net_cfg_save_run(); @@ -633,38 +642,71 @@ static void default_task_net_cfg_save_notify(void) } #endif +/* + * 名称指针合法性校验（栈溢出/越界可能已破坏 TCB，指针不可信）： + * 只接受落在 Flash / 主 SRAM / CCM 映射范围内的指针；不校验就直接交给 UART， + * 钩子自身也会以同样方式崩（2026-09-24 实测 HardFault：BFAR=0x10010000 恰为 + * CCM 末尾+1，PC 落在 HAL_UART_Transmit 的缓冲读取处）。 + */ +static int hook_ptr_ok(const void *p) +{ + uint32_t a = (uint32_t)p; + uint32_t win = 32u; /* 将要读取的最大字节数（任务名 ≤ 32） */ + + if ((a >= 0x08000000u) && (a <= (0x08100000u - win))) { + return 1; /* Flash（RO 区） */ + } + if ((a >= 0x20000000u) && (a <= (0x20020000u - win))) { + return 1; /* SRAM1 + SRAM2 */ + } + if ((a >= 0x10000000u) && (a <= (0x10010000u - win))) { + return 1; /* CCM（FreeRTOS 堆：TCB/栈所在） */ + } + return 0; +} + /* * 栈溢出钩子（configCHECK_FOR_STACK_OVERFLOW=2，2026-09-20 存储套件死机事故后加）： - * 溢出 = 内核状态已不可信，禁止走 printf/内核对象，裸 UART 报任务名后复位。 + * 溢出 = 内核状态已不可信，禁止走 printf/内核对象/控制台锁，裸发固定文本后复位。 + * 2026-09-24 加固：任务名先经范围校验并拷入本地缓冲（不再把 TCB 指针交给 UART）， + * 指针不可信时打印占位文本——避免"上报崩溃的代码自己再崩一次"。 */ void vApplicationStackOverflowHook(void *xTask, signed char *pcTaskName) { static const char msg_head[] = "\r\n[ERR] STACK OVERFLOW task="; + static const char msg_bad[] = "(name unavailable)"; + uint16_t len = 0u; (void)xTask; - HAL_UART_Transmit(&huart1, (const uint8_t *)msg_head, - (uint16_t)(sizeof(msg_head) - 1u), 0xFFFFu); - if (pcTaskName != NULL) { - uint16_t len = 0; - while (len < 32u && pcTaskName[len] != '\0') { + dbg_console_write_raw(msg_head, (unsigned)(sizeof(msg_head) - 1u)); + + if ((pcTaskName != NULL) && (hook_ptr_ok(pcTaskName) != 0)) { + while ((len < 32u) && (pcTaskName[len] != '\0')) { len++; } - HAL_UART_Transmit(&huart1, (const uint8_t *)pcTaskName, len, 0xFFFFu); } - HAL_UART_Transmit(&huart1, (const uint8_t *)"\r\n", 2u, 0xFFFFu); + if (len == 0u) { + dbg_console_write_raw(msg_bad, (unsigned)(sizeof(msg_bad) - 1u)); + } else { + char name[33]; /* 拷入本地缓冲：UART 永不接触 TCB 指针 */ + + memcpy(name, pcTaskName, (size_t)len); + name[len] = '\0'; + dbg_console_write_raw(name, (unsigned)len); + } + dbg_console_write_raw("\r\n", 2u); HAL_Delay(200); NVIC_SystemReset(); } /* * 堆分配失败钩子：只告警不复位（NULL 由各调用点自行处理并上报自检）。 - * 同样走裸 UART——钩子可能在临界区内被调，printf/信号量不可用。 + * 同样走裸 UART 有界发送——钩子可能在临界区内被调，printf/信号量不可用。 */ void vApplicationMallocFailedHook(void) { static const char msg[] = "\r\n[ERR] MALLOC FAILED (heap exhausted)\r\n"; - HAL_UART_Transmit(&huart1, (const uint8_t *)msg, - (uint16_t)(sizeof(msg) - 1u), 0xFFFFu); + dbg_console_write_raw(msg, (unsigned)(sizeof(msg) - 1u)); } /* USER CODE END Application */ diff --git a/Src/stm32f4xx_it.c b/Src/stm32f4xx_it.c index 44f20888..4a8e52cc 100644 --- a/Src/stm32f4xx_it.c +++ b/Src/stm32f4xx_it.c @@ -118,16 +118,22 @@ __asm void HardFault_Handler(void) * 函数说明：直接 HAL_UART_Transmit 轮询输出 PC/LR/xPSR 与 CFSR/HFSR 故障 * 寄存器，供开机日志定位崩溃点（对照 .map 找符号）；输出后复位。 */ -static void hard_fault_puts(const char *s) +static void hard_fault_write(const char *s, uint16_t len) { - uint16_t len = 0; - - while (s[len] != '\0') { - len++; + /* 显式长度 + 有界单次发送：上报路径自身不得再崩（2026-09-24 加固； + * 不做 '\0' 遍历，长度由调用方 sizeof 给出） */ + if ((s == NULL) || (len == 0u)) { + return; + } + if (len > 64u) { + len = 64u; } HAL_UART_Transmit(&huart1, (const uint8_t *)s, len, 0xFFFFu); } +/* 字面量输出宏：长度由 sizeof 定，编译期即可确定 */ +#define HF_PUTS(lit) hard_fault_write((lit), (uint16_t)(sizeof(lit) - 1u)) + static void hard_fault_puthex(uint32_t v) { static const char digits[] = "0123456789ABCDEF"; @@ -138,37 +144,37 @@ static void hard_fault_puthex(uint32_t v) out[i] = digits[(v >> (28 - i * 4)) & 0xFu]; } out[8] = '\0'; - hard_fault_puts(out); + hard_fault_write(out, 8u); } void hard_fault_report(uint32_t *frame) { - hard_fault_puts("\r\n[ERR] HARDFAULT PC="); + HF_PUTS("\r\n[ERR] HARDFAULT PC="); hard_fault_puthex(frame[6]); - hard_fault_puts(" LR="); + HF_PUTS(" LR="); hard_fault_puthex(frame[5]); - hard_fault_puts(" xPSR="); + HF_PUTS(" xPSR="); hard_fault_puthex(frame[7]); - hard_fault_puts(" R0="); + HF_PUTS(" R0="); hard_fault_puthex(frame[0]); - hard_fault_puts(" R1="); + HF_PUTS(" R1="); hard_fault_puthex(frame[1]); - hard_fault_puts(" R2="); + HF_PUTS(" R2="); hard_fault_puthex(frame[2]); - hard_fault_puts(" R3="); + HF_PUTS(" R3="); hard_fault_puthex(frame[3]); - hard_fault_puts(" CFSR="); + HF_PUTS(" CFSR="); hard_fault_puthex(SCB->CFSR); - hard_fault_puts(" HFSR="); + HF_PUTS(" HFSR="); hard_fault_puthex(SCB->HFSR); /* BFAR/MMFAR 仅在对应 valid 位为 1 时有意义 */ if ((SCB->CFSR & (1UL << 15)) != 0U) { - hard_fault_puts(" BFAR="); + HF_PUTS(" BFAR="); hard_fault_puthex(SCB->BFAR); } if ((SCB->CFSR & (1UL << 7)) != 0U) { - hard_fault_puts(" MMFAR="); + HF_PUTS(" MMFAR="); hard_fault_puthex(SCB->MMFAR); } diff --git a/Src/usart.c b/Src/usart.c index deb5a839..072fa2c0 100644 --- a/Src/usart.c +++ b/Src/usart.c @@ -475,11 +475,224 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle) /* USER CODE BEGIN 1 */ #include +#include "FreeRTOS.h" +#include "task.h" +#include "cmsis_os.h" +#include "sys_events.h" +/* ===== 控制台单写者日志（2026-09-24 加固，HardFault 定位结论驱动）===== + * 背景：旧路径 DBG_* → printf → fputc **每字符一次** HAL_UART_Transmit。HAL 的锁只保证 + * "单字节"原子，任务切换发生在字符之间 → 两行日志逐字符交错（2026-09-24 崩溃前 + * 实测："[2026-[2026-0909-24 15:2-24 15:27:37:39]…"）；更严重的是字符串指针一旦 + * 被破坏，脏指针会直接进入 UART 缓冲遍历（同日 HardFault：BFAR=0x10010000 恰为 + * CCM 末尾+1，PC 落在 HAL_UART_Transmit 的缓冲读取处）。 + * 架构：**defaultTask 是唯一串口发送者**；其余任务/上下文只把文本写入环形缓冲。 + * ① 行级原子：整行在一次临界区内拷入环形缓冲，写者按块一次 HAL_UART_Transmit + * 发出 → 行与行不可能再交错（UART 只有这一个调用点）； + * ② 指针可控：进 UART 的缓冲恒为本文件的环形缓冲，调用方脏指针再也到不了 UART； + * ③ 写者未注册（内核启动早期/裸机）或中断上下文：回退直接阻塞发送（无并发或必须裸发）。 + * 约束：不新增任务、不动态分配；环形缓冲为 BSS（SRAM1，非 CCM），无 DMA 可达性冲突。 + */ +#define DBG_CON_LINE_MAX 192U /* 单行文本上限（含结尾 '\0'，超出截断） */ +#define DBG_CON_RING_SIZE 4096U /* 环形缓冲字节数（必须为 2 的幂） */ +#define DBG_CON_CHUNK_MAX 256U /* 写者单次 HAL_UART_Transmit 字节上限 */ +#define DBG_CON_WAIT_MS 200U /* 缓冲满时生产者最长等待（ms），仍满则丢弃并计数 */ + +static uint8_t s_con_ring[DBG_CON_RING_SIZE]; +static volatile uint16_t s_con_head; /* 生产者写入位置 */ +static volatile uint16_t s_con_tail; /* 写者读取位置 */ +static volatile uint32_t s_con_drop; /* 因缓冲满丢弃的行数 */ +static volatile uint8_t s_con_writer_up; /* 1 = 写者已注册（此后走环形缓冲） */ +static TaskHandle_t s_con_writer_task; /* 写者任务句柄（自等保护用） */ + +void dbg_console_write_raw(const char *buf, unsigned len); +void dbg_console_writer_attach(void); +void dbg_console_drain(void); +int dbg_console_write_line(const char *line, unsigned len); +uint32_t dbg_console_dropped(void); + +static uint16_t con_used(void) +{ + return (uint16_t)((uint16_t)(s_con_head - s_con_tail) & (DBG_CON_RING_SIZE - 1U)); +} + +/* + * 函数功能：控制台裸发送（异常/早期路径专用：有界、单次、不加锁） + * 入口参数：buf - 文本缓冲；len - 字节数（超上限截断） + * 限定条件：串口已初始化；仅用于写者未注册、中断/异常上下文、崩溃上报 + */ +void dbg_console_write_raw(const char *buf, unsigned len) +{ + if ((buf == NULL) || (len == 0U)) { + return; + } + if (len > DBG_CON_CHUNK_MAX) { + len = DBG_CON_CHUNK_MAX; + } + (void)HAL_UART_Transmit(&huart1, (uint8_t *)buf, (uint16_t)len, 0xFFFFu); +} + +/* + * 函数功能：注册控制台写者（defaultTask 在进入主循环前调用一次） + * 函数说明：注册后生产者改走环形缓冲；未注册时直接阻塞发送（内核启动早期） + */ +void dbg_console_writer_attach(void) +{ + s_con_writer_task = xTaskGetCurrentTaskHandle(); + s_con_writer_up = 1U; +} + +/* + * 函数功能：排空环形缓冲（仅写者任务调用） + * 函数说明：按块一次 HAL_UART_Transmit 发出；每块完成后再推进读指针（临界区保护） + */ +void dbg_console_drain(void) +{ + uint16_t used; + + if (s_con_writer_up == 0U) { + return; + } + + while ((used = con_used()) != 0U) { + uint16_t tail = s_con_tail; + uint16_t contig = (uint16_t)(DBG_CON_RING_SIZE - tail); /* 到环尾的连续段 */ + uint16_t n = (used < contig) ? used : contig; + + if (n > DBG_CON_CHUNK_MAX) { + n = DBG_CON_CHUNK_MAX; + } + (void)HAL_UART_Transmit(&huart1, &s_con_ring[tail], n, 0xFFFFu); + taskENTER_CRITICAL(); + s_con_tail = (uint16_t)((uint16_t)(s_con_tail + n) & (DBG_CON_RING_SIZE - 1U)); + taskEXIT_CRITICAL(); + } + + /* 丢弃可观测性：缓冲满丢行必须显式可见（否则会掩盖开机自检/测试标记的丢失） */ + if (s_con_drop != 0U) { + char note[64]; + uint32_t d = s_con_drop; + int n; + + s_con_drop = 0U; + n = snprintf(note, sizeof(note), "\r\n[ERR] CONSOLE dropped %lu lines\r\n", + (unsigned long)d); + if (n > 0) { + if (n > (int)sizeof(note) - 1) { + n = (int)sizeof(note) - 1; + } + dbg_console_write_raw(note, (unsigned)n); + } + } +} + +/* + * 函数功能：把一段文本放入控制台（写者已注册）/直接发出（未注册或中断上下文） + * 返回值：0 - 已入缓冲或已直发；-1 - 缓冲满丢弃（计入 dbg_console_dropped） + * 函数说明：生产者不持锁等待过久：最多 DBG_CON_WAIT_MS，仍满则丢弃该行； + * 写者自身记录日志时先排空缓冲，避免自等。 + */ +static int con_append(const char *buf, uint16_t len) +{ + uint32_t waited = 0U; + + if ((buf == NULL) || (len == 0U)) { + return -1; + } + + if ((s_con_writer_up == 0U) || (__get_IPSR() != 0U)) { + dbg_console_write_raw(buf, len); + return 0; + } + if (len > (DBG_CON_RING_SIZE / 2U)) { + len = (uint16_t)(DBG_CON_RING_SIZE / 2U); /* 超长保护（正常路径不会触发） */ + } + + if (xTaskGetCurrentTaskHandle() == s_con_writer_task) { + dbg_console_drain(); /* 写者自己记录：先腾空，避免自等 */ + } + + for (;;) { + uint16_t used = con_used(); + uint16_t free_space = (uint16_t)((DBG_CON_RING_SIZE - 1U) - used); + + if (free_space >= len) { + break; + } + if (waited >= DBG_CON_WAIT_MS) { + s_con_drop++; + return -1; + } + vTaskDelay(1); + waited++; + } + + taskENTER_CRITICAL(); + { + uint16_t head = s_con_head; + uint16_t first = (uint16_t)(DBG_CON_RING_SIZE - head); + uint16_t i; + + if (first > len) { + first = len; + } + for (i = 0U; i < first; i++) { + s_con_ring[head + i] = (uint8_t)buf[i]; + } + for (i = first; i < len; i++) { + s_con_ring[(uint16_t)((uint16_t)(head + i) & (DBG_CON_RING_SIZE - 1U))] = + (uint8_t)buf[i]; + } + s_con_head = (uint16_t)((uint16_t)(head + len) & (DBG_CON_RING_SIZE - 1U)); + } + taskEXIT_CRITICAL(); + + if (sys_evtHandle != NULL) { + (void)osEventFlagsSet(sys_evtHandle, SYS_EVT_CONSOLE_TX); /* 唤醒写者 */ + } + return 0; +} + +/* + * 函数功能：把一行已格式化的文本交给单写者控制台（生产者入口，**非可变参数**） + * 入口参数：line - 整行文本（含结尾换行）；len - 字节数 + * 返回值：写入字节数；-1 - 参数非法或被丢弃 + * 函数说明：整行一次入环形缓冲 → 行级原子（不会与他行交错）；调用方缓冲随即可复用。 + * 刻意不用自研可变参数函数（规范 S12 7.6）；格式化由 DBG_PRINT 宏内 + * 库 snprintf 在调用点完成。 + */ +int dbg_console_write_line(const char *line, unsigned len) +{ + if ((line == NULL) || (len == 0U)) { + return -1; + } + if (len > DBG_CON_LINE_MAX) { + len = DBG_CON_LINE_MAX; /* 截断（丢尾，保开头的标记信息） */ + } + if (con_append(line, (uint16_t)len) != 0) { + return -1; + } + return (int)len; +} + +/* + * 函数功能：已丢弃的日志行数（诊断用） + */ +uint32_t dbg_console_dropped(void) +{ + return s_con_drop; +} + +/* + * 函数功能：MicroLIB printf 底层重定向（库内部/遗留 printf 调用） + * 函数说明：同样只把字节交给单写者路径；未注册写者时直发（与旧行为一致） + */ int fputc(int ch, FILE *f) { + uint8_t b = (uint8_t)ch; + (void)f; - HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, HAL_MAX_DELAY); + (void)con_append((const char *)&b, 1U); return ch; } /* USER CODE END 1 */