yf_zjb 1 月之前
父节点
当前提交
c562c46c1c
共有 42 个文件被更改,包括 8757 次插入 和 408 次删除
  1. 1 1
      Application_CBD/.settings/language.settings.xml
  2. 49 0
      Application_CBD/.workbuddy/memory/2026-10-01.md
  3. 148 0
      Application_CBD/.workbuddy/memory/2026-10-02.md
  4. 327 30
      Application_CBD/applications/control.c
  5. 12 6
      Application_CBD/applications/control.h
  6. 559 230
      Application_CBD/applications/dtu_uart2.c
  7. 2 0
      Application_CBD/applications/dtu_uart2.h
  8. 170 46
      Application_CBD/applications/hmi.c
  9. 5 0
      Application_CBD/applications/hmi.h
  10. 2 1
      Application_CBD/applications/main.c
  11. 74 5
      Application_CBD/applications/param_mirror.c
  12. 13 3
      Application_CBD/applications/sample_mb_master.c
  13. 219 28
      Application_CBD/applications/selfcheck.c
  14. 116 31
      Application_CBD/applications/sht30_collect.c
  15. 4 0
      Application_CBD/applications/sht30_collect.h
  16. 143 0
      Application_CBD/readme.md
  17. 二进制
      Application_CBD/doc/test_logs/console_20261002_165053.log
  18. 二进制
      Application_CBD/doc/test_logs/console_20261002_185247.log
  19. 4934 0
      Application_CBD/doc/test_logs/watch_20261002_165437.log
  20. 52 0
      Application_CBD/doc/test_logs/自动化测试结果_20261002_165053.md
  21. 53 0
      Application_CBD/doc/test_logs/自动化测试结果_20261002_185247.md
  22. 29 0
      Application_CBD/doc/tools/console_recon.py
  23. 398 0
      Application_CBD/doc/tools/console_test.py
  24. 73 0
      Application_CBD/doc/tools/counter_probe.py
  25. 82 0
      Application_CBD/doc/tools/gen_su.sh
  26. 9 0
      Application_CBD/doc/tools/list_ports.py
  27. 50 0
      Application_CBD/doc/tools/probe_uarts.py
  28. 39 0
      Application_CBD/doc/tools/send_cmd.py
  29. 229 0
      Application_CBD/doc/tools/stack_usage.py
  30. 20 0
      Application_CBD/doc/代码分析.md
  31. 239 0
      Application_CBD/doc/代码审查修复记录.md
  32. 304 0
      Application_CBD/doc/代码审查报告.md
  33. 0 0
      Application_CBD/doc/线程分配.xls
  34. 267 0
      Application_CBD/doc/自动化测试方案.md
  35. 7 4
      Application_CBD/drivers/board.c
  36. 23 6
      Application_CBD/drivers/drv_flash_f1.c
  37. 57 6
      Application_CBD/drivers/drv_usart.c
  38. 5 2
      Application_CBD/link.lds
  39. 33 7
      Application_CBD/packages/fal-latest/samples/porting/fal_flash_sfud_port.c
  40. 6 0
      Application_CBD/rt-thread/src/scheduler.c
  41. 3 1
      Application_CBD/rtconfig.h
  42. 1 1
      CBD_FOTA_BootLoader/.settings/language.settings.xml

+ 1 - 1
Application_CBD/.settings/language.settings.xml

@@ -5,7 +5,7 @@
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1326132237523407386" id="ilg.gnuarmeclipse.managedbuild.cross.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT ARM Cross GCC Built-in Compiler Settings " parameter="${COMMAND} ${FLAGS} ${cross_toolchain_flags} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="-437269440237603829" id="ilg.gnuarmeclipse.managedbuild.cross.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT ARM Cross GCC Built-in Compiler Settings " parameter="${COMMAND} ${FLAGS} ${cross_toolchain_flags} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>

文件差异内容过多而无法显示
+ 49 - 0
Application_CBD/.workbuddy/memory/2026-10-01.md


+ 148 - 0
Application_CBD/.workbuddy/memory/2026-10-02.md

@@ -0,0 +1,148 @@
+# 2026-10-02 工作日志
+
+## 主题:自动化测试方案落地 + 10-02 固件版本交付
+
+### 1. 真机自动化测试(UART2 自环回 / UART4 自环回 / 调试口 COM3)
+
+**测试拓扑**:串口2 RX-TX 短接、串口4 RX-TX 短接、Debug 口接电脑 COM3(CH340, 115200)。
+
+**主机侧工具**(`doc/tools/`,全部交付):
+- `console_test.py`:T0~T9 一键回归 + `--watch N` 长时监视;ANSI 剥离、崩溃特征扫描、
+  `list_thread` 表格解析(须用 `.search` 且容忍应用日志与表格行交错)、
+  Markdown 报告落盘 `doc/test_logs/`。
+- `console_recon.py` / `list_ports.py` / `probe_uarts.py`:串口侦察。
+- `stack_usage.py`:静态栈深度分析(objdump 调用图 + `-fstack-usage`)。
+- `gen_su.sh`:生成 `.su` 栈帧数据(复用 `Debug/applications/subdir.mk` 的真实编译参数)。
+
+**测试结果**:
+- T0/T1/T2/T2b/T5/T5b/T5c/T6 PASS;T7 SKIP(旧固件无 `uart_loop_test`)。
+- **T3 UART2 自环回 PASS(闭环证据)**:长时监视捕获一次上传周期
+  `uart2_tx 34405→35058(+653)` / `uart2_rx 26506→27159(+653)`,两增量完全一致,
+  累计上传 +1,全程无崩溃。
+- **T4 UART4 异常(待判别)**:`uart4_tx` 有增量(3724→3734,屏幕 sleep=1 屏保指令),
+  `uart4_rx` 恒为 0。已排除固件侧因素(DMA 配置、驱动与 UART2 同源、引脚 PC10/PC11、
+  线程存活)。需用户确认短接点是否在主控板 UART4 排针,并用 `uart_loop_test 4` 判别。
+
+**测试中发现的真实固件缺陷(D-1)**:
+`MSH_CMD_EXPORT(ctr_lamp/ctr_led/ctr_clear/HardWare_Check)` 导出的是 `uint8_t` 形参的
+业务函数,与 FinSH 的 `(int argc, char **argv)` 调用约定不匹配 → 串口执行时形参是垃圾值:
+`ctr_led on` 完全不生效,`ctr_clear` 会以随机参数驱动清扫电机(危险)。
+修复:统一改为 `ctr_test <item> <act> [val]`,原 4 个导出注释掉并注明原因。
+
+### 2. 固件侧新增测试接口
+
+- `uart_loop_test <2|4> [len]`:临时接管端口(close→open→换回调)→发 `55AA+len+图案`→读回校验→恢复回调。
+- `ctr_test <item> <act> [val]`:lamp/led/clear/shake/heat/cold/up/down/hwinit/hwcheck。
+- `dtu_send` / `hmi_send <str>`:向 uart2/uart4 注入报文,配合短接做端到端闭环。
+- `hmi_uart4_reinit_rx()`:UART4 接收回调重注册(与既有 `dtu_uart2_reinit_rx()` 对称)。
+
+### 3. 版本与产物
+
+- 版本宏:`1.72.41(HK)` / `1.72.40(2000W)` / `1.72.1(ZP)` / `1.72.1(GK)`(`applications/control.h`)。
+- 编译(GCC 6.3.1):text 244,356B / data 2,476B / bss 39,888B。
+- 可烧录镜像:`bin/Application_CBD-1.72.41-20261002.bin`(246,832B,基址 `0x08032000`,
+  与旧版一致);带符号 elf:`Debug/Application_CBD-1.72.41-20261002.elf`。
+- ROM 槽 312KB,余量约 71KB。
+
+### 4. 线程栈预算(双重核对,写进 `doc/自动化测试方案.md` §6.3)
+
+| 线程 | 栈(B) | 实测水位 | 静态最坏 | 静态占用 |
+| --- | --- | --- | --- | --- |
+| DTU_Uart(recv) | 2560 | 1408 (55%) | 1440 | 56% |
+| Control_Heat | 1024 | 276 (27%) | 624 | **61%(全系统最高)** |
+| Work_status | 1024 | 194 (19%) | 584 | 57% |
+| Power Ch (Power_ReadCheck) | 1536 | 799 (52%) | 848 | 55% |
+| adc_thread | 1024 | 266 (26%) | 560 | 55% |
+| mb_master_samlpe("master t") | 512 | 159 (31%) | 256 | **50%(栈最小,需留意)** |
+| Work_Loop | 2048 | 512 (25%) | 928 | 45% |
+| Control_Clear | 2048 | 164 (08%) | 892 | 44% |
+| md_m_sen (send_thread_entry) | 1024 | 256 (25%) | **272** | 27% ← 修复前 824/512 溢出 |
+| tshell | 2048 | 552 (27%) | 404 | 20%(新命令 ctr_test 552 / uart_loop_test 312 / dtu_send 160 均在此线程) |
+
+结论:实测 08%~55%,静态 18%~61%,无超预算线程;"启动即崩"根因已由实测+静态双重确认消除。
+
+### 5. 踩坑记录(重要,工具已加固)
+
+1. **`gen_su.sh` 工具链版本坑**:本机装了 GCC **5.4.1** 与 **6.3.1** 两套,脚本原先在第一个
+   匹配处 `return`,导致用 5.4.1 编译 → 同一份 `control.c` 多个函数栈帧小 8 字节(内联决策
+   不同)→ 栈预算结论错误。已改为 `sort -V | tail -1` 取最高版本并回显版本号。
+   **`.su` 必须与生成 elf 的编译器同版本。**
+2. **`stack_usage.py` 两个坑**:
+   - 原生 `subprocess.run(text=True)` 在 objdump 输出含非 UTF-8 字节时会抛
+     `UnicodeDecodeError` → 加 `errors="replace"`;
+   - 工具链不在 PATH 时 `arm-none-eabi-objdump` 静默返回空输出 → 表现为"无入口函数",
+     已加 `_find_toolchain()`(env `RTT_TOOLCHAIN_BIN` > RT-Thread Studio 目录 > PATH)。
+   - `.su` 缺失某函数时会退化为反汇编估算(偏小),出现"异常偏小值"先查 `.su` 覆盖情况。
+3. **`bash script.sh | head -N` 会 SIGPIPE 杀掉脚本**,导致只生成了部分 `.su`;
+   批量生成类脚本不要管道截断输出。
+4. **Python heredoc(`python - <<EOF`)里的中文会按本地代码页解码**,写文件类操作会损坏
+   中文。改用独立的 UTF-8 脚本文件执行。
+5. **`assert i > 0` vs `i >= 0`**:readme 插入脚本因 marker 在文件**第 0 字符**处导致断言
+   失败(此前误判为编码问题)。定位字符串位置时用 `>= 0`。
+
+---
+
+## 补充(当天傍晚):固件 1.72.41 烧录后的真机测试 —— 发现生产级串口接收缺陷
+
+### 起因
+
+用户烧录 1.72.41 后,执行回归测试。`uart_loop_test 2` 报 FAIL(收到 64 字节全 0),
+`uart_loop_test 4` 报 FAIL(recv=0)。追查后定位到**驱动层两处耦合缺陷**。
+
+### 缺陷 D-4(生产级,严重):串口 DMA 接收在 close/open 之后永久失效
+
+- `HAL_UART_Receive_DMA()` 的首要判断是 `huart->RxState == HAL_UART_STATE_READY`,
+  否则直接 `return HAL_BUSY`;而 `RxState` **只由 HAL 自己的接收完成回调复位**。
+- 本驱动绕开 HAL 接收路径、自己在 `uart_isr` 里处理 IDLE 中断 → `RxState` 永远停在
+  `HAL_UART_STATE_BUSY_RX` → **第二次调用必然失败,DMA 根本没启动**。
+- 原失败分支只有 `RT_ASSERT(0)`,未开 `RT_DEBUG` 时是空操作 → **失败完全静默**。
+- 受影响路径:`RTU_Power_Off_Safe()`(RTU 断电重启)、屏幕升级后恢复、环回自检等
+  **所有 close/open**。现场表现=**"对 DTU 断电重启一次,主控就再也收不到平台下行指令"**。
+- 修复:武装前显式 `uart->handle.RxState = HAL_UART_STATE_READY;`,失败时 `LOG_E`。
+
+### 缺陷 D-5:DMA 未运行时 CNDTR 读回 0 被误算成"整缓冲区已收满"
+
+- `recv_total_index = bufsz - CNDTR`;DMA 停用时 CNDTR=0 → 算得 `bufsz`(2048)。
+  `dma_isr` 里 `recv_total_index==0` 分支更会得出 `bufsz - 0 = bufsz`。
+- 后果:`put_index` 回绕 → `rx_fifo->is_full` 置位 → 之后读取一直返回被 `rt_memset`
+  过的全 0 缓冲区。**把"接收链路已死"伪装成"收到乱码数据"**,是 D-4 难被发现的原因。
+- 修复:DMA 通道未使能(`CCR.EN==0`)时不推算长度;`dma_isr` 加回绕判断与上界钳位。
+
+### 缺陷 D-6:uart_loop_test 自身触发 D-4(我引入的)
+
+- 原实现用 `rt_device_close()`+`rt_device_open()` 接管端口 → 一次执行就让被测串口接收
+  永久失效,污染后续所有测试。
+- 修复:改为**只临时替换 `rx_indicate`**(不 close/open)。原理:应用接收线程因收不到
+  信号量而自然让出数据;测完重注册回调并读空残留。另加"仅报文头匹配"次判据区分
+  "链路通但被抢走部分字节"与"完全没收到"。
+
+### 关键判据(本次定位的核心方法)
+
+**用"写耗时"和"是否触发 IDLE"两个正交信号,把接线问题与固件问题彻底分开:**
+
+| 命令 | recv | 实测耗时 | 理论耗时@115200 | 结论 |
+| --- | --- | --- | --- | --- |
+| uart_loop_test 2 64 | 64(全0) | 6ms | 5.6ms | TX 发送正常(耗时吻合)+ RX 引脚有信号(IDLE 触发)→ 物理环回正常,故障在 FIFO 索引 |
+| uart_loop_test 2 512 | 512(全0) | 49ms | 44.4ms | 同上 |
+| uart_loop_test 2 2048 | 2048(全0) | 198ms | 177.8ms | 同上 |
+| uart_loop_test 4 64 | **0** | 215ms(=读超时) | — | **无 IDLE 触发 → RX 引脚完全无信号 → 接线问题** |
+| uart_loop_test 4 512 | **0** | 249ms(=读超时) | — | 同上 |
+
+> 经验:`recv` 恰好等于请求长度、内容全 0、耗时等于该长度的波特率时间 —— 这三条同时
+> 出现就是"RX FIFO 索引被写坏、DMA 实际没在跑"的指纹,不要误判为接线问题。
+> IDLE 是 UART 外设级中断,只要有任意字节到达 RX 引脚就会触发,因此它是判断
+> "引脚上到底有没有信号"最可靠的手段(与 DMA/驱动是否正常无关)。
+
+### 回归结果(1.72.41)
+
+T0/T1/T2/T2b/T5/T5b/T5c/T6 **PASS**(13 线程栈最高 `DTU_Uart=41%`,无 ≥80%;
+RTU 安全重启未崩溃;全程无栈溢出/HardFault)。T3/T4/T7 FAIL(原因见上)。
+
+### 产物
+
+- 修复版固件:`bin/Application_CBD-1.72.41-20261002-rxfix.bin`(246,872 B,text 244,396 B,
+  较上一版仅 +40 B);带符号 elf 在 `Debug/`。
+- 用 `mingw32-make all` 在 `Debug/` 下可增量编译(需把工具链 bin 加入 PATH)。
+- 新增主机脚本:`doc/tools/send_cmd.py`(发命令并完整抓取 N 秒日志,**不在提示符处提前退出**)、
+  `doc/tools/counter_probe.py`(命令前后采集串口计数器算增量)。
+

+ 327 - 30
Application_CBD/applications/control.c

@@ -33,7 +33,6 @@
 #define WORK_LOOP_THREAD_STACK_SIZE       2048    //栈大小
 #define WORK_LOOP_THREAD_TIMESLICE        5       //时间片
 
-#define PWM_EN    1   //0关闭,1-打开
 //设备状态表结构体
 Device_Status_typedef device_status;
 System_stats_t system_status;
@@ -43,34 +42,162 @@ rt_thread_t tid_wkstc = RT_NULL;
 rt_thread_t tid_ctr = RT_NULL;
 rt_thread_t tid_heat = RT_NULL;
 
-int thread_delete_workloop(void)
+/* 快速停止所有功率输出(全部为无延时写引脚,供删除线程/升级等紧急场景使用) */
+static void Stop_Outputs_Fast(void)
 {
-    LOG_W("thread_delete_workloop.");
-    rt_err_t result;
-    if(tid_workloop!=RT_NULL)
+    /* 上仓门:双高电平=刹车停止(与 ctr_cangmen_up(OFF) 相同,只是不等待 1s) */
+    rt_pin_mode(Collect_fan_R, PIN_MODE_OUTPUT);
+    rt_pin_mode(Collect_fan_L, PIN_MODE_OUTPUT);
+    rt_pin_write(Collect_fan_R, ON);
+    rt_pin_write(Collect_fan_L, ON);
+
+    /* 下仓门 */
+    rt_pin_mode(C_DOWN_R, PIN_MODE_OUTPUT);
+    rt_pin_mode(C_DOWN_L, PIN_MODE_OUTPUT);
+    rt_pin_write(C_DOWN_R, ON);
+    rt_pin_write(C_DOWN_L, ON);
+
+    /* 清扫推杆/卷带电机 */
+#if PWM_EN == 0
+    rt_pin_mode(CLEAR_R, PIN_MODE_OUTPUT);
+    rt_pin_mode(CLEAR_L, PIN_MODE_OUTPUT);
+    rt_pin_write(CLEAR_R, ON);
+    rt_pin_write(CLEAR_L, ON);
+#else
+    Motor_Qingsao_R_PWM(OFF);
+    Motor_Qingsao_L_PWM(OFF);
+#endif
+
+    /* 加热/震动/灯管/补光 */
+    rt_pin_mode(Heat_Pin, PIN_MODE_OUTPUT);
+    rt_pin_write(Heat_Pin, OFF);
+    rt_pin_mode(SHAKE_SW, PIN_MODE_OUTPUT);
+    rt_pin_write(SHAKE_SW, OFF);
+    rt_pin_mode(LAMP_SW, PIN_MODE_OUTPUT);
+    rt_pin_write(LAMP_SW, OFF);
+    rt_pin_mode(LED_SW, PIN_MODE_OUTPUT);
+    rt_pin_write(LED_SW, OFF);
+}
+
+/* 判断线程当前是否挂在某个 IPC 对象(互斥量/信号量/消息队列等)的等待链表上。
+ *
+ * 背景:本内核版本(4.0.2)的 rt_thread_delete() 对"正阻塞在 IPC 对象上"的线程,
+ * 会把同一个 tlist 节点同时挂进 IPC 等待链表和 rt_thread_defunct 链表;
+ * 空闲线程回收 TCB(含栈)后,IPC 等待链表仍指向已释放内存,之后 rt_mutex_release()
+ * 会向野指针写入并把"已释放线程"插入就绪链表,破坏内核对象链表。
+ * 现场表现为:栈溢出误报(线程名乱码) + list_thread() 精确总线错误(BFAR 为垃圾地址)。
+ *
+ * 判据:挂起态 且 线程定时器未激活。
+ *  - rt_thread_delay / 带超时的 IPC 等待 都会启动线程定时器;
+ *  - RT_WAITING_FOREVER 的 IPC 等待不会启动定时器。
+ * 注意:若将来在这些线程中引入"带超时的 IPC 等待",该判据会失效,需改用其它同步方式。 */
+static rt_bool_t thread_in_ipc_wait(rt_thread_t t)
+{
+    if (t == RT_NULL)
     {
-        result = rt_thread_delete(tid_workloop);
+        return RT_FALSE;
     }
-    if(tid_wkstc!=RT_NULL)
+    if ((t->stat & RT_THREAD_STAT_MASK) != RT_THREAD_SUSPEND)
     {
-        result = rt_thread_delete(tid_wkstc);
+        return RT_FALSE;        /* 就绪/运行/关闭态:不在 IPC 等待链表上 */
     }
-    if(tid_heat!=RT_NULL)
+    if (t->thread_timer.parent.flag & RT_TIMER_FLAG_ACTIVATED)
     {
-        result = rt_thread_delete(tid_heat);
+        return RT_FALSE;        /* 延时中或带超时的等待:定时器在跑 */
     }
-    if(tid_ctr!=RT_NULL)
+    return RT_TRUE;             /* 无超时的 IPC 等待 */
+}
+
+/* 在关中断的临界区内"判定 + 删除",保证判定与删除之间不会被抢占
+ * (否则线程可能恰好在这两步之间进入 IPC 等待)。
+ * 返回 0=已删除或无需删除;-1=线程正处于 IPC 等待,本次不删除。 */
+int thread_delete_safe(rt_thread_t *ptid)
+{
+    rt_base_t level;
+    int ret = 0;
+
+    if (ptid == RT_NULL || *ptid == RT_NULL)
+    {
+        return 0;
+    }
+
+    level = rt_hw_interrupt_disable();
+    if (thread_in_ipc_wait(*ptid))
+    {
+        ret = -1;
+    }
+    else
+    {
+        rt_thread_delete(*ptid);
+        *ptid = RT_NULL;        /* 句柄置空,防止悬挂句柄/二次删除 */
+    }
+    rt_hw_interrupt_enable(level);
+
+    return ret;
+}
+
+int thread_delete_workloop(void)
+{
+    int32_t try_cnt;
+    int left;
+
+    LOG_W("thread_delete_workloop.");
+
+    /* 先停掉正在执行的动作输出并清除中继标志,避免线程被删除后电机/加热仍处于导通状态 */
+    device_status.ctr_up_motor   = 0;
+    device_status.ctr_down_motor = 0;
+    device_status.clear_status   = 0;
+    Stop_Outputs_Fast();
+
+    /* 安全删除 4 个线程:若某个线程此刻正挂在 IPC 等待链表上则先不删除,
+     * 稍后重试(最多 60 x 50ms ≈ 3s)。仍无法安全删除的线程保留运行并告警,
+     * 宁可不删也不能破坏内核对象链表。 */
+    for (try_cnt = 0; try_cnt < 60; try_cnt++)
+    {
+        left  = (thread_delete_safe(&tid_workloop) != 0) ? 1 : 0;
+        left += (thread_delete_safe(&tid_wkstc)    != 0) ? 1 : 0;
+        left += (thread_delete_safe(&tid_heat)     != 0) ? 1 : 0;
+        left += (thread_delete_safe(&tid_ctr)      != 0) ? 1 : 0;
+        if (left == 0)
+        {
+            break;
+        }
+        rt_thread_mdelay(50);
+    }
+    if (left != 0)
     {
-        result = rt_thread_delete(tid_ctr);
+        LOG_E("thread_delete_workloop: %d thread(s) still blocked on IPC, skip deleting!", left);
     }
     return 0;
 }
 
+/* 恢复所有被 thread_delete_workloop() 删除的线程。
+ * 注意:必须按开机时的创建条件恢复全部 4 个线程(原来只恢复 workloop,
+ * 导致自检后 work_status 判定/清扫/加热线程永久缺失,工作流程卡死)。 */
 int thread_restart_workloop(void)
 {
-    rt_err_t result;
-    result = Work_Loop_Task();
-    return result;
+    LOG_W("thread_restart_workloop.");
+
+    if(device_status.dtype!=7&&device_status.version_type!=30 && tid_wkstc==RT_NULL)
+    {
+        Workstatus_check();              /* 工作状态判定线程 */
+    }
+    if(device_status.version_type!=30 && tid_workloop==RT_NULL)
+    {
+        Work_Loop_Task();                /* 工作流程线程 */
+    }
+    if(device_status.dtype!=7)
+    {
+        if(tid_ctr==RT_NULL)
+        {
+            Control_clear();             /* 清扫线程 */
+        }
+        if(tid_heat==RT_NULL)
+        {
+            Control_heat();              /* 恒温加热线程 */
+        }
+    }
+    return 0;
 }
 
 /**************************1.0定制2000W*************************************/
@@ -639,9 +766,10 @@ void ctr_develop(void)
     while(device_status.develop_flag==1)
     {
         float stayedtime = 0.01;
-        char stayed[5];
+        char stayed[10];
         stayedtime = (float)device_status.stay_time / 60.0;
-        sprintf(stayed,"%0.02f",stayedtime);
+        /* 浮点用 libc snprintf,并放大缓冲区:原 stayed[5] 在培养时间≥10小时("10.00")时会越界 */
+        snprintf(stayed, sizeof(stayed), "%0.02f", stayedtime);
         HMI_WRITE("workSta.staytime.txt=\"%s\"",stayed);
         ii++;
         LOG_I("developing...................................%d\n",ii);
@@ -862,6 +990,13 @@ uint8_t ctr_lamp(uint8_t status_lamp, uint8_t lamp_num)
 //震动电机
 uint8_t ctr_shake(uint8_t status_shake,uint16_t shake_sec)
 {
+    /* 防御:震动时间异常(参数损坏/非法下发)时钳位,避免超长时间阻塞工作流程 */
+    if(shake_sec > 1000)
+    {
+        LOG_W("shake_sec(%d) too large, clamp to 1000", shake_sec);
+        shake_sec = 1000;
+    }
+
     rt_pin_mode(SHAKE_SW, PIN_MODE_OUTPUT);
     #if 0
     rt_pin_write(SHAKE_SW,ON);
@@ -871,7 +1006,8 @@ uint8_t ctr_shake(uint8_t status_shake,uint16_t shake_sec)
     {
         if(device_status.dtype==3)
         {
-            for(uint8_t shake_i = 0;shake_i<shake_sec;shake_i++)
+            /* 注意:循环变量必须与 shake_sec 同为 16 位,原 uint8_t 在 shake_sec>=256 时会溢出成死循环 */
+            for(uint16_t shake_i = 0;shake_i<shake_sec;shake_i++)
             {
                 rt_pin_write(SHAKE_SW,ON);
                 rt_thread_delay(100);
@@ -1544,9 +1680,20 @@ void ctr_RTU_DTU(uint8_t status_rtu)
  */
 void RTU_Power_Off_Safe(void)
 {
-    /* 2. 【关键】关闭串口设备。
-     * 这会触发底层的 HAL_UART_MspDeInit (如果BSP实现了的话),
-     * 或者至少停止了UART外设的时钟和中断,防止它继续驱动引脚。
+    if(dtuserial == RT_NULL)
+    {
+        LOG_E("RTU_Power_Off_Safe: dtuserial is NULL!");
+        return;
+    }
+
+    /* 1. 【关键】先把 USART2 外设置入复位态:
+     * 停止接收和 DMA 请求,避免关闭串口、释放接收缓冲区后 DMA 仍继续写入该内存。
+     */
+    __HAL_RCC_USART2_FORCE_RESET();
+    rt_thread_mdelay(1);
+    __HAL_RCC_USART2_RELEASE_RESET();
+
+    /* 2. 关闭串口设备(会释放接收缓冲区并关中断)。
      */
     rt_device_close(dtuserial);
     dtuserial->flag &= ~RT_DEVICE_FLAG_ACTIVATED;
@@ -1892,16 +2039,33 @@ void ResetInit(void)
                if(device_status.photo_ws==0){       //2026-06-05  修复工作结束后最后一张照片拍到清扫电机问题;
                    device_status.clear_status=1;
                }
-               while(device_status.clear_status==1){
-                   rt_thread_delay(1000);
+               /* 等待清扫完成,最长 120s:清扫线程异常/被删除时可强制放行,避免工作流程永久卡死 */
+               {
+                   uint16_t clear_wait = 0;
+                   while(device_status.clear_status==1){
+                       rt_thread_delay(1000);
+                       if(++clear_wait>=120){
+                           LOG_E("wait clear timeout, force clear_status=0");
+                           device_status.clear_status = 0;
+                           break;
+                       }
+                   }
                }
 #if DZ_260917_1 == 1
                //再执行4次清扫
                for(int i=0;i<4;i++)
                {
                    if(device_status.photo_ws==0)    device_status.clear_status=1;
-                   while(device_status.clear_status==1){
-                       rt_thread_delay(1000);
+                   {
+                       uint16_t clear_wait2 = 0;
+                       while(device_status.clear_status==1){
+                           rt_thread_delay(1000);
+                           if(++clear_wait2>=120){
+                               LOG_E("wait clear timeout(loop %d), force clear_status=0", i);
+                               device_status.clear_status = 0;
+                               break;
+                           }
+                       }
                    }
                }
 #endif
@@ -2497,7 +2661,12 @@ void WorkTask(void)
             //3.收集
             clt_time = device_status.clt_time * 60;
 
-            while(clt_time!=1)
+            /* 防御:参数异常(clt_time<=0)时不再进入无限倒计时(原实现 while(clt_time!=1) 会一直递减为负数) */
+            if(clt_time <= 0)
+            {
+                LOG_E("invalid clt_time(%d), skip collecting!", device_status.clt_time);
+            }
+            while(clt_time>1)
             {
                 #if 0//LAMP_EN == 0
                     ctr_Fan_IN(ON);
@@ -2898,9 +3067,12 @@ int Work_Loop_Task(void)
     #endif
     return 0;
 }
-MSH_CMD_EXPORT(HardWare_Check,HardWare_Check<ON|OFF>);
-MSH_CMD_EXPORT(ctr_lamp,ctr_lamp<ON|OFF>);
-MSH_CMD_EXPORT(ctr_clear,ctr_clear<ON|OFF>);
+/* 注意:以下 3 个函数签名与 FinSH 的 (int argc, char **argv) 不匹配,
+ * 直接导出会导致串口执行时参数为 argc/argv 垃圾值(命令无效果或随机动作),
+ * 已统一替换为下方的 ctr_test 命令,此处不再导出。 */
+//MSH_CMD_EXPORT(HardWare_Check,HardWare_Check<ON|OFF>);
+//MSH_CMD_EXPORT(ctr_lamp,ctr_lamp<ON|OFF>);
+//MSH_CMD_EXPORT(ctr_clear,ctr_clear<ON|OFF>);
 
 // RTU/DTU 电源控制 shell 命令
 static void ctr_rtu_dtu(int argc, char** argv)
@@ -2938,6 +3110,131 @@ static void ctr_rtu_dtu(int argc, char** argv)
         rt_kprintf("Usage: ctr_rtu_dtu <ON|OFF|0>\n");
     }
 }
+
+/* ==================== 测试/调试用命令行接口 ====================
+ * 背景:原代码将控制函数直接 MSH_CMD_EXPORT(ctr_lamp / ctr_led / ctr_clear / HardWare_Check),
+ * 但这些函数的签名是 (uint8_t[,uint8_t]),与 FinSH 的 (int argc, char **argv) 不匹配,
+ * 从串口执行时参数实为 argc/argv 的垃圾值 —— 命令要么无任何效果(实测 ctr_led on 不生效)、
+ * 要么以随机参数动作。现统一改为 argv 形式的 ctr_test,并移除上述有风险的直接导出。
+ */
+static int ctr_test(int argc, char **argv)
+{
+    const char *item;
+    const char *act;
+
+    if (argc < 3)
+    {
+        rt_kprintf("usage: ctr_test <item> <act> [val]\n"
+                   "  lamp <1|2|3> <on|off> | led <on|off> | clear <on|off>\n"
+                   "  shake <on|off> [sec]  | heat <on|off> | cold <on|off>\n"
+                   "  up <on|off> | down <on|off> | hwinit | hwcheck\n");
+        return -1;
+    }
+    item = argv[1];
+    act  = argv[2];
+
+    if (strcmp(item, "lamp") == 0)
+    {
+        int num = atoi(act);
+        const char *onoff = (argc >= 4) ? argv[3] : "off";
+        ctr_lamp((strcmp(onoff, "on") == 0) ? ON : OFF, (uint8_t)num);
+        rt_kprintf("[ctr_test] lamp%d %s\n", num, onoff);
+    }
+    else if (strcmp(item, "led") == 0)
+    {
+        ctr_led((strcmp(act, "on") == 0) ? ON : OFF);
+        rt_kprintf("[ctr_test] led %s\n", act);
+    }
+    else if (strcmp(item, "clear") == 0)
+    {
+        /* 置标志位由清扫线程执行(非阻塞),off 用于停止 */
+        device_status.clear_status = (strcmp(act, "on") == 0) ? 1 : 0;
+        rt_kprintf("[ctr_test] clear %s (clear_status=%d)\n", act, device_status.clear_status);
+    }
+    else if (strcmp(item, "shake") == 0)
+    {
+        uint16_t sec = (argc >= 4) ? (uint16_t)atoi(argv[3]) : 0;
+        ctr_shake((strcmp(act, "on") == 0) ? ON : OFF, sec);
+        rt_kprintf("[ctr_test] shake %s %d\n", act, sec);
+    }
+    else if (strcmp(item, "heat") == 0)
+    {
+        ctr_Heat((strcmp(act, "on") == 0) ? ON : OFF);
+        rt_kprintf("[ctr_test] heat %s\n", act);
+    }
+    else if (strcmp(item, "cold") == 0)
+    {
+        ctr_Cold((strcmp(act, "on") == 0) ? ON : OFF);
+        rt_kprintf("[ctr_test] cold %s\n", act);
+    }
+    else if (strcmp(item, "up") == 0)
+    {
+        device_status.ctr_up_motor = (strcmp(act, "on") == 0) ? 1 : 2;
+        rt_kprintf("[ctr_test] up %s\n", act);
+    }
+    else if (strcmp(item, "down") == 0)
+    {
+        device_status.ctr_down_motor = (strcmp(act, "on") == 0) ? 1 : 2;
+        rt_kprintf("[ctr_test] down %s\n", act);
+    }
+    else if (strcmp(item, "hwinit") == 0)
+    {
+        HardWare_Init(0);
+        rt_kprintf("[ctr_test] HardWare_Init done\n");
+    }
+    else if (strcmp(item, "hwcheck") == 0)
+    {
+        HardWare_Check(1);
+        rt_kprintf("[ctr_test] HardWare_Check(manual) done\n");
+    }
+    else
+    {
+        rt_kprintf("[ctr_test] unknown item: %s\n", item);
+        return -1;
+    }
+    return 0;
+}
+MSH_CMD_EXPORT(ctr_test, ctr_test <item> <act> [val] : 外设测试命令(lamp/led/clear/shake/heat/cold/up/down));
+
+/* 串口注入命令:配合 TX-RX 自环回,可从控制台向 MCU 注入一路串口数据。
+ *  - dtu_send:向 uart2 发送字符串(环回后等于"RTU 下发报文",可下发 JSON-RPC)
+ *  - hmi_send:向 uart4 发送字符串(环回后等于"屏幕下发指令")
+ * 注意:字符串不要包含空格(FinSH 以空格分参)。 */
+static int dtu_send(int argc, char **argv)
+{
+    if (argc < 2)
+    {
+        rt_kprintf("usage: dtu_send <string>   例: dtu_send {\"cmd\":\"read\"}\n");
+        return -1;
+    }
+    if (dtuserial == RT_NULL)
+    {
+        rt_kprintf("[dtu_send] uart2 not ready\n");
+        return -1;
+    }
+    rt_kprintf("[dtu_send] %s\n", argv[1]);
+    rt_device_write(dtuserial, 0, argv[1], rt_strlen(argv[1]));
+    return 0;
+}
+MSH_CMD_EXPORT(dtu_send, uart2 发送字符串(自环回时用于向MCU注入报文));
+
+static int hmi_send(int argc, char **argv)
+{
+    if (argc < 2)
+    {
+        rt_kprintf("usage: hmi_send <string>   例: hmi_send getFullData\n");
+        return -1;
+    }
+    if (serial == RT_NULL)
+    {
+        rt_kprintf("[hmi_send] uart4 not ready\n");
+        return -1;
+    }
+    rt_kprintf("[hmi_send] %s\n", argv[1]);
+    rt_device_write(serial, 0, argv[1], rt_strlen(argv[1]));
+    return 0;
+}
+MSH_CMD_EXPORT(hmi_send, uart4 发送字符串(自环回时用于向MCU注入屏幕指令));
+
 MSH_CMD_EXPORT(ctr_rtu_dtu,ctr_rtu_dtu<ON|OFF>);
-MSH_CMD_EXPORT(ctr_led,sample:ctr_led <ON|OFF>);
 MSH_CMD_EXPORT(cmd_rtu_restart, Safe restart RTU power);

+ 12 - 6
Application_CBD/applications/control.h

@@ -14,6 +14,8 @@
 #include "stdio.h"
 #include <rtdevice.h>
 //定制相关//////////////////////////////////////////////////////
+/* 清扫/卷带电机驱动方式:0-普通IO(H桥双高刹车),1-PWM(pwm8) */
+#define PWM_EN           1
 #define LAMP_EN          0             //李新3灯管:0关闭,1打开
 #define SENSOR_EN        1              //温湿度:0关闭,1打开
 #define ROBOT_EN         0              //机器人
@@ -29,26 +31,27 @@
     #define VERSION_HK_2000W    "1.3led0.40(2000W)"       //水稻
 #else
 #if DZ_260630_1 == 0
-     #define VERSION_HK          "1.70.41(HK)"            //4.0海康-1200W
+     #define VERSION_HK          "1.72.41(HK)"            //4.0海康-1200W
 #else
-    #define VERSION_HK          "1.70.41(HK-DZ260630_1)"  //4.0海康-1200W
+    #define VERSION_HK          "1.72.41(HK-DZ260630_1)"  //4.0海康-1200W
 #endif
 #if DZ_260623_2 == 0
 #if DZ_260630_1 == 0
-    #define VERSION_HK_2000W    "1.70.40(2000W)"         //4.0水稻
+    #define VERSION_HK_2000W    "1.72.40(2000W)"         //4.0水稻
 #else
-    #define VERSION_HK_2000W    "1.70.40(2000W-DZ260630_1)"         //4.0水稻
+    #define VERSION_HK_2000W    "1.72.40(2000W-DZ260630_1)"         //4.0水稻
 #endif
 #else
     #define VERSION_HK_2000W    "DZ_260623_2"         //4.0水稻
 #endif
 #endif
 #if DZ_260519 == 0
-#define VERSION_ZP          "1.70.1(ZP)"                //1.0转盘
+#define VERSION_ZP          "1.72.1(ZP)"                //1.0转盘
 #else
 #define VERSION_ZP          "DZ_260519"                 //1.0转盘
 #endif
-#define VERSION_GK          "1.70.1(GK)"                //1.0高空
+#define VERSION_GK          "1.72.1(GK)"                //1.0高空
+
 #define VERSION_XCT         "1.13.6(HK)"                //吸虫塔-海康
 #define VERSION_Robot       "1.0(robot)"                //展厅机器人
 #define VERSION_BZY         "2.60"                      //孢子仪
@@ -360,6 +363,9 @@ int Control_heat(void);
 
 int thread_delete_workloop(void);
 int thread_restart_workloop(void);
+/* 安全删除线程:仅在"线程未挂在 IPC 等待链表上"时删除(返回 0=已删除/无需删除;
+ * -1=线程正在 IPC 等待,本次未删除)。避免 rt_thread_delete 造成 IPC 链表野指针。 */
+int thread_delete_safe(rt_thread_t *ptid);
 
 /*******************************************************/
 void RTU_Power_Off_Safe(void);

文件差异内容过多而无法显示
+ 559 - 230
Application_CBD/applications/dtu_uart2.c


+ 2 - 0
Application_CBD/applications/dtu_uart2.h

@@ -62,4 +62,6 @@ void recover_param_from_rtu(void);
 void upload_sys_monitor_info(void);
 
 void dtu_uart2_reinit_rx(void);
+/* 安全删除 DTU 发送线程(内部先判定线程未挂在 IPC 等待链表上再删除) */
+void dtu_send_thread_delete_safe(void);
 #endif /* APPLICATIONS_INC_DTU_UART2_H_ */

+ 170 - 46
Application_CBD/applications/hmi.c

@@ -98,29 +98,111 @@ static int HMI_uart4_init(void)
     return RT_EOK;
 }
 /*串口屏写数据*/
+/* ---------- UART4(屏幕)发送互斥与升级状态 ---------- */
+static struct rt_mutex hmi_write_mutex;
+static rt_bool_t        hmi_mutex_inited = RT_FALSE;
+static volatile rt_tick_t s_hmi_upgrade_tick = 0;   /* 0=不在升级;非0=最近一次升级数据时间 */
+
+static rt_bool_t hmi_write_lock(void)
+{
+    /* 中断上下文不加锁(互斥锁不允许在中断中获取) */
+    if (rt_interrupt_get_nest() != 0)
+    {
+        return RT_FALSE;
+    }
+    if (!hmi_mutex_inited)
+    {
+        rt_base_t level = rt_hw_interrupt_disable();
+        if (!hmi_mutex_inited)
+        {
+            if (rt_mutex_init(&hmi_write_mutex, "hmi_mtx", RT_IPC_FLAG_FIFO) == RT_EOK)
+            {
+                hmi_mutex_inited = RT_TRUE;
+            }
+        }
+        rt_hw_interrupt_enable(level);
+    }
+    if (hmi_mutex_inited)
+    {
+        rt_mutex_take(&hmi_write_mutex, RT_WAITING_FOREVER);
+        return RT_TRUE;
+    }
+    return RT_FALSE;
+}
+
+static void hmi_write_unlock(void)
+{
+    if (hmi_mutex_inited)
+    {
+        rt_mutex_release(&hmi_write_mutex);
+    }
+}
+
+void Hmi_Upgrade_Begin(void)
+{
+    s_hmi_upgrade_tick = rt_tick_get();
+    LOG_I("HMI upgrade begin");
+}
+
+void Hmi_Upgrade_End(void)
+{
+    s_hmi_upgrade_tick = 0;
+    LOG_I("HMI upgrade end");
+}
+
+/* 升级传输期间返回真:屏蔽普通属性刷新,避免混入固件数据流;
+ * 60s 内没有新的升级数据自动解除(防止升级中断后屏幕刷新永久失效)。 */
+static rt_bool_t hmi_upgrade_busy(void)
+{
+    rt_tick_t t = s_hmi_upgrade_tick;
+    if (t == 0)
+    {
+        return RT_FALSE;
+    }
+    if ((rt_tick_get() - t) > (60 * RT_TICK_PER_SECOND))
+    {
+        s_hmi_upgrade_tick = 0;
+        LOG_W("HMI upgrade timeout, auto clear busy flag");
+        return RT_FALSE;
+    }
+    return RT_TRUE;
+}
+
 // 在你的代码基础上最小改动
 void HMI_WRITE(char *fmt, ...)
 {
+    va_list ap;
+    char str[256 + 3];  /* 预留 3 字节结束符 0xFF 0xFF 0xFF */
+    rt_size_t str_length;
+    rt_bool_t locked;
+
     if (serial == NULL || fmt == NULL) {
         return;
     }
 
-    va_list ap;
-    char str[256];  // 合理的大小
-    rt_size_t str_length;
+    /* 升级传输期间屏蔽普通业务指令 */
+    if (hmi_upgrade_busy()) {
+        return;
+    }
 
     va_start(ap, fmt);
-    str_length = rt_vsnprintf(str, sizeof(str), fmt, ap);
+    str_length = rt_vsnprintf(str, sizeof(str) - 3, fmt, ap);
     va_end(ap);
 
-    if (str_length > 0 && str_length < sizeof(str)) {
-        // 发送命令
-        rt_device_write(serial, 0, str, str_length);
-        // 发送结束符
-        static const char terminator[3] = {0xFF, 0xFF, 0xFF};
-        rt_device_write(serial, 0, terminator, 3);
+    if (str_length > 0 && str_length < sizeof(str) - 3) {
+        /* 结束符与指令合并为一次串口写入,减少写入次数、避免发送被拆散 */
+        str[str_length]     = (char)0xFF;
+        str[str_length + 1] = (char)0xFF;
+        str[str_length + 2] = (char)0xFF;
+
+        locked = hmi_write_lock();
+        rt_device_write(serial, 0, str, str_length + 3);
+        if (locked)
+        {
+            hmi_write_unlock();
+        }
+        system_status.uart4_tx_bytes += str_length + 3;
     }
-    system_status.uart4_tx_bytes+=str_length+3;
 }
 /* 接收数据回调函数 */
 static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
@@ -140,6 +222,18 @@ static rt_err_t uart_input(rt_device_t dev, rt_size_t size)
     return result;
 }
 
+/* UART4(屏幕口)接收回调重新注册。
+ * 注意:rt_device_close() 会清空 rx_indicate,设备被 close/open 后(如串口环回自检、
+ * 屏幕升级流程)必须重新注册,否则屏幕数据无法被 Hmi_thread_entry 读取。 */
+void hmi_uart4_reinit_rx(void)
+{
+    if (serial != RT_NULL)
+    {
+        rt_device_set_rx_indicate(serial, uart_input);
+        LOG_I("hmi uart4 rx_indicate re-registered");
+    }
+}
+
 // 预计算转换表
 static const int8_t hex_to_byte[256] = {
     [0 ... 255] = -1,
@@ -190,25 +284,40 @@ static inline int fast_hex_to_bin(const char* hex, uint8_t* bin, int max_len)
 // 发送原始数据到HMI
 static int send_raw_to_hmi(const uint8_t* data, uint32_t size)
 {
+    rt_size_t sent;
+    rt_bool_t locked;
+
     if (!serial || !data || size == 0) return -1;
 
-    rt_size_t sent = rt_device_write(serial, 0, data, size);
+    /* 与 HMI_WRITE 共用同一把锁,避免升级大包数据与业务指令互相穿插 */
+    locked = hmi_write_lock();
+    sent = rt_device_write(serial, 0, data, size);
+    if (locked)
+    {
+        hmi_write_unlock();
+    }
     return (sent == size) ? 0 : -1;
 }
 
 
 // 最简洁版本 - 每4096字节直接清空
 void process_hex_payload(const char* hex_str, int req_id) {
+    int data_len;
+    int progress;
+    uint8_t temp[JSON_CHUNK_SIZE];
+    char progress_json[256];
+
     if (!hex_str) return;
     current_state = STATE_RECEIVING;
+    s_hmi_upgrade_tick = rt_tick_get();     /* 刷新"升级活动中"时间戳 */
+
     // 转换HEX
-    uint8_t temp[JSON_CHUNK_SIZE];
-    int data_len = fast_hex_to_bin(hex_str, temp, JSON_CHUNK_SIZE);
+    data_len = fast_hex_to_bin(hex_str, temp, JSON_CHUNK_SIZE);
     if (data_len <= 0) return;
 
     // 添加到缓冲区
     if (recv_write_pos + data_len > sizeof(recv_buffer)) {
-        LOG_E("缓冲区溢出");
+        LOG_E("HMI升级缓冲区溢出(recv=%u,new=%d), 丢弃本包", (unsigned)recv_write_pos, data_len);
         return;
     }
 
@@ -217,18 +326,26 @@ void process_hex_payload(const char* hex_str, int req_id) {
     bytes_received += data_len;
 
     LOG_I("收到 %d 字节,缓冲: %u/%u",
-          data_len, recv_write_pos, sizeof(recv_buffer));
+          data_len, (unsigned)recv_write_pos, (unsigned)sizeof(recv_buffer));
 
-    // 每4096字节发送一次
+    /* 每满 4096 字节发送一块。
+     * 修复:原实现发送后直接清空缓冲,若积攒超过 4096 字节(分块长度不固定时)
+     * 会把超出的部分丢掉导致屏幕固件损坏;这里改为发送后把剩余数据前移保留。 */
     if (recv_write_pos >= 4096) {
         LOG_I("发送 4096 字节到HMI...");
-
-        if (send_raw_to_hmi(recv_buffer, 4096) == 0) {
-            LOG_I("发送成功");
-            // ✅ 直接清空缓冲区
+        /* 失败时重试一次,仍失败才丢弃本块 */
+        if (send_raw_to_hmi(recv_buffer, 4096) != 0 &&
+            send_raw_to_hmi(recv_buffer, 4096) != 0)
+        {
+            LOG_E("发送 4096 字节到HMI失败(已重试), 丢弃本块(请检查屏幕连接)");
             recv_write_pos = 0;
-        } else {
-            LOG_E("发送失败");
+        }
+        else
+        {
+            recv_write_pos -= 4096;
+            if (recv_write_pos > 0) {
+                memmove(recv_buffer, recv_buffer + 4096, recv_write_pos);
+            }
         }
         return;
     }
@@ -236,26 +353,26 @@ void process_hex_payload(const char* hex_str, int req_id) {
     // 检查完成
     if (bytes_received >= total_file_size && total_file_size > 0) {
         if (recv_write_pos > 0) {
-            LOG_I("发送最后 %u 字节", recv_write_pos);
+            LOG_I("发送最后 %u 字节", (unsigned)recv_write_pos);
             send_raw_to_hmi(recv_buffer, recv_write_pos);
             recv_write_pos = 0;  // 清空
         }
         current_state = STATE_COMPLETED;
+        Hmi_Upgrade_End();
         LOG_I("升级完成!");
         return;
     }
 
     // 发送进度
-    int progress = total_file_size > 0 ?
-                  (bytes_received * 100 / total_file_size) : 0;
+    progress = total_file_size > 0 ?
+                  (int)(bytes_received * 100 / total_file_size) : 0;
 
-    char progress_json[256];
     rt_snprintf(progress_json, sizeof(progress_json),
                "{\"jsonrpc\":\"2.0\",\"method\":\"upgradehmi\","
                "\"params\":{\"received\":%u,\"total\":%u,\"progress\":%d},\"id\":%d}",
-               bytes_received, total_file_size, progress, req_id);
+               (unsigned)bytes_received, (unsigned)total_file_size, progress, req_id);
 
-    DTU_Write(progress_json);
+    DTU_Write("%s", progress_json);      /* 修复:进度串必须作为参数而不是格式串 */
 }
 
 
@@ -287,7 +404,11 @@ static void Hmi_thread_entry(void *parameter)
                 //\r 对应的hex为0x0d,0x0a,占两个字节,屏幕发送的数据都以\r结尾
                 if(rx_length==1&&rx_buffer[rx_length-1]==0x05){
                     LOG_W("屏幕响应信号!");
-                    if(current_state==STATE_COMPLETED) return;
+                    if(current_state==STATE_COMPLETED){
+                        Hmi_Upgrade_End();
+                        hmi1 = RT_NULL;     /* 线程即将退出,句柄置空以便后续按需重建 */
+                        return;
+                    }
                     //RTU可以发送升级文件了
                     char* upgrade_hmi = makeJsonRpc2_0("upgradehmi",NULL,1);
                     if(upgrade_hmi){
@@ -1111,7 +1232,7 @@ static void HMI_Decode(void)
         rt_thread_delay(2000);
         MA_save();
         param_mirror_sync();
-        rt_free(var);
+        /* 注意:var 指向静态 rx_buffer 内部,不是堆内存,不能 rt_free(原实现会误导后续维护) */
         rt_kprintf("工作时间参数已保存:模式-%d,光控时间-%d,时控开始时间-%d,时控结束时间-%d\n",device_status.timeSwitch,device_status.sunBar,device_status.startBar,device_status.stopBar);
     }
 #endif
@@ -1217,7 +1338,7 @@ static void HMI_Decode(void)
         rt_thread_delay(1000);
         MA_save();
         param_mirror_sync();
-        rt_free(var);
+        /* 注意:var 指向静态 rx_buffer 内部,不是堆内存,不能 rt_free(原实现会误导后续维护) */
         rt_kprintf("系统设置已保存:收集时间-%d,加热时间-%d,加热温度-%d,音量-%d,自动关屏-%d\n",device_status.clt_time,device_status.heattime,device_status.heatvalue,device_status.vol,device_status.thsp);
     }
     else if (strstr(rx_buffer,"rtc_h=")!=NULL) {
@@ -1267,7 +1388,7 @@ static void HMI_Decode(void)
         else {
             rt_kprintf("设置失败!!!\n");
         }
-        rt_free(var);
+        /* 注意:var 指向静态 rx_buffer 内部,不是堆内存,不能 rt_free(原实现会误导后续维护) */
         rt_kprintf("数据上传设置:%d\n",device_status.dattim);
     }
     //光控测试
@@ -1291,7 +1412,7 @@ static void HMI_Decode(void)
         else {
             LOG_E("设置失败!!!");
         }
-        rt_free(var);
+        /* 注意:var 指向静态 rx_buffer 内部,不是堆内存,不能 rt_free(原实现会误导后续维护) */
         LOG_D("震动时间设置:%d",device_status.shake_sec);
     }
     //切换大数据平台
@@ -2460,23 +2581,26 @@ void Debug_log_OFF(void)
 {
     rt_console_set_device("uart1");
     finsh_set_device("uart1");
-    rt_mq_init(&rx_mq, "rx_mq",
+    /* 线程已存在时不再重复创建(原实现每次调用都会新建线程且不回收,造成线程泄漏) */
+    if (hmi1 == RT_NULL)
+    {
+        rt_mq_init(&rx_mq, "rx_mq",
                    msg_pool,                 /* 存放消息的缓冲区 */
                    sizeof(struct rx_msg),    /* 一条消息的最大长度 */
                    sizeof(msg_pool),         /* 存放消息的缓冲区大小 */
                    RT_IPC_FLAG_FIFO);        /* 如果有多个线程等待,按照先来先得到的方法分配消息 */
-    rt_device_set_rx_indicate(serial, uart_input);
-    hmi1 = rt_thread_create("Hmi_Fresh_thread",
-                            Hmi_thread_entry,
-                            RT_NULL,
-                            HMI_THREAD_STACK_SIZE,
-                            HMI_THREAD_PRIORITY,
-                            HMI_THREAD_TIMESLICE);
-    if (hmi1 != RT_NULL)
-    {
-       rt_thread_startup(hmi1);
+        rt_device_set_rx_indicate(serial, uart_input);
+        hmi1 = rt_thread_create("Hmi_Fresh_thread",
+                                Hmi_thread_entry,
+                                RT_NULL,
+                                HMI_THREAD_STACK_SIZE,
+                                HMI_THREAD_PRIORITY,
+                                HMI_THREAD_TIMESLICE);
+        if (hmi1 != RT_NULL)
+        {
+           rt_thread_startup(hmi1);
+        }
     }
-
 }
 MSH_CMD_EXPORT(Debug_log_ON,Debug_log_ON);
 MSH_CMD_EXPORT(Debug_log_OFF,Debug_log_OFF);

+ 5 - 0
Application_CBD/applications/hmi.h

@@ -80,6 +80,9 @@ typedef struct {
     uint32_t chunk_filled;       // 当前块已填充大小
 } hmi_upgrade_protocol_t;
 void process_hex_payload(const char* hex_str, int req_id);
+/* HMI(屏幕)固件升级状态控制:升级期间屏蔽业务指令,避免污染固件数据流 */
+void Hmi_Upgrade_Begin(void);
+void Hmi_Upgrade_End(void);
 
 
 void Check_ParamConfig(void);
@@ -95,4 +98,6 @@ void bubblesort(int a[], int n);
 
 int delete_hmi_thread(void);
 void Stop_timer_Uart2(void);
+/* UART4(屏幕口)接收回调重新注册(设备 close/open 后必须调用) */
+void hmi_uart4_reinit_rx(void);
 #endif /* APPLICATIONS_INC_HMI_H_ */

+ 2 - 1
Application_CBD/applications/main.c

@@ -52,7 +52,8 @@ int main(void)
     *(__IO uint16_t *)(0x40006C00 + 4 * 2) = 0x0000;
     CompileTime;      //读取固件的编译时间
     /* 初始化设备 */
-    rt_device_init(wdg_dev);
+    /* 注意:wdg_dev 在 wdt_init() 中才会通过 rt_device_find 获取,
+     * 此处原代码在句柄尚未获取(NULL)时就调用 rt_device_init(),属于误用,已移除。 */
     led_add_device(LED0_PIN);
     led_set_level(1,0);
     LOG_W("System Clock information:");

+ 74 - 5
Application_CBD/applications/param_mirror.c

@@ -26,6 +26,51 @@ Device_Status_typedef device_status;
 
 static const struct fal_partition *s_part = RT_NULL;
 
+/* ---- 防写放大/并发保护 ----
+ * 1) 内容未变化时直接跳过(避免每条 JSON/每次同步都擦写 2 个扇区,耗尽 Flash 寿命);
+ * 2) 用互斥锁串行化多线程的镜像读写(HMI/DTU/工作流程线程都会调用)。
+ */
+static struct rt_mutex s_mirror_lock;
+static rt_bool_t        s_mirror_lock_ready = RT_FALSE;
+static param_payload_t  s_last_payload;
+static rt_bool_t        s_last_valid = RT_FALSE;
+
+static void mirror_lock(void)
+{
+    if (!s_mirror_lock_ready)
+    {
+        rt_base_t level = rt_hw_interrupt_disable();
+        if (!s_mirror_lock_ready)
+        {
+            if (rt_mutex_init(&s_mirror_lock, "pm_mtx", RT_IPC_FLAG_PRIO) == RT_EOK)
+            {
+                s_mirror_lock_ready = RT_TRUE;
+            }
+        }
+        rt_hw_interrupt_enable(level);
+    }
+    if (s_mirror_lock_ready)
+    {
+        rt_mutex_take(&s_mirror_lock, RT_WAITING_FOREVER);
+    }
+}
+
+static void mirror_unlock(void)
+{
+    if (s_mirror_lock_ready)
+    {
+        rt_mutex_release(&s_mirror_lock);
+    }
+}
+
+/* 只比较配置体(跳过 magic/version/write_seq/crc32 头部) */
+static rt_bool_t payload_body_equal(const param_payload_t *a, const param_payload_t *b)
+{
+    return (rt_memcmp((const rt_uint8_t *)a + HDR_SIZE,
+                      (const rt_uint8_t *)b + HDR_SIZE,
+                      sizeof(param_payload_t) - HDR_SIZE) == 0) ? RT_TRUE : RT_FALSE;
+}
+
 static uint32_t calc_crc32(const void *buf, size_t size)
 {
     /* EF ships ef_calc_crc32; reuse to avoid bringing our own table. */
@@ -105,15 +150,20 @@ int param_mirror_load(param_payload_t *dst)
     if (va && !vb)
     {
         *dst = a;
-        return RT_EOK;
     }
-    if (!va && vb)
+    else if (!va && vb)
     {
         *dst = b;
-        return RT_EOK;
     }
-    /* both valid: pick the one with higher write_seq */
-    *dst = (a.write_seq >= b.write_seq) ? a : b;
+    else
+    {
+        /* both valid: pick the one with higher write_seq */
+        *dst = (a.write_seq >= b.write_seq) ? a : b;
+    }
+
+    /* 记录已加载内容:后续 param_mirror_sync() 内容相同则跳过擦写(防写放大) */
+    s_last_payload = *dst;
+    s_last_valid   = RT_TRUE;
     return RT_EOK;
 }
 
@@ -279,9 +329,28 @@ uint32_t mirror_to_device_status(const param_payload_t *in)
 void param_mirror_sync(void)
 {
     param_payload_t payload;
+
     device_status_to_mirror(&payload);
+
+    mirror_lock();
+
+    /* 内容未变化:直接跳过。避免每条 JSON(心跳/查询应答) 都触发
+     * 两次 4KB 扇区擦除,既保护 Flash 寿命也避免阻塞串口接收线程。 */
+    if (s_last_valid && payload_body_equal(&payload, &s_last_payload))
+    {
+        mirror_unlock();
+        return;
+    }
+
     if (param_mirror_save(&payload) != RT_EOK)
     {
         LOG_W("param mirror save failed");
+        mirror_unlock();
+        return;
     }
+
+    s_last_payload = payload;
+    s_last_valid   = RT_TRUE;
+
+    mirror_unlock();
 }

+ 13 - 3
Application_CBD/applications/sample_mb_master.c

@@ -32,6 +32,10 @@
 #define MB_SEND_REG_NUM    10
 
 #define MB_POLL_CYCLE_MS   500
+/* 线程栈:原为 512 字节,实测最坏调用链(Modbus 请求/应答 + rt_kprintf/rt_sprintf)
+ * 已接近该值,且历史上曾因栈不足触发溢出(破坏相邻堆对象 → HardFault)。
+ * 这里增大到 1024 字节留出余量。 */
+#define MB_THREAD_STACK_SIZE   1024
 rt_thread_t tid1 = RT_NULL, tid2 = RT_NULL;
 
 Device_Status_typedef device_status;
@@ -130,7 +134,13 @@ static void send_thread_entry(void *parameter)
                     rt_kprintf("usMRegHoldBuf[4]:%d\n",(int)usMRegHoldBuf[0][4]);
                     rt_kprintf("usMRegHoldBuf[5]:%d\n",(int)usMRegHoldBuf[0][5]);
                     rt_kprintf("usMRegHoldBuf[6]:%d\n",(int)usMRegHoldBuf[0][6]);
-                    rt_sprintf(device_status.wind_speed,"%0.01f",(float)usMRegHoldBuf[0][0]/100);
+                    /* 注意:本线程栈较小,禁止在此使用浮点 printf(%f/%0.01f):
+                     * newlib 浮点格式化链(_svfprintf_r+_dtoa_r+_Balloc+_calloc_r)约需 700+ 字节栈,
+                     * 会导致本线程栈溢出并破坏相邻堆对象(历史故障: 启动即 HardFault)。
+                     * 与其它字段保持一致,用整数格式化输出 wind_speed。 */
+                    rt_sprintf(device_status.wind_speed, "%d.%d",
+                               (int)usMRegHoldBuf[0][0]/100,
+                               (int)(usMRegHoldBuf[0][0]%100)/10);
                     rt_sprintf(device_status.wind_dir,"%d",(int)usMRegHoldBuf[0][1]);
                     rt_sprintf(device_status.tempture,"%d.%d",(int)usMRegHoldBuf[0][2]/10, (uint)usMRegHoldBuf[0][2] % 10);
                     rt_sprintf(device_status.humidity,"%d.%d",(int)usMRegHoldBuf[0][3]/10, (uint)usMRegHoldBuf[0][3] % 10);
@@ -184,7 +194,7 @@ int mb_master_samlpe(void)
         rt_kprintf("sample is running\n");
         return -RT_ERROR;
     }
-    tid1 = rt_thread_create("md_m_poll", mb_master_poll, RT_NULL, 512, MB_POLL_THREAD_PRIORITY, 10);
+    tid1 = rt_thread_create("md_m_poll", mb_master_poll, RT_NULL, MB_THREAD_STACK_SIZE, MB_POLL_THREAD_PRIORITY, 10);
     if (tid1 != RT_NULL)
     {
         rt_thread_startup(tid1);
@@ -194,7 +204,7 @@ int mb_master_samlpe(void)
         goto __exit;
     }
 
-    tid2 = rt_thread_create("md_m_send", send_thread_entry, RT_NULL, 512, MB_SEND_THREAD_PRIORITY, 10);
+    tid2 = rt_thread_create("md_m_send", send_thread_entry, RT_NULL, MB_THREAD_STACK_SIZE, MB_SEND_THREAD_PRIORITY, 10);
     if (tid2 != RT_NULL)
     {
         rt_thread_startup(tid2);

+ 219 - 28
Application_CBD/applications/selfcheck.c

@@ -22,6 +22,7 @@
 #include "selfcheck.h"
 #include <hmi.h>
 #include <dtu_uart2.h>
+#include "beep.h"
 #define DBG_ENABLE
 #define DBG_COLOR
 #define DBG_TAG "selfcheck"
@@ -209,35 +210,28 @@ int selfcheck(uint8_t type)
     HMI_WRITE("sysSet.va0.txt=\"当前电压:%s-温度:%d\"",device_status.voltage,heat_temp_off);
     //开启加热
     rt_thread_delay(1000);
-    //温度大于50摄氏度小于150摄氏度证明加热已经工作了
-    if(voltage_off>50.0&&voltage_off<150.0)
+    /* 注意:原实现用“电压是否在50~150之间”判断加热是否已工作,该条件恒不成立(死代码)。
+     * 这里改为始终执行加热测试:加热60s后,温度上升≥2℃ 或 电压跌落≥1.5V 视为加热回路正常。 */
+    ctr_Heat(ON);
+    //持续1分钟
+    for(int i = 60;i>0;i--)
+    {
+        HMI_WRITE("sysSet.va0.txt=\"加热测试中...%d\"",i);
+        rt_thread_delay(1000);
+    }
+    LOG_I("当前温度:%d电压:%s",device_status.heatvalue,device_status.voltage);
+    //比较当前电压、温度探头温度和开启前(注意使用有符号比较,避免无符号回绕误判为正常)
+    if(((int)device_status.heattem - (int)heat_temp_off)>=2 || (atof(device_status.voltage) - voltage_off)>=1.5)
     {
         HMI_WRITE("selfcheck.t2.bco=2024");
         device_status.C01 &= ~(1<<1);
         HMI_WRITE("sysSet.va0.txt=\"加热正常\"");
     }
-    else {
-        ctr_Heat(ON);
-        //持续1分钟
-        for(int i = 60;i>0;i--)
-        {
-            HMI_WRITE("sysSet.va0.txt=\"加热测试中...%d\"",i);
-            rt_thread_delay(1000);
-        }
-        LOG_I("当前温度:%d电压:%s",device_status.heatvalue,device_status.voltage);
-        //比较当前电压、温度探头温度和开启前
-        if((device_status.heattem - heat_temp_off)>=2 || (atof(device_status.voltage) - voltage_off)>=1.5)
-        {
-            HMI_WRITE("selfcheck.t2.bco=2024");
-            device_status.C01 &= ~(1<<1);
-            HMI_WRITE("sysSet.va0.txt=\"加热正常\"");
-        }
-        else
-        {
-            HMI_WRITE("selfcheck.t2.bco=63488");
-            device_status.C01 |= (1<<1);
-            HMI_WRITE("sysSet.va0.txt=\"加热故障\"");
-        }
+    else
+    {
+        HMI_WRITE("selfcheck.t2.bco=63488");
+        device_status.C01 |= (1<<1);
+        HMI_WRITE("sysSet.va0.txt=\"加热故障\"");
     }
     ctr_Heat(OFF);
     rt_thread_delay(1000);
@@ -252,8 +246,19 @@ int selfcheck(uint8_t type)
     }
     rt_thread_delay(1000);
     /*******************************************************/
-    //清扫
-    device_status.clear_status = 1;
+    /* 清扫测试:自检开始时清扫线程已被删除(device_status.clear_status 无人消费),
+     * 原来仅置位 clear_status 并不会真正执行清扫。这里在自检流程内直接驱动
+     * 清扫电机,并在运行过程中采样电流,与待机电流比较判定。 */
+    HMI_WRITE("sysSet.va0.txt=\"清扫测试中...\"");
+#if PWM_EN == 0
+    rt_pin_mode(CLEAR_R, PIN_MODE_OUTPUT);
+    rt_pin_mode(CLEAR_L, PIN_MODE_OUTPUT);
+    rt_pin_write(CLEAR_R, ON);
+    rt_pin_write(CLEAR_L, OFF);
+#else
+    Motor_Qingsao_R_PWM(ON);
+    Motor_Qingsao_L_PWM(OFF);
+#endif
     rt_thread_delay(2000);
     for(int i = 0;i<5;i++)
     {
@@ -261,8 +266,16 @@ int selfcheck(uint8_t type)
         rt_thread_delay(1000);
     }
     current_open = calculate_average(current_i,5);
+#if PWM_EN == 0
+    rt_pin_write(CLEAR_R, ON);
+    rt_pin_write(CLEAR_L, ON);
+#else
+    Motor_Qingsao_R_PWM(OFF);
+    Motor_Qingsao_L_PWM(OFF);
+#endif
     rt_thread_delay(1000);
-    if(atoi(device_status.power)-current_open>150)
+    /* 与待机电流比较(判据与灯管/仓门一致) */
+    if(current_open-current_>150)
     {
         HMI_WRITE("selfcheck.t11.bco=2024");
         device_status.C01 &= ~(1<<10);
@@ -274,6 +287,7 @@ int selfcheck(uint8_t type)
         device_status.C01 |= (1<<10);
         HMI_WRITE("sysSet.va0.txt=\"清扫故障\"");
     }
+    device_status.clear_status = 0;     /* 自检自行完成清扫,清除标志防止残留触发 */
     /*******************************************************/
     HMI_WRITE("sysSet.va0.txt=\"故障码:%d\"",device_status.C01);
     char *js = makeJson_C01_Warn(device_status.C01,1.0);
@@ -287,7 +301,9 @@ int selfcheck(uint8_t type)
 int rt_software_timer_init(void)
 {
     //启动拍照超时定时器
-    timer_takephoto = rt_timer_create("t_takephoto",t_takephoto_callback,RT_NULL, 100000, RT_TIMER_FLAG_ONE_SHOT);
+    /* 必须使用软件定时器:回调中会调用 HMI_WRITE/LOG 等阻塞接口,不能运行在中断上下文 */
+    timer_takephoto = rt_timer_create("t_takephoto",t_takephoto_callback,RT_NULL, 100000,
+                                      RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER);
     if(timer_takephoto==RT_NULL)
     {
         LOG_E("rt_timer_create t_takephoto failed!");
@@ -301,3 +317,178 @@ int rt_software_timer_init(void)
 
 INIT_APP_EXPORT(rt_software_timer_init);
 
+/* ==================== 串口自环回自检(自动化测试用) ====================
+ * 前置:目标串口 TX-RX 短接(自环回)。
+ * 用途:一次调用即可验证 驱动→DMA接收→IDLE中断→FIFO→读 的完整收发链路,
+ *       排除应用层线程/消息队列的干扰,用于区分"接线问题"与"固件接收路径问题"。
+ * 用法:uart_loop_test <2|4> [len]    len 默认 64,最大 2048(uart4 限制 512)
+ * 说明:测试期间临时接管该串口的接收回调(close→open→换回调),结束后恢复应用侧
+ *       (uart2: dtu_uart2_reinit_rx / uart4: hmi_uart4_reinit_rx)。
+ */
+#define LP_MAX_LEN      2048
+static rt_uint8_t  lp_tx[LP_MAX_LEN];
+static rt_uint8_t  lp_rx[LP_MAX_LEN + 64];
+static struct rt_semaphore lp_sem;
+static rt_bool_t   lp_sem_ready = RT_FALSE;
+
+static rt_err_t lp_rx_ind(rt_device_t dev, rt_size_t size)
+{
+    rt_sem_release(&lp_sem);
+    return RT_EOK;
+}
+
+/* 恢复应用侧接收回调。
+ * 注意:这里刻意【不做 close/open】。本驱动的 close/open 会调 HAL_UART_Receive_DMA
+ * 重新武装接收,一旦失败(例如 HAL 的 RxState 未复位导致返回 HAL_BUSY),
+ * 该串口的接收链路就会永久失效直到重启。仅重新注册 rx_indicate 即可达到
+ * "把接收权交还应用"的目的,对硬件状态零扰动。 */
+static void lp_resume_app(rt_device_t dev)
+{
+    if (dev == dtuserial)
+    {
+        dtu_uart2_reinit_rx();
+    }
+    else
+    {
+        hmi_uart4_reinit_rx();
+    }
+}
+
+static void uart_loop_test(int argc, char **argv)
+{
+    rt_device_t dev;
+    const char *port;
+    int len = 64;
+    int i, ok = 0, hdr_ok = 0;
+    rt_uint32_t got = 0, t0, timeout_ms;
+    char drain[64];
+
+    if (argc < 2)
+    {
+        rt_kprintf("usage: uart_loop_test <2|4> [len<=%d]\n", LP_MAX_LEN);
+        return;
+    }
+    if (argv[1][0] == '2')      { dev = dtuserial; port = "uart2"; }
+    else if (argv[1][0] == '4') { dev = serial;    port = "uart4"; }
+    else
+    {
+        rt_kprintf("[LP] invalid port(arg=%s)\n", argv[1]);
+        return;
+    }
+    if (dev == RT_NULL)
+    {
+        rt_kprintf("[LP %s] device handle is NULL\n", port);
+        return;
+    }
+    if (argc >= 3)
+    {
+        len = atoi(argv[2]);
+    }
+    if (len < 4) len = 4;
+    if (len > LP_MAX_LEN) len = LP_MAX_LEN;
+    if (dev == serial && len > 512)
+    {
+        len = 512;      /* uart4 接收缓冲 512B,避免回绕丢数据 */
+        rt_kprintf("[LP uart4] len clamped to 512\n");
+    }
+
+    if (!lp_sem_ready)
+    {
+        rt_sem_init(&lp_sem, "lp_sem", 0, RT_IPC_FLAG_FIFO);
+        lp_sem_ready = RT_TRUE;
+    }
+    /* 图案:55 AA + 长度 + 递增异或值,便于在被其它串口流量混入时定位 */
+    rt_memset(lp_tx, 0, sizeof(lp_tx));
+    for (i = 4; i < len; i++)
+    {
+        lp_tx[i] = (rt_uint8_t)(0xA5 ^ i);
+    }
+    lp_tx[0] = 0x55;
+    lp_tx[1] = 0xAA;
+    lp_tx[2] = (rt_uint8_t)(len & 0xFF);
+    lp_tx[3] = (rt_uint8_t)((len >> 8) & 0xFF);
+    rt_memset(lp_rx, 0, sizeof(lp_rx));
+
+    /* ---- 接管端口(只换回调,不做 close/open)----
+     * 只替换 rx_indicate:应用接收线程收不到信号量就不会来抢数据。
+     * 应用线程此前已把 FIFO 读空并阻塞在信号量上,我们保留这段等待以确保它进入阻塞。
+     * 刻意避开 close/open:该路径会重新武装 DMA,历史上曾因 HAL RxState 未复位
+     * 而静默失败,导致该串口接收永久失效(详见 lp_resume_app 注释)。 */
+    rt_device_set_rx_indicate(dev, lp_rx_ind);
+    rt_thread_mdelay(120);
+    /* 清掉在途残留,避免把上次的尾巴当成回环数据 */
+    while (rt_device_read(dev, 0, drain, sizeof(drain)) > 0) { }
+
+    /* ---- 发送 ---- */
+    t0 = rt_tick_get();
+    if (rt_device_write(dev, 0, lp_tx, len) != (rt_size_t)len)
+    {
+        rt_kprintf("[LP %s] FAIL: write error\n", port);
+        lp_resume_app(dev);
+        return;
+    }
+    /* 读回:超时 = 10bit/字节@115200 + 200ms 余量 */
+    timeout_ms = (rt_uint32_t)(((rt_uint32_t)len * 10UL * 1000UL) / 115200UL + 200UL);
+    while (got < (rt_uint32_t)len && (rt_tick_get() - t0) < timeout_ms)
+    {
+        rt_size_t n = rt_device_read(dev, 0, lp_rx + got, (rt_size_t)(len - (int)got));
+        if (n > 0)
+        {
+            got += n;
+            continue;
+        }
+        rt_sem_take(&lp_sem, 20);
+    }
+
+    /* ---- 校验:允许混入其它串口流量,按图案子串匹配 ---- */
+    for (i = 0; i + len <= (int)got; i++)
+    {
+        if (rt_memcmp(lp_rx + i, lp_tx, len) == 0)
+        {
+            ok = 1;
+            break;
+        }
+    }
+    /* 次判据:整帧未匹配上时,若能找到 4 字节报文头(55 AA len_lo len_hi),
+     * 说明收发链路是通的,只是被应用线程/其它流量抢走了部分字节。 */
+    if (!ok && got >= 4)
+    {
+        for (i = 0; i + 4 <= (int)got; i++)
+        {
+            if (rt_memcmp(lp_rx + i, lp_tx, 4) == 0)
+            {
+                hdr_ok = 1;
+                break;
+            }
+        }
+    }
+    rt_kprintf("[LP %s] len=%d recv=%d t=%dms %s\n", port, len, (int)got,
+               (int)(rt_tick_get() - t0),
+               ok ? "PASS" : (hdr_ok ? "PASS(仅报文头)" : "FAIL"));
+    if (!ok && hdr_ok)
+    {
+        rt_kprintf("[LP %s] 找到报文头但整帧不全:链路通,部分字节被应用线程取走\n", port);
+    }
+    if (!ok && !hdr_ok)
+    {
+        if (got > 0)
+        {
+            rt_kprintf("[LP %s] head:", port);
+            for (i = 0; i < ((int)got < 16 ? (int)got : 16); i++)
+            {
+                rt_kprintf(" %02x", lp_rx[i]);
+            }
+            rt_kprintf("\n[LP %s] 收到数据但与图案不符(可能有其它流量混入或丢字节)\n", port);
+        }
+        else
+        {
+            rt_kprintf("[LP %s] 未收到任何数据:请检查 TX-RX 是否短接、DMA/中断配置\n", port);
+        }
+    }
+
+    /* 清空测试残留:否则这些图案字节会被应用解析器当成非法报文 */
+    while (rt_device_read(dev, 0, drain, sizeof(drain)) > 0) { }
+    lp_resume_app(dev);
+}
+MSH_CMD_EXPORT(uart_loop_test, uart_loop_test <2|4> [len] : UART TX-RX loopback self test);
+

+ 116 - 31
Application_CBD/applications/sht30_collect.c

@@ -28,7 +28,10 @@
 #define THREAD_TIMESLICE        5       //时间片
 //电压,电流
 #define P_THREAD_PRIORITY       13      //线程优先级
-#define P_THREAD_STACK_SIZE     1024    //栈大小
+/* 栈大小:本线程使用浮点格式化(snprintf %.2f)与 atof,newlib 浮点链
+ * (_svfprintf_r+_dtoa_r+_Balloc+_calloc_r / _strtod_r) 需要数百字节栈,
+ * 1024 字节时最坏链路占用率约 83%,这里增大到 1536 字节留出余量。 */
+#define P_THREAD_STACK_SIZE     1536    //栈大小
 #define P_THREAD_TIMESCLICE     5       //时间片
 //ADC
 #define ADC_DEV_NAME "adc1"     /*ADC设备名称*/
@@ -181,8 +184,12 @@ static void adc_collect_thread_entry(void *parameter)
                 system_status.rain_control_triggers +=1;
                 device_status.rain_status = 1;
                 ctr_lamp(OFF,1);
+#if LAMP_EN == 1
+                /* 非三光源版本不得调用 ctr_lamp(2/3):会把 PB10/PB11 重配为普通 IO,
+                 * 与 UART3(喇叭) 的复用引脚冲突 */
                 ctr_lamp(OFF,2);
                 ctr_lamp(OFF,3);
+#endif
                 device_status.ctr_up_motor = 2; //关闭上仓门
                 checkrain_num = 0;
                 checkrain_unlock = 0;
@@ -261,11 +268,24 @@ static void Power_ReadCheck(void *parameter)
     int RV;
     MovingAverageFilter* filter = moving_average_filter_init(10);
     MovingAverageFilter* filter_v = moving_average_filter_init(10);
+    if (filter == NULL || filter_v == NULL)
+    {
+        /* 分配失败时退化为直接采样,不能直接崩溃/退出(否则欠压保护会失效) */
+        LOG_E("moving average filter alloc failed, fallback to raw adc value!");
+    }
     rt_thread_mdelay(1000);
     while(1)
     {
-        //sprintf(device_status.power,"%.2f",(float)Read_Real_Current()/100*2.5);
-        sprintf(device_status.power,"%.2f",(float)(moving_average_filter_update(filter, (float)Read_Real_Current()/100*2.5))+20.0);
+        {
+            /* 注意:RT-Thread 的 rt_snprintf/rt_vsnprintf 不支持 %f(浮点),
+             * 浮点格式化必须用 libc 的 snprintf(同样带长度上限,避免越界) */
+            float cur_filtered = (float)Read_Real_Current()/100*2.5;
+            if (filter != NULL)
+            {
+                cur_filtered = moving_average_filter_update(filter, cur_filtered);
+            }
+            snprintf(device_status.power, sizeof(device_status.power), "%.2f", cur_filtered+20.0);
+        }
         if (Read_Real_Voltage()/100<12) {
                     //关闭外设
                     ctr_photo(OFF); //关闭相机供电
@@ -300,59 +320,87 @@ static void Power_ReadCheck(void *parameter)
         //
         if(device_status.dtype==7)
         {
-            //箱体温度
-            RV = 10000 * (4096 - Read_Rain_Voltage()) / Read_Rain_Voltage();
-            if(TempCalculate(RV, 3950, 10000)-TempCalculate(RV, 3950, 10000)>10)
+            /* 说明:原实现用 TempCalculate(RV,..)-TempCalculate(RV,..)>10 做异常判断,
+             * 两边完全相同恒为 0(死代码)。这里改为对换算结果做合理区间判断。 */
+            unsigned int adc_box = Read_Rain_Voltage();
+            unsigned int adc_pre = Read_Light_Voltage();
+            int t_box, t_pre;
+
+            if(adc_box==0||adc_box>=4096)
             {
-                LOG_E("temp value err!!!!");
+                LOG_E("box temp adc invalid:%d", adc_box);
             }
             else
             {
-                device_status.box_temp = TempCalculate(RV, 3950, 10000);
-                if(device_status.box_temp>160)
+                RV = 10000 * (4096 - (int)adc_box) / (int)adc_box;      //注意:分母已判 0
+                t_box = TempCalculate(RV, 3950, 10000);
+                if(t_box<-40||t_box>160)
+                {
+                    LOG_E("box temp value err:%d", t_box);
+                }
+                else
                 {
-                    device_status.box_temp = 25;
+                    device_status.box_temp = (uint8_t)t_box;
                 }
             }
-            //培养仓温度
-            RV = 10000 * (4096 - Read_Light_Voltage()) / Read_Light_Voltage();
-            if(TempCalculate(RV, 3950, 10000)-TempCalculate(RV, 3950, 10000)>10)
+
+            if(adc_pre==0||adc_pre>=4096)
             {
-                LOG_E("temp value err!!!!");
+                LOG_E("pre temp adc invalid:%d", adc_pre);
             }
             else
             {
-                device_status.pre_temp = TempCalculate(RV, 3950, 10000);
-                if(device_status.pre_temp>160)
+                RV = 10000 * (4096 - (int)adc_pre) / (int)adc_pre;      //注意:分母已判 0
+                t_pre = TempCalculate(RV, 3950, 10000);
+                if(t_pre<-40||t_pre>160)
+                {
+                    LOG_E("pre temp value err:%d", t_pre);
+                }
+                else
                 {
-                    device_status.pre_temp = 25;
+                    device_status.pre_temp = (uint8_t)t_pre;
                 }
             }
         }
         else {
-            RV = 10000 * (4096 - Read_Ntc_Voltage()) / Read_Ntc_Voltage();
-            if(TempCalculate(RV, 3950, 10000)-TempCalculate(RV, 3950, 10000)>10)
+            unsigned int adc_ntc = Read_Ntc_Voltage();
+            int t_heat;
+
+            if(adc_ntc==0||adc_ntc>=4096)
             {
-                LOG_E("temp value err!!!!");
+                //LOG_E("ntc adc invalid:%d", adc_ntc);
+                device_status.heattem = 25;
             }
-            else {
-                device_status.heattem = TempCalculate(RV, 3950, 10000);
-                if(device_status.heattem>160)
+            else
+            {
+                RV = 10000 * (4096 - (int)adc_ntc) / (int)adc_ntc;      //注意:分母已判 0
+                t_heat = TempCalculate(RV, 3950, 10000);
+                if(t_heat<-40||t_heat>160)
                 {
+                    LOG_E("temp value err:%d", t_heat);
                     device_status.heattem = 25;
                 }
+                else {
+                    device_status.heattem = (uint8_t)t_heat;
+                }
             }
-            //LOG_D("rain_cnt:%d-value:%d",rain_cnt,Read_Rain_Voltage());
         }
         if(bat_cnt>=100){  //持续10s
             bat_cnt = 0;
             device_status.bat_status = 1; //欠压
         }
         #if ROBOT_EN == 0
-        sprintf(device_status.voltage,"%.2f",(float)(moving_average_filter_update(filter_v, (float)Read_Real_Voltage()/100)));
-        //rt_sprintf(device_status.voltage,"%d.%02d",filter_voltage()/100,filter_voltage()%100);
-        //LOG_D("voltage is:%sV",device_status.voltage);
-        sprintf(device_status.fuse_voltage, "%d.%02d",Read_Fuse_Voltage()/100,Read_Fuse_Voltage()%100);
+        {
+            float vol_filtered = (float)Read_Real_Voltage()/100;
+            if (filter_v != NULL)
+            {
+                vol_filtered = moving_average_filter_update(filter_v, vol_filtered);
+            }
+            /* 浮点用 libc snprintf(rt_*printf 不支持 %f) */
+            snprintf(device_status.voltage, sizeof(device_status.voltage), "%.2f", vol_filtered);
+            rt_snprintf(device_status.fuse_voltage, sizeof(device_status.fuse_voltage), "%d.%02d",
+                        Read_Fuse_Voltage()/100, Read_Fuse_Voltage()%100);
+        }
         #endif
         rt_thread_mdelay(10);
     }
@@ -407,8 +455,8 @@ int Read_Real_Voltage(void)
     HAL_ADCEx_Calibration_Start(adc_dev->parent.user_data);
     rt_adc_enable(adc_dev, ADC_DEV_CHANNLE_0);
 
-    //adc0_value = rt_adc_read(adc_dev, ADC_DEV_CHANNLE_0);
-    adc0_value = filter_Mid(rt_adc_read(adc_dev, ADC_DEV_CHANNLE_0));
+    /* 使用真实多次采样中位值滤波(原 filter_Mid 只是复制同一采样值,无滤波效果) */
+    adc0_value = adc_read_median(adc_dev, ADC_DEV_CHANNLE_0);
     /* 关闭通道 */
     rt_adc_disable(adc_dev, ADC_DEV_CHANNLE_0);
     return  (adc0_value * REFER_VOLTAGE/CONVERT_BITS*12+20);
@@ -511,7 +559,44 @@ int TempCalculate(float Rv,int B,int BasicRx)
     return (int)(Rx+0.5);
 }
 /*
+ * 中位值平均滤波(真实多次采样版)
+ * 对同一通道连续采样 N 次,排序后去掉最大/最小值再取平均。
+ * 原 filter_Mid() 是把“单次采样值”复制 N 份,既不滤波又阻塞 5×10ms,这里不再使用。
+ */
+unsigned int adc_read_median(rt_adc_device_t adc_dev, rt_uint32_t channel)
+{
+    unsigned char count,i,j;
+    unsigned int value_buf[N],temp=0;
+    int sum = 0;
+
+    for(count = 0;count<N;count++)
+    {
+        value_buf[count] = rt_adc_read(adc_dev, channel);
+        rt_thread_delay(2);
+    }
+    for(j=0;j<N-1;j++)
+    {
+        for(i=0;i<N-j-1;i++)
+        {
+            if(value_buf[i]>value_buf[i+1])
+            {
+                temp = value_buf[i];
+                value_buf[i] = value_buf[i+1];
+                value_buf[i+1] = temp;
+            }
+        }
+    }
+    for(count = 1;count < N - 1;count++)
+    {
+        sum+= value_buf[count];
+    }
+    return (int)(sum/(N-2));
+}
+
+/*
  * 中位值平均滤波法
+ * 说明:保留原接口以兼容外部调用;内部对传入的单个采样值排序意义有限,
+ * 新代码请使用 adc_read_median() 做真实多次采样滤波。
  * */
 unsigned int filter_Mid(int adc_return)
 {
@@ -578,7 +663,7 @@ int Read_Ntc_Voltage(void)
         return RT_ERROR;// adc 采样值不可能为负值,返回负值表示出错
     }
     rt_adc_enable(adc_dev, ADC_DEV_CHANNLE_4);
-    adc12_ntc = filter_Mid(rt_adc_read(adc_dev,ADC_DEV_CHANNLE_4));
+    adc12_ntc = adc_read_median(adc_dev, ADC_DEV_CHANNLE_4);
     //LOG_D("Read_Ntc_Voltage:%d",adc12_ntc);
     rt_adc_disable(adc_dev, ADC_DEV_CHANNLE_4);
     HAL_ADCEx_Calibration_Start(adc_dev->parent.user_data);

+ 4 - 0
Application_CBD/applications/sht30_collect.h

@@ -9,6 +9,8 @@
  */
 #ifndef APPLICATIONS_INC_SHT30_COLLECT_H_
 #define APPLICATIONS_INC_SHT30_COLLECT_H_
+#include <rtthread.h>
+#include <rtdevice.h>       /* 需要 rt_adc_device_t 类型 */
 #define ADC_VOL_BASE                            1.20 //ADC内部电压基准,后续版本可改为针对每一块板子实际测量后写入 flash
 #define N 5        //adc采样计算次数
 #define UART_485 "uart5"  /*串口设备名称*/
@@ -27,6 +29,8 @@ int Read_Ntc_Voltage(void);
 int TempCalculate(float Rv,int B,int BasicRx);
 short Get_Temprate(void);
 unsigned int filter_Mid(int adc_return);
+/* 真实多次采样中位值滤波(替代 filter_Mid 的新接口) */
+unsigned int adc_read_median(rt_adc_device_t adc_dev, rt_uint32_t channel);
 unsigned int filter_voltage(void);
 
 

+ 143 - 0
Application_CBD/readme.md

@@ -1,3 +1,146 @@
+# 2026-10-02 更新说明(自动化测试接口 + 控制台命令缺陷修复)
+
+	#define VERSION_HK          "1.72.41(HK)"            //4.0海康-1200W
+    #define VERSION_HK_2000W    "1.72.40(2000W)"         //4.0水稻
+	#define VERSION_ZP          "1.72.1(ZP)"             //1.0转盘
+	#define VERSION_GK          "1.72.1(GK)"             //1.0高空
+		编译:text 244356B / data 2476B / bss 39888B(arm-none-eabi-gcc 6.3.1);可烧录镜像
+		bin/Application_CBD-1.72.41-20261002.bin(基址 0x08032000,与旧版一致),
+		带符号 elf 见 Debug/Application_CBD-1.72.41-20261002.elf。
+	说明:本次为"真机自动化测试"配套的固件改动,测试拓扑(UART2 自环回、UART4 自环回、调试口接
+		电脑 COM3)、测试脚本、过程记录与结果见 doc/自动化测试方案.md;主机侧测试脚本在 doc/tools/
+		(console_test.py 一键跑 T0~T7 并出报告,stack_usage.py 静态栈深度分析)。
+	1、修复:控制台(MSH)命令签名不匹配(实测发现的真实缺陷):
+		原 MSH_CMD_EXPORT(ctr_lamp / ctr_led / ctr_clear / HardWare_Check) 直接导出了形参为
+		uint8_t 的业务函数,而 FinSH 调用约定是 (int argc, char **argv) —— 从串口执行时形参拿到的是
+		垃圾值:实测 "ctr_led on" 完全不生效,ctr_clear 会以随机参数驱动清扫电机,存在安全风险。
+		现统一改为 ctr_test <item> <act> [val](item=lamp/led/clear/shake/heat/cold/up/down/hwinit/
+		hwcheck),原 4 个错误导出已注释并注明原因;
+	2、新增:串口自环回自检命令 uart_loop_test <2|4> [len]:临时接管端口(close→open→换回调) →
+		发送 55AA+长度+递增图案 → 读回逐字节校验 → 恢复应用侧回调(out_len 实测)。用于把
+		"外部接线问题"与"固件接收路径问题"分开,输出 PASS/FAIL + 收字节数 + 耗时;
+	3、新增:串口注入命令 dtu_send / hmi_send <字符串>:配合 TX-RX 短接可向 uart2 注入 JSON
+		(RTU 下行报文)、向 uart4 注入屏幕指令,用于端到端联调闭环(MSH 下字符串不含空格);
+	4、新增:hmi_uart4_reinit_rx():UART4 接收回调重注册(rt_device_close/open 会清空
+		rx_indicate),与既有的 dtu_uart2_reinit_rx() 对称,用于屏幕升级、环回自检后的接收恢复;
+	5、自动化测试结论(2026-10-02 真机实测):
+		① 线程栈:list_thread 的 "max used"(填充图案扫描得到的历史最高水位)实测全部线程
+		   08%~55%,无 ≥80% 线程;静态栈深度分析(stack_usage.py,objdump 调用图 + -fstack-usage)
+		   最坏路径占用 18%~61%,最高为 Control_Heat_thread_entry 624B/1024B。
+		   "启动即崩"的根因线程 send_thread_entry(md_m_sen)最坏栈深度由修复前的 824B 降到
+		   272B(栈 1024B,占 27%)→ 10-01 的根因修复已由实测 + 静态分析双重确认;
+		② UART2 自环回闭环验证通过:捕获到一次完整上传周期 uart2_tx +653 / uart2_rx +653
+		   (两个增量完全一致)、累计上传数据 +1,全程无崩溃/无栈溢出特征;
+		③ UART4 自环回异常(待判别,非本次固件引入):uart4_tx 有增长(3724→3734,为屏幕
+		   sleep=1 屏保指令)但 uart4_rx 恒为 0;已排除固件侧因素(DMA 配置、驱动路径与 UART2
+		   完全同源、引脚 PC10/PC11、线程存活均正常)。请确认短接点是否落在主控板 UART4
+		   排针(PC10↔PC11)上,并用 uart_loop_test 4 判别(PASS=固件与接线都好,FAIL=接线/焊点问题);
+		④ 测试中同时确认:uart1/2/4 设备均正常打开,syswatch 正常运行,无看门狗复位。
+	6、注意(本次新增接口的使用约束):uart_loop_test 会短暂接管串口并替换回调,测完自动恢复;
+		若在屏幕固件升级过程中执行会造成升级数据流中断,请避免同时在用。
+	7、【真机测试发现的严重缺陷,已修复】串口 DMA 接收在 close/open 之后永久失效:
+		现象:rt_device_close()+rt_device_open() 之后,该串口再也收不到数据(且表现为
+		"读到 bufsz 字节全 0"而非"读不到",故障被伪装成乱码数据)。
+		机理(两处耦合缺陷):
+		① HAL_UART_Receive_DMA() 的首要判断是 RxState == HAL_UART_STATE_READY,否则直接
+		   返回 HAL_BUSY;而 RxState 只由 HAL 自己的接收完成回调复位,本驱动绕开 HAL
+		   接收路径、自己处理 IDLE 中断,RxState 会永远停在 BUSY_RX —— 于是第二次武装
+		   必然失败,DMA 根本没有启动。原代码在失败分支只有 RT_ASSERT(0),未开 RT_DEBUG
+		   时是空操作,失败完全静默。修复:武装前显式置 RxState = HAL_UART_STATE_READY,
+		   并在失败时打印错误日志;
+		② DMA 停用后 CNDTR 读回 0,被算成"整个缓冲区都已收满"(dma_isr 里
+		   recv_total_index==0 时更会得出 bufsz - 0 = bufsz),put_index 回绕导致
+		   rx_fifo 的 is_full 置位,此后读取一直返回 memset 过的全 0 缓冲区。
+		   修复:DMA 通道未使能(CCR.EN==0)时不推算长度;recv_total_len 增加上界钳位。
+		【生产影响】所有 close/open 路径都会踩到:RTU 断电重启(RTU_Power_Off_Safe)、
+		屏幕固件升级后的恢复、串口环回自检。即"现场对 DTU 断电重启一次,主控就再也
+		收不到平台下行指令,直到重启"。该缺陷在 10-02 环回自检中被暴露。
+	8、uart_loop_test 同步加固(避免测试自身触发上述缺陷):
+		不再 close/open 设备,改为只临时替换 rx_indicate(应用接收线程因收不到信号量
+		而自然让出数据),测完重新注册应用回调并把残留字节读空;另增加"仅报文头匹配"
+		的次判据,用于区分"链路通但被应用线程抢走部分字节"与"完全没收到"。
+	9、2026-10-02 真机测试结果(固件已烧录,UART2/UART4 各自 TX-RX 短接,调试口 COM3):
+		① T0/T1/T2/T2b/T5/T5b/T5c/T6 全部 PASS:设备存活、uart1/2/4 均正常打开、
+		   13 个线程栈最高占用 DTU_Uart=41%(无 ≥80%)、RTU 安全重启流程未崩溃、全程无
+		   栈溢出/HardFault 特征;
+		② UART2 物理环回**正常**:uart_loop_test 的写操作耗时与该长度@115200 的理论值
+		   精确吻合(64B→6ms、512B→49ms、2048B→198ms)证明 TX 确实在发送;且 IDLE
+		   中断被触发证明 RX 引脚确实收到了信号。读回全 0 是上述 7① / 7② 的故障表现,
+		   非接线问题;
+		③ UART4 接收**完全没有信号**:uart_loop_test 4 在 64/512 两种长度下 recv 均为 0
+		   且无任何 IDLE 触发(与 UART2 形成明确对照)。固件侧已排除(UART4 仅开机 open
+		   一次、DMA 配置与 UART2 同源、引脚 PC10/PC11)。请现场确认短接点是否真正落在
+		   主控板 UART4 的 MCU 引脚(PC10↔PC11)上。
+		④ 修复版镜像:bin/Application_CBD-1.72.41-20261002-rxfix.bin(text 244396B),
+		   烧录后 uart_loop_test / RTU 重启路径应均恢复正常。
+
+# 2026-10-01 更新说明(全量代码审查后的稳定性修复)
+	#define VERSION_HK          "1.71.41(HK)"            //4.0海康-1200W
+    #define VERSION_HK_2000W    "1.71.40(2000W)"         //4.0水稻
+	#define VERSION_ZP          "1.71.1(ZP)"             //1.0转盘
+	#define VERSION_GK          "1.71.1(GK)"             //1.0高空
+	说明:本次为代码审查(详见 doc/代码审查报告.md)后的批量修复,修复清单见 doc/代码审查修复记录.md,
+		已用真实工具链(arm-none-eabi-gcc 6.3.1)编译+链接验证(无新增告警,text 242276B/data 2476B/bss 35688B,
+		初始 MSP=0x200011ac);第 13 条为"启动即崩"现场故障的根因与修复。
+	1、自检流程修复(重要):
+		① thread_delete_workloop 删除的 4 个线程原来只恢复 workloop,导致自检后光控/时控判定、
+		   清扫、加热线程永久缺失、工作流程卡死;现按开机条件全部恢复;
+		② 自检的清扫项原来只置位 clear_status(清扫线程已被删除),实际未执行清扫;
+		   现改为在自检流程内直接驱动清扫电机并采流判定,判据与灯管/仓门一致;
+		③ 加热自检去掉"电压 50~150"死判据,温差比较改为有符号比较(避免回绕误判);
+		④ ResetInit 等待清扫完成增加 120s 超时,清扫异常不再永久卡死工作流程;
+	2、参数镜像防写放大:每次同步前先比较内容,未变化不再擦写(原每条 JSON 都擦 2×4KB 扇区,
+		镜像扇区寿命不足数月),并增加互斥锁避免多线程混叠;
+	3、串口通信加固:
+		① DTU_Write 格式化+发送整体加锁(原在锁外用共享 static 缓冲,多线程会互相覆盖报文);
+		② HMI_WRITE 增加互斥锁,指令与 FF FF FF 结束符合并为一次写;
+		③ RTU 接收线程改为批量读取,非法字节日志限速(原每字节一条日志会拖垮系统);
+	4、下行数据(RTU/平台)校验:签名/图片地址/经纬度/版本号/imei/iccid/平台地址等字段
+		全部增加类型+长度校验;修复 sync_param 无范围校验(clt_time=0 会导致收集倒计时
+		死循环、shake_sec 超大导致超长阻塞)、"st" 参数误写入 sunBar 键、deviceId 取到键名;
+	5、修复:远程指令 heat_off 实际调用 ctr_Heat(ON)(关闭加热变成打开加热);
+	6、修复:ctr_shake 的循环变量 uint8_t 在 shake_sec≥256 时溢出成死循环,并对 shake_sec 钳位;
+	7、屏幕固件升级:分块发送不再丢字节(memmove 保留余量)+ 失败重试一次;
+		升级期间屏蔽普通业务指令(60s 无新数据自动解除),避免混入固件数据流;修复进度串被当作格式串;
+	8、串口驱动:恢复 DMA 接收 TC/HT 回调,解决连续数据流下 IDLE 不触发导致的接收错乱;
+	9、RTU 通信:2 小时无数据看门狗改为线程启动即计时(原来只在"曾收到过 JSON"后才生效);
+		断电前先复位 USART2 停止 DMA,避免 DMA 继续写入已释放的接收缓冲;
+	10、外设与初始化:
+		① ADC 通道 PC1~PC3 补为模拟输入(与代码读取的雨控/光控/NTC/保险丝后电压通道一致);
+		② ADC 换算增加除零保护,改用真实多次采样中位值滤波(原滤波为单值复制、无效果);
+		③ 片内 Flash 写改用中断保存/恢复(原 __disable_irq/__enable_irq 会破坏嵌套临界区);
+		④ 拍照超时定时器改为软件定时器(原来在中断上下文调用 HMI_WRITE),软定时器线程栈 256→1024;
+		⑤ FAL 外部 Flash 设备改为惰性查找,不再依赖 fal_init 与 SFUD probe 的链接顺序;
+		⑥ main 中删除对 NULL 句柄的 rt_device_init 调用;
+		⑦ 雨控关灯的 ctr_lamp(OFF,2/3) 增加 LAMP_EN 保护,避免与 UART3(喇叭) 复用引脚冲突;
+	11、注意(可复用经验):RT-Thread 的 rt_snprintf/rt_sprintf/rt_vsnprintf 不支持 %f(浮点),
+		浮点格式化必须用 libc 的 snprintf;本次修正电流/电压/风速/培养时长/相机参数等浮点字段,
+		并给原 sprintf 越界点(stayed[5]、d_ExposureTime[10]、d_Gamma[10])加了长度上限;
+	12、串口性能:报文间隔改为可配置 DTU_TX_GAP_MS(默认 10ms 保持原节奏,现场可下调);
+		后续可评估:UART2 发送改 DMA、把长耗时命令(拍照/参数保存/RTU 重启)移出接收线程。
+	13、【现场 HardFault 根因(已更正)】"启动即崩:栈溢出误报 + list_thread 精确总线错误 BFAR=0x0019A3D7":
+		根因:485 采集线程 send_thread_entry 的栈只有 512 字节,而风速字段使用了浮点格式化
+		(snprintf "%0.01f"),newlib 浮点 printf 链(_svfprintf_r 304B + _dtoa_r 144B + _Balloc +
+		_calloc_r ≈700B)使该线程最坏栈深度达 824B → 栈向下越界写坏相邻线程 TCB → 下一次切换误报
+		"栈溢出"(线程名乱码) → list_thread() 遍历被写坏的链表 → 精确总线错误。该线程开机 ~5s 即运行,
+		故表现为"刚启动、什么都没做就崩"。
+		处理:① 风速改回整数格式化 rt_sprintf("%d.%d",...)(与温度/湿度/气压等字段一致,显示不变),
+		彻底避开浮点链;② 两个 Modbus 线程栈 512→1024;③ Power Check 线程 1024→1536(含 snprintf
+		浮点与 atof);④ DTU 收发线程 2048→2560;⑤ 新增静态栈分析工具 doc/tools/stack_usage.py
+		(反汇编调用图 + -fstack-usage) 复核各线程最坏栈深度,修复后全部线程占用率 23%~61%。
+		【经验】小栈线程(≤1KB)禁止浮点 printf/scanf;改动小栈线程内的格式化/日志语句前先跑该工具。
+	14、系统栈(MSP)由 512B 增大到 2KB(link.lds 的 _system_stack_size):所有中断以及
+		"栈溢出/硬件异常"诊断打印(rt_kprintf + list_thread)都在系统栈上运行,原 512B 会让诊断
+		输出自身溢出并向下覆盖 .data,导致故障现场丢失、二次 HardFault(初始 MSP 0x20000bac→0x200011ac);
+	15、栈溢出日志增强(rt-thread/src/scheduler.c,带 [BZY PATCH] 标记):除线程名外追加打印
+		sp/base/size,便于一次定位溢出线程与超出量;如不需要内核改动可删除该行恢复原样;
+	16、【预防性加固】新增 thread_delete_safe()(control.c/h、dtu_uart2.c/h):
+		本内核版本(4.0.2)的 rt_thread_delete() 不会把线程从 IPC 等待链表摘除,删除"正阻塞在互斥量/
+		信号量上"的线程会造成 IPC 链表野指针(空闲线程回收 TCB 后仍被引用 → 野指针写入 → 内核链表
+		破坏)。现改为在关中断临界区内判定"线程未挂在任何 IPC 等待链表上"(挂起态且线程定时器未激活)
+		后再删除,判定不通过则重试,仍不通过则保留线程并告警;thread_delete_workloop() 与屏幕升级
+		路径同步改用该接口。注:本条是同一现场日志暴露的独立隐患,未证实为本次崩溃触发点,但与
+		HMI_WRITE/DTU_Write 增加互斥锁的改动配套保留(被删线程阻塞在锁上的概率已增大)。
 # 2026-08-26 更新说明
 	#define VERSION_HK          "1.70.41(HK)"            //4.0海康-1200W
     #define VERSION_HK_2000W    "1.70.40(2000W)"         //4.0水稻

二进制
Application_CBD/doc/test_logs/console_20261002_165053.log


二进制
Application_CBD/doc/test_logs/console_20261002_185247.log


文件差异内容过多而无法显示
+ 4934 - 0
Application_CBD/doc/test_logs/watch_20261002_165437.log


+ 52 - 0
Application_CBD/doc/test_logs/自动化测试结果_20261002_165053.md

@@ -0,0 +1,52 @@
+# 控制台自动化测试结果
+
+- 生成时间: 2026-10-02 16:52:56
+- 串口: COM3 @ 115200 8N1
+- 接线: UART2 TX-RX 短接 / UART4 TX-RX 短接 / 调试口接 PC
+
+| 测试项 | 结果 | 说明 |
+| --- | --- | --- |
+| T0 设备存活/无崩溃日志 | **PASS** | 未发现崩溃特征 |
+| T1 设备枚举(uart1/2/4) | **PASS** | uart1/uart2/uart4 均在设备表 |
+| T2 线程栈预算 | **PASS** | 共 12 个线程, 最高占用 DTU_Uart=55%; 无 >=80% 的线程 |
+| T2b Modbus 线程栈已放大(>=1024B) | **PASS** | md_m_sen=1024B |
+| T5 RTU 安全重启(关闭->30s->恢复->重注册RX) | **PASS** | 开始执行 cmd_rtu_restart ... |
+| T5b 重启后设备存活 | **PASS** | 未发现崩溃特征 |
+| T5c 重启后线程表可读 | **PASS** | 解析到 14 个线程 |
+| T7 固件内建环回自检(uart_loop_test) | **SKIP** | 当前固件未包含该命令(需烧录含自检命令的版本) |
+| T3 UART2 自环回(接收字节增长) | **FAIL** | uart2 rx: 26506 -> 26506 (+0) |
+| T4 UART4 自环回(接收字节增长) | **FAIL** | uart4 rx: 0 -> 0 (+0) |
+| T6 全过程稳定性(无崩溃特征) | **PASS** | 全程未出现 stack overflow/hard fault |
+
+## 线程栈实测(list_thread 的 max used)
+
+| 线程 | 栈大小(B) | max used | 占用率 | 状态 |
+| --- | --- | --- | --- | --- |
+| DTU_Uart | 2560 | 1408 | 55% | suspend |
+| DTU_Uart | 2560 | 998 | 39% | suspend |
+| sys_moni | 1024 | 276 | 27% | suspend |
+| tshell | 2048 | 552 | 27% | running |
+| work_loo | 2048 | 512 | 25% | suspend |
+| md_m_sen | 1024 | 256 | 25% | suspend |
+| tidle0 | 1024 | 256 | 25% | ready |
+| md_m_pol | 1024 | 235 | 23% | suspend |
+| work_sta | 1024 | 194 | 19% | suspend |
+| syswatch | 1024 | 153 | 15% | suspend |
+| Hmi_Fres | 2048 | 225 | 11% | suspend |
+| timer | 1024 | 112 | 11% | suspend |
+
+## 自环回流量统计
+
+| 项目 | 起始 | 结束 | 增量(B) |
+| --- | --- | --- | --- |
+| uart2_rx | 26506 | 26506 | 0 |
+| uart4_rx | 0 | 0 | 0 |
+| uart2_tx | 34405 | 34405 | 0 |
+
+## 其它观测
+
+- 累计捕获控制台日志 55978 字节
+
+## 原始日志
+
+`D:\RT-ThreadStudio\workspace\iot_-cbd_-bzy_-ctrl\Application_CBD\doc\test_logs\console_20261002_165053.log`

+ 53 - 0
Application_CBD/doc/test_logs/自动化测试结果_20261002_185247.md

@@ -0,0 +1,53 @@
+# 控制台自动化测试结果
+
+- 生成时间: 2026-10-02 18:55:21
+- 串口: COM3 @ 115200 8N1
+- 接线: UART2 TX-RX 短接 / UART4 TX-RX 短接 / 调试口接 PC
+
+| 测试项 | 结果 | 说明 |
+| --- | --- | --- |
+| T0 设备存活/无崩溃日志 | **PASS** | 未发现崩溃特征 |
+| T1 设备枚举(uart1/2/4) | **PASS** | uart1/uart2/uart4 均在设备表 |
+| T2 线程栈预算 | **PASS** | 共 13 个线程, 最高占用 DTU_Uart=41%; 无 >=80% 的线程 |
+| T2b Modbus 线程栈已放大(>=1024B) | **PASS** | md_m_sen=1024B |
+| T5 RTU 安全重启(关闭->30s->恢复->重注册RX) | **PASS** | 开始执行 cmd_rtu_restart ... |
+| T5b 重启后设备存活 | **PASS** | 未发现崩溃特征 |
+| T5c 重启后线程表可读 | **PASS** | 解析到 15 个线程 |
+| T7 固件内建环回自检(uart_loop_test) | **FAIL** | 存在 FAIL 用例,详见日志 |
+| T3 UART2 自环回(接收字节增长) | **FAIL** | uart2 rx: 6267 -> 6267 (+0) |
+| T4 UART4 自环回(接收字节增长) | **FAIL** | uart4 rx: 0 -> 0 (+0) |
+| T6 全过程稳定性(无崩溃特征) | **PASS** | 全程未出现 stack overflow/hard fault |
+
+## 线程栈实测(list_thread 的 max used)
+
+| 线程 | 栈大小(B) | max used | 占用率 | 状态 |
+| --- | --- | --- | --- | --- |
+| DTU_Uart | 2560 | 1049 | 41% | suspend |
+| DTU_Uart | 2560 | 998 | 39% | suspend |
+| Control_ | 1024 | 276 | 27% | suspend |
+| sys_moni | 1024 | 276 | 27% | suspend |
+| work_loo | 2048 | 512 | 25% | suspend |
+| md_m_sen | 1024 | 256 | 25% | suspend |
+| tshell | 2048 | 512 | 25% | running |
+| tidle0 | 1024 | 256 | 25% | ready |
+| md_m_pol | 1024 | 235 | 23% | suspend |
+| work_sta | 1024 | 194 | 19% | suspend |
+| syswatch | 1024 | 153 | 15% | suspend |
+| Hmi_Fres | 2048 | 225 | 11% | suspend |
+| timer | 1024 | 112 | 11% | suspend |
+
+## 自环回流量统计
+
+| 项目 | 起始 | 结束 | 增量(B) |
+| --- | --- | --- | --- |
+| uart2_rx | 6267 | 6267 | 0 |
+| uart4_rx | 0 | 0 | 0 |
+| uart2_tx | 4219 | 4875 | 656 |
+
+## 其它观测
+
+- 累计捕获控制台日志 79436 字节
+
+## 原始日志
+
+`D:\RT-ThreadStudio\workspace\iot_-cbd_-bzy_-ctrl\Application_CBD\doc\test_logs\console_20261002_185247.log`

+ 29 - 0
Application_CBD/doc/tools/console_recon.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""控制台快速侦察:打开串口读取若干秒,观察设备状态与日志格式"""
+import sys
+import time
+import serial
+
+port = sys.argv[1] if len(sys.argv) > 1 else "COM3"
+secs = float(sys.argv[2]) if len(sys.argv) > 2 else 8.0
+
+s = serial.Serial(port=port, baudrate=115200, bytesize=8, parity="N",
+                  stopbits=1, timeout=0.05)
+print("opened %s @115200, reading %.1fs ..." % (port, secs))
+buf = b""
+t0 = time.time()
+while time.time() - t0 < secs:
+    n = s.in_waiting
+    if n:
+        buf += s.read(n)
+    else:
+        time.sleep(0.05)
+s.close()
+
+text = buf.decode("utf-8", errors="replace")
+print("=== bytes: %d ===" % len(buf))
+print(text[:4000])
+if len(text) > 4000:
+    print("...(truncated)...")
+    print(text[-1500:])

+ 398 - 0
Application_CBD/doc/tools/console_test.py

@@ -0,0 +1,398 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+控制台自动化测试脚本(面向植物病菌孢子捕捉系统主控固件)
+
+前置条件(现场接线):
+  * 调试/控制台口(UART1, 115200-8N1) 接 PC 的 COM 口(默认 COM3)
+  * UART2(RTU/DTU 口) 的 TX-RX 短接(自环回)
+  * UART4(串口屏口) 的 TX-RX 短接(自环回)
+
+测试项:
+  T0 设备存活与控制台连通性
+  T1 设备/驱动枚举(list_device 应含 uart1/uart2/uart4)
+  T2 线程栈预算(解析 list_thread 的 max used 列;校验 Modbus 线程栈已放大)
+  T3 UART2 自环回(统计 uart2 接收字节增长;无外部设备接入时的闭环流量)
+  T4 UART4 自环回(ctr_lamp/ctr_led 触发 HMI 写 → 回环 → uart4 接收字节增长)
+  T5 RTU 安全重启路径回归(cmd_rtu_restart 后串口可恢复、回环仍工作)
+  T6 稳定性监测(扫描崩溃特征:stack overflow / hard fault / bus fault ...)
+  T7 固件内建环回自检(若固件含 uart_loop_test 命令则执行精确校验)
+
+用法:
+  python console_test.py [--port COM3] [--baud 115200] [--monitor 60] [--skip-restart]
+
+输出:
+  doc/test_logs/console_<时间戳>.log        原始控制台日志
+  doc/test_logs/自动化测试结果_<时间戳>.md  测试报告
+"""
+import argparse
+import os
+import re
+import sys
+import time
+import datetime
+
+import serial
+
+ANSI_RE = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+CRASH_RE = re.compile(
+    r"stack overflow|hard fault|hardfault|bus fault|usage fault|mem manage|"
+    r"PRECISERR|IMPRECISERR|assert failed|data abort",
+    re.IGNORECASE,
+)
+
+CRASH_THREAD_ROW_RE = re.compile(
+    r"^(?P<name>\S+)\s+(?P<pri>\d+)\s+(?P<status>\S+)\s+"
+    r"0x(?P<sp>[0-9a-fA-F]+)\s+0x(?P<size>[0-9a-fA-F]+)\s+"
+    r"(?P<used>\d+)%\s+0x(?P<tick>[0-9a-fA-F]+)\s+(?P<err>\d+)"
+)
+
+RX2_RE = re.compile(r"串口2累计接收字节[::]\s*(\d+)")
+RX4_RE = re.compile(r"串口4累计接收字节[::]\s*(\d+)")
+TX2_RE = re.compile(r"串口2累计发送字节[::]\s*(\d+)")
+TX4_RE = re.compile(r"串口4累计发送字节[::]\s*(\d+)")
+
+
+class Console(object):
+    def __init__(self, port, baud, logpath):
+        self.port = port
+        self.baud = baud
+        self.logpath = logpath
+        self.ser = None
+        self.logf = None
+        self.buf = ""
+
+    def open(self):
+        self.ser = serial.Serial(
+            port=self.port, baudrate=self.baud, bytesize=8,
+            parity="N", stopbits=1, timeout=0.05, write_timeout=1.0,
+        )
+        self.logf = open(self.logpath, "a", encoding="utf-8")
+        self.raw("\n===== console opened %s @ %d =====\n" %
+                 (self.port, self.baud))
+
+    def close(self):
+        if self.logf:
+            self.logf.flush()
+            self.logf.close()
+            self.logf = None
+        if self.ser and self.ser.is_open:
+            self.ser.close()
+
+    def raw(self, text):
+        if self.logf:
+            self.logf.write(text)
+            self.logf.flush()
+        sys.stdout.write(text)
+        sys.stdout.flush()
+
+    def read_until_idle(self, idle=0.6, max_wait=8.0):
+        """读到连续 idle 秒无数据为止(或超时)"""
+        got = []
+        t0 = time.time()
+        last = time.time()
+        while True:
+            n = self.ser.in_waiting
+            if n:
+                data = self.ser.read(n)
+                if data:
+                    got.append(data)
+                    last = time.time()
+            else:
+                time.sleep(0.03)
+            now = time.time()
+            if now - last >= idle or now - t0 >= max_wait:
+                break
+        text = b"".join(got).decode("utf-8", errors="replace")
+        self.raw(text)
+        self.buf += text
+        return text
+
+    def send(self, cmd, crlf="\r\n"):
+        self.raw("\n>>> %s\n" % cmd)
+        self.ser.write((cmd + crlf).encode())
+
+    def cmd(self, cmd, idle=0.6, max_wait=8.0):
+        self.send(cmd)
+        return self.read_until_idle(idle=idle, max_wait=max_wait)
+
+    def drain(self, seconds=1.0):
+        return self.read_until_idle(idle=seconds, max_wait=seconds + 1)
+
+
+class TestReport(object):
+    def __init__(self):
+        self.rows = []
+        self.logs = []
+
+    def add(self, name, ok, detail):
+        tag = "PASS" if ok else ("FAIL" if ok is False else "SKIP")
+        self.rows.append((name, tag, detail))
+        print("[%s] %s - %s" % (tag, name, detail))
+
+    def note(self, text):
+        self.logs.append(text)
+
+    def crash_free(self, text):
+        m = CRASH_RE.search(ANSI_RE.sub("", text))
+        return (m is None), (m.group(0) if m else "")
+
+    def markdown(self, extra):
+        lines = []
+        lines.append("# 控制台自动化测试结果\n")
+        lines.append("- 生成时间: %s" % datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+        lines.append("- 串口: %s @ %d 8N1" % (extra.get("port"), extra.get("baud")))
+        lines.append("- 接线: UART2 TX-RX 短接 / UART4 TX-RX 短接 / 调试口接 PC\n")
+        lines.append("| 测试项 | 结果 | 说明 |")
+        lines.append("| --- | --- | --- |")
+        for name, tag, detail in self.rows:
+            lines.append("| %s | **%s** | %s |" % (name, tag, detail.replace("|", "/")))
+        if extra.get("stacks"):
+            lines.append("\n## 线程栈实测(list_thread 的 max used)\n")
+            lines.append("| 线程 | 栈大小(B) | max used | 占用率 | 状态 |")
+            lines.append("| --- | --- | --- | --- | --- |")
+            for r in extra["stacks"]:
+                lines.append("| %s | %d | %d | %d%% | %s |" %
+                             (r["name"], r["size"], r["used_b"], r["used_pct"], r["status"]))
+        if extra.get("counters"):
+            lines.append("\n## 自环回流量统计\n")
+            lines.append("| 项目 | 起始 | 结束 | 增量(B) |")
+            lines.append("| --- | --- | --- | --- |")
+            for k, (a, b) in extra["counters"].items():
+                lines.append("| %s | %d | %d | %d |" % (k, a, b, b - a))
+        if self.logs:
+            lines.append("\n## 其它观测\n")
+            for t in self.logs:
+                lines.append("- " + t)
+        lines.append("\n## 原始日志\n")
+        lines.append("`%s`\n" % extra.get("logpath"))
+        return "\n".join(lines)
+
+
+def parse_threads(text):
+    rows = []
+    for line in ANSI_RE.sub("", text).splitlines():
+        m = CRASH_THREAD_ROW_RE.search(line.strip())
+        if not m:
+            continue
+        size = int(m.group("size"), 16)
+        pct = int(m.group("used"))
+        rows.append({
+            "name": m.group("name"),
+            "status": m.group("status"),
+            "size": size,
+            "used_pct": pct,
+            "used_b": size * pct // 100,
+        })
+    return rows
+
+
+def last_match(regex, text, default=None):
+    vals = regex.findall(ANSI_RE.sub("", text))
+    return int(vals[-1]) if vals else default
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--port", default="COM3")
+    ap.add_argument("--baud", type=int, default=115200)
+    ap.add_argument("--monitor", type=int, default=60, help="稳定性监测秒数")
+    ap.add_argument("--skip-restart", action="store_true")
+    ap.add_argument("--watch", type=int, default=0, help="纯监视模式秒数")
+    args = ap.parse_args()
+
+    if args.watch > 0:
+        return watch(args)
+
+    here = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # doc/
+    outdir = os.path.join(here, "test_logs")
+    os.makedirs(outdir, exist_ok=True)
+    ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    logpath = os.path.join(outdir, "console_%s.log" % ts)
+    mdpath = os.path.join(outdir, "自动化测试结果_%s.md" % ts)
+
+    rpt = TestReport()
+    con = Console(args.port, args.baud, logpath)
+    try:
+        con.open()
+    except Exception as e:
+        print("打开 %s 失败: %s" % (args.port, e))
+        print("请确认串口未被其它终端占用后重试。")
+        return 2
+
+    extra = {"port": args.port, "baud": args.baud, "logpath": logpath,
+             "stacks": [], "counters": {}}
+
+    try:
+        # ---------- T0 存活 + T1 设备枚举 ----------
+        con.drain(1.5)                      # 先收集启动/周期日志
+        alive_ok, crash = rpt.crash_free(con.buf)
+        rpt.add("T0 设备存活/无崩溃日志", alive_ok,
+                "未发现崩溃特征" if alive_ok else ("发现: " + crash))
+
+        t1 = con.cmd("list_device")
+        dev_ok = ("uart1" in t1) and ("uart2" in t1) and ("uart4" in t1)
+        rpt.add("T1 设备枚举(uart1/2/4)", dev_ok,
+                "uart1/uart2/uart4 均在设备表" if dev_ok else "设备表缺少期望串口")
+
+        # ---------- T2 线程栈预算 ----------
+        t2 = con.cmd("list_thread", idle=0.8, max_wait=6)
+        stacks = parse_threads(t2)
+        extra["stacks"] = sorted(stacks, key=lambda r: -r["used_pct"])
+        if stacks:
+            worst = extra["stacks"][0]
+            over = [r for r in stacks if r["used_pct"] >= 80]
+            mbth = [r for r in stacks if r["name"].startswith("md_m_s")]
+            mb_ok = bool(mbth) and all(r["size"] >= 1024 for r in mbth)
+            rpt.add("T2 线程栈预算", len(over) == 0,
+                    "共 %d 个线程, 最高占用 %s=%d%%; 无 >=80%% 的线程"
+                    % (len(stacks), worst["name"], worst["used_pct"])
+                    if not over else "存在高占用线程: " +
+                    ", ".join("%s=%d%%" % (r["name"], r["used_pct"]) for r in over))
+            rpt.add("T2b Modbus 线程栈已放大(>=1024B)", mb_ok,
+                    ", ".join("%s=%dB" % (r["name"], r["size"]) for r in mbth) or
+                    "未找到 md_m_send/md_m_poll")
+        else:
+            rpt.add("T2 线程栈预算", None, "未能解析 list_thread 输出")
+
+        # ---------- T3/T4 自环回:基线计数 ----------
+        base = con.read_until_idle(idle=schedule_idle(args), max_wait=args.monitor)
+        c2a = last_match(RX2_RE, base)
+        c4a = last_match(RX4_RE, base)
+        done_ok, crash = rpt.crash_free(base)
+
+        # T4 主动触发 UART4 写(HMI 指令回环)
+        con.cmd("ctr_lamp ON")
+        con.cmd("ctr_led ON")
+        time.sleep(0.5)
+        con.cmd("ctr_lamp OFF")
+        con.cmd("ctr_led OFF")
+
+        # ---------- T5 RTU 安全重启回归 ----------
+        if not args.skip_restart:
+            rpt.add("T5 RTU 安全重启(关闭->30s->恢复->重注册RX)",
+                    True, "开始执行 cmd_rtu_restart ...")
+            con.cmd("cmd_rtu_restart", idle=1.0, max_wait=5)
+            t_after = con.read_until_idle(idle=schedule_idle(args), max_wait=60)
+            alive2, crash2 = rpt.crash_free(t_after)
+            rpt.add("T5b 重启后设备存活", alive2,
+                    "未发现崩溃特征" if alive2 else ("发现: " + crash2))
+            t5 = con.cmd("list_thread", idle=0.8, max_wait=6)
+            rpt.add("T5c 重启后线程表可读", len(parse_threads(t5)) > 3,
+                    "解析到 %d 个线程" % len(parse_threads(t5)))
+
+        # ---------- T7 固件内建环回自检(可选) ----------
+        t7 = con.cmd("uart_loop_test", idle=0.8, max_wait=5)
+        if re.search(r"not found|未找到|command not", t7, re.IGNORECASE):
+            rpt.add("T7 固件内建环回自检(uart_loop_test)", None,
+                    "当前固件未包含该命令(需烧录含自检命令的版本)")
+        else:
+            ok_all = True
+            for plate in (("2", "64"), ("2", "512"), ("2", "2048"), ("4", "64"), ("4", "512")):
+                out = con.cmd("uart_loop_test %s %s" % plate, idle=1.0, max_wait=12)
+                if "PASS" not in out:
+                    ok_all = False
+            rpt.add("T7 固件内建环回自检(uart_loop_test)", ok_all,
+                    "全部用例 PASS" if ok_all else "存在 FAIL 用例,详见日志")
+
+        # ---------- T3/T6 最终计数 + 稳定性 ----------
+        tail = con.read_until_idle(idle=schedule_idle(args), max_wait=args.monitor)
+        c2b = last_match(RX2_RE, tail, c2a)
+        c4b = last_match(RX4_RE, tail, c4a)
+        c2xa = last_match(TX2_RE, base)
+        c2xb = last_match(TX2_RE, tail, c2xa)
+        if c2a is not None and c2b is not None:
+            extra["counters"]["uart2_rx"] = (c2a, c2b)
+            extra["counters"]["uart4_rx"] = (c4a or 0, c4b or 0)
+            if c2xa is not None and c2xb is not None:
+                extra["counters"]["uart2_tx"] = (c2xa, c2xb)
+            rpt.add("T3 UART2 自环回(接收字节增长)", (c2b - c2a) > 0,
+                    "uart2 rx: %d -> %d (+%d)" % (c2a, c2b, c2b - c2a))
+            rpt.add("T4 UART4 自环回(接收字节增长)", ((c4b or 0) - (c4a or 0)) > 0,
+                    "uart4 rx: %d -> %d (+%d)" % (c4a or 0, c4b or 0, (c4b or 0) - (c4a or 0)))
+        else:
+            rpt.add("T3 UART2 自环回", None,
+                    "未捕获到 sys_monitor 的串口计数日志(需要 LOG_D 级别日志)")
+
+        whole = con.buf
+        ok, crash = rpt.crash_free(whole)
+        rpt.add("T6 全过程稳定性(无崩溃特征)", ok,
+                "全程未出现 stack overflow/hard fault" if ok else ("发现: " + crash))
+        rpt.note("累计捕获控制台日志 %d 字节" % len(whole))
+    finally:
+        con.close()
+
+    md = rpt.markdown(extra)
+    with open(mdpath, "w", encoding="utf-8") as f:
+        f.write(md)
+    print("\n=== 测试报告: %s ===" % mdpath)
+    print("\n".join(md.splitlines()[4:16]))
+    return 0
+
+
+
+def watch(args):
+    """长时监视:周期采样串口计数/上传条数,捕获一次自然上传以验证自环回"""
+    import re as _re
+    here = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    outdir = os.path.join(here, "test_logs")
+    os.makedirs(outdir, exist_ok=True)
+    ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    logpath = os.path.join(outdir, "watch_%s.log" % ts)
+
+    con = Console(args.port, args.baud, logpath)
+    con.open()
+    up_re = _re.compile(r"累计上传数据[::]\s*(\d+)")
+    t_end = time.time() + args.watch
+    last = {"uart2_tx": None, "uart2_rx": None, "uart4_tx": None,
+            "uart4_rx": None, "upload": None}
+    events = []
+    crash_hit = None
+    print("watch for %d s (sample every 15s) ..." % args.watch)
+    try:
+        while time.time() < t_end:
+            txt = con.read_until_idle(idle=15.0, max_wait=20.0)
+            clean = ANSI_RE.sub("", txt)
+            for line in clean.splitlines():
+                if CRASH_RE.search(line):
+                    crash_hit = line.strip()
+                    events.append(("CRASH", line.strip()))
+            m = last_match(TX2_RE, clean)
+            if m is None:
+                m = last_match(RX2_RE, clean)
+            vals = {
+                "uart2_tx": last_match(TX2_RE, clean),
+                "uart2_rx": last_match(RX2_RE, clean),
+                "uart4_tx": last_match(TX4_RE, clean),
+                "uart4_rx": last_match(RX4_RE, clean),
+                "upload": last_match(up_re, clean),
+            }
+            stamp = datetime.datetime.now().strftime("%H:%M:%S")
+            delta = []
+            for k in vals:
+                v = vals[k]
+                if v is None:
+                    continue
+                if last[k] is not None and v != last[k]:
+                    delta.append("%s %d->%d(+%d)" % (k, last[k], v, v - last[k]))
+                last[k] = v
+            info = ", ".join("%s=%s" % (k, vals[k]) for k in vals if vals[k] is not None)
+            line_out = "[%s] %s%s" % (stamp, info, ("  || " + "; ".join(delta)) if delta else "")
+            print(line_out)
+            events.append(("SAMPLE", line_out))
+    finally:
+        con.close()
+    print("\n===== watch 汇总 =====")
+    print("崩溃特征: %s" % (crash_hit if crash_hit else "无"))
+    for tag, line in events:
+        if tag == "SAMPLE" and "->" in line:
+            print("变化事件: " + line)
+    return 0
+
+def schedule_idle(args):
+    """等待 sys_monitor 的 10s 周期日志至少出现两次"""
+    return 11.0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

+ 73 - 0
Application_CBD/doc/tools/counter_probe.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""在命令执行前后采集串口计数器,判断"自检发送的数据是否真的被硬件接收"。
+
+用法: python counter_probe.py <port> <command> [pre_seconds] [post_seconds]
+"""
+import re
+import sys
+import time
+
+import serial
+
+ANSI = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+RX2 = re.compile(r"串口2累计接收字节[::]\s*(\d+)")
+TX2 = re.compile(r"串口2累计发送字节[::]\s*(\d+)")
+RX4 = re.compile(r"串口4累计接收字节[::]\s*(\d+)")
+TX4 = re.compile(r"串口4累计发送字节[::]\s*(\d+)")
+UP = re.compile(r"累计上传数据[::]\s*(\d+)")
+
+
+def collect(ser, seconds):
+    """读取 seconds 秒,返回最后一次看到的各计数器值"""
+    last = {}
+    keys = [("rx2", RX2), ("tx2", TX2), ("rx4", RX4), ("tx4", TX4), ("up", UP)]
+    deadline = time.time() + seconds
+    buf = ""
+    while time.time() < deadline:
+        chunk = ser.read(4096)
+        if not chunk:
+            continue
+        buf += ANSI.sub("", chunk.decode("utf-8", "replace"))
+        for name, rx in keys:
+            m = rx.findall(buf)
+            if m:
+                last[name] = int(m[-1])
+        # 保留尾部,避免 buf 无限增长(一个报文可能跨 chunk)
+        if len(buf) > 20000:
+            buf = buf[-4000:]
+    return last
+
+
+def main():
+    port = sys.argv[1] if len(sys.argv) > 1 else "COM3"
+    cmd = sys.argv[2] if len(sys.argv) > 2 else "uart_loop_test 2 64"
+    pre = float(sys.argv[3]) if len(sys.argv) > 3 else 4.0
+    post = float(sys.argv[4]) if len(sys.argv) > 4 else 8.0
+
+    with serial.Serial(port, 115200, timeout=0.2, write_timeout=2) as ser:
+        ser.reset_input_buffer()
+        print("[*] 基线采集 %.0fs ..." % pre)
+        before = collect(ser, pre)
+        print("    before:", before)
+
+        print("[*] 发送命令: %s" % cmd)
+        ser.write(cmd.encode("utf-8", "replace") + b"\r\n")
+        ser.flush()
+
+        print("[*] 后置采集 %.0fs ..." % post)
+        after = collect(ser, post)
+        print("    after :", after)
+
+        print("\n[*] 增量:")
+        for k in ("rx2", "tx2", "rx4", "tx4", "up"):
+            b, a = before.get(k), after.get(k)
+            if b is None or a is None:
+                print("    %-4s : (缺数据)" % k)
+            else:
+                print("    %-4s : %d -> %d  (%+d)" % (k, b, a, a - b))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

+ 82 - 0
Application_CBD/doc/tools/gen_su.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# 为指定源文件生成 -fstack-usage (.su) 数据,供 stack_usage.py 做线程栈深度分析。
+#
+# 用途:stack_usage.py 需要 .su 才能拿到精确的栈帧大小;gcc 默认不生成 .su,
+#       必须用 -fstack-usage 重新编译。本脚本复用 Debug/ 下 makefile 的真实编译参数,
+#       保证与正式固件完全一致的优化级别(-Os 下栈帧与 -O0 差异很大,不能随便编译)。
+#
+# 用法:
+#   bash doc/tools/gen_su.sh                 # 默认重编 control/dtu_uart2/hmi/selfcheck
+#   bash doc/tools/gen_su.sh applications/foo.c applications/bar.c
+#   RTT_TOOLCHAIN_BIN=/path/to/bin bash doc/tools/gen_su.sh
+#
+# 之后:
+#   python doc/tools/stack_usage.py <elf> /tmp/su <输出目录>
+#
+set -u
+cd "$(dirname "$0")/../.." || exit 1          # 项目根目录
+ROOT=$(pwd)
+
+# ---- 定位工具链(与 stack_usage.py 同一套规则)----
+# 注意:必须与生成该 elf 的编译器版本一致。本机同时装了 5.4.1 与 6.3.1 两套,
+# 实测同一份 control.c 用 5.4.1 编译,多个函数栈帧会小 8 字节(内联决策不同),
+# 会得出错误的栈预算结论。因此这里收集全部候选后取最高版本,并回显实际版本号。
+find_tc() {
+  if [ -n "${RTT_TOOLCHAIN_BIN:-}" ] && [ -d "$RTT_TOOLCHAIN_BIN" ]; then
+    echo "$RTT_TOOLCHAIN_BIN"; return
+  fi
+  for d in /d/RT-ThreadStudio /c/RT-ThreadStudio; do
+    for p in "$d"/repo/Extract/ToolChain_Support_Packages/ARM/GNU_Tools_for_ARM_Embedded_Processors/*/bin; do
+      [ -x "$p/arm-none-eabi-gcc.exe" ] && echo "$p"
+    done
+  done
+}
+TC=$(find_tc | sort -V | tail -1)
+if [ -z "$TC" ]; then echo "未找到 arm-none-eabi 工具链,请设置 RTT_TOOLCHAIN_BIN"; exit 1; fi
+echo "toolchain: $TC"
+echo "version:   $("$TC/arm-none-eabi-gcc" --version 2>/dev/null | head -1)"
+
+# ---- 生成 .su 输出目录 ----
+if [ -n "${SU_OUT:-}" ]; then
+  OUT="$SU_OUT"
+else
+  OUT=/tmp/su_"$(date +%Y%m%d_%H%M%S)"
+fi
+mkdir -p "$OUT"
+echo "output:    $OUT"
+
+# ---- 从 makefile 取真实编译参数 ----
+MK=Debug/applications/subdir.mk
+if [ ! -f "$MK" ]; then
+  echo "缺少 $MK(需先在 RT-Thread Studio / scons 里编译过一次,以便拿到编译参数)"
+  exit 1
+fi
+RECIPE=$(grep -m1 "^	arm-none-eabi-gcc" "$MK" | sed 's/^\t//')
+[ -z "$RECIPE" ] && { echo "未在 $MK 中找到编译规则"; exit 1; }
+# 去掉编译器名,截断到 -MMD 之前(保留 -D/-I/-include/-std 等),与正式构建参数一致
+BASE="${RECIPE#arm-none-eabi-gcc }"
+BASE="${BASE%% -MMD*}"
+
+# ---- 待处理文件:命令行参数,或默认的 4 个(10-02 改动文件)----
+if [ $# -gt 0 ]; then FILES=("$@"); else
+  FILES=(applications/control.c applications/dtu_uart2.c applications/hmi.c applications/selfcheck.c)
+fi
+
+fail=0
+for SRC in "${FILES[@]}"; do
+  [ -f "$SRC" ] || { echo "跳过(不存在): $SRC"; fail=1; continue; }
+  base=$(basename "$SRC" .c)
+  printf -- '--- %s ---\n' "$SRC"
+  # eval 让引号按 Makefile 的方式被剥离(-I/-include 的路径含反斜杠,不能自己拆词)
+  eval "\"$TC/arm-none-eabi-gcc\" $BASE -fstack-usage -c -o \"$OUT/$base.o\" \"$SRC\"" 2>&1 \
+      | grep -E "error|警告|warning" | head -5
+  if [ -f "$OUT/$base.su" ]; then
+    echo "    OK: $(wc -l < "$OUT/$base.su") 个函数栈帧"
+  else
+    echo "    失败:未生成 .su"; fail=1
+  fi
+done
+
+echo
+echo "下一步:python doc/tools/stack_usage.py <elf> /tmp/su \"$OUT\""
+exit $fail

+ 9 - 0
Application_CBD/doc/tools/list_ports.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""串口枚举与连通性探测(列出本机可用串口)"""
+from serial.tools import list_ports
+
+ports = list(list_ports.comports())
+print("serial port count:", len(ports))
+for p in ports:
+    print(" -", p.device, "|", p.description, "|", p.hwid)

+ 50 - 0
Application_CBD/doc/tools/probe_uarts.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""针对性探测:list_device(串口 open 标志)+ list_thread(线程状态)"""
+import re
+import sys
+import time
+import serial
+
+port = sys.argv[1] if len(sys.argv) > 1 else "COM3"
+ANSI = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+
+s = serial.Serial(port=port, baudrate=115200, bytesize=8, parity="N",
+                  stopbits=1, timeout=0.05)
+
+
+def read_idle(idle=0.8, max_wait=6.0):
+    got, t0, last = [], time.time(), time.time()
+    while True:
+        n = s.in_waiting
+        if n:
+            got.append(s.read(n))
+            last = time.time()
+        else:
+            time.sleep(0.03)
+        if time.time() - last >= idle or time.time() - t0 >= max_wait:
+            break
+    return b"".join(got).decode("utf-8", errors="replace")
+
+
+def cmd(c, idle=0.8, max_wait=6.0):
+    s.write((c + "\r\n").encode())
+    return read_idle(idle, max_wait)
+
+
+def show(title, text, pattern=None):
+    print("\n########## %s ##########" % title)
+    for line in ANSI.sub("", text).splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        if pattern and not re.search(pattern, line):
+            continue
+        print(line)
+
+
+out = cmd("list_device")
+show("list_device", out, r"uart|adc|pwm|i2c|spi|Device|device|类型|name")
+out = cmd("list_thread")
+show("list_thread", out, r"thread|---|Hmi|hmi|dtu|work|md_m|Power|adc|sysmon|timer|tidle|tshell|main|clean|heat|Ctr")
+s.close()

+ 39 - 0
Application_CBD/doc/tools/send_cmd.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""向控制台发送一条命令,并完整抓取随后 N 秒的原始日志(不在提示符处提前退出)。
+
+用法: python send_cmd.py <port> <command> [capture_seconds]
+      python send_cmd.py COM3 'dtu_send {"cmd":"read"}' 10
+"""
+import re
+import sys
+import time
+
+import serial
+
+ANSI = re.compile(r"\x1b\[[0-9;]*[A-Za-z]")
+
+
+def main():
+    port = sys.argv[1] if len(sys.argv) > 1 else "COM3"
+    cmd = sys.argv[2] if len(sys.argv) > 2 else "help"
+    wait = float(sys.argv[3]) if len(sys.argv) > 3 else 6.0
+
+    with serial.Serial(port, 115200, timeout=0.2, write_timeout=2) as ser:
+        ser.reset_input_buffer()
+        time.sleep(0.3)
+        ser.write(cmd.encode("utf-8", "replace") + b"\r\n")
+        ser.flush()
+
+        deadline = time.time() + wait
+        buf = b""
+        while time.time() < deadline:
+            chunk = ser.read(4096)
+            if chunk:
+                buf += chunk
+        print(ANSI.sub("", buf.decode("utf-8", "replace")))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

+ 229 - 0
Application_CBD/doc/tools/stack_usage.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+静态栈深度分析工具(RT-Thread / Cortex-M 固件)
+用途:从编译产物(.elf) + -fstack-usage 结果(.su) 反推每个线程入口的最坏栈深度,
+     用于定位"栈溢出"类 HardFault(如 rt_thread_stack_check 误报/真溢出)。
+
+用法:
+  python stack_usage.py <elf> <su_dir...> [--entry func ...]
+"""
+import re
+import sys
+import os
+import glob
+import shutil
+import subprocess
+from collections import defaultdict
+
+
+def _find_toolchain():
+    """定位 arm-none-eabi-* 所在目录。
+    顺序:环境变量 RTT_TOOLCHAIN_BIN > RT-Thread Studio 安装目录 > PATH。
+    工具链不在 PATH 时若直接调用会静默返回空输出,导致"无入口函数"的假象。
+    """
+    env = os.environ.get("RTT_TOOLCHAIN_BIN")
+    if env and os.path.isdir(env):
+        return env
+    pats = [
+        r"D:/RT-ThreadStudio/repo/Extract/ToolChain_Support_Packages/ARM/"
+        r"GNU_Tools_for_ARM_Embedded_Processors/*/bin",
+        r"C:/RT-ThreadStudio/repo/Extract/ToolChain_Support_Packages/ARM/"
+        r"GNU_Tools_for_ARM_Embedded_Processors/*/bin",
+        r"D:/RT-ThreadStudio/**/GNU_Tools_for_ARM_Embedded_Processors/*/bin",
+    ]
+    cands = []
+    for p in pats:
+        cands += glob.glob(p, recursive=True)
+    cands.sort(reverse=True)          # 取版本号较大的
+    for c in cands:
+        if os.path.isfile(os.path.join(c, "arm-none-eabi-objdump.exe")) or \
+           os.path.isfile(os.path.join(c, "arm-none-eabi-objdump")):
+            return c
+    return None
+
+
+_TC = _find_toolchain()
+_EXE = ".exe" if os.name == "nt" else ""
+
+
+def _tool(name):
+    """优先用定位到的工具链,否则回退到 PATH"""
+    if _TC:
+        p = os.path.join(_TC, name + _EXE)
+        if os.path.isfile(p):
+            return '"%s"' % p
+    return name
+
+
+OBJDUMP = _tool("arm-none-eabi-objdump")
+NM = _tool("arm-none-eabi-nm")
+
+
+def run(cmd):
+    # errors="replace":objdump/nm 输出中可能混入非 UTF-8 字节(调试信息里的中文路径等),
+    # Windows 下默认按 locale 解码会直接抛 UnicodeDecodeError
+    return subprocess.run(cmd, shell=True, capture_output=True,
+                          text=True, errors="replace").stdout
+
+
+def load_symbols(elf):
+    """地址 -> (名字, 大小)"""
+    out = run(f'{NM} -S --defined-only "{elf}"')
+    syms = []
+    for line in out.splitlines():
+        p = line.split()
+        if len(p) < 3:
+            continue
+        try:
+            addr = int(p[0], 16)
+        except ValueError:
+            continue
+        size = 0
+        name = p[2]
+        if len(p) >= 4:
+            try:
+                size = int(p[1], 16)
+                name = p[3]
+            except ValueError:
+                name = p[2]
+        syms.append((addr, size, name))
+    syms.sort()
+    return syms
+
+
+def addr_to_sym(syms, addr):
+    lo, hi = 0, len(syms) - 1
+    best = None
+    while lo <= hi:
+        mid = (lo + hi) // 2
+        if syms[mid][0] <= addr:
+            best = mid
+            lo = mid + 1
+        else:
+            hi = mid - 1
+    if best is None:
+        return None
+    a, s, n = syms[best]
+    if s and addr >= a + s:
+        return None
+    return n
+
+
+def load_frames(su_dirs):
+    """函数名 -> 栈帧字节数,来自 -fstack-usage (.su)"""
+    frames = {}
+    for d in su_dirs:
+        if not os.path.isdir(d):
+            continue
+        for fn in os.listdir(d):
+            if not fn.endswith(".su"):
+                continue
+            with open(os.path.join(d, fn), errors="ignore") as f:
+                for line in f:
+                    parts = line.split("\t")
+                    if len(parts) < 2:
+                        continue
+                    m = re.match(r".*?:(\d+):(\d+):(\w+)", parts[0])
+                    if not m:
+                        continue
+                    name = m.group(3)
+                    try:
+                        frames[name] = int(parts[1])
+                    except ValueError:
+                        pass
+    return frames
+
+
+def parse_disasm(elf):
+    """函数名 -> (自身帧估算, [被调用函数名])"""
+    out = run(f'{OBJDUMP} -d "{elf}"')
+    funcs = {}
+    cur = None
+    for line in out.splitlines():
+        m = re.match(r"^([0-9a-f]{8}) <([^>]+)>:", line)
+        if m:
+            cur = m.group(2)
+            funcs[cur] = {"push": 0, "sub": 0, "calls": []}
+            continue
+        if cur is None:
+            continue
+        if re.search(r"\tbl\t", line) or re.search(r"\tbl\.w\t", line):
+            t = re.search(r"<([^>+]+)(\+0x[0-9a-f]+)?>", line)
+            if t:
+                funcs[cur]["calls"].append(t.group(1))
+        else:
+            m2 = re.search(r"\tpush\t\{([^}]*)\}", line)
+            if m2:
+                funcs[cur]["push"] = max(funcs[cur]["push"], 4 * (m2.group(1).count(",") + 1))
+            m3 = re.search(r"\tsub\tsp, #(\d+)", line)
+            if m3:
+                funcs[cur]["sub"] = max(funcs[cur]["sub"], int(m3.group(1)))
+    return funcs
+
+
+EXCLUDES = {"list_thread", "rt_hw_hard_fault_exception", "object_split", "object_split.constprop.1", "list_get_next"}
+
+
+def main():
+    elf = sys.argv[1]
+    su_dirs = []
+    entries = []
+    i = 2
+    while i < len(sys.argv):
+        if sys.argv[i] == "--entry":
+            entries = sys.argv[i + 1:]
+            break
+        su_dirs.append(sys.argv[i])
+        i += 1
+
+    frames = load_frames(su_dirs)
+    funcs = parse_disasm(elf)
+
+    def frame_of(name):
+        if name in frames:
+            return frames[name]
+        if name in funcs:
+            return funcs[name]["push"] + funcs[name]["sub"]
+        return 0
+
+    global EXCLUDES
+    if not entries:
+        entries = [n for n in funcs if n.endswith("_entry")]
+
+    INF = 1 << 30
+
+    def worst(name, path, memo):
+        """返回 (最坏栈深度, 最深路径)"""
+        if name in path:
+            return (0, [])
+        if name in memo:
+            return memo[name]
+        f = frame_of(name)
+        best = (0, [])
+        for c in funcs.get(name, {}).get("calls", []):
+            if c not in funcs or c in EXCLUDES:
+                continue
+            d, p = worst(c, path | {name}, memo)
+            if d > best[0]:
+                best = (d, p)
+        res = (f + best[0], [name] + best[1])
+        memo[name] = res
+        return res
+
+    print(f"{'entry':34s} {'deepest-path-bytes':>18s}   path")
+    print("-" * 110)
+    rows = []
+    for e in entries:
+        if e not in funcs:
+            continue
+        memo = {}
+        d, p = worst(e, set(), memo)
+        rows.append((d, e, p))
+    for d, e, p in sorted(rows, reverse=True):
+        chain = " -> ".join(p[:8]) + (" -> ..." if len(p) > 8 else "")
+        print(f"{e:34s} {d:18d}   {chain}")
+
+
+if __name__ == "__main__":
+    main()

+ 20 - 0
Application_CBD/doc/代码分析.md

@@ -0,0 +1,20 @@
+你是一名嵌入式代码审查工程师。请审查项目的 C/C++ 固件代码。
+
+硬件平台:APM32F103RET6 128KBRAM 512KB FLASH
+运行环境:RT-Thread
+约束条件:资源受限、实时性要求、中断安全、低功耗、串口/外设通信稳定性。
+
+请重点检查:
+- 中断安全与竞态条件
+- 缓冲区溢出、指针越界、野指针
+- 内存分配与泄漏
+- 外设初始化顺序
+- 串口/通信协议解析健壮性
+- 超时、重试、错误恢复
+- 寄存器或引脚配置是否正确
+- 日志、断言、错误码是否完善
+
+输出:
+1. 功能理解
+2. 风险清单
+3. 改进建议

文件差异内容过多而无法显示
+ 239 - 0
Application_CBD/doc/代码审查修复记录.md


文件差异内容过多而无法显示
+ 304 - 0
Application_CBD/doc/代码审查报告.md


Application_CBD/线程分配.xls → Application_CBD/doc/线程分配.xls


文件差异内容过多而无法显示
+ 267 - 0
Application_CBD/doc/自动化测试方案.md


+ 7 - 4
Application_CBD/drivers/board.c

@@ -359,11 +359,14 @@ void HAL_ADC_MspInit(ADC_HandleTypeDef* hadc)
     __HAL_RCC_GPIOC_CLK_ENABLE();
     __HAL_RCC_GPIOA_CLK_ENABLE();
     /**ADC1 GPIO Configuration
-    PC0     ------> ADC1_IN10
-    PA0-WKUP     ------> ADC1_IN0
-    PA1     ------> ADC1_IN1
+    PC0     ------> ADC1_IN10  光控(Read_Light_Voltage)
+    PC1     ------> ADC1_IN11  雨控(Read_Rain_Voltage)
+    PC2     ------> ADC1_IN12  加热/培养仓温度NTC(Read_Ntc_Voltage)
+    PC3     ------> ADC1_IN13  保险丝后电压(Read_Fuse_Voltage)
+    PA0-WKUP------> ADC1_IN0   电流(Read_Real_Current)
+    PA1     ------> ADC1_IN1   电压(Read_Real_Voltage)
     */
-    GPIO_InitStruct.Pin = GPIO_PIN_0;
+    GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3;
     GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
     HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 

+ 23 - 6
Application_CBD/drivers/drv_flash_f1.c

@@ -79,6 +79,7 @@ int stm32_flash_write(rt_uint32_t addr, const rt_uint8_t *buf, size_t size)
 {
     rt_err_t result        = RT_EOK;
     rt_uint32_t end_addr   = addr + size;
+    rt_base_t level;
 
     if (addr % 4 != 0)
     {
@@ -91,15 +92,32 @@ int stm32_flash_write(rt_uint32_t addr, const rt_uint8_t *buf, size_t size)
         LOG_E("write outrange flash size! addr is (0x%p)", (void *)(addr + size));
         return -RT_EINVAL;
     }
-    //APM32此处关闭中断
-    __disable_irq();
+    /* APM32 片内 Flash 编程期间需关闭中断。
+     * 使用 rt_hw_interrupt_disable/rt_hw_interrupt_enable 保存并恢复中断状态,
+     * 避免嵌套临界区被 __enable_irq() 提前打开。 */
+    level = rt_hw_interrupt_disable();
     HAL_FLASH_Unlock();
 
     while (addr < end_addr)
     {
-        if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, addr, *((rt_uint32_t *)buf)) == HAL_OK)
+        rt_uint32_t word;
+        size_t remain = (size_t)(end_addr - addr);
+
+        if (remain >= 4)
+        {
+            rt_memcpy(&word, buf, 4);
+        }
+        else
+        {
+            /* 尾部不足一个字的:高位用 0xFF 补齐(NOR 编程只会清位,
+             * 不会破坏已擦除区域),同时避免越界读取 buf */
+            word = 0xFFFFFFFFu;
+            rt_memcpy(&word, buf, remain);
+        }
+
+        if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, addr, word) == HAL_OK)
         {
-            if (*(rt_uint32_t *)addr != *(rt_uint32_t *)buf)
+            if (*(rt_uint32_t *)addr != word)
             {
                 result = -RT_ERROR;
                 break;
@@ -115,8 +133,7 @@ int stm32_flash_write(rt_uint32_t addr, const rt_uint8_t *buf, size_t size)
     }
 
     HAL_FLASH_Lock();
-    //打开中断
-    __enable_irq();
+    rt_hw_interrupt_enable(level);
     if (result != RT_EOK)
     {
         return result;

+ 57 - 6
Application_CBD/drivers/drv_usart.c

@@ -626,6 +626,15 @@ static const struct rt_uart_ops stm32_uart_ops =
     .dma_transmit = stm32_dma_transmit
 };
 
+/* [BZY FIX] 判断 DMA 接收通道是否真的在运行。
+ * DMA 停用(或 HAL_UART_Receive_DMA 失败、从未武装)时 CNDTR 会读回 0,
+ * 若仍用它推算"已收多少字节",会得到"整个缓冲区都已收满"的错误结论,
+ * 进而写坏 rx_fifo 的 put_index / is_full —— 应用侧表现为读出 bufsz 字节全 0,
+ * 同时掩盖"接收链路已死"这一真实故障。 */
+#define STM32_DMA_RX_RUNNING(uart)                                            \
+    ((((uart)->dma_rx.handle.Instance) != RT_NULL) &&                          \
+     (((((uart)->dma_rx.handle.Instance)->CCR) & DMA_CCR_EN) != 0U))
+
 /**
  * Uart common interrupt process. This need add to uart ISR.
  *
@@ -653,9 +662,20 @@ static void uart_isr(struct rt_serial_device *serial)
              && (__HAL_UART_GET_IT_SOURCE(&(uart->handle), UART_IT_IDLE) != RESET))
     {
         level = rt_hw_interrupt_disable();
-        recv_total_index = serial->config.bufsz - __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
-        recv_len = recv_total_index - uart->dma_rx.last_index;
-        uart->dma_rx.last_index = recv_total_index;
+        /* [BZY FIX] 只有 DMA 通道确实在运行时,CNDTR 才能用来推算已收长度。
+         * DMA 停用/未成功武装时 CNDTR 读回 0,会被算成"整缓冲区都收到了",
+         * 进而写坏 rx_fifo 的 put_index/is_full(现象:应用读出 bufsz 字节全 0)。
+         * 该情形下按"本次无可信新数据"处理,不累加长度。*/
+        if (STM32_DMA_RX_RUNNING(uart))
+        {
+            recv_total_index = serial->config.bufsz - __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
+            recv_len = recv_total_index - uart->dma_rx.last_index;
+            uart->dma_rx.last_index = recv_total_index;
+        }
+        else
+        {
+            recv_len = 0;
+        }
         rt_hw_interrupt_enable(level);
 
         if (recv_len)
@@ -734,16 +754,32 @@ static void dma_isr(struct rt_serial_device *serial)
     if ((__HAL_DMA_GET_IT_SOURCE(&(uart->dma_rx.handle), DMA_IT_TC) != RESET) ||
             (__HAL_DMA_GET_IT_SOURCE(&(uart->dma_rx.handle), DMA_IT_HT) != RESET))
     {
+        /* [BZY FIX] DMA 未运行时不推算长度,避免 CNDTR=0 被误算成"整缓冲区已收满"。
+         * 另:last_index == 0 且 recv_total_index == 0 时,原式会得出
+         * bufsz - 0 = bufsz(虚报整缓冲区),这也是"读出 2048 字节全 0"的直接来源。*/
+        if (!STM32_DMA_RX_RUNNING(uart))
+        {
+            return;
+        }
         level = rt_hw_interrupt_disable();
         recv_total_index = serial->config.bufsz - __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
         if (recv_total_index == 0)
         {
             recv_len = serial->config.bufsz - uart->dma_rx.last_index;
         }
-        else
+        else if (recv_total_index >= uart->dma_rx.last_index)
         {
             recv_len = recv_total_index - uart->dma_rx.last_index;
         }
+        else
+        {
+            /* 索引回绕:本次无法可靠推算增量,交由 IDLE 路径处理,宁少报不误报 */
+            recv_len = 0;
+        }
+        if (recv_len > serial->config.bufsz)
+        {
+            recv_len = serial->config.bufsz;
+        }
         uart->dma_rx.last_index = recv_total_index;
         rt_hw_interrupt_enable(level);
 
@@ -1174,10 +1210,21 @@ static void stm32_dma_config(struct rt_serial_device *serial, rt_ubase_t flag)
     if (flag == RT_DEVICE_FLAG_DMA_RX)
     {
         rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+        /* [BZY FIX] 重新武装 DMA 前必须把 HAL 的接收状态机复位为 READY。
+         * 原因:HAL_UART_Receive_DMA() 开头就是
+         *     if (huart->RxState == HAL_UART_STATE_READY) {...} else return HAL_BUSY;
+         * 而 RxState 只由 HAL 自己的接收完成回调复位;本驱动绕开 HAL 接收路径、
+         * 自己处理 IDLE 中断,所以 RxState 会永远停在 BUSY_RX ——
+         * 第二次调用(即任何 rt_device_close()+rt_device_open() 之后)直接返回
+         * HAL_BUSY,DMA 根本没被武装,接收链路永久失效(且下面的 RT_ASSERT 在
+         * 未开 RT_DEBUG 时是空操作,失败完全静默)。
+         * 受影响场景:RTU 断电重启、屏幕固件升级、串口环回自检等所有 close/open 路径。*/
+        uart->handle.RxState = HAL_UART_STATE_READY;
         /* Start DMA transfer */
         if (HAL_UART_Receive_DMA(&(uart->handle), rx_fifo->buffer, serial->config.bufsz) != HAL_OK)
         {
             /* Transfer error in reception process */
+            LOG_E("%s HAL_UART_Receive_DMA failed (rx disabled!)", uart->config->name);
             RT_ASSERT(0);
         }
         /* Reset last_index to 0 after reinitializing DMA.
@@ -1228,7 +1275,10 @@ void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
     struct stm32_uart *uart;
     RT_ASSERT(huart != NULL);
     uart = (struct stm32_uart *)huart;
-    //dma_isr(&uart->serial);
+    /* DMA 接收缓冲区回绕(TC)时必须把已收到的数据推入 FIFO:
+     * 否则在“数据流没有空闲间隔”的场景下,IDLE 中断不触发,
+     * 回绕后的 recv_len 计算会下溢,导致接收数据错乱。 */
+    dma_isr(&uart->serial);
 }
 
 /**
@@ -1243,7 +1293,8 @@ void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart)
     struct stm32_uart *uart;
     RT_ASSERT(huart != NULL);
     uart = (struct stm32_uart *)huart;
-    //dma_isr(&uart->serial);
+    /* 半传输中断同样上报增量,避免长时间无 IDLE 时 FIFO 长时间得不到更新 */
+    dma_isr(&uart->serial);
 }
 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
 {

+ 5 - 2
Application_CBD/link.lds

@@ -5,11 +5,14 @@
 /* Program Entry, set to mark it as "used" and avoid gc */
 MEMORY
 {
-ROM (rx) : ORIGIN =0x8032000,LENGTH =512k
+ROM (rx) : ORIGIN =0x8032000,LENGTH =312k
 RAM (rw) : ORIGIN =0x20000000,LENGTH =128k
 }
 ENTRY(Reset_Handler)
-_system_stack_size = 0x200;
+/* 系统栈(MSP):所有中断、以及"栈溢出/硬件异常"诊断打印(rt_kprintf + list_thread)
+ * 都在该栈上运行。原值 0x200(512B) 过小:诊断输出会溢出并向下覆盖 .data,
+ * 且自身触发 HardFault 导致故障现场丢失。这里放大到 2KB。 */
+_system_stack_size = 0x800;
 
 SECTIONS
 {

+ 33 - 7
Application_CBD/packages/fal-latest/samples/porting/fal_flash_sfud_port.c

@@ -36,12 +36,32 @@ struct fal_flash_dev nor_flash0 =
     .write_gran = 1
 };
 
+/* 惰性获取 SFUD 设备。
+ * 说明:本文件的 INIT_DEVICE_EXPORT 中 rt_hw_on_chip_flash_init()(内部调用 fal_init())
+ * 可能先于 rt_hw_spi_flash_init()(注册 FAL_USING_NOR_FLASH_DEV_NAME) 执行,
+ * 若在此之前只能获取一次设备句柄,则 sfud_dev 会永久为 NULL 导致外部 Flash 读写静默失败。
+ * 这里改为每次操作时按需重试查找(首次成功后缓存)。
+ */
+static sfud_flash_t fal_sfud_dev(void)
+{
+    if (sfud_dev == NULL)
+    {
+        sfud_dev = rt_sfud_flash_find_by_dev_name(FAL_USING_NOR_FLASH_DEV_NAME);
+    }
+    return sfud_dev;
+}
+
 static int init(void)
 {
 
 #ifdef RT_USING_SFUD
     /* RT-Thread RTOS platform */
-    sfud_dev = rt_sfud_flash_find_by_dev_name(FAL_USING_NOR_FLASH_DEV_NAME);
+    if (fal_sfud_dev() == NULL)
+    {
+        /* SPI Flash 设备此时可能尚未注册(初始化顺序依赖),
+         * 读/写/擦除时会再次尝试获取,这里不算致命错误。 */
+        return -1;
+    }
 #else
     /* bare metal platform */
     extern sfud_flash sfud_norflash0;
@@ -62,8 +82,10 @@ static int init(void)
 
 static int read(long offset, uint8_t *buf, size_t size)
 {
-    assert(sfud_dev);
-    assert(sfud_dev->init_ok);
+    if (fal_sfud_dev() == NULL || !sfud_dev->init_ok)
+    {
+        return -1;
+    }
     sfud_read(sfud_dev, nor_flash0.addr + offset, size, buf);
 
     return size;
@@ -71,8 +93,10 @@ static int read(long offset, uint8_t *buf, size_t size)
 
 static int write(long offset, const uint8_t *buf, size_t size)
 {
-    assert(sfud_dev);
-    assert(sfud_dev->init_ok);
+    if (fal_sfud_dev() == NULL || !sfud_dev->init_ok)
+    {
+        return -1;
+    }
     if (sfud_write(sfud_dev, nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
     {
         return -1;
@@ -83,8 +107,10 @@ static int write(long offset, const uint8_t *buf, size_t size)
 
 static int erase(long offset, size_t size)
 {
-    assert(sfud_dev);
-    assert(sfud_dev->init_ok);
+    if (fal_sfud_dev() == NULL || !sfud_dev->init_ok)
+    {
+        return -1;
+    }
     if (sfud_erase(sfud_dev, nor_flash0.addr + offset, size) != SFUD_SUCCESS)
     {
         return -1;

+ 6 - 0
Application_CBD/rt-thread/src/scheduler.c

@@ -94,6 +94,12 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread)
         rt_ubase_t level;
 
         rt_kprintf("thread:%s stack overflow\n", thread->name);
+        /* [BZY PATCH] 追加打印栈参数:便于直接定位溢出线程与超出范围。
+         * 原实现只打印线程名,现场抓日志困难;此处仅增加输出内容,不改变控制流。 */
+        rt_kprintf("  [stack] sp:0x%08x base:0x%08x size:%u\n",
+                   (rt_uint32_t)(rt_ubase_t)thread->sp,
+                   (rt_uint32_t)(rt_ubase_t)thread->stack_addr,
+                   (rt_uint32_t)thread->stack_size);
 #ifdef RT_USING_FINSH
         {
             extern long list_thread(void);

+ 3 - 1
Application_CBD/rtconfig.h

@@ -17,7 +17,9 @@
 #define IDLE_THREAD_STACK_SIZE 1024
 #define RT_USING_TIMER_SOFT
 #define RT_TIMER_THREAD_PRIO 4
-#define RT_TIMER_THREAD_STACK_SIZE 256
+/* 软件定时器线程栈:软定时器回调中可能会调用 HMI_WRITE/LOG 等接口(含 256B 栈缓冲),
+ * 原值 256 字节明显不足,提高为 1024 字节 */
+#define RT_TIMER_THREAD_STACK_SIZE 1024
 
 /* Inter-Thread communication */
 

+ 1 - 1
CBD_FOTA_BootLoader/.settings/language.settings.xml

@@ -5,7 +5,7 @@
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1369183061114295484" id="ilg.gnuarmeclipse.managedbuild.cross.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT ARM Cross GCC Built-in Compiler Settings " parameter="${COMMAND} ${FLAGS} ${cross_toolchain_flags} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
+			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="1367540331451133130" id="ilg.gnuarmeclipse.managedbuild.cross.GCCBuiltinSpecsDetector" keep-relative-paths="false" name="CDT ARM Cross GCC Built-in Compiler Settings " parameter="${COMMAND} ${FLAGS} ${cross_toolchain_flags} -E -P -v -dD &quot;${INPUTS}&quot;" prefer-non-shared="true">
 				<language-scope id="org.eclipse.cdt.core.gcc"/>
 				<language-scope id="org.eclipse.cdt.core.g++"/>
 			</provider>