Просмотр исходного кода

固件代码审计与优化报告

zhunk 1 месяц назад
Родитель
Сommit
d031e2c67c
29 измененных файлов с 3481 добавлено и 950 удалено
  1. 1 1
      Application_cbd_apm32f1/.cproject
  2. 185 0
      Application_cbd_apm32f1/.workbuddy/memory/2026-09-28.md
  3. 202 251
      Application_cbd_apm32f1/.workbuddy/memory/MEMORY.md
  4. 51 0
      Application_cbd_apm32f1/.workbuddy/ota_uart_close_check.txt
  5. 271 0
      Application_cbd_apm32f1/.workbuddy/tools/ota_uart_close_check.py
  6. 74 17
      Application_cbd_apm32f1/applications/beep.c
  7. 120 54
      Application_cbd_apm32f1/applications/control.c
  8. 36 28
      Application_cbd_apm32f1/applications/control.h
  9. 723 455
      Application_cbd_apm32f1/applications/dtu_uart2.c
  10. 9 0
      Application_cbd_apm32f1/applications/dtu_uart2.h
  11. 162 99
      Application_cbd_apm32f1/applications/hmi.c
  12. 5 0
      Application_cbd_apm32f1/applications/hmi.h
  13. 5 0
      Application_cbd_apm32f1/applications/main.c
  14. 52 5
      Application_cbd_apm32f1/applications/param_backup.c
  15. 8 0
      Application_cbd_apm32f1/applications/param_backup.h
  16. 34 8
      Application_cbd_apm32f1/applications/sample_mb_master.c
  17. 8 1
      Application_cbd_apm32f1/applications/selfcheck.c
  18. 84 21
      Application_cbd_apm32f1/applications/sht30_collect.c
  19. 6 0
      Application_cbd_apm32f1/applications/sys_monitor.c
  20. 7 0
      Application_cbd_apm32f1/applications/sys_monitor.h
  21. 17 1
      Application_cbd_apm32f1/drivers/board.h
  22. 44 3
      Application_cbd_apm32f1/drivers/drv_adc.c
  23. 32 0
      Application_cbd_apm32f1/drivers/drv_common.c
  24. 13 1
      Application_cbd_apm32f1/drivers/drv_flash_f1.c
  25. 26 2
      Application_cbd_apm32f1/drivers/drv_rtc.c
  26. 16 2
      Application_cbd_apm32f1/drivers/drv_usart_v2.c
  27. 705 0
      Application_cbd_apm32f1/readme.md
  28. 4 1
      Application_cbd_apm32f1/rtconfig.h
  29. 581 0
      Application_cbd_apm32f1/固件代码审计与优化报告_2026-09-28.md

Разница между файлами не показана из-за своего большого размера
+ 1 - 1
Application_cbd_apm32f1/.cproject


+ 185 - 0
Application_cbd_apm32f1/.workbuddy/memory/2026-09-28.md

@@ -0,0 +1,185 @@
+# 2026-09-28
+
+## 全工程静态代码审计(只分析,未改任何源码)
+- 产出:`固件代码审计与优化报告_2026-09-28.md`(工程根目录)。P0×4 / P1×18 / P2×15 / P3×8 / 待确认×6。
+- 用户明确"不要改动代码"→ 本次**也未动 readme.md**(与"改代码才同步 readme"的约定一致)。
+
+## 本次新查实的高价值结论(后续改动前先看)
+1. **生效串口驱动只有 `drv_usart_v2.c`**。`RT_USING_SERIAL_V1` 与 `RT_USING_SERIAL_X` 都未定义 →
+   `drv_usart.c`、`drv_usartX.c` 整文件是死代码,别再照着它们改。
+2. **`UpLoad_Data()` 里 `DTU_Write(updata)` 把 JSON 当格式串**(dtu_uart2.c:3225)→ 最高频路径,
+   含 `%` 或 makeJson 返回 NULL 即崩。同类还有 1334/1344/1453/1962/1970。
+3. **平台下发 JSON 字段大面积未判空**:2086-2088(`item_ext`/`type`)、2540/2597/2628(`lat`/`lng`)。
+   只需下发 `{"cmd":"ctrl"}` 不带 ext 就能打挂。
+4. **`LOG_W("invalid JSON byte:%s[%x]",ch,ch)`**(308/356)把 char 当 `%s` → 串口一有噪声就炸。
+5. **`selfcheck.c:331` HARD_TIMER 回调 → `HMI_WRITE` → `rt_thread_mdelay`**(ISR 违规,hmi.c:146)。
+6. **`utos[5]` 装 uint16**(1461/1687/1717)、**`res[30]` 装 fuse_voltage[32]**(541)、
+   **`buf[7]` 配 `%-6s`**(control.c:2161)——三处已确认的越界写。
+7. **`rt_thread_delete(dtu_send_data)` 不释放 `dtu_write_mutex`**(2310/1886)→ 之后所有 DTU_Write 永久挂起。
+8. **全局 `System_stats_t system_status` 仍在 5 个 .c 各定义一次**(靠 -fcommon),
+   是 device_status 已经修掉的同款坑,换 -fno-common 就炸。
+9. **`parse_param_to_mcu` 里 `deviceId` 用了 `value->string`(key 名)而非 `valuestring`**(1206)→
+   设备编码被写成字面量 "deviceId"。
+10. **`coll_time[0]=ct1` 把栈地址存进全局 `const char* coll_time[10]`**(1636)→ 悬垂指针。
+
+## 第一批代码改进(同日下午,用户批准后实施)
+版本号 2.42 → **2.43**(control.h 四个 VERSION_* 宏),readme.md 顶部已插入 2026-09-28 条目。
+
+已改(均属报告"第一批"):
+| 文件 | 改动 |
+|---|---|
+| selfcheck.c:337 | 拍照超时定时器 HARD_TIMER → **SOFT_TIMER**(回调调 HMI_WRITE→rt_thread_mdelay,ISR 里不能挂起线程) |
+| rtconfig.h:21 | `RT_TIMER_THREAD_STACK_SIZE` 512 → **1024**(回调改到 timer 线程后 vsnprintf 吃栈) |
+| dtu_uart2.c UpLoad_Data | `DTU_Write(updata)` → `DTU_Write("%s", updata)` + `updata != RT_NULL` 判空 |
+| dtu_uart2.c:311/362 | `%s[ch]` → `LOG_W("invalid JSON byte: 0x%02x", (unsigned char)ch)` |
+| dtu_uart2.c:550 | `res[30]` → `res[64]` + `sprintf` → `rt_snprintf` |
+| control.c:2165 | `rt_sprintf(buf,"%-6s",alarm_tg)` → `rt_snprintf(buf,sizeof,"%-6.6s",...)`(`%-6` 是最小宽度不是截断) |
+| beep.c | timeout_cb 删 rt_kprintf×2 与 rt_device_close,改置 `g_beep_timer_fired`;新增线程上下文 `beep_timer_release()`;修掉 init_tim2 里同名局部 `hw_dev` 屏蔽全局;stop_motor_86 删 rt_kprintf + 形参 `void`→`void *args`;10 处 PWM 句柄判空 |
+
+### 新学到的约定/坑
+- **`HMI_WRITE()` 内含 `rt_thread_mdelay(1)` 且用无锁 static 缓冲** → 任何 ISR / HARD_TIMER 回调都不许调;
+  改 SOFT_TIMER 时必须同步放大 `RT_TIMER_THREAD_STACK_SIZE`。
+- **`rt_pin_attach_irq` 回调签名必须是 `void (*)(void *)`**,声明成 `void(void)` 是 UB(宿主 gcc 会报 -Wincompatible-pointer-types)。
+- `rt_device_close()` 内部有 `RT_ASSERT` + 会调 `dev->close()`,属线程上下文 API,不能在 ISR 里调。
+- **`rt_pwm_disable()` 走 HAL 不取 IPC 锁,可以在 ISR 里调**(前提是句柄非 NULL)。
+- 宿主 gcc 语法检查脚本已落在 `C:\Users\Administrator\.workbuddy\backups\syn_check.bat`(用法:`syn_check.bat beep.c`,
+  输出到同目录 syn_out.txt)。**注意:control.c / dtu_uart2.c / selfcheck.c 在宿主 gcc 上跑不通**
+  (会拉进 x86 avx512 内联头,报一堆 CMSIS/vendor 头错误),只有 beep.c 这类能干净通过;
+  报错要区分"vendor 头里的环境性错误"和"本文件错误"。
+  必需的两个 include 目录容易漏:`rt-thread\components\legacy`(rtlegacy.h)和 `rt-thread\components\drivers`。
+
+## 第二批代码改进(同日下午晚些时候)
+版本 2.43 → **2.44**,readme.md 顶部已插入 2026-09-28 第二批条目。
+
+核心:在 dtu_uart2.c 顶部加三个收口入口,之后全文件不再直接碰 `->valuestring`:
+```c
+static const char *cj_getstr(cJSON *obj, const char *key, const char *def); // 按 key 取(判 obj/空/非String/NULL)
+static const char *cj_str   (cJSON *it,  const char *def);                  // 对已有节点取
+#define SET_STATUS_STR(dst, src)  rt_snprintf((dst), sizeof(dst), "%s", (src))
+```
+- 数字型字段(gps/csq/net/sim/volume/link_sta/vt)缺省传 **"-1"**,让范围判断自然落进 else 分支,
+  与"字段缺失"行为保持一致(传 "" 会 atoi 成 0 而误进正常分支 —— 这是个坑)。
+- 已改:P0-3 全域判空;P1-1 定长写入(csq/net/sim/gps/gps_state 只有 **8 字节**最危险);
+  `utos[5]`→`utos[12]`;`driver[64]` 拼接改 rt_snprintf + `.485` 改定长追加;
+  `parse_param_to_mcu` 加 `sync_u8/sync_i8/sync_u16` 范围校验;
+  **`deviceId` 的 `value->string` → `valuestring`**(原来把 key 名 "deviceId" 写进设备编码)。
+
+### 🔴 结构性变更(务必记住)
+- **`control.h` 的 `const char *coll_time[10]` 已改成 `char coll_time[10][16]`**。
+  → `Device_Status_typedef` **不再有任何指针成员**,旧备忘里"不能整体 memcpy 做持久化"的顾虑消失
+  (持久化仍走 `param_persist_t`,流程不变)。结构体尺寸 1592 → 约 1712。
+  ⚠️ `cJSON_CreateStringArray()` 要 `const char *const *`,**二维数组不能强转**,
+  必须用一个局部 `const char *ptr[2]` 适配。
+- `parse_param_to_mcu` 现在会**丢弃越界值并 LOG_E** —— 这是行为变更,现场若需更大取值就改范围表。
+
+### 🔴 第二批上机编译踩坑(已修)
+- 报错 `error: 'cJSON' has no member named 'tm_year'`(6 个 tm_* 各一次),
+  位置都指向 `LOG_E(...)` 展开到 `rtdbg.h:144`。
+- 根因:`rtdbg.h:136-137` 在文件作用域定义全局 `time_t timep; struct tm *p;`,
+  `LOG_*` 宏用 `p->tm_year` 打时间戳;我的 `sync_u8/i8/u16` 形参叫 `p` 把它屏蔽了。
+  → **形参改名 `params`**。本工程以后局部变量禁用 `p` / `timep`。
+- 同批还有两条**既有警告**(非本次引入,未改):
+  `dtu_uart2.c:2416 ymodem_ota` 隐式声明、`main.c:49 memtrace` 隐式声明。
+
+## 第三批代码改进(同日傍晚)
+版本 2.44 → **2.45**,readme.md 顶部已插入第三批条目。
+
+核心新增两个入口(都在 dtu_uart2.c/h):
+- `void dtu_write_json(char *json)` —— "发送堆上 JSON + 自动 free"一步到位,固定用 "%s"。
+  ⚠️ **只能传堆内存**;栈上缓冲仍用 `DTU_Write("%s", buf)`。
+- `void dtu_stop_send_thread(void)` —— 替代裸 `rt_thread_delete(dtu_send_data)`。
+
+### 🔴 第三批踩到的重要事实
+- **本工程 RT-Thread 的 `rt_mutex_control()` 是空实现**(`rt-thread/src/ipc.c:1216-1223`
+  直接 `return -RT_ERROR`)→ **mutex 不能用 `RT_IPC_CMD_RESET` 复位**,
+  要"清锁"只能 `rt_mutex_detach` + `rt_mutex_init`。
+- **`system_status` 已收敛为唯一定义**(在 `sys_monitor.c`),`sys_monitor.h` 加 extern;
+  control.c / dtu_uart2.c / hmi.c / sht30_collect.c 里的同名定义已删除。
+  和 device_status 是同一个 `-fcommon` 坑。
+- `HMI_WRITE()` 已加 `hmi_write_mutex`(惰性初始化放临界区)。**内部仍有 rt_thread_mdelay,
+  ISR/HARD_TIMER 回调禁止调用**(这条不变)。
+- 驱动层已改:`drv_flash_f1.c` 擦除+编程屏蔽中断;`drv_adc.c` 加 `adc_lock` 并判 HAL 返回值;
+  `drv_usart_v2.c` 把 `rt_hw_serial_isr` 移出关中断区、DMA 自愈时 `rt_ringbuffer_reset`。
+- `param_backup` 失败退避:`g_fail_backoff_tick` + `PARAM_FAIL_BACKOFF_TICKS`(默认 60s)。
+
+### 工具备忘(第二批踩到)
+- 宿主 gcc 语法检查**对 dtu_uart2.c / control.c / selfcheck.c 不可用**(会拉进 CMSIS core_cm3.h,
+  x86 下报一堆 vendor 头环境性错误)。替代校验:全文件花括号配平 + 旧标识符残留扫描。
+- 检查脚本 `C:\Users\Administrator\.workbuddy\backups\syn_check.bat` 已补齐 include:
+  `rt-thread\components\legacy`、`\drivers`、`utilities\ymodem`、`fal\src|inc|samples\porting`、
+  EasyFlash port 等。仍只对 beep.c 这类文件有效。
+
+## 工具/环境备忘
+- 本次 Bash 工具 PATH 坏了(`dirname/ls not found`),PowerShell 工具**不回传 stdout**。
+  可行做法:PowerShell 把结果 `Set-Content` 到 `C:\Users\Administrator\.workbuddy\backups\xxx.txt`,再用 Read 读。
+  但 `& "xxx.bat" arg` **可以正常执行**(只是看不到回显,要靠脚本重定向到文件)。
+
+## 第四批:清理(P3 全部)+ 接收链路批量化
+版本 2.45 → **2.46**(control.h 四宏)。readme.md 顶部已插入本批说明(倒序)。
+
+### 用户指定项:接收线程批量读(dtu_uart2.c)
+- 原来 `rt_device_read(dev,-1,&ch,1)` 逐字节 → 115200bps 下**每秒 1.1 万次系统调用**,
+  且每次进出 serial_v2 ringbuffer 临界区。
+- 改为:回调 `dtu_input`/`uart5_input` 只累加 `size` 到 `dtu_rx_pending`/`uart5_rx_pending`
+  并 release 信号量;接收线程 `rt_device_read(dev,0,rx_blk,128)` 一次读一块,
+  再调新抽的公共函数 `dtu_feed_block()` 逐字节喂 lwjson。系统调用降到约 1/128。
+- 设计保守点:pending 计数**只作参考不参与正确性**(read 返回 0 就退回等信号量,不丢不死等)。
+- 顺带把 uart5 的解析器独立成 `lwparser_485`(原来与 uart2 共用全局 lwparser,双线程会互相
+  破坏 parse_state/stack_pos;MATCH_DEVICE=0 时不建线程属休眠缺陷)。
+
+### P3 全部
+- **P3-5(最关键)**:`board.h` 只声明 `BSP_USING_PWM3/PWM8` 而无 `_CH*` → `pwm_get_channel()`
+  得 0 → `HAL_TIM_PWM_ConfigChannel()` 一次不调,PWM 全靠 board.c 的 MX_TIM3_Init/MX_TIM8_Init
+  残留配置撑着。已补 PWM3_CH1~CH4 + PWM8_CH2/CH3。**上机需确认频率占空比与改前一致**。
+- P3-1 lwjson.c/lwjson_debug.c 已加进 `.cproject` sourceEntries 排除列表(顺带补回丢失的
+  `//.workbuddy`)。改完必须 IDE Refresh+Clean+Build。
+- P3-2 main.c 补 `extern int memtrace(int, char**)`;P3-3 hasElementGreater* 两函数名互换
+  (比较方向不动,现有取反逻辑恰好正确);P3-4 8 个猜结构的分支合并为 `sscanf("%u-%u")`;
+  P3-6 `HAL_Delay` 改为 HAL_GetTick 差值忙等(**不能用 mdelay**,hw_board_init 在调度器前跑);
+  P3-7 `%d`→`%lu`;P3-8 RTC 两处判 HAL 返回值。
+
+### 改到时新发现(不在原报告里)
+- 🔴 **`DTU_Write()` 的锁位置错了**:`dtu_str` 是 static 共享缓冲,原来在 `va_start` 之前就
+  `rt_vsnprintf` 填好,锁只护住 `rt_device_write` → 并发时发出去半截/混合 JSON。
+  已把锁提到最前,覆盖格式化→写串口→485转发→日志全过程。
+- 🔴 **`Uart5_Write()` 同样裸奔 + 格式串注入**:`DTU_Write` 里 `Uart5_Write(dtu_str)` 是拿内容
+  当格式串 → 平台内容含 %s/%n 被解释。改 `Uart5_Write("%s", dtu_str)`,并给它独立的
+  `uart5_write_mutex`(**不能**复用 dtu_write_mutex,转发时已持有 → 自死锁)+ serial_485 判空。
+  hmi.c `#if 0` 块里的 `DTU_Write(rep)` 也统一成 `dtu_write_json(rep)`。
+
+### P2 剩余
+- P2-6 NTC:除零 + 一行调两次 Read_Ntc_Voltage(各含 6×10ms 阻塞)+ 恒假异常判断 →
+  采样一次 → 判 0<adc<4096 → 区间检查(-40~160℃),异常保留上次有效值。
+- P2-7 `voltage[6]`(零余量)/`power[8]`/`heat_power[8]`(必溢出) → 统一放宽到 16 + rt_snprintf。
+  ⚠️ Device_Status_typedef 因此涨到 ≈1746 字节,更不能上栈。已确认 param_persist_t 不含这些字段。
+- P2-8 sht30 两线程栈 1024→2048(%f 软浮点 dtoa 峰值 500~800B + TempCalculate 内含 log)。
+- P2-9 UART_485_INIT 补判空;P2-11 param_dump/restore 改用私有 `g_dbg_dump`/`g_dbg_restore`
+  (原来锁外用 g_work,与落盘线程竞争);P2-12 栈 512→1024 + 拼好串一次性写入 + 日志降 LOG_D
+  + 补 `#include <rtdbg.h>`;P2-14 开机 180s+12s 阻塞等联网搬进独立 `net_wait` 线程(栈2048,优先级12)。
+
+### 校验
+- 本机无 arm-none-eabi。做了全文件花括号/圆括号/方括号配平(全部 OK)+ 新增符号定义/引用一致性扫描
+  + 格式串误用扫描(`DTU_Write(x)`/`Uart5_Write(x)` 已无漏网)。仍需用户上机 Refresh+Clean+Build。
+
+--- 追加:第五批 OTA 前关闭串口4/串口5 ---
+
+---
+## 第五批:OTA 升级前关闭串口4(屏幕)/串口5(485)  [版本 2.46 -> 2.47]
+- 用户需求:升级(ymodem)前把 uart4、uart5 关掉。
+- 新增 `uart_stop_for_ota()`(control.c/h)+ `ota_close_uart()`:置标志 -> 摘 console/finsh 回 uart1
+  -> 循环 close 到 ref_count 归零 -> 两个句柄置 NULL。
+- 新增显式标志 `g_hmi_port_closed`(hmi.h extern),`HMI_WRITE`/`send_raw_to_hmi` 第一行就判。
+- 三个硬约束(详见 MEMORY.md「升级机制现状」):
+  ① rt_device_close 只在 ref_count 归 0 时才真关,uart4 会被 HMI+console+finsh 多重持有,必须循环 close;
+  ② 句柄置 NULL 挡不住 HardFault(serial_v2 的 fifo 被 rt_free 但 dev 仍非空)-> 必须显式标志;
+  ③ close 前先 rt_device_set_rx_indicate(dev, RT_NULL) 摘回调。
+- 调用顺序固定:thread_stop_all_for_ota() -> uart_stop_for_ota() -> ymodem_ota(1,0),不能反。
+- 顺带收敛 `serial_485`:原 dtu_uart2.c:72 与 sht30_collect.c:51 各一份定义(靠 -fcommon),
+  现仅 dtu_uart2.c:72 一处,sht30 改 include dtu_uart2.h。`Uart5_Write_Bin()` 补 serial_485 判空。
+- 版本号改 control.h 的 VERSION_HK / VERSION_HK_2000W(2000W 分支) / VERSION_ZP / VERSION_GK -> 2.47。
+- readme.md 顶部已插入「第五批」专题(含原理、改动清单、待上机确认项)。
+- 新增校验脚本 `.workbuddy/tools/ota_uart_close_check.py`(A语法/B括号/C符号/D调用顺序),
+  报告写到 `.workbuddy/ota_uart_close_check.txt`,**四项全 PASS**。
+  踩坑:桩里只 `typedef struct rt_device` 不给 `rt_device_t` 别名会报 unknown type name;
+  Bash 工具 PATH 坏时反引号会被 shell 吞掉,写含反引号的内容要用 Edit 工具而非 python -c。
+- 待用户上机:IDE Refresh(F5)+Clean+Build,触发一次远程 update 验证。

+ 202 - 251
Application_cbd_apm32f1/.workbuddy/memory/MEMORY.md

@@ -1,253 +1,204 @@
-# 项目长期备忘 — 孢子仪2.x 滑台/运动控制(Application_cbd_apm32f1)
-
-## 🔴 改动代码必须同步 Readme.md(用户硬性要求)
-- **只要动了任何源码,就必须把本次修改内容写进 `readme.md`**;没有该文件就自动创建。
-- `readme.md` 是**倒序更新日志**(最新在最上)+ 顶部专题的形式。
-  写专题时插到**文件最顶部**,并在对应日期条目下**追加一行索引**,不要动用户原有条目。
-- 用户明确说过"不用改了,把修改内容写入 Readme"——即**先记录、后决策**,
-  待确认项在文档里单列"已知未修",不要擅自改行为。
-- 用户 Readme 里长期有他自己未提交的改动 → **禁止整体重写**,只做插入。
-
-## 🔴 升级机制现状(2026-09-26 第五、六轮后,以此为准)
-- **升级只有一条入口**: `dtu_uart2.c` 收到远程 `update` 指令后,**在本线程直接调 `ymodem_ota(1,0)`**。
-  **不再"置标志 + 重启"**——那条路要过 EasyFlash,参数一丢标志就没了(现场升级静默失效的主因)。
-- 历史上的 `Upgrade_Flag_Set/Clear`、`UPG_BKP_DR3/DR4` 宏、`upgrade_set`/`upgrade_clear`
-  msh 命令、`hmi.c` 的 `hmi_update` 分支体、开机侧 ymodem 分支 **全部已被用户删除**(2026-09-26 核实)。
-  ⚠️ 提到这些名字时先 grep 确认,别再照着旧记忆改。
-- 🔴 **`ymodem_ota.c:117` 有 `rt_console_set_device("uart2")`** —— 调试口被切成 ymodem 接收口。
-  此后**任何线程的 rt_kprintf / LOG 都会污染 ymodem 字节流**。所以升级分支内禁止 rt_kprintf
-  (只能用 LOG_W,且必须在调用 ymodem_ota 之前打完)。
-- 🔴 **`DTU_UART_NAME` 就是 `"uart2"`**(dtu_uart2.h:14)—— DTU 通信与 ymodem 接收**同一个串口**。
-  进入 ymodem 前必须先停 uart2 上的发送源: `rt_timer_stop(timer_uart2)` +
-  `rt_thread_delete(dtu_send_data)`,否则传输必被打断。
-- 升级前统一调 **`thread_stop_all_for_ota()`**(control.c,control.h 导出)停掉全部业务线程,详见下一节。
-- `syswatch` 看门狗无需处理: 喂狗靠 syswatch 线程每秒执行,OTA 期间照跑;且
-  `syswatch_thread_switch_hook`(syswatch.c:286-288) 在切到 idle 时会清零计数,
-  ymodem 阻塞会让出 CPU → 不会误判异常线程。
-- ⚠️ 遗留隐患: `hmi.c` 的 `iSave != FLASH_FLAG` 分支仍会把 flash/快照里残留的
-  `update_flag=1` 恢复到 RAM,而 Control_Clear / Control_Check / thread_485play 会靠它 break
-  → 会被误认为"有升级请求"而一开机就退出(不清扫/不恒温)。已告知用户,未擅自改。
-
-## 🔴 线程名与线程清理(2026-09-26,重要)
-- **`RT_NAME_MAX = 8`**(rtconfig.h:8)→ 内核**只存前 7 个字符**。实测撞名:
-  `Control_Clear_thread_entry` 与 `Control_Check_thread_entry` 都变成 `Control`;
-  `DTU_Uart_thread_send` 与 `DTU_Uart_thread_recv` 都变成 `DTU_Uar`
-  —— 后者**就是执行升级的当前线程**。
-  → **禁止用 `rt_thread_find(全名)` 操作线程**,可能删错甚至删掉自己。
-- 正确做法(`list_thread` 同款): 遍历 `rt_object_get_information(RT_Object_Class_Thread)->object_list`
-  + `rt_list_for_each` + `rt_list_entry(node, struct rt_thread, list)` + **前缀匹配**
-  (比较长度截到 RT_NAME_MAX-1)+ **显式跳过 `rt_thread_self()`**。
-  ⚠️ `struct rt_thread` 的 rt_object 部分是**内联展开**(name/type/flags/list 在最前面),
-  没有 `struct rt_object parent;` 成员,所以 member 用 `list`。
-- **先收集到数组再删**(遍历中删节点会把链表走坏),遍历期间 `rt_enter_critical()`。
-- `thread_stop_all_for_ota()` 的保留名单: **syswatch(喂狗) / tshell / tidle / main**。
-  注意 `syswatch` 线程名走宏 `SYSWATCH_THREAD_NAME`,不是字面量。
-- 需要停的 17 个业务线程及其截断名,见 `.workbuddy/tools/ota_thread_stop_check.py` 的 [C] 项输出。
-- 停线程顺序: ① `thread_delete_adc()` 优雅退出(它可能持 ADC 设备锁, 强删会死锁)
-  ② RAM 内置 `device_status.update_flag = 1`(**绝不落盘**)让带 break 的线程自己退
-  ③ mdelay(300) ④ 收集 + 强删其余。
-
-## 升级标志 update_flag(2026-09-24 第八轮 —— 机制已于 09-26 废弃,留作历史)
-- 当年方案: 三通道 ① EasyFlash env ② param_a/b 快照 ③ RTC BKP_DR3(魔数 0x5AA5),
-  置位/清位调 `Upgrade_Flag_Set()` / `Upgrade_Flag_Clear()`。
-- ⚠️ 这套函数**现在已不存在**(定义被删)。若还要用三通道思路,需重新实现;
-  当前 `update_flag` 的唯一用途是"RAM 置 1 触发线程 break 退出",全程不写 flash。
-- 历史经验仍有价值: ① 单通道存标志必丢 → 至少双通道; ② `iSave != FLASH_FLAG` 分支
-  **不许无条件清零 update_flag**;③ `param_unpack()` 整包覆盖后要把已置位的 flag OR 回去;
-  ④ `ymodem_ota()` 成功失败都会 `rt_hw_cpu_reset()`,必须有失败上限防死循环。
-
-## 版本控制
-- 仓库根 = `D:\RT-ThreadStudio\workspace\IOT_CBD_BZY_CTRL`(本工程是子目录)。HEAD="3.7.13"。
-- 本机 git 不在 PATH, 用 `C:\Users\Administrator\.workbuddy\binaries\PortableGit\versions\1.2.0\cmd\git.exe`。
-- 工作区长期带**用户自己未提交的改动**(control.c/h、hmi.c、dtu_uart2.c、readme.md)。
-  **禁止 git checkout 一把梭回退**, 会冲掉用户的活; 必须按 hunk 精确回退。
+# 项目长期备忘 — 孢子仪2.x 控制器(Application_cbd_apm32f1)
+
+## 🔴 硬性约定
+- **改了源码必须同步写 `readme.md`**(倒序更新日志,最新在最上;专题插到文件最顶部并在对应日期条目加一行索引)。
+  用户 readme 常有自己未提交的改动 → **禁止整体重写,只做插入**。用户说"只分析不要改"时连 readme 都不要动。
+- 备份/临时文件**绝不能放工程树内任何 .c/.h**(含 .workbuddy/)→ CDT 全扫会 multiple definition。
+  放 `C:\Users\Administrator\.workbuddy\backups\` 或改 `.c.bak`。
+- 版本号 2.42→2.46(2026-09-28 四批修复)→ **2.47**(2026-09-28 第五批:OTA 前关串口4/5)。
+  改 `control.h` 的 `VERSION_HK/VERSION_HK_2000W/VERSION_ZP/VERSION_GK`(注意 `VERSION_HK_2000W`
+  在 `#if TG_MODULE / JINGJIKUAN / QINGSAO_YUGUAQI / MATCH_DEVICE` 分支下有多份,只改生效那份)。
+
+## 生效配置(2026-09-28 核实)
+- 串口驱动只有 `drivers/drv_usart_v2.c`(`RT_USING_SERIAL_V1/X` 未定义,drv_usart.c/X.c 是死代码)。
+  **uart1=调试console、uart2=DTU(+RX DMA)、uart4=屏幕(+RX DMA)、uart5=485**。
+- RT_NAME_MAX=8(内核只存前 7 字符,线程名会撞)、TICK=1000、HEAP 开、TIMER_SOFT 开、WDT 5s 开、main 栈 4096。
+  编译开关:MATCH_DEVICE 0、PCB_V1 1、LAMP_EN 0、UART_TEST_EN 0、SENSOR_EN 0。
+- 字段尺寸(改字符串写入前必查 control.h):csq/net/sim/gps/gps_state **仅 8 字节**,alarm_tg 12,
+  power/heat_power/voltage **16**(第四批从 8/8/6 扩,原值必溢出),voltage_sun 16,tempture/humidity 12,
+  fuse_voltage 32,lat/lng/stamp/imei/iccid/link_ip/deviceId/project 32,driver/driver_4g/mqttcfg2 64,
+  json_w_* 与 qianming/photolink 128。**全部字符串写入一律用 rt_snprintf 限长**。
+- ⚠️ `Device_Status_typedef` ≈**1746 字节**(更早的 1712/1592 数值均已作废)→ 栈上更不能放。
+  `coll_time` 已改成 `char coll_time[10][16]`(原 `const char*[10]` 存栈地址会悬垂),
+  改后结构体无指针成员,但 `cJSON_CreateStringArray()` 要 `const char *const *`,
+  二维数组**不能强转**,须用局部 `const char *ptr[2]` 适配。
+- 🔴 **平台/RTU 下发的 JSON 一律不可信**:dtu_uart2.c 顶部已有 `cj_getstr(obj,key,def)` /
+  `cj_str(item,def)` / `SET_STATUS_STR(dst,src)` 三个入口,新增代码不要再直接碰 `->valuestring`
+  (节点非 String 时恒为 NULL)。数字型字段缺省传 **"-1"** 而不是 ""("" 会 atoi 成 0 误进正常分支)。
+- `device_status` 唯一定义在 main.c;`system_status` 已收敛到 sys_monitor.c(2026-09-28)。
+  `serial_485` 已收敛到 dtu_uart2.c:72 唯一定义(2026-09-28,原 sht30_collect.c 有一份靠 -fcommon 合并)。
+
+## 🔴 编译级硬坑:局部变量绝不能叫 `p` / `timep`
+- `rtdbg.h:136-137` 在**文件作用域**定义了 `time_t timep;` 和 `struct tm *p;`(LOG_* 宏用它打时间戳)。
+  任何函数里声明同名局部变量 `p` 会屏蔽它 → 报 `has no member named 'tm_year'`。
+  **2026-09-28 实测**:`sync_u8/sync_i8/sync_u16` 形参叫 `p` → 6 个 tm_* 成员各报一次。改名 `params` 解决。
+- 这两个是**非 static 的 tentative definition**,靠 `-fcommon` 合并 → 又一个 `-fno-common` 雷。
+
+## 升级(OTA)机制现状(2026-09-28 第五批后,以此为准)
+- **唯一入口**:`dtu_uart2.c` 收到 `update` → **本线程直接 `ymodem_ota(1,0)`**。不再"置标志+重启"。
+- `Upgrade_Flag_Set/Clear`、`UPG_BKP_DR3/DR4`、`upgrade_set/clear` msh 命令、`hmi.c` 的 hmi_update 分支、
+  开机 ymodem 分支**已被用户删除**;提这些名字先 grep。
+- `ymodem_ota.c:117` 会 `rt_console_set_device("uart2")` → 升级分支内**禁止 rt_kprintf**(只 LOG_W,且要在调用前打完)。
+- `DTU_UART_NAME == "uart2"` → 进 ymodem 前必须停 `timer_uart2` + 删 `dtu_send_data`。
+- 执行顺序(**不能反**):`thread_stop_all_for_ota()` → `uart_stop_for_ota()` → `ymodem_ota(1,0)`。
+  先停线程(没人再发数据)再关设备;反过来关设备的瞬间还有线程在写 tx fifo。
+- `thread_stop_all_for_ota()`(control.c/h):遍历 `rt_object_get_information(RT_Object_Class_Thread)`
+  的 `object_list` + `rt_list_for_each` + `rt_list_entry(node, struct rt_thread, list)` + **前缀匹配**(截到
+  RT_NAME_MAX-1)+ 显式跳过 `rt_thread_self()` + **先收集到数组再删**(遍历中删会走坏链表)。
+  ⚠️ `struct rt_thread` 的 rt_object 是**内联展开**,member 用 `list`。
+  🔴 **禁止 `rt_thread_find(全名)`**(名字截断会删错/删自己 —— 撞名实例:
+  `Control_Clear_`/`Control_Check_` 都是 `Control`,`DTU_Uart_thread_send/recv` 都是 `DTU_Uar`,
+  后者就是执行升级的当前线程)。保留名单:syswatch/tshell/tidle/main。
+  停线程顺序:① `thread_delete_adc()` 优雅退出(可能持 ADC 设备锁,强删死锁)
+  ② RAM 置 `device_status.update_flag=1`(**绝不落盘**)让带 break 的线程自己退 ③ mdelay(300) ④ 强删其余。
+- `uart_stop_for_ota()`(control.c/h,2026-09-28 新增):**升级前关 uart4(HMI屏) 与 uart5(485)**。
+  流程 = ① 置 `g_hmi_port_closed=1` ② 若 console 正是 uart4 则 `rt_console_set_device("uart1")`
+  + `finsh_set_device("uart1")` ③ `ota_close_uart(serial/serial_485)` ④ 两个句柄置 NULL。
+  **必须在 `thread_stop_all_for_ota()` 之后调。**
+- 🔴 串口关闭的三个硬约束(下次改这块前必读):
+  ① **引用计数**:`rt_device_open` 每次 +1,`rt_device_close` 只在归 0 时才真调驱动 close。
+     uart4 可能被 HMI 业务 + console + finsh 同时持有(`rt_console_set_device`/`finsh_set_device`
+     内部都是 open 新 + close 旧)→ **必须循环 close 到 ref_count==0**,单次 close 等于没关。
+  ② **置 NULL 挡不住 HardFault**:`rt_serial_close()` 会 `rt_free` 掉 rx/tx ringbuffer 并置 NULL,
+     但 `dev` 指针本身仍非空;再 `rt_device_write` 会解引用已释放的 `serial_tx->activated` → HardFault。
+     → 必须有**显式标志** `g_hmi_port_closed`(hmi.h extern),`HMI_WRITE`/`send_raw_to_hmi` 第一行就判。
+  ③ `rt_device_set_rx_indicate(dev, RT_NULL)` 要在 close 前先摘,否则窗口期仍有回调触发。
+- `syswatch` 喂狗无需处理(OTA 期间照跑;切 idle 时 `syswatch_thread_switch_hook` 会清零计数)。
+- ⚠️ 遗留隐患:`hmi.c` 的 `iSave != FLASH_FLAG` 分支仍会把 flash 残留 `update_flag=1` 恢复到 RAM
+  → Control_Clear/Control_Check/thread_485play 靠它 break → 一开机就误退出。已告知用户,未擅改。
 
 ## 硬件口径
-- 脉冲脚 PC6 = TIM3_CH1(pwm3/CH1); DIR=PB15(CTR_RO_LIMIT), EN=PB14(HK_IO);
-  轴电源: X=ctr_lamp(1), Y=ctr_Collect_Fan, Z=ctr_swz。限位: X=PC13, Y=PB8(dir0), Z=PB9(dir1), 高=触发。
-- **三路电源互斥, 同时只准一个轴上电运动**(共用 PC6/PB14)。切换顺序固定"先开目标轴、再关另两轴"。
-- **驱动器有启动时间**: 上电/EN/DIR 建立后 ≥100ms 才能发脉冲, 否则起步丢步。
-- 发脉冲前先 pwm_stop(), 避免上电自检期吃到杂散脉冲。
-- Y 轴垂直带载(弹簧平衡, 肉眼无下滑), 但点位间 X/Z 移动必然使 Y 断电 → 转子重对齐(每次数十脉冲)。
-- TIM3 无 RCR(重复计数器), 只有 TIM1/TIM8 有 → 本芯片做不到"一次发 N 个脉冲"。
-- TIM3_IRQHandler 当前**未定义**(曾实现过计数方案已回退); 若开 BSP_USING_TIM 且用 TIM3, 必须合并同名入口。
-
-## 运动接口约定(改前必读)
-- `ctr_move(轴,方向,dis_,pulse)` = "定时开PWM"而非脉冲计数: dis_ 单位≈tick(ms)。
-  **dis_>=8000 时每格 10ms, <8000 每格 1ms** —— 同数值跨门槛行程差 10 倍(撞机械极限的经典坑)。
-  返回 dis_(非实际行程)。起停调度延迟 → 相对往返必然累积偏差。
-- RT_TICK_PER_SECOND=1000。对焦/预对焦用 1ms 周期使 1 单位=1 脉冲; 复位/到位用 mapSpeed(50)=125us(8kHz)。
-- 所有滑台动作由 `slide_thread_entry` 串行执行, 靠 `slide_para.en_slide` 派发
-  (1/2=X/Z移动, 3=X复位, 4=Z复位, 6=Y步进, 7=Y复位, 8=录制)。stop_move() 置 stop_flag=1 且不清零。
-- **en_slide=6 有 4 个派发点且 ydis 口径不统一**(脉冲数 vs tick): hmi.c 的 auto_focus_move_to /
-  calibrate_move / Ctr_Mortor 走位(y_init_dis≈9000, ≥8000 档实测约 90s) / dtu_uart2.c 远程命令。
-  想只改其中一个必须加显式模式位(曾经的 y_pulse_mode 即如此, 已随回退删除)。
-- 🔴 **派发自死锁(2026-09-22 实修)**: 在 `slide_thread_entry` 内部调用的函数里, **绝不能**
-  `en_slide=6` 后死等清零 —— 执行 case 6 的就是本线程, 会永久卡死(现象: 收到 focus 后整机无输出)。
-  现已抽出底层 `slide_y_step(dir,dis,pulse)`; `pf_move()` 用 `rt_thread_self()==g_slide_thread`
-  判断: 在滑台线程内直接调底层, 其它线程(如 hmi.c 的 Ctr_Mortor)仍走派发以保持串行。
-
-## 预对焦(Pre-Focus)策略 [2026-09-22 实装]
-现状: `FOCUS_STEP_EN=0`, 爬山式自动对焦**不启用**; 实际链路是
-**MCU 发 `mov_init_y/takephoto_done` → 工控机开录 → 下发 `record_start` → case 8 下行+回程 →
-发 `record_stop` → 工控机在视频流里挑最清晰帧**。
-- `PF_EN`(=1, control.h) 开关: 每个点位录制前先 `slide_pre_focus()`, 以 PF_STEP 下采样清晰度
-  找"上升沿", 回退 PF_HEADROOM 作录制起点 → 下行 3~5 秒即罩住焦区。
-  实现全在 control.c "预对焦"块: pf_request_focus / pf_move / pf_scan_down / slide_pre_focus /
-  slide_set_record_travel + `g_record_dis_1/0` + `g_record_preroll`。
-- 两阶段搜索: ①向下 PF_SEARCH_LIMIT; ②失败则上退 PF_PHASE2_UP 再长距离重扫(应对"起点已在焦后
-  下降段"); 仍失败则**先退回进入时高度**再按加长行程兜底(否则净下行叠加会撞下限)。
-- `g_pf_busy` 必须: dtu_uart2.c 每收到 focus 就置 autotakepic=2 并发信号, 预对焦期间靠它在
-  hmi.c 的 ==2 分支里挡掉这些帧, 否则旧状态机同时驱动 Y 轴。
-- 口径陷阱: 预对焦 1ms/格 → 1 单位=1 脉冲; hmi.c ==3 分支扣 PF_APPROACH_BACKOFF 后**仍须 ≥8000**。
-- PF 退出时恢复 `slide_para.pulse_period`(否则污染后续 X/Z 复位速度档)。
-- 🔴 **历史 bug(已修)**: 老 case 8 下行预启动 1500 / 回程硬编码 800 不对称 → 每点位净往下 700
-  单位(≈93 脉冲), 32 点位累计约 3000 脉冲单向爬行 —— "走着走着拍不到清晰位置"的主因。
-  现已两向共用 `g_record_preroll`, 另留 `PF_RETURN_BIAS_MS` 补偿实测偏差。
-- 待现场标定: PF_STEP / PF_SEARCH_LIMIT / PF_HEADROOM / PF_APPROACH_BACKOFF / PF_RISE_RATIO /
-  PF_RECORD_MS_OK / PF_RETURN_BIAS_MS。
-
-## 点位间漂移(结构性, 未根治)
-- 一轮 32 点位内 Y 不复位, 每点位以上一点位落点为原点相对移动, 只在整轮开始(autotakepic==1/3)
-  复位一次 → 误差逐级累加; 点位间 X/Z 移动又必然使 Y 断电再上电。
-- **限位开关是唯一绝对基准**(无编码器)。表现: 越往后的点位画面越往 dir=1 偏, 实测一轮偏 2~3 秒行程。
-- 诊断钩子: hmi.c 的 `g_y_abs`, 每点位对焦完成后 LOG_I 打印绝对位置; 超 AF_ABS_DRIFT_LIMIT(=1200)
-  会 LOG_E, 但 `af_drift_over` 上报被 `#if 0` 关着。
-- **已知未修**: 注释称 g_y_abs 在整轮复位处清零, 但代码里没有该赋值 → 跨轮持续累积。
-
-## 录制流程(case 8)
-- 现状: 下行 `ctr_move(Y_,1,dis_1,133Hz档)` → 发 record_stop → `rt_thread_delay(200)` → 回程
-  `ctr_move(Y_,0,dis_0,...)`。相对往返, 两向脉冲数不可能严格相等 → 每次留净偏差。
-- 回程 dir=0 是限位方向, ctr_move 对 Y 有两处限位保护: ①起始前读到限位 → 3 声鸣叫 + 不动;
-  ②循环内读到 → 截断行程。另有 `stop_flag!=0` → 3 声鸣叫 + break。
-  **鸣叫次数是判据**: 3 声=限位或急停, 无声=脉冲/周期问题。
-- `stop_move()` 调用点(dtu_uart2.c): 某下行命令(1079)、`xdis==0`(1135)、`led_off`(1217)。
-  平台发 led_off 或 movx:0 都可能打断录制回程。
-
-## 硬件计数方案(已回退, 备查) — 2026-09-21
-`ctr_move_pulse()`(TIM3 更新中断计数, 返回实际脉冲数)已实现并验证, 后因"回程时间不够"整体回退,
-**当前源码无此实现**。复用要点: 先 pwm_stop() 再开轴电源; EN/DIR 后等 ≥100ms; 三轴电源互斥
-顺序; case 6 四个派发点口径不同需显式模式位。
-回退做法: `git diff` 逐 hunk 分组, 只反向应用"含自己新增标记"的分组, 用户改动组跳过;
-纯新增块反向应用要连同换行一起删。
-
-## 构建系统约定(踩过坑)
-- Eclipse CDT managed build(RT-Thread Studio), 产物在 `Debug/`, sources.mk/subdir.mk 自动生成。
-- ⚠️ **绝不把 .c/.h 备份或临时副本留在工程树内任何目录(含 .workbuddy/)** —— CDT 扫描全部 .c/.h
-  且不跳点开头目录 → 链接期 multiple definition。备份放 `C:\Users\Administrator\.workbuddy\backups\`
-  或改扩展名 .c.bak。(2026-09-21 实际踩过)
-- `.cproject` 的 sourceEntries 已排除 `//.workbuddy`(共 110 项)。
-- 排 multiple definition 顺序: ①Debug/sources.mk 的 SUBDIRS ②工程树内同名 .c 副本 ③陈旧 .o。
-- 改完源码需 IDE 里 Refresh(F5) + Clean + Build。
-
-## 交付/验证环境
-- 本机无 arm-none-eabi 工具链, 无法本地编译。
-- 现成工具 `.workbuddy/tools/c_syntax_check.py`: 按标记切出改动块 + 最小桩声明, 用宿主 gcc
-  (`D:\Strawberry\c\bin\gcc.exe`) 做 `-fsyntax-only -Wall -Wextra`。参数 `--func 起 止` /
-  `--case 标记` / `--block 起 止`。中间文件 `.workbuddy/tmp_syn.txt` + `gcc -x c`, 跑完自删。
-  **改了 control.h 的结构体/原型要同步脚本里的 STUB**。
-- 备份约定: `C:\Users\Administrator\.workbuddy\backups\`(工程外)。
-- 专用检查脚本(都在 `.workbuddy/tools/`, 宿主 gcc + python, 跑完自删中间文件):
-  - `param_syn_check.py` — param_backup 模块 + control.h 真实结构体桩
-  - `ef_key_audit.py` — EasyFlash key/字段错位、default_env_set 重复/缺失审计
-  - `verify_fix.py` — device_status `-fno-common` 对照链接实验
-  - `sizeof_probe.py` — 实测结构体大小(往线程栈放大对象前先量)
-  - `degraded_boot_check.py` — flash 降级启动链路
-  - `ota_direct_check.py` — update 分支(禁 rt_kprintf、停机、进 ymodem)
-  - **`ota_thread_stop_check.py`** — ★含**线程覆盖性验证**: 从源码提取全部线程名,
-    按 RT_NAME_MAX=8 模拟截断+前缀匹配, 报告"漏网"线程。加新线程后跑一次即可确认被覆盖。
-  - `upgrade_flag_check.py` — 已改写为"升级机制现状检查", 核心是守住
-    **"函数删了但调用点还在"** 这类链接错误([B] 项)。
-- **函数被删时务必全局 grep 调用点** —— 2026-09-26 就踩到 `Upgrade_Flag_Clear()`
-  调用点还在而定义已删, 会 undefined reference。
-- `Debug/rtthread.map` 是旧构建产物(含已回退的 ctr_move_pulse), 不要拿来判当前源码状态。
-
-## device_status 全局唯一定义(2026-09-24 收敛)
-- **唯一真实定义在 `main.c`**。`control.h` 里有 `extern Device_Status_typedef device_status;`,
-  其余 .c(含 packages/syswatch.c)一律靠这个 extern, **不要再写第二份定义**。
-- 历史包袱: 原本 10 个 .c 各写一行 tentative definition, 靠 `-fcommon` 合并成 1592B COMMON 符号。
-  已实测: 该写法在 `-fno-common` 下直接 `multiple definition` 链接失败。
-- 引用 device_status 的 11 个 .c 全都 include control.h, 已核对; **新增 .c 若要用
-  device_status, 必须 include control.h**。
-
-## EasyFlash env key 别名表(改参数前必读)
-key 名与 `device_status` 字段名**故意不一致**的历史别名(读写成对, 别"顺手改成一致"):
-
-| env key | 字段 | 含义 |
-|---|---|---|
-| `reboot_time` | `rebootcnt` | 启动次数 |
-| `stime` | `clt_time` | 收集时间 |
-| `jtime` | `heattime` | 加热时间 |
-| `env_t` / `env_h` | `tempture` / `humidity` | 环境温湿度 |
-| `platform` | `mqttcfg1` | 平台地址 |
-
-- 🔴 **`heatvalue` 是双语义字段**: 测报灯(dtype!=7)写/读 `jheat`(加热温度, 0~130);
-  **孢子仪(dtype==7)写/读 `heatvalue`(培养温度, 10~50)**。开机已按 dtype 分支读取,
-  老设备回退 jheat。改这块前先看 hmi.c 的 dtype==7 分支。
-- `default_env_set` 在 `packages/EasyFlash-v4.1.0/src/ef_fal_port.c`, 53 项。
-  已修: `workmode`→`work_mode`、`shake_sw`→`shake_ws`(字段名是 shake_ws)、删重复 `run_sta`。
-- **已知未修(会改变行为, 等用户确认)**: `wind_sw`(风机开关)、`driver_compile`(BL 编译时间)
-  在 default_env_set 里有默认值, 但代码**从未 ef_get/ef_set** -> 重启不保存/读不到。
-- 审计工具 `.workbuddy/tools/ef_key_audit.py`: 查 key/字段错位、default_env_set 重复/缺失/未使用。
-
-## flash 损坏降级启动(2026-09-24 加固, 场景 A)
-- 🔴 **改了 RT-Thread 公共组件** `rt-thread/components/fal/samples/porting/fal_flash_sfud_port.c`。
-  IDE 更新/重生成 FAL 组件时**可能被覆盖**, 升级后确认 `nor_flash0_is_ready()` 还在不在。
-- 原链路四处返回值被丢弃(probe / fal_init / ops.init / 分区校验只查 offset 不查 offset+len),
-  flash 整体失效时一路"假装正常", 直到 `sfud_read(NULL,...)` 空指针 hard fault。
-- 加固要点: `nor_flash0_is_ready()` 对外暴露; init 失败时 **`nor_flash0.len = 0`**(让分区表
-  越界校验失败 -> fal_partition_find 返回 NULL, 把故障顶到上层); read/write/erase 显式判空。
-- 🔴 **`ef_fal_port.c` 的 `EF_ASSERT(part)` 已改成返回 `EF_ENV_INIT_FAILED`** ——
-  原来它是 `while(1)` 且 EF_DEBUG 不打印 -> 串口全无输出, 现场只见"通电没反应"。
-- `hmi.c Check_ParamConfig` 开头用 `nor_flash0_is_ready()` 门控: 不 ready 就**完全不调
-  easyflash_init()**, 32 连写用 `if (ef_ok)` 跳过, 走 RAM 出厂值 + 三声短鸣。
-- `nor_flash0_is_ready()` 在 **init 没被调用过时返回 1**(保守), 否则会把"从未探测"
-  误判成"flash 损坏" -> 整机参数凭空回出厂, 后果比原 bug 更严重。
-- `param_backup.c` 的 `g_disabled`: 分区都找不到时 mark_dirty/flush 直接失败, 不重试。
-- 判据: 串口出现 `!! SPI FLASH NOT READY` = 已损坏并降级启动。
-
-## 🔴 FAL / flash 的坑(2026-09-24 断言死循环血的教训)
-- **绝不能把 `nor_flash0.len` 清 0** 来"让分区表失效"。
-  `fal_partition.c` 的 `check_and_update_part_cache()` 一见 `offset >= len` 就 return -1
-  → `fal_partition_init()` 整体失败 → fal.c `init_ok` 永远为 0
-  → **任何 `fal_partition_find()` 都会撞第一行 `assert(init_ok)` 死循环**(全局杀伤,
-  连片内 bl/app 分区一起废)。想表达"这个设备坏了", 用 `nor_flash0_ready` 标志,
-  而不是改 len。
-- **`fal_partition_find()` 之前必须先查 `fal_init_check()`**。
-  `fal_init_check()` 定义在 fal.c 但 **fal.h 没导出**(fal_rtt.c 里是 extern 现声明的),
-  已在 `applications/fal_cfg.h` 补 extern。
-- `fal_flash_init()`(fal_flash.c:45)**丢弃** `ops.init()` 返回值 —— 移植层 init()
-  返回 -1 并不会让 FAL 失败, 别指望靠返回值传递故障。
-- 降级分支里**别忘了给 param_backup_init() 之类"顺带调用"加闸门**:
-  实测就是它第一个撞上断言(hmi.c 的 `Check_ParamConfig` 里它不在 ef_ok 门控内)。
-- 时序现状(正确, 别乱改): `rt_hw_spi_init`=INIT_BOARD(1) < sfud probe=INIT_COMPONENT(4)
-  < `fal_init`=INIT_APP(6), 都在 main 线程 `rt_components_init()` 里跑完才进 main()。
-
-## 栈的坑(2026-09-24 hard fault 血的教训)
-- **`sizeof(param_persist_t) = 820` 字节。任何线程栈上都不许放它**(哪怕只放一个)。
-  模块内部一律用 param_backup.c 的 `static param_persist_t g_work`(配 g_lock 保护);
-  调用方(如 hmi.c)需要持有就必须写 `static`。
-- 线程栈基线: `RT_MAIN_THREAD_STACK_SIZE` 已由 2048 提到 4096; 落盘线程栈 1024→2048。
-  **`rt_kprintf`/`vsnprintf` 本身就要好几百字节栈**, 新开线程栈别低于 2048。
-- RT-Thread 的 mutex **支持同线程递归 take**(`ipc.c`: `if (mutex->owner == thread) mutex->hold++`),
-  所以"外层持锁 → 调内部又加锁的函数"是安全的, 不会死锁。
-- 排查同类 hard fault 的工具: `.workbuddy/tools/sizeof_probe.py`(量结构体实际字节数)。
-  判据: 局部变量字节数 > 线程栈的 60% 就要警惕。
-- EasyFlash 相关另用 `.workbuddy/tools/param_syn_check.py`(抽真实 Device_Status_typedef + 桩)。
-
-## 参数存储(EasyFlash V4.1.0 NG) [2026-09-24 加双分区备份]
-- ENV 区: FAL 分区 `easyflash` @ norflash0 偏移 0, 64KB(16×4KB sector)。**分区起始必须保持 0、
-  不得小于 64KB**, 否则老设备升级后 ENV 读不出来 -> 整机参数回出厂。
-- `ef_set_env_blob` 立即落 flash(NG 的 `ef_save_env` 是空实现), 无掉电保护窗口。
-  写一半复位 -> 该条被判 ENV_ERR_HDR 永久丢失; GC 中断 -> 整个 sector 被 format。
-- **`iSave`(==FLASH_FLAG 2)是整机唯一哨兵**, 它一丢就全量刷出厂值。别再引入第二个单点哨兵。
-- 🔴 **绝不能 memcpy 整个 `Device_Status_typedef` 做持久化** —— 里面有 `const char *coll_time[10]`
-  指针数组, 存进去的是无效地址。持久化只用 `param_persist_t`(param_backup.h)。
-  新增需持久化字段要同步改: 结构体 + `param_pack()` + `param_unpack()` + `param_write_back_to_easyflash()`。
-- 双备份区: `param_a`@128K / `param_b`@132K 各 4KB, ping-pong + CRC32 + seq 递增 + 回读校验。
-- 写入一律走 `param_mark_dirty()`(延迟 500ms 静默 + 内容比对 + 最小间隔 10s);
-  只有恢复出厂用 `param_flush_force()`。**屏幕每帧刷屏也会打 dirty, 没节流几天就写穿 4KB。**
-- `param_mark_dirty()` 故意不加锁(只写对齐字长变量, M3 上原子), 加锁会卡住业务线程 ~100ms。
-- 已知未修的确定性 bug: `dtu_uart2.c` parse_param_to_mcu 里把 `startBar` 写进了 key `sunBar`;
-  `default_env_set` 有 `workmode` 但代码用 `work_mode`, 且缺 `cold_sw`/`heatvalue` 默认值。
-- syswatch 看门狗 5s 已启用(rtconfig.h:262)。flash GC / 固件备份的长阻塞有触发复位风险。
+- 脉冲 PC6=TIM3_CH1(pwm3/CH1);DIR=PB15(CTR_RO_LIMIT);EN=PB14(HK_IO)。
+  轴电源 X=ctr_lamp(1)、Y=ctr_Collect_Fan、Z=ctr_swz。限位 X=PC13、Y=PB8(dir0)、Z=PB9(dir1),高=触发。
+- **三路电源互斥,同时只准一个轴运动**(共用 PC6/PB14);切换顺序"先开目标轴、再关另两轴"。
+- 驱动器上电/EN/DIR 后需 ≥100ms 才发脉冲;发脉冲前先 pwm_stop()。
+- Y 轴垂直带载;点位间 X/Z 移动必然使 Y 断电 → 转子重对齐(每次数十脉冲)。
+- TIM3 无 RCR → 做不到"一次发 N 个脉冲";TIM1/TIM8 才有。TIM3_IRQHandler 当前未定义。
+- `board.h` **必须同时**声明 `BSP_USING_PWMx` 和 `BSP_USING_PWMx_CHy`。
+  只声明 PWM3/PWM8 时 `pwm_get_channel()` 得到 channel=0 → `stm32_hw_pwm_init` 的 4 个 if 全不成立 →
+  `HAL_TIM_PWM_ConfigChannel()` 一次都不调,PWM 靠 `board.c` 残留配置撑着(隐式耦合,改 CubeMX 就静默失效)。
+  现值:PWM3_CH1(PC6 蜂鸣器/步进)、CH2/CH3/CH4(PB1 清洁刷),PWM8_CH2(PC7)/CH3(PC8)。
+
+## 运动接口约定
+- `ctr_move(轴,方向,dis_,pulse)` 是"定时开 PWM"不是脉冲计数;**dis_≥8000 每格 10ms,<8000 每格 1ms**
+  → 同数值跨门槛行程差 10 倍(撞机械极限的经典坑)。返回 dis_ 而非实际行程。
+- 复位/到位用 mapSpeed(50)=125us(8kHz);对焦/预对焦用 1ms 使 1 单位=1 脉冲。
+- 所有滑台动作由 `slide_thread_entry` 串行派发:`slide_para.en_slide`
+  1/2=X/Z移动、3=X复位、4=Z复位、6=Y步进、7=Y复位、8=录制。`stop_move()` 置 stop_flag=1 且不清零。
+- 🔴 **派发自死锁**:在 slide 线程内调用的函数里绝不能 `en_slide=6` 后死等清零。
+  已抽底层 `slide_y_step(dir,dis,pulse)`;`pf_move()` 用 `rt_thread_self()==g_slide_thread` 判断。
+- `en_slide=6` 有 4 个派发点且 ydis 口径不统一(脉冲 vs tick):hmi.c 的 auto_focus_move_to /
+  calibrate_move / Ctr_Mortor(y_init_dis≈9000) / dtu_uart2.c 远程命令。改单个必须加显式模式位。
+
+## 预对焦(Pre-Focus)
+- `FOCUS_STEP_EN=0`,爬山对焦未启用。实际链路:MCU 发 `mov_init_y/takephoto_done` → 工控机开录 →
+  下发 `record_start` → case 8 下行+回程 → 发 `record_stop` → 工控机挑最清晰帧。
+- `PF_EN`(=1) 每点位录制前先 `slide_pre_focus()`:PF_STEP 下采样找清晰度上升沿,回退 PF_HEADROOM 作录制起点。
+  实现在 control.c "预对焦"块:pf_request_focus/pf_move/pf_scan_down/slide_pre_focus/slide_set_record_travel
+  + `g_record_dis_1/0` + `g_record_preroll`。两阶段:①向下 PF_SEARCH_LIMIT;②失败上退 PF_PHASE2_UP 重扫;
+  仍失败先退回进入高度再兜底(否则净下行叠加会撞下限)。
+- `g_pf_busy` 在 hmi.c 的 `autotakepic==2` 分支挡掉预对焦期间收到的 focus 帧。
+- hmi.c ==3 分支扣 PF_APPROACH_BACKOFF 后**仍须 ≥8000**;PF 退出要恢复 `slide_para.pulse_period`。
+- 🔴 历史 bug(已修):老 case 8 下行 1500 / 回程硬编码 800 不对称 → 每点位净下移 700 单位,
+  32 点位累计约 3000 脉冲单向爬行。现两向共用 `g_record_preroll`,留 `PF_RETURN_BIAS_MS` 补偿。
+- 待现场标定:PF_STEP/SEARCH_LIMIT/HEADROOM/APPROACH_BACKOFF/RISE_RATIO/RECORD_MS_OK/RETURN_BIAS_MS。
+
+## 点位漂移 / 录制 case 8 / stop_move
+- 一轮 32 点位内 Y 不复位,只在整轮开始复位一次 → 误差累加;**限位开关是唯一绝对基准**(无编码器)。
+  越靠后的点位画面越往 dir=1 偏,实测一轮偏 2~3 秒行程。
+  诊断钩子 hmi.c 的 `g_y_abs`,超 AF_ABS_DRIFT_LIMIT(1200) LOG_E,上报被 `#if 0` 关着。
+  **已知未修**:注释称整轮复位处清零 `g_y_abs`,代码里没这行 → 跨轮累积。
+- case 8:下行 → record_stop → delay(200) → 回程。相对往返必然留净偏差,两向现共用 `g_record_preroll`。
+  回程 dir=0 是限位方向,`ctr_move` 对 Y 有起始前/循环内两处限位保护。
+  **鸣叫次数是判据:3 声=限位或急停,无声=脉冲/周期问题**。
+- `stop_move()` 调用点:dtu_uart2.c 某下行命令、`xdis==0`、`led_off` → 平台指令可打断录制回程。
+
+## 参数存储(EasyFlash NG) + 双分区备份
+- ENV 区 `easyflash`@norflash0 偏移 0、128KB(**起始必须 0 且 ≥64KB**,否则老设备升级后参数回出厂)。
+- `ef_set_env_blob` 立即落 flash(NG 的 ef_save_env 是空实现),无掉电保护窗口。
+- **`iSave`(==FLASH_FLAG 2) 是整机唯一哨兵**,别引入第二个单点哨兵。
+- 持久化只用 `param_persist_t`(820B,**任何线程栈上都不许放**,模块内用 `static g_work` + g_lock);
+  新增字段要同步改 结构体 + param_pack + param_unpack + param_write_back_to_easyflash。
+- 双备份 `param_a`@128K / `param_b`@132K 各 4KB,ping-pong + CRC32 + seq 递增 + 回读校验。
+  写入一律 `param_mark_dirty()`(延迟 500ms + 比对 + 最小间隔 10s);只有恢复出厂用 `param_flush_force()`。
+- `param_mark_dirty()` 故意不加锁(只写对齐字长,M3 上原子)。
+- key↔字段历史别名(成对,别"顺手改成一致"):`reboot_time`↔rebootcnt、`stime`↔clt_time、
+  `jtime`↔heattime、`env_t`/`env_h`↔tempture/humidity、`platform`↔mqttcfg1。
+- 🔴 `heatvalue` 双语义:dtype!=7 读写 `jheat`(0~130),dtype==7 读写 `heatvalue`(10~50)。
+- 已知未修:`wind_sw`/`driver_compile` 在 default_env_set 有默认值但代码从不 ef_get/ef_set。
+
+## FAL / flash 降级启动
+- 🔴 **绝不能把 `nor_flash0.len` 清 0** 让分区表失效 → `fal_partition_find()` 撞 `assert(init_ok)`
+  死循环(全局杀伤)。要表达"坏了"用 `nor_flash0_ready` 标志。
+- `fal_partition_find()` 前**必须先查 `fal_init_check()`**(fal.h 未导出,已在 applications/fal_cfg.h 补 extern)。
+- `fal_flash_init()` 丢弃 `ops.init()` 返回值,别指望靠返回值传故障。
+- 改过 `rt-thread/components/fal/samples/porting/fal_flash_sfud_port.c`(`nor_flash0_is_ready()`);
+  `ef_fal_port.c` 的 `EF_ASSERT(part)` 已改成返回 `EF_ENV_INIT_FAILED`。
+  **IDE 更新 FAL 组件可能被覆盖,升级后要确认还在**。
+- `nor_flash0_is_ready()` 在 init 没被调用过时返回 1(保守,否则会把"从未探测"误判成损坏)。
+- 判据:串口出现 `!! SPI FLASH NOT READY` = 已降级启动。
+- 时序:spi_init(INIT_BOARD) < sfud probe(INIT_COMPONENT) < fal_init(INIT_APP)。
+
+## 栈 / 并发 / 发送
+- `sizeof(param_persist_t)=820`,`Device_Status_typedef`≈1746 → 都不许上栈。
+- 线程栈基线:main 4096、DTU 4096、work_loop 2048、Control_Clear 2048、net_wait 2048、
+  sht30 两线程 **2048**(第四批从 1024 提上来,因 `sprintf("%.2f")` dtoa 峰值 500~800B 且 `TempCalculate()` 含 `log()`)、
+  **Control_Check / work_status_check / thread_485play 仍只有 1024**(待扩容)。
+- `HAL_Delay()` 在 drv_common.c 实现为 `HAL_GetTick()` 差值忙等。
+  ⚠️ **不能**改成 `rt_thread_mdelay()`:`hw_board_init()` 在调度器启动**之前**就调 `HAL_Init()`,那时永久挂起。
+- `dtu_write_json(char *json)`:发送**堆上** JSON 并自动 free(内部固定 `"%s"`)。
+  栈/静态缓冲**不能**传进去。栈上缓冲用 `DTU_Write("%s", buf)`。
+- 🔴 **`DTU_Write()` 的锁覆盖全过程**(格式化→写串口→485 转发→日志)。`dtu_str` 是 static 共享缓冲,
+  第四批已把锁提到 `va_start` 之前;原来只在 `rt_device_write` 前后加锁 → 并发时发出半截/混合 JSON。
+- 🔴 `DTU_Write`/`Uart5_Write` 都是变参函数,**绝不能把内容当格式串传**(平台下发含 `%s/%n` 会被当格式指令)。
+- `Uart5_Write` 有自己的 `uart5_write_mutex`(**不能**复用 `dtu_write_mutex`,会自死锁)。
+- `dtu_stop_send_thread()`:替代裸 `rt_thread_delete(dtu_send_data)`。
+  **`rt_thread_delete()` 不释放被删线程持有的 mutex** → owner 指向已销毁线程 → 之后所有 `DTU_Write()` 永久挂起。
+- 🔴 **本工程 `rt_mutex_control()` 是空实现**(ipc.c:1216 直接 return -RT_ERROR),
+  **`RT_IPC_CMD_RESET` 对 mutex 无效**。要"清锁"只能 `rt_mutex_detach` + `rt_mutex_init`。
+- `HMI_WRITE()` 已加 `hmi_write_mutex`(第三批);内部仍有 `rt_thread_mdelay` → **ISR/HARD_TIMER 禁止调用**。
+- RT-Thread mutex **支持同线程递归 take**;惰性 init mutex 必须包在 `rt_enter_critical()` 里。
+
+## 🔴 uart2 / uart5 接收链路(2026-09-28 第四批改为批量读)
+- **绝不能**再写 `rt_device_read(dev,-1,&ch,1)` 逐字节:115200bps = 11520 字节/秒 = 每秒上万次系统调用。
+- 现状:`rx_indicate`(`dtu_input`/`uart5_input`)只把 size 累加进 `dtu_rx_pending`/`uart5_rx_pending`
+  并 release 信号量;接收线程 `rt_device_read(dev, 0, rx_blk, DTU_RX_BLK_SIZE=128)` 一次读 128 字节,
+  再调公共 `dtu_feed_block()` 逐字节喂 lwjson。`dtu_rx_pending` **只作参考**,read 返回 0 就退回等信号量。
+- `lwjson_stream_parse()` 本身是单字节 API,这步省不掉;省的是系统调用。
+- uart2 用 `lwparser`,uart5 用**独立的 `lwparser_485`** —— 共用会互相破坏 parse_state/stack_pos。
+  (`MATCH_DEVICE=0` 时 uart5 线程不建,属休眠缺陷;一旦打开就是必现故障。)
+
+## 版本控制 / 构建 / 工具
+- 仓库根 = `D:\RT-ThreadStudio\workspace\IOT_CBD_BZY_CTRL`(本工程是子目录),HEAD 曾为 "3.7.13"。
+  git 不在 PATH,用 `C:\Users\Administrator\.workbuddy\binaries\PortableGit\versions\1.2.0\cmd\git.exe`。
+- 工作区长期带用户未提交改动(control.c/h、hmi.c、dtu_uart2.c、readme.md)→ **禁止 git checkout 一把梭**,
+  必须 `git diff` 逐 hunk 精确回退。
+- Eclipse CDT managed build,`Debug/` 产物,sources.mk/subdir.mk 自动生成;改完需 IDE Refresh+Clean+Build。
+- `.cproject` 的 `sourceEntries/excluding` 已排除 `//applications/lwjson.c`、`//lwjson_debug.c` 与 `//.workbuddy`。
+  ⚠️ 改这里**必须 Refresh+Clean+Build**才生效。
+- 排 multiple definition:①Debug/sources.mk 的 SUBDIRS ②工程树内同名 .c 副本 ③陈旧 .o。
+- **本机无 arm-none-eabi,不能本地编译**。工具在 `.workbuddy/tools/`(宿主 gcc `D:\Strawberry\c\bin\gcc.exe` + python):
+  `c_syntax_check.py`(按标记切块 -fsyntax-only)、`verify_fix.py`、`param_syn_check.py`、`ef_key_audit.py`、
+  `sizeof_probe.py`、`degraded_boot_check.py`、**`ota_uart_close_check.py`(★第五批新增:A语法/B括号/C符号/D调用顺序)**、
+  `upgrade_flag_check.py`。改了 control.h 结构体/原型要同步脚本里的 STUB。
+  ⚠️ 新写这类脚本时:桩里要 `typedef struct rt_device *rt_device_t;`(只 typedef struct 不给别名会报 unknown type name)。
+- `Debug/rtthread.map` 是旧产物(含已回退的 ctr_move_pulse),别拿来判当前源码状态。
+- 函数被删时务必全局 grep 调用点(踩过 `Upgrade_Flag_Clear()` 定义删了调用还在 → undefined reference)。
+- 🔧 Bash 工具 PATH 有时坏(`dirname/ls: command not found`);PowerShell **不回传 stdout**。
+  变通:让脚本自己把结果写文件,再用 Read 读(`ota_uart_close_check.py` 就是这么用的)。
+
+## 已回退/废弃备查
+- `ctr_move_pulse()`(TIM3 更新中断计数)曾实现并验证,因"回程时间不够"整体回退,**当前源码无此实现**。
+- 升级三通道标志机制(EasyFlash + 快照 + RTC BKP_DR3 魔数 0x5AA5)已废弃;
+  当前 `update_flag` 唯一用途是"RAM 置 1 触发线程 break 退出",全程不写 flash。
+
+## 审计报告与修复进度
+- 2026-09-28 产出 `固件代码审计与优化报告_2026-09-28.md`(P0×4 / P1×18 / P2×15 / P3×8 / 待确认×6)。
+  最高危:`UpLoad_Data()` 的 `DTU_Write(updata)` 格式串、平台 JSON 字段大面积未判空、`LOG_W("...%s...",ch)`、
+  HARD_TIMER 里调 HMI_WRITE、多处定长数组越界、DTU_Write 未配对 free。
+- 修复进度(2.42 → 2.46):一批 P0-1/2/3/4 + P1-2/4/15/16;二批 P1-1/3/5/8/18;
+  三批 P1-6~14/17 + P2-1~5/10/13/15;四批 P2-6~9/11/12/14 + P3 全部
+  + 报告外的 DTU_Write 锁位置、Uart5_Write 格式串注入、board.h 补 CH 宏、接收批量读。第五批(2.47)= OTA 前关串口4/5。
+- **遗留未动**:`ymodem_ota`/`itoa` 隐式声明 warning、报告第六节 6 项待上机确认、
+  `hmi.c` 的 `iSave != FLASH_FLAG` 恢复 `update_flag`、`g_y_abs` 跨轮不清零、
+  Control_Check/work_status_check/thread_485play 线程栈仍 1024。

+ 51 - 0
Application_cbd_apm32f1/.workbuddy/ota_uart_close_check.txt

@@ -0,0 +1,51 @@
+==========================================================================
+[A] control.c: ota_close_uart() + uart_stop_for_ota() —— 宿主 gcc 语法检查
+==========================================================================
+  切出片段行数: ota_close_uart=25, uart_stop_for_ota=43
+  gcc exit=0
+  => PASS
+
+==========================================================================
+[B] 本批改动文件的花括号/圆括号配平
+==========================================================================
+  control.c          {}=+0  ()=+0  => OK
+  control.h          {}=+0  ()=+0  => OK
+  hmi.c              {}=+0  ()=+0  => OK
+  hmi.h              {}=+0  ()=+0  => OK
+  dtu_uart2.c        {}=+0  ()=+0  => OK
+  dtu_uart2.h        {}=+0  ()=+0  => OK
+  sht30_collect.c    {}=+0  ()=+0  => OK
+  => PASS
+
+==========================================================================
+[C] 符号一致性: 定义 / 声明 / 引用
+==========================================================================
+    定义点 1 处: ['applications\\dtu_uart2.c:72']
+  serial_485 唯一定义: PASS
+  g_hmi_port_closed: 定义=1 extern=1 总引用=7
+    => PASS
+  sht30_collect.c 已删重复定义并 include dtu_uart2.h: PASS
+  uart_stop_for_ota 声明(control.h)+调用(dtu_uart2.c): PASS
+  Uart5_Write_Bin 判空 serial_485: PASS
+  => PASS
+
+==========================================================================
+[D] update 分支调用顺序: 先 thread_stop_all_for_ota() 再 uart_stop_for_ota()
+==========================================================================
+  匹配到 'thread_stop_all...(); ... uart_stop_for_ota();' 顺序块: 是
+  片段:
+    | thread_stop_all_for_ota();
+    | 
+    | /* ---- 再关串口4(HMI屏) 与串口5(485) ----
+    | ★ 顺序不能反: 必须先停线程(没人再发数据)再关设备。
+    | 反过来的话, 关设备的瞬间还有线程在 HMI_WRITE / Uart5_Write,
+    | 会写到正在被拆掉的 tx fifo 上。
+    | 关闭后句柄被置 NULL、g_hmi_port_closed 置 1, 所有发送路径
+    | 直接 return —— 这段时间对外静默正是升级需要的。 */
+    | uart_stop_for_ota();
+  uart_stop_for_ota() 之后才是 ymodem_ota(): 是
+  => PASS
+
+==========================================================================
+总计: 全部通过
+==========================================================================

+ 271 - 0
Application_cbd_apm32f1/.workbuddy/tools/ota_uart_close_check.py

@@ -0,0 +1,271 @@
+# -*- coding: utf-8 -*-
+"""
+第五批「OTA 升级前关闭串口4/串口5」的验证脚本。
+
+只读源文件, 中间产物全部写系统临时目录, 不在工程树里留 .c/.h
+(CDT 会扫描全部 .c/.h, 留在树内会 multiple definition)。
+
+验证四项:
+  [A] control.c 的 ota_close_uart() / uart_stop_for_ota() —— 宿主 gcc -fsyntax-only
+  [B] 括号/花括号配平(本批改动的 6 个文件)
+  [C] 符号一致性: g_hmi_port_closed / uart_stop_for_ota / serial_485 定义-引用匹配
+  [D] 调用顺序: update 分支里 thread_stop_all_for_ota() 必须在 uart_stop_for_ota() 之前
+"""
+import os
+import re
+import sys
+import shutil
+import tempfile
+import subprocess
+
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+GCC = r"D:\Strawberry\c\bin\gcc.exe"
+OUT = os.path.join(ROOT, ".workbuddy", "ota_uart_close_check.txt")
+
+APP = os.path.join(ROOT, "applications")
+FILES = ["control.c", "control.h", "hmi.c", "hmi.h",
+         "dtu_uart2.c", "dtu_uart2.h", "sht30_collect.c"]
+
+lines = []
+
+
+def log(s=""):
+    lines.append(s)
+
+
+def read(path):
+    with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        return f.read()
+
+
+def run_gcc(args, cwd):
+    try:
+        p = subprocess.run([GCC] + args, cwd=cwd, capture_output=True, text=True,
+                           encoding="utf-8", errors="replace", timeout=120)
+        return p.returncode, (p.stdout or "") + (p.stderr or "")
+    except Exception as e:
+        return -1, str(e)
+
+
+def slice_lines(path, start_pat, end_pat):
+    src = read(path).splitlines()
+    s = e = -1
+    for i, ln in enumerate(src):
+        if s < 0 and re.search(start_pat, ln):
+            s = i
+        elif s >= 0 and re.search(end_pat, ln):
+            e = i
+            break
+    return src[s:e + 1] if (s >= 0 and e >= 0) else []
+
+
+# ---------------- A. 语法检查 ----------------
+def check_syntax(tmp):
+    log("=" * 74)
+    log("[A] control.c: ota_close_uart() + uart_stop_for_ota() —— 宿主 gcc 语法检查")
+    log("=" * 74)
+    ctl_c = os.path.join(APP, "control.c")
+
+    blk1 = slice_lines(ctl_c, r"static void ota_close_uart\(", r"^\}")
+    blk2 = slice_lines(ctl_c, r"^int uart_stop_for_ota\(void\)", r"^\}")
+    if not blk1 or not blk2:
+        log("  [FAIL] 未定位到改动块 (ota_close_uart=%d 行, uart_stop_for_ota=%d 行)"
+            % (len(blk1), len(blk2)))
+        return False
+
+    stub = r"""
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+typedef unsigned char  rt_uint8_t;
+typedef unsigned char  uint8_t;
+typedef long           rt_int32_t;
+typedef unsigned long  rt_uint32_t;
+typedef unsigned long  rt_size_t;
+
+typedef struct rt_object {
+    char name[8];
+    unsigned char type;
+    unsigned char flags;
+} rt_object_t;
+
+typedef struct rt_device {
+    rt_object_t parent;
+    rt_uint8_t type;
+    rt_uint8_t ref_count;
+} rt_device;
+typedef struct rt_device *rt_device_t;
+
+typedef struct rt_mutex { rt_uint32_t dummy; } rt_mutex_t;
+typedef struct rt_semaphore { rt_uint32_t dummy; } rt_sem_t;
+typedef struct rt_thread { rt_uint32_t dummy; } rt_thread_t;
+
+#define RT_NULL ((void *)0)
+#define RT_EOK 0
+#define RT_CONSOLE_DEVICE_NAME "uart1"
+#define UART_NAME "uart4"
+#define LOG_I(...) do { } while (0)
+
+extern rt_device_t serial;
+extern rt_device_t serial_485;
+extern rt_uint8_t g_hmi_port_closed;
+rt_device_t rt_console_get_device(void);
+rt_device_t rt_console_set_device(const char *name);
+int rt_strcmp(const char *a, const char *b);
+int finsh_set_device(const char *name);
+rt_int32_t rt_device_close(rt_device_t device);
+rt_int32_t rt_device_set_rx_indicate(rt_device_t device, void (*hdr)(rt_device_t, rt_size_t));
+"""
+
+    body = "\n".join(blk1 + [""] + blk2)
+    p = os.path.join(tmp, "a_ota.c")
+    with open(p, "w", encoding="utf-8") as f:
+        f.write(stub + "\n" + body + "\n")
+
+    rc, out = run_gcc(["-x", "c", "-fsyntax-only", "-std=gnu99", "-Wall", "-Wextra",
+                       "-Wno-unused-parameter", "-Wno-unused-variable",
+                       "-D__ota_stub", p], tmp)
+    log("  切出片段行数: ota_close_uart=%d, uart_stop_for_ota=%d" % (len(blk1), len(blk2)))
+    log("  gcc exit=%d" % rc)
+    if out.strip():
+        log(out.strip()[:2500])
+    ok = (rc == 0)
+    log("  => %s" % ("PASS" if ok else "FAIL"))
+    return ok
+
+
+# ---------------- B. 括号配平 ----------------
+def check_braces():
+    log()
+    log("=" * 74)
+    log("[B] 本批改动文件的花括号/圆括号配平")
+    log("=" * 74)
+    ok = True
+    for fn in FILES:
+        p = os.path.join(APP, fn)
+        if not os.path.exists(p):
+            log("  %-18s [SKIP] 文件不存在" % fn)
+            continue
+        txt = read(p)
+        # 粗略剔除字符串/注释,避免误判
+        t = re.sub(r"/\*.*?\*/", "", txt, flags=re.S)
+        t = re.sub(r"//[^\n]*", "", t)
+        t = re.sub(r'"(\\.|[^"\\])*"', '""', t)
+        t = re.sub(r"'(\\.|[^'\\])*'", "''", t)
+        b, r = t.count("{") - t.count("}"), t.count("(") - t.count(")")
+        good = (b == 0 and r == 0)
+        ok = ok and good
+        log("  %-18s {}=%+d  ()=%+d  => %s"
+            % (fn, b, r, "OK" if good else "BRACE_FAIL"))
+    log("  => %s" % ("PASS" if ok else "FAIL"))
+    return ok
+
+
+# ---------------- C. 符号一致性 ----------------
+def check_symbols():
+    log()
+    log("=" * 74)
+    log("[C] 符号一致性: 定义 / 声明 / 引用")
+    log("=" * 74)
+    ok = True
+
+    def scan(pat_def, expect_def_files):
+        """统计全 applications 下的定义点"""
+        hits = []
+        for dirpath, _, names in os.walk(APP):
+            for n in names:
+                if not n.endswith((".c", ".h")):
+                    continue
+                fp = os.path.join(dirpath, n)
+                for i, ln in enumerate(read(fp).splitlines()):
+                    if re.search(pat_def, ln):
+                        hits.append("%s:%d" % (os.path.relpath(fp, ROOT), i + 1))
+        log("    定义点 %d 处: %s" % (len(hits), hits if hits else "无"))
+        good = len(hits) == 1
+        return good, hits
+
+    # serial_485: 必须只 1 处定义
+    good, hits = scan(r"^\s*rt_device_t\s+serial_485\s*(\[[^\]]*\])?\s*;", 1)
+    ok = ok and good
+    log("  serial_485 唯一定义: %s" % ("PASS" if good else "FAIL(多份定义,靠 -fcommon 合并)"))
+
+    # g_hmi_port_closed: 1 定义 + extern
+    txts = {fn: read(os.path.join(APP, fn)) for fn in FILES if os.path.exists(os.path.join(APP, fn))}
+    alltxt = "\n".join(txts.values())
+    ndef = len(re.findall(r"^\s*rt_uint8_t\s+g_hmi_port_closed\s*=", alltxt, re.M))
+    next_ = len(re.findall(r"^\s*extern\s+rt_uint8_t\s+g_hmi_port_closed\s*;", alltxt, re.M))
+    nref = len(re.findall(r"g_hmi_port_closed", alltxt))
+    log("  g_hmi_port_closed: 定义=%d extern=%d 总引用=%d" % (ndef, next_, nref))
+    good = (ndef == 1 and next_ >= 1)
+    ok = ok and good
+    log("    => %s" % ("PASS" if good else "FAIL"))
+
+    # sht30_collect.c 必须 include dtu_uart2.h 才能拿到 extern
+    sht = txts.get("sht30_collect.c", "")
+    good = ('#include "dtu_uart2.h"' in sht) and ("rt_device_t serial_485;" not in sht)
+    ok = ok and good
+    log("  sht30_collect.c 已删重复定义并 include dtu_uart2.h: %s"
+        % ("PASS" if good else "FAIL"))
+
+    # uart_stop_for_ota: control.h 有声明, dtu_uart2.c 有调用
+    good = ("int uart_stop_for_ota(void);" in txts.get("control.h", "")
+            and "uart_stop_for_ota();" in txts.get("dtu_uart2.c", ""))
+    ok = ok and good
+    log("  uart_stop_for_ota 声明(control.h)+调用(dtu_uart2.c): %s"
+        % ("PASS" if good else "FAIL"))
+
+    # Uart5_Write_Bin 必须判 serial_485
+    u5 = slice_lines(os.path.join(APP, "dtu_uart2.c"),
+                     r"Uart5_Write_Bin\s*\(", r"^\}")
+    joined = "\n".join(u5)
+    good = ("serial_485 == RT_NULL" in joined) or ("!serial_485" in joined)
+    ok = ok and good
+    log("  Uart5_Write_Bin 判空 serial_485: %s" % ("PASS" if good else "FAIL"))
+
+    log("  => %s" % ("PASS" if ok else "FAIL"))
+    return ok
+
+
+# ---------------- D. 调用顺序 ----------------
+def check_order():
+    log()
+    log("=" * 74)
+    log("[D] update 分支调用顺序: 先 thread_stop_all_for_ota() 再 uart_stop_for_ota()")
+    log("=" * 74)
+    dtu = read(os.path.join(APP, "dtu_uart2.c"))
+    m = re.search(r"thread_stop_all_for_ota\s*\(\s*\)\s*;.*?uart_stop_for_ota\s*\(\s*\)\s*;",
+                  dtu, re.S)
+    log("  匹配到 'thread_stop_all...(); ... uart_stop_for_ota();' 顺序块: %s"
+        % ("是" if m else "否"))
+    if m:
+        log("  片段:")
+        for ln in m.group(0).splitlines():
+            log("    | " + ln.strip())
+    # ymodem_ota 必须在两者之后
+    tail = dtu[m.end():] if m else ""
+    good = bool(m) and "ymodem_ota" in tail
+    log("  uart_stop_for_ota() 之后才是 ymodem_ota(): %s" % ("是" if good else "否"))
+    log("  => %s" % ("PASS" if (m and good) else "FAIL"))
+    return bool(m and good)
+
+
+def main():
+    tmp = tempfile.mkdtemp(prefix="otauart_")
+    try:
+        a = check_syntax(tmp)
+        b = check_braces()
+        c = check_symbols()
+        d = check_order()
+        log()
+        log("=" * 74)
+        log("总计: %s" % ("全部通过" if (a and b and c and d) else "存在 FAIL, 见上"))
+        log("=" * 74)
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+    with open(OUT, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
+    print("done ->", OUT)
+
+
+if __name__ == "__main__":
+    main()

+ 74 - 17
Application_cbd_apm32f1/applications/beep.c

@@ -21,18 +21,41 @@
 struct rt_device_pwm    *pwm_device = RT_NULL; //定义 pwm 设备指针
 struct rt_device_pwm    *pwm_tim8 = RT_NULL; //定义 pwm 设备指针
 
-/* 定时器超时回调函数 */
+/* 定时器设备句柄(文件作用域, 供 beep_timer_release() 在线程上下文收尾) */
+rt_device_t hw_dev = RT_NULL;
+
+/* ★ ISR 里只允许置标志 + 纯 HAL 操作, 不允许任何可能阻塞的 API。
+   g_beep_timer_fired: hwtimer one-shot 已到期, 由线程上下文的 beep_timer_release() 收尾。 */
+static volatile uint8_t g_beep_timer_fired = 0;
+
+/* 定时器超时回调函数(硬件定时器中断上下文) */
 static rt_err_t timeout_cb(rt_device_t dev, rt_size_t size)
 {
-    rt_kprintf("this is hwtimer timeout callback fucntion!\n");
-    rt_kprintf("tick is :%d !\n", rt_tick_get());
-    rt_pwm_disable(pwm_device, BEEP_PWM_CH);
-    rt_device_close(dev);
+    /* ★ 原实现在 ISR 里做了三件不该做的事:
+         ① rt_kprintf  -> 走 console 设备 rt_device_write, 发送未完成时会在完成量上等待;
+         ② rt_device_close -> 内部有 RT_ASSERT 且会调 dev->close(), 属线程上下文 API;
+       这两者在中断里调用会死锁在 ISR 内, 整机停死后 5s 看门狗复位,
+       现象是"蜂鸣器响/电机走到限位时随机死机"。
+       现在只置标志 + 关 PWM(rt_pwm_disable 走 HAL, 不取任何 IPC 锁)。 */
+    g_beep_timer_fired = 1;
+    if (pwm_device != RT_NULL)
+    {
+        rt_pwm_disable(pwm_device, BEEP_PWM_CH);
+    }
     return 0;
 }
 
-
-rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
+/* 线程上下文: 关掉上一次 one-shot 到期后遗留的 hwtimer 设备句柄。
+   不能在 timeout_cb 里 close(见上), 放在下一次 init_tim2() 开头收尾。 */
+static void beep_timer_release(void)
+{
+    if (g_beep_timer_fired && hw_dev != RT_NULL)
+    {
+        rt_device_close(hw_dev);
+        hw_dev = RT_NULL;
+    }
+    g_beep_timer_fired = 0;
+}
 
 static int hwtimer_sample(int argc, char *argv[])
 {
@@ -115,10 +138,13 @@ static int init_tim2(void)
 {
     rt_err_t ret = RT_EOK;
     rt_hwtimerval_t timeout_s;      /* 定时器超时值 */
-    rt_device_t hw_dev = RT_NULL;   /* 定时器设备句柄 */
     rt_hwtimer_mode_t mode;         /* 定时器模式 */
     rt_uint32_t freq = 10000;               /* 计数频率 */
 
+    /* ★ 原来这里又声明了一个同名的局部 hw_dev, 把文件作用域的 hw_dev 整个屏蔽掉,
+       函数一返回句柄就丢了, beep_timer_release() 无从收尾。改用全局那份。 */
+    beep_timer_release();
+
     /* 查找定时器设备 */
     hw_dev = rt_device_find(HWTIMER_DEV_NAME);
     if (hw_dev == RT_NULL)
@@ -169,7 +195,13 @@ int hwtimer2_pwm3_output(rt_uint32_t time,rt_uint32_t freq,uint8_t EN,uint8_t DI
     rt_pin_write(Motor_EN, EN);
     rt_thread_delay(1);
     rt_pin_write(Motor_DIR, DIR);
-    init_pwm3();
+    /* ★ init_pwm3() 失败时 pwm_device 为 NULL, 原代码不判空直接传给 rt_pwm_set/enable
+       -> 解引用空 struct rt_device_pwm -> hard fault。 */
+    if (init_pwm3() != 0 || pwm_device == RT_NULL)
+    {
+        rt_kprintf("hwtimer2_pwm3_output: pwm3 not available!\n");
+        return -RT_ERROR;
+    }
 
     rt_pwm_set(pwm_device, BEEP_PWM_CH, freq, freq/2);//channel,period,pulse
     if(init_tim2()==0)
@@ -177,10 +209,19 @@ int hwtimer2_pwm3_output(rt_uint32_t time,rt_uint32_t freq,uint8_t EN,uint8_t DI
     return 0;
 }
 
-static void stop_motor_86(void)
+/* 86 电机限位中断回调(GPIO 中断上下文)
+   ★ 形参必须是 void *args: rt_pin_attach_irq 要求的类型是 void (*)(void *),
+     原来声明成 void(void), 属函数指针类型不匹配(未定义行为)。 */
+static void stop_motor_86(void *args)
 {
-    rt_kprintf("stop_motor_86!\n");
-    rt_pwm_disable(pwm_device, BEEP_PWM_CH);
+    (void)args;
+    /* ★ 原来是 rt_kprintf + 无判空的 rt_pwm_disable。
+       rt_kprintf 在中断里走 console 设备写, 可能阻塞 -> 死锁在 ISR。
+       PWM 句柄为空时 rt_pwm_disable 会解引用空 struct -> hard fault。 */
+    if (pwm_device != RT_NULL)
+    {
+        rt_pwm_disable(pwm_device, BEEP_PWM_CH);
+    }
 }
 
 void pin_motor_86_bind(void)
@@ -201,6 +242,9 @@ void pin_motor_86_unbind(void)
 /*打开蜂鸣器*/
 int pwm_on(uint8_t pwn_ch,rt_uint32_t pwm_freq)
 {
+    /* ★ PWM 句柄判空(与 beep_init 等价, 找不到设备时返回非 0) */
+    if (pwm_device == RT_NULL && beep_init() != 0)
+        return -RT_ERROR;
     rt_pwm_set(pwm_device, pwn_ch, pwm_freq, pwm_freq/2);
     rt_pwm_enable(pwm_device, pwn_ch); //使能蜂鸣器对应的 PWM 通道
     return 0;
@@ -208,6 +252,8 @@ int pwm_on(uint8_t pwn_ch,rt_uint32_t pwm_freq)
 /*关闭蜂鸣器*/
 int pwm_off(uint8_t pwn_ch,rt_uint32_t pwm_freq)
 {
+    if (pwm_device == RT_NULL && beep_init() != 0)
+        return -RT_ERROR;
     rt_pwm_set(pwm_device, pwn_ch, pwm_freq, 0);
     rt_pwm_disable(pwm_device, pwn_ch); //使能蜂鸣器对应的 PWM 通道
     return 0;
@@ -225,12 +271,16 @@ int pwm8_init(void)
 /*打开蜂鸣器*/
 int beep_on(void)
 {
+    if (pwm_device == RT_NULL && beep_init() != 0)
+        return -RT_ERROR;
     rt_pwm_enable(pwm_device, BEEP_PWM_CH); //使能蜂鸣器对应的 PWM 通道
     return 0;
 }
 /*关闭蜂鸣器*/
 int beep_off(void)
 {
+    if (pwm_device == RT_NULL && beep_init() != 0)
+        return -RT_ERROR;
     rt_pwm_disable(pwm_device, BEEP_PWM_CH); //失能蜂鸣器对应的 PWM 通道
     return 0;
 }
@@ -244,7 +294,9 @@ void beep_set(uint32_t freq, uint32_t volume)
 {
 
     rt_uint32_t period, pulse;
-    beep_init();
+    /* ★ beep_init() 失败时 pwm_device 仍是 NULL, 原代码不判空继续用 -> hard fault */
+    if (beep_init() != 0 || pwm_device == RT_NULL)
+        return;
     /* 将频率转化为周期 周期单位:ns 频率单位:HZ */
     //period = 1000000000 / freq;  //unit:ns 1/HZ*10^9 = ns
     period = freq;    /* 周期为0.5ms,单位为纳秒500000ns-200k */
@@ -271,7 +323,9 @@ void Beep_Tip(uint16_t volnum)
 }
 void Motor_Juandai(uint8_t on_off)
 {
-    pwm8_init();
+    /* ★ pwm8_init() 失败时 pwm_tim8 为 NULL, 原代码不判空 -> hard fault */
+    if (pwm8_init() != 0 || pwm_tim8 == RT_NULL)
+        return;
 
     rt_pwm_set(pwm_tim8, PC7_TIM3_CH, 200000, 100000);//channel,period,pulse
 
@@ -285,7 +339,8 @@ void Motor_Juandai(uint8_t on_off)
 }
 void Motor_Qingsao_R_PWM(uint8_t on_off)
 {
-    pwm8_init();
+    if (pwm8_init() != 0 || pwm_tim8 == RT_NULL)
+        return;
     rt_pwm_set(pwm_tim8, PC7_TIM3_CH, 200000, 150000);//channel,period,pulse
     if(on_off==ON){
         rt_pwm_enable(pwm_tim8, PC7_TIM3_CH);
@@ -296,7 +351,8 @@ void Motor_Qingsao_R_PWM(uint8_t on_off)
 }
 void Motor_Qingsao_L_PWM(uint8_t on_off)
 {
-    pwm8_init();
+    if (pwm8_init() != 0 || pwm_tim8 == RT_NULL)
+        return;
     rt_pwm_set(pwm_tim8, PC8_TIM3_CH, 200000, 150000);//channel,period,pulse
     if(on_off==ON)
     {
@@ -308,7 +364,8 @@ void Motor_Qingsao_L_PWM(uint8_t on_off)
 }
 void Motor_shake(uint8_t status_shake,uint16_t shake_sec)
 {
-    beep_init();
+    if (beep_init() != 0 || pwm_device == RT_NULL)
+        return;
     rt_pwm_set(pwm_device, PB1_TIM3_CH, 200000, 150000);//channel,period,pulse
     if(status_shake==ON)
     {

+ 120 - 54
Application_cbd_apm32f1/applications/control.c

@@ -18,6 +18,9 @@
 #include "sht30_collect.h"
 #include <user_mb_app.h>
 #include <selfcheck.h>
+#ifdef RT_USING_FINSH
+#include <shell.h>   /* finsh_set_device(): uart_stop_for_ota 要把 finsh 摘回 uart1 */
+#endif
 #define DBG_ENABLE
 #define DBG_COLOR
 #define DBG_TAG "control"
@@ -37,7 +40,7 @@
 #define PWM_EN    1   //0关闭,1-打开
 //设备状态表结构体
 /* device_status 已收敛为全工程唯一定义(在 main.c), 此处不再重复定义, 见 control.h 的 extern 声明 */
-System_stats_t system_status;
+/* system_status 已收敛为全工程唯一定义(在 sys_monitor.c), 见 sys_monitor.h 的 extern 声明 */
 
 
 rt_thread_t tid_workloop = RT_NULL;
@@ -232,6 +235,111 @@ int thread_stop_all_for_ota(void)
     return done;
 }
 
+/**
+ * @brief 把一个串口设备彻底关掉(解引用到 ref_count==0), 用于 OTA 前收尾。
+ *
+ * 为什么不能只 rt_device_close() 一次:
+ *   rt_device_close() 只有在 ref_count 减到 0 时才会真正调用驱动的 close,
+ *   否则只减计数就返回 RT_EOK。而 uart4/uart5 的引用不止一处:
+ *     uart4 → HMI_uart4_init() 开 1 次, 若现场跑过 Debug_log_ON(),
+ *             rt_console_set_device("uart4") + finsh_set_device("uart4")
+ *             又各开 1 次(共 3 次);
+ *     uart5 → DTU_uart5_init() 开 1 次, UART_485_INIT() 再开 1 次,
+ *             freemodbus 的 xMBMasterPortSerialInit() 还会再开 1 次。
+ *   所以必须循环 close 到 ref_count 归零, 否则设备仍在收发、ISR 仍会触发。
+ *
+ * @param dev   设备句柄, 可为 RT_NULL
+ * @param name  名字, 仅用于日志
+ */
+static void ota_close_uart(rt_device_t dev, const char *name)
+{
+    rt_uint8_t guard = 8;
+
+    if (dev == RT_NULL)
+    {
+        return;
+    }
+
+    /* ① 先摘掉接收回调。close() 内部也会清, 但清回调后到 close 之间
+          还有窗口期, 此刻若有数据到达, 回调里会 release 已经没人等的
+          信号量 / 往已删线程的消息队列里塞消息。 */
+    rt_device_set_rx_indicate(dev, RT_NULL);
+
+    /* ② 循环 close 到引用计数归零。guard 兜底, 防止内核行为异常时空转。 */
+    while (dev->ref_count > 0 && guard-- > 0)
+    {
+        if (rt_device_close(dev) != RT_EOK)
+        {
+            break;
+        }
+    }
+
+    LOG_I("[ota] %s closed, ref_count=%d", name, (int)dev->ref_count);
+}
+
+/**
+ * @brief OTA 升级前关闭串口4(HMI屏) 和串口5(485)。
+ *
+ * 为什么要关:
+ *   1) ymodem_ota() 内部会 rt_console_set_device("uart2"), 之后 console 指向
+ *      uart2。此时 uart4/uart5 若还在工作, 它们的 ISR、以及仍可能残留的
+ *      485 播报/屏幕刷新, 都会和 ymodem 抢 CPU 与中断, 导致传输丢字节;
+ *   2) 485 是**半双工**总线, 收发器被驱动着去收 ymodem 期间还挂着一个
+ *      从机在等应答, 升级完复位后从机状态与 MCU 不同步, 现场表现为
+ *      "升级完 485 读不到数据";
+ *   3) 屏幕在升级过程中继续刷新, 白白占用带宽, 且部分屏会因长时间收不到
+ *      指令而重新初始化自身。
+ *
+ * ★ 本函数必须在 thread_stop_all_for_ota() **之后**调用:
+ *   先停线程(没人再发数据) → 再关设备。反过来的话, 关设备的瞬间还有
+ *   线程在 HMI_WRITE/Uart5_Write, 会写到已被 disable 的 fifo 上。
+ *
+ * @return 关闭的串口个数
+ */
+int uart_stop_for_ota(void)
+{
+    int n = 0;
+
+    /* 置标志必须**先于**关设备: 中间还有别的线程可能正在 HMI_WRITE,
+       看到标志后直接 return, 不会碰到正在被拆掉的 fifo。 */
+    g_hmi_port_closed = 1;
+
+    /* ---- 串口4: HMI 屏 ----
+       先把 console / finsh 摘回 uart1, 否则它们各自持有 uart4 的一次 open
+       (rt_console_set_device / finsh_set_device 内部都是 open 新的 + close 旧的),
+       引用计数降不到 0, 设备等于没关; 而且 tshell 正阻塞在 uart4 的 read 上,
+       设备被关后它会一直读到 0。 */
+    if (rt_console_get_device() != RT_NULL &&
+        rt_strcmp(rt_console_get_device()->parent.name, UART_NAME) == 0)
+    {
+        rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
+    }
+#if defined(RT_USING_FINSH) && !defined(RT_USING_POSIX_STDIO) && defined(RT_USING_DEVICE)
+    finsh_set_device(RT_CONSOLE_DEVICE_NAME);
+#endif
+    if (serial != RT_NULL)
+    {
+        ota_close_uart(serial, UART_NAME);
+        n++;
+    }
+
+    /* ---- 串口5: 485 ---- */
+    if (serial_485 != RT_NULL)
+    {
+        ota_close_uart(serial_485, "uart5");
+        n++;
+    }
+
+    /* 把句柄置 NULL: 让上层即使漏判 g_hmi_port_closed 也不会往已废设备写。
+       ⚠️ 置 NULL 之后 ymodem 失败返回也不会有任何 HMI/485 输出, 这是预期的
+          ——升级流程本来就要求这段时间对外静默。 */
+    serial = RT_NULL;
+    serial_485 = RT_NULL;
+
+    LOG_I("[ota] uart4/uart5 stopped (%d)", n);
+    return n;
+}
+
 
 /****************************5.0***********************************/
 void ctr_turnv5(void)
@@ -811,9 +919,8 @@ void ctr_turn(uint8_t v,uint8_t sta)
             rt_pin_write(TURN_ZP_R, OFF);
             rt_pin_write(TURN_ZP_L, OFF);
             //Motor_shake(OFF,0);
-            char *turn_warn =makeJson_Warn("超时", "转盘");
-            DTU_Write(turn_warn);
-            rt_free(turn_warn);
+            /* ★ 原来 DTU_Write(turn_warn) 把 JSON 当格式串(含 '%' 就会被解析) -> 走 dtu_write_json */
+            dtu_write_json(makeJson_Warn("超时", "转盘"));
             break;
         }
     }
@@ -1865,32 +1972,10 @@ void WorkTask(void)
                 static struct tm tm;
                 gmtime_r(&stamp, &tm);
                 rt_sprintf(device_status.stamp,"%04d%02d%02d%02d%02d%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
-                char* debug_str = makeJson_Warn("Work start!", device_status.stamp);
-                DTU_Write(debug_str);
-                rt_free(debug_str);
+                dtu_write_json(makeJson_Warn("Work start!", device_status.stamp));
             }
         }
-        //1.打开灯管
-        #if LAMP_EN == 1
-        if(device_status.lamp_status==1&&device_status.sun_status==0)   //光控状态不亮灯
-        {
-            ctr_lamp(ON,1);
-            ctr_lamp(OFF,2);
-            ctr_lamp(OFF,3);
-        }
-        else if (device_status.lamp1_status==1&&device_status.sun_status==0) {
-            ctr_lamp(OFF,1);
-            ctr_lamp(ON,2);
-            ctr_lamp(OFF,3);
-        }
-        else if (device_status.lamp2_status==1&&device_status.sun_status==0) {
-            ctr_lamp(OFF,1);
-            ctr_lamp(OFF,2);
-            ctr_lamp(ON,3);
-        }
-        #else
-            ctr_lamp(ON,1);
-        #endif
+        ctr_lamp(ON,1);
         LOG_I("打开灯管!!!");
         if(device_status.version_type!=5)
         {
@@ -1913,10 +1998,6 @@ void WorkTask(void)
                 if(device_status.bat_status == 1 || device_status.temp_status == 1|| device_status.rain_status==1)
                 {
                     ctr_lamp(OFF,1);
-                    #if LAMP_EN == 1
-                    ctr_lamp(OFF,2);
-                    ctr_lamp(OFF,3);
-                    #endif
                     #if 0//LAMP_EN == 0
                     ctr_Fan_IN(OFF);
                     #endif
@@ -1926,10 +2007,6 @@ void WorkTask(void)
                 if(device_status.timeSwitch==0&&device_status.sun_status==1)
                 {
                     ctr_lamp(OFF,1);
-                    #if LAMP_EN == 1
-                    ctr_lamp(OFF,2);
-                    ctr_lamp(OFF,3);
-                    #endif
                     #if 0//LAMP_EN == 0
                     ctr_Fan_IN(OFF);
                     #endif
@@ -1941,10 +2018,6 @@ void WorkTask(void)
             if(device_status.bat_status == 1 || device_status.temp_status == 1|| device_status.rain_status==1)
             {
                 ctr_lamp(OFF,1);
-                #if LAMP_EN == 1
-                ctr_lamp(OFF,2);
-                ctr_lamp(OFF,3);
-                #endif
                 #if 0//LAMP_EN == 0
                 ctr_Fan_IN(OFF);
                 #endif
@@ -1954,10 +2027,6 @@ void WorkTask(void)
             if(device_status.timeSwitch==0&&device_status.sun_status==1)
             {
                 ctr_lamp(OFF,1);
-                #if LAMP_EN == 1
-                ctr_lamp(OFF,2);
-                ctr_lamp(OFF,3);
-                #endif
                 #if 0//LAMP_EN == 0
                 ctr_Fan_IN(OFF);
                 #endif
@@ -2159,8 +2228,10 @@ static void Work_Loop_thread_entry(void *parameter)
                 ctr_lamp(OFF, 1);
             }
             char buf[7] = {0};
-            // 拷贝闹钟字符串(保证安全截断)
-            rt_sprintf(buf, "%-6s", device_status.alarm_tg);
+            /* ★ 原来用 "%-6s": 6 是"最小宽度"不是截断宽度, alarm_tg 是 char[12],
+               超过 6 字符时会完整写出 12+1 字节到 7 字节的 buf -> 栈溢出 6 字节。
+               必须写成 "%-6.6s"(精度 .6 才是截断)。 */
+            rt_snprintf(buf, sizeof(buf), "%-6.6s", device_status.alarm_tg);
 
             // 截取 时: 前2位
             alarm_h = (buf[0] - '0') * 10 + (buf[1] - '0');
@@ -2179,19 +2250,14 @@ static void Work_Loop_thread_entry(void *parameter)
             if((tm_tg_run.tm_hour)==alarm_h&&(tm_tg_run.tm_min==alarm_m)&&(tm_tg_run.tm_sec>=alarm_s))
             {
                 LOG_W("预制执行 开始!");
-                char *temp_s =makeJson_Warn("执行完成", "预制模式");
-                DTU_Write("%s",temp_s);
-                rt_free(temp_s);
+                dtu_write_json(makeJson_Warn("执行完成", "预制模式"));
                 rt_thread_delay(2000);
                 //{"jsonrpc":"2.0","method":"COPY_IMAGE","params":{"st":20,"et":7},"id":1}
                 cJSON *params = cJSON_CreateObject();        // params 子对象
                 cJSON_AddNumberToObject(params, "st", device_status.startBar);     // st:20
                 cJSON_AddNumberToObject(params, "et", device_status.stopBar);      // et:7
-                char* temp = makeJsonRpc2_0("COPY_IMAGE", params, 1);
-                if(temp){
-                    DTU_Write(temp);
-                    free(temp);
-                }
+                /* ★ 原来 DTU_Write(temp) 把 JSON 当格式串 -> 走 dtu_write_json */
+                dtu_write_json(makeJsonRpc2_0("COPY_IMAGE", params, 1));
                 rt_thread_delay(20000);
             }
         }

+ 36 - 28
Application_cbd_apm32f1/applications/control.h

@@ -15,8 +15,6 @@
 #include <rtdevice.h>
 //定制相关//////////////////////////////////////////////////////
 
-
-#define LAMP_EN          0             //李新3灯管:0关闭,1打开
 #define PCB_V1           1             //1-旧PCB,0-新PCB(模块化)
 #define MATCH_DEVICE     0             //比赛设备1-开启 0-关闭
 #define SENSOR_EN        0             //温湿度:0关闭,1打开
@@ -27,7 +25,7 @@
 #define WENKONG          1             //温控功能1-开启 0-关闭
 #define YUKONG           1             //雨控功能1-开启 0-关闭
 #define QIANYA           1             //欠压功能1-开启 0-关闭
-#define JINGJIKUAN       0             //经济款1-开启 0-关闭
+#define JINGJIKUAN       1             //经济款1-开启 0-关闭
 #define QINGSAO_YUGUAQI  0             //雨刮器清扫,带限位:1-开启 0-关闭
 
 #if MATCH_DEVICE == 1
@@ -36,33 +34,29 @@
 #define LAMP_CURRENT    400
 #endif
 ////////////////////////////////////////////////////////////////
-#if LAMP_EN == 1
-    #define VERSION_HK          "1.(3ledV9).41(HK)"      //4.0海康-三色光源
-    #define VERSION_HK_2000W    "1.3led.40(2000W)"       //水稻
-#else
-    #define VERSION_HK          "2.42.41(HK)"            //4.0海康-1200W
-    #if TG_MODULE == 0
 
-#if JINGJIKUAN == 0
-#if QINGSAO_YUGUAQI == 1
-    #define VERSION_HK_2000W    "2.42.4(y)"         //4.0水稻
-#else
-        #define VERSION_HK_2000W    "2.42.4(2000W)"         //4.0水稻
-#endif
-#else
-    #define VERSION_HK_2000W    "2.48.4(jjk-5)"           //经济款
-#endif
+#define VERSION_HK          "2.47.41(HK)"            //4.0海康-1200W
+#if TG_MODULE == 0
+    #if JINGJIKUAN == 0
+        #if QINGSAO_YUGUAQI == 1
+            #define VERSION_HK_2000W    "2.42.4(y)"         //4.0水稻
+        #else
+            #define VERSION_HK_2000W    "2.47.4(2000W)"         //4.0水稻
+        #endif
     #else
+        #define VERSION_HK_2000W    "2.48.4(jjk-5)"           //经济款
+    #endif
+#else
     #if MATCH_DEVICE == 1
-    #define VERSION_HK_2000W    "3.3.4(TG)"             //推杆结构比赛设备
+        #define VERSION_HK_2000W    "3.3.4(TG)"             //推杆结构比赛设备
     #else
-    #define VERSION_HK_2000W    "2.13.4(TG111)"         //推杆结构
-    #endif
+        #define VERSION_HK_2000W    "2.13.4(TG111)"         //推杆结构
     #endif
 #endif
 
-#define VERSION_ZP          "2.42.1(ZP)"            //1.0转盘
-#define VERSION_GK          "2.42.1(GK)"            //1.0高空
+
+#define VERSION_ZP          "2.47.1(ZP)"            //1.0转盘
+#define VERSION_GK          "2.47.1(GK)"            //1.0高空
 
 extern rt_event_t event_485_play;
 
@@ -169,7 +163,10 @@ typedef struct  _packed
     int passWord;              //初始密码
     double process;
     long photo_stamp;           //采集时间戳
-    const char *coll_time[10];
+    /* ★ 原来是 const char *coll_time[10](指针数组), dtu_uart2.c 把栈上局部数组的地址
+       存进去, 函数一返回就成了悬垂指针; 也正因如此整个结构体不能 memcpy 做持久化。
+       改成二维字符数组, 值自带存储, 不再有悬垂问题。 */
+    char coll_time[10][16];
     char alarm_tg[12];         //闹钟时间
     char mqttcfg1[64];         //
     char mqttcfg2[64];         //
@@ -195,11 +192,18 @@ typedef struct  _packed
     char json_w_clock[128];    //修改时间
     char json_w_reset[128];    //
     char json_w_platform[128]; //
-    char power[8];             //功率
-    char heat_power[8];        //加热功率
-    char voltage[6];           //电池电压
+    /* ★ P2-7 这三个字段原来分别是 power[8] / heat_power[8] / voltage[6],
+       而写入用的是无长度检查的 sprintf:
+         voltage    <- "%d.%02d"  如 "39.80" = 5 字符 + '\0' = 6 字节  → 零余量
+         power      <- "%.2f"     如 "25000.00" = 8 字符 + '\0' = 9 字节 → 必溢出 1
+         heat_power <- "%.2f"     同上
+       越界会踩掉紧邻的 deviceId / voltage_sun 等字段(结构体是全局单例)。
+       现在统一放宽到 16 字节,并全部改 rt_snprintf 限长写入。 */
+    char power[16];            //功率
+    char heat_power[16];       //加热功率
+    char voltage[16];          //电池电压
     char deviceId[32];         //bdh-设备编码
-    char voltage_sun[8];       //太阳能板电压
+    char voltage_sun[16];      //太阳能板电压
     char qianming[128];
     char photolink[128];        //图片地址
 }Device_Status_typedef;
@@ -365,6 +369,10 @@ int thread_restart_workloop(void);
 /* OTA 升级前停掉全部业务线程(只留 tshell/idle/syswatch)。
    返回实际删除的线程数。详见 control.c 的说明。 */
 int thread_stop_all_for_ota(void);
+/* OTA 升级前关闭串口4(HMI屏) 与串口5(485), 并把句柄置 NULL。
+   ★ 必须在 thread_stop_all_for_ota() 之后调用(先停线程, 再关设备)。
+   返回关闭的串口个数。详见 control.c 的说明。 */
+int uart_stop_for_ota(void);
 /*******************************************************/
 void RTU_Power_Off_Safe(void);
 void RTU_Power_On_Restore(void);

Разница между файлами не показана из-за своего большого размера
+ 723 - 455
Application_cbd_apm32f1/applications/dtu_uart2.c


+ 9 - 0
Application_cbd_apm32f1/applications/dtu_uart2.h

@@ -17,6 +17,10 @@ typedef struct{
     char msg_pool[MAX_DTU_SIZE];
 }DataTemp;
 extern rt_device_t dtuserial;   /*串口设备句柄*/
+/* 串口5(485)句柄。定义同时存在于 dtu_uart2.c 和 sht30_collect.c,
+   靠 -fcommon 合并成同一个符号 —— 两边赋值的是同一个指针, 行为正确,
+   但这里必须 extern 出来给 control.c 的 uart_stop_for_ota() 用。 */
+extern rt_device_t serial_485;
 //enum B_2
 //{
 //    "STATUS_UNACTIVE",
@@ -61,6 +65,11 @@ void dtu_send_data_start(void);
 
 //{"cmd":"synchronization","ext":{"year":1,"month":1,"day":0,"hour":25,"min":0,"sec":0,"lat":"113.2056","lng":"21.0596","csq",31,"net",0,"iccid","123135453","imei":"895864646464464"}}
 void DTU_Write(char *fmt, ...);
+/* ★ 发送"堆上分配的 JSON 串"并自动释放(一步到位, 防止漏 free 把堆吃光)。
+   传进来的必须是 cJSON_PrintUnformatted / malloc 的产物, 不能是栈/静态缓冲。 */
+void dtu_write_json(char *json);
+/* ★ 安全停掉 DTU 发送线程(删完会重建 dtu_write_mutex, 防止后续 DTU_Write 永久挂起) */
+void dtu_stop_send_thread(void);
 void Uart5_Write(char *fmt, ...);
 void Uart5_Write_Bin(const uint8_t *data, uint16_t len);
 extern volatile uint8_t uart5_rx_flag;   /* 485收到数据标志 */

+ 162 - 99
Application_cbd_apm32f1/applications/hmi.c

@@ -54,7 +54,7 @@ void list_mem(void);
 int mb_master_samlpe();
 /**/
 /* device_status 已收敛为全工程唯一定义(在 main.c), 此处不再重复定义, 见 control.h 的 extern 声明 */
-System_stats_t system_status;
+/* system_status 已收敛为全工程唯一定义(在 sys_monitor.c), 见 sys_monitor.h 的 extern 声明 */
 
 extern eMBMasterReqErrCode _485_play(USHORT *Buffer,USHORT NREGS);
 
@@ -86,6 +86,12 @@ static struct rt_messagequeue rx_mq;//接收数据消息队列
 static void HMI_Decode(void);
 static rt_err_t uart_input(rt_device_t dev, rt_size_t size);
 
+/* P2-14 把开机等联网搬进独立线程时新增的两个函数, 定义在文件后段
+   (Check_ParamConfig 之后), 但 net_wait_start() 在前面的 Check_ParamConfig 里
+   就被调用 -> 必须先有前向声明, 否则报 implicit declaration。 */
+static void net_wait_thread_entry(void *parameter);
+static void net_wait_start(void);
+
 static rt_bool_t uart2_timeout_flag = RT_FALSE;
 
 #ifdef RT_USING_SERIAL_V2
@@ -125,7 +131,22 @@ static int HMI_uart4_init(void)
 #endif
 
 
-/*串口屏写数据*/
+/* ★ HMI_WRITE 用的是**共享的 static 缓冲**, 又被 dtu 接收线程 / workloop /
+   控制线程等多个线程并发调用。原来完全无锁: 一个线程刚 vsnprintf 到一半,
+   另一个线程就把它覆盖掉, 屏幕会收到拼接错乱的指令(表现: 偶发乱码/控件跳值/
+   指令丢失)。这里加一把互斥锁把"格式化 + 发送"整段保护起来。
+   ⚠️ 因为内部有 rt_thread_mdelay(), **ISR / HARD_TIMER 回调里绝不能调 HMI_WRITE**。 */
+static struct rt_mutex hmi_write_mutex;
+
+/* 串口4(HMI屏)在 OTA 升级前被关闭, 置 1 后所有发送路径直接 return。
+   为什么必须有这个标志而不能只靠句柄判空:
+     rt_device_close() 真正关掉设备时, serial_v2 的 rt_serial_rx/tx_disable()
+     会 rt_free 掉 rx/tx fifo 并把 serial->serial_rx / serial_tx 置 NULL,
+     但 dev 指针本身依然非空、依然能被 rt_device_write() 调到;
+     而 rt_serial_write() 会直接 `serial->serial_tx->activated` 解引用 →
+     空指针, 整机 HardFault。所以必须靠这个显式标志拦住。 */
+rt_uint8_t g_hmi_port_closed = 0;
+
 void HMI_WRITE(char *fmt, ...)
 {
     va_list ap;
@@ -134,6 +155,32 @@ void HMI_WRITE(char *fmt, ...)
     static char str[MAX_SIZE];
     //memset(str,'\0',sizeof(str));
     rt_size_t str_length;
+
+    /* OTA 期间串口4已关闭(见 hmi_uart_stop_for_ota), 这里必须最先返回:
+       判空放在 mutex 之后会白等 200ms。 */
+    if (g_hmi_port_closed || serial == RT_NULL)
+    {
+        return;
+    }
+
+    /* 首次使用时惰性初始化(与 DTU_Write 里 dtu_write_mutex 的做法一致);
+       初始化动作本身放在临界区里, 防止两个线程同时首次调用时重复 init。 */
+    if (rt_object_get_type(&hmi_write_mutex.parent.parent) != RT_Object_Class_Mutex)
+    {
+        rt_enter_critical();
+        if (rt_object_get_type(&hmi_write_mutex.parent.parent) != RT_Object_Class_Mutex)
+        {
+            rt_mutex_init(&hmi_write_mutex, "hmi_mtx", RT_IPC_FLAG_FIFO);
+        }
+        rt_exit_critical();
+    }
+
+    if (rt_mutex_take(&hmi_write_mutex, rt_tick_from_millisecond(200)) != RT_EOK)
+    {
+        LOG_E("HMI_WRITE: busy, frame dropped");
+        return;
+    }
+
     va_start(ap,fmt);
     // 预留3字节空间给 hmi_hex
     str_length = rt_vsnprintf(str, sizeof(str) - 3, fmt, ap);
@@ -143,6 +190,8 @@ void HMI_WRITE(char *fmt, ...)
     // 追加三个 0xff
     memcpy(str + str_length, hmi_hex, sizeof(hmi_hex));
     rt_device_write(serial, 0, str, str_length + sizeof(hmi_hex));
+    rt_mutex_release(&hmi_write_mutex);
+
     rt_thread_mdelay(1);    //2025-0308
     system_status.uart4_tx_bytes+=str_length + sizeof(hmi_hex);
 }
@@ -214,7 +263,7 @@ 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)
 {
-    if (!serial || !data || size == 0) return -1;
+    if (g_hmi_port_closed || !serial || !data || size == 0) return -1;
 
     rt_size_t sent = rt_device_write(serial, 0, data, size);
     return (sent == size) ? 0 : -1;
@@ -279,7 +328,8 @@ void process_hex_payload(const char* hex_str, int req_id) {
                "\"params\":{\"received\":%u,\"total\":%u,\"progress\":%d},\"id\":%d}",
                bytes_received, total_file_size, progress, req_id);
 
-    DTU_Write(progress_json);
+    /* ★ progress_json 是栈上数组(不能交给 dtu_write_json 释放), 但要加 "%s" 防止被当格式串 */
+    DTU_Write("%s", progress_json);
 }
 
 
@@ -312,11 +362,7 @@ static void Hmi_thread_entry(void *parameter)
                 LOG_W("屏幕响应信号!");
                 if(current_state==STATE_COMPLETED) return;
                 //RTU可以发送升级文件了
-                char* upgrade_hmi = makeJsonRpc2_0("upgradehmi",NULL,1);
-                if(upgrade_hmi){
-                    DTU_Write(upgrade_hmi);
-                    free(upgrade_hmi);
-                }
+                dtu_write_json(makeJsonRpc2_0("upgradehmi",NULL,1));
             }else {
                 HMI_Decode();
             }
@@ -607,10 +653,6 @@ static void HMI_Decode(void)
         device_status.test_flag=1;
         rt_kprintf("Open Lamp!\n");
         ctr_lamp(ON,1);
-        #if LAMP_EN == 1
-        ctr_lamp(ON,2);
-        ctr_lamp(ON,3);
-        #endif
         device_status.rain_status = 0;
     }
 
@@ -620,10 +662,6 @@ static void HMI_Decode(void)
         device_status.test_flag=0;
         rt_kprintf("Close Lamp1!\n");
         ctr_lamp(OFF,1);
-        #if LAMP_EN == 1
-        ctr_lamp(OFF,2);
-        ctr_lamp(OFF,3);
-        #endif
     }
     //关闭加热
     else if(strstr(rx_buffer,"putTest.switchHeat=0")!=NULL) {
@@ -1364,9 +1402,9 @@ static void HMI_Decode(void)
             char temp_val_mqtt[10],temp_val_pic[10];
             itoa(param1, temp_val_pic, 10);
             itoa(param2, temp_val_mqtt, 10);
-            char *write_record_param = makeJson_record_write(temp_val_mqtt,temp_val_pic);
-            DTU_Write(write_record_param);
-            free(write_record_param);
+            /* ★ 原来 DTU_Write(write_record_param) 把 JSON 当格式串(内容含 '-' 等无所谓,
+               但一旦含 '%' 就会被 vsnprintf 当格式说明符) -> 统一走 dtu_write_json */
+            dtu_write_json(makeJson_record_write(temp_val_mqtt,temp_val_pic));
         } else {
             LOG_E("Parse failed.\n");
         }
@@ -1375,9 +1413,7 @@ static void HMI_Decode(void)
 
     else if (strstr(rx_buffer,"ReadRecordParam")!=NULL){
         LOG_I("读离线存储参数");
-        char* read_record =makeJson_record_read("data");
-        DTU_Write(read_record);
-        free(read_record);
+        dtu_write_json(makeJson_record_read("data"));
     }
     else if (strstr(rx_buffer,"checkcamera")!=NULL){
         DTU_Write("{\"ctr_cam\":\"checkcamera\"}");
@@ -1403,7 +1439,10 @@ static void HMI_Decode(void)
         {
             // 移动到前缀之后的位置
             start_pos += prefix_len;
-            DTU_Write("%s",makeJson_Cam("SaveParam",start_pos));
+            /* ★ makeJson_Cam 的返回值原来没人释放 -> 每次点"保存相机参数"漏一块堆。
+               (start_pos 是 const char*, 与 makeJson_Cam(char*,char*) 的形参有 const 冲突,
+                这里做一次显式转换消除 -Wdiscarded-qualifiers) */
+            dtu_write_json(makeJson_Cam("SaveParam", (char *)start_pos));
         }
         //开启超时定时器
         Start_timer_Uart2();
@@ -1438,32 +1477,17 @@ static void HMI_Decode(void)
         ef_set_env_blob("work_mode", &device_status.work_mode, sizeof(device_status.work_mode));
         LOG_W("修改工作模式:%d",device_status.work_mode);
     }else if(strstr(rx_buffer,"DeleteUimage")!=NULL){
-        char* temp = makeJsonRpc2_0("upan_delete_image", NULL, 1);
-        if(temp){
-            DTU_Write(temp);
-            free(temp);
-        }
+        /* ★ 原来 DTU_Write(temp) 把 JSON 当格式串; 统一走 dtu_write_json("%s" + 判空 + 自动释放) */
+        dtu_write_json(makeJsonRpc2_0("upan_delete_image", NULL, 1));
     }else if(strstr(rx_buffer,"MOVE_IMAGE")!=NULL){
-        char* temp = makeJsonRpc2_0("MOVE_IMAGE", NULL, 1);
-        if(temp){
-            DTU_Write(temp);
-            free(temp);
-        }
+        dtu_write_json(makeJsonRpc2_0("MOVE_IMAGE", NULL, 1));
     }else if(strstr(rx_buffer,"COPY_IMAGE")!=NULL){
         cJSON *params = cJSON_CreateObject();        // params 子对象
         cJSON_AddNumberToObject(params, "st", device_status.startBar);     // st:20
         cJSON_AddNumberToObject(params, "et", device_status.stopBar);      // et:7
-        char* temp = makeJsonRpc2_0("COPY_IMAGE", params, 1);
-        if(temp){
-            DTU_Write(temp);
-            free(temp);
-        }
+        dtu_write_json(makeJsonRpc2_0("COPY_IMAGE", params, 1));
     }else if(strstr(rx_buffer,"UMOUNT_UPAN")!=NULL){
-            char* temp = makeJsonRpc2_0("UMOUNT_UPAN", NULL, 1);
-            if(temp){
-                DTU_Write(temp);
-                free(temp);
-            }
+            dtu_write_json(makeJsonRpc2_0("UMOUNT_UPAN", NULL, 1));
     }
     /* 一屏指令处理完, 若有参数变更则由落盘线程合并写入备份分区 */
     param_mark_dirty();
@@ -1494,10 +1518,9 @@ static void Ctr_Mortor_entry(void* parameter)
         if((alarm_reset12V.tm_hour)==8&&(alarm_reset12V.tm_min==18)&&(alarm_reset12V.tm_sec==00))
         {
             char *rep = makeJsonRpc2_0("reboot",NULL, 1);
-            if(rep){
-                DTU_Write(rep);
-                free(rep);
-            }
+            /* ★ 第四批: DTU_Write 是变参函数, 原来直接传 rep 等于"拿 JSON 当格式串"。
+               统一走 dtu_write_json(固定 "%s" + 判空 + 自动释放)。 */
+            dtu_write_json(rep);
             rt_thread_delay(1000);
         }
 
@@ -2100,53 +2123,104 @@ void Check_ParamConfig(void)
 #if SENSOR_EN==1
         mb_master_samlpe();
 #endif
-        uint16_t connect_num=0;
-        //等待联网,
-        while(atoi(device_status.net)==1)
+        /* ★ P2-14: 原来这里在 main 线程里做最长 180s + 12s 的阻塞等联网,
+           期间后面的 dtu_send_data_start / Workstatus_check / Work_Loop_Task
+           全部延后。现在搬到独立线程, main 立刻往下走。 */
+        net_wait_start();
+        dtu_send_data_start();
+        Workstatus_check();
+        Work_Loop_Task();
+    }
+}
+/* ★ P2-14: 开机等联网的独立线程。
+   原来这两个 while 直接写在 main 线程(Check_ParamConfig)里, 最长阻塞 180s + 10s:
+     while(atoi(net)==1) { ... rt_thread_delay(1000) ... }   // 最多 180 次 = 180s
+     while(atoi(net)==0) { ... rt_thread_delay(2000) ... }   // 最多 6 次 = 12s
+   期间 main 线程后面的 dtu_send_data_start() / Workstatus_check() / Work_Loop_Task()
+   全部延后 —— 现场表现是"开机后近 3 分钟内不自检、不进工作循环、不上报"。
+   现在把等待搬到本线程, main 立刻往下走。
+   ⚠️ 本线程里所有用到 tm 的地方都用本函数自己的时间快照, 不再借用
+      Check_ParamConfig() 的 static struct tm(那里开机后还会被别处改写)。 */
+static void net_wait_thread_entry(void *parameter)
+{
+    uint16_t connect_num = 0;
+    time_t nnow = time(RT_NULL);
+    static struct tm ntm;
+    gmtime_r(&nnow, &ntm);
+
+    /* 等待联网 */
+    while (atoi(device_status.net) == 1)
+    {
+        char *readinfo = makeJson_ReadInfo();
+        if (readinfo != RT_NULL)
         {
-            char *readinfo =  makeJson_ReadInfo();
-            DTU_Write("%s",readinfo);
+            DTU_Write("%s", readinfo);
             rt_free(readinfo);
-            rt_thread_delay(1000);
-            connect_num++;
-            LOG_I("联网中......%d",connect_num);
-            //超时时间为3分钟
-            #if MATCH_DEVICE == 1
-            if(connect_num==60) //180
-            #else
-            if(connect_num==180) //180
-            #endif
-            {
-                device_status.timeSwitch = 0;
-                LOG_W("Time not set:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
-                #if 0
-                set_date(2020, 1, 1);
-                set_time(0, 0, 0);
-                #endif
-                break;
-            }
-
         }
-        connect_num = 0;
-        while(atoi(device_status.net)==0)
+        rt_thread_delay(1000);
+        connect_num++;
+        LOG_I("联网中......%d", connect_num);
+        /* 超时时间为 3 分钟 */
+#if MATCH_DEVICE == 1
+        if (connect_num == 60)   /* 180 */
+#else
+        if (connect_num == 180)  /* 180 */
+#endif
+        {
+            device_status.timeSwitch = 0;
+            LOG_W("Time not set:%04d-%02d-%02d %02d:%02d:%02d",
+                  ntm.tm_year + 1900, ntm.tm_mon + 1, ntm.tm_mday,
+                  ntm.tm_hour, ntm.tm_min, ntm.tm_sec);
+#if 0
+            set_date(2020, 1, 1);
+            set_time(0, 0, 0);
+#endif
+            break;
+        }
+    }
+
+    connect_num = 0;
+    while (atoi(device_status.net) == 0)
+    {
+        char *readinfo = makeJson_ReadInfo();
+        if (readinfo != RT_NULL)
         {
-            char *readinfo =  makeJson_ReadInfo();
-            DTU_Write("%s",readinfo);
+            DTU_Write("%s", readinfo);
             rt_free(readinfo);
-            rt_thread_delay(2000);
-            connect_num++;
-            if(connect_num>5) break;
         }
-        #if MATCH_DEVICE == 1
-        device_status.timeSwitch = 1;
-        #endif
-        DTU_Write("%s",makeJson_Warn("turnon", "device_stm32"));
-        rt_thread_delay(1000);
-        dtu_send_data_start();
-        Workstatus_check();
-        Work_Loop_Task();
+        rt_thread_delay(2000);
+        connect_num++;
+        if (connect_num > 5) break;
     }
+#if MATCH_DEVICE == 1
+    device_status.timeSwitch = 1;
+#endif
+    /* ★ 原来 makeJson_Warn() 的返回值从未释放 -> 每次开机都漏一块堆 */
+    dtu_write_json(makeJson_Warn("turnon", "device_stm32"));
+    rt_thread_delay(1000);
+    LOG_I("net wait thread exit");
 }
+
+/* 启动"等待联网"线程, 立即返回, 不阻塞调用者 */
+static void net_wait_start(void)
+{
+    static rt_thread_t tid = RT_NULL;
+
+    if (tid != RT_NULL)
+    {
+        return;
+    }
+    tid = rt_thread_create("net_wait", net_wait_thread_entry, RT_NULL,
+                           2048,   /* 栈: 里面有 cJSON/DTU_Write 的 vsnprintf */
+                           12, 20);
+    if (tid == RT_NULL)
+    {
+        LOG_E("create net_wait thread failed, run net wait inline");
+        return;
+    }
+    rt_thread_startup(tid);
+}
+
 void ResetParamDefault(void)
 {
     #if MATCH_DEVICE == 1
@@ -2170,10 +2244,9 @@ void ResetParamDefault(void)
     if(device_status.dtype==3)
     {
         device_status.clt_time = 6;    //收集时间
-        #if LAMP_EN == 0
         device_status.startBar = 20;    //定时开始时间
         device_status.stopBar = 5;      //定时结束时间
-        #endif
+
         device_status.heattime = 8;    //加热时间
         device_status.shake_ws = 1;     //针对开关
         #if TG_MODULE == 0
@@ -2181,11 +2254,7 @@ void ResetParamDefault(void)
         #else
         device_status.shake_sec = 2;    //震动时间,s
         #endif
-        #if LAMP_EN == 1
-        device_status.sunBar = 3;       //光控定时时长
-        #else
         device_status.sunBar = 8;
-        #endif
         device_status.tph = 70;         //高温保护阈值
         device_status.tpl = -5;          //低温保护阈值
         device_status.timeSwitch = 0;   //定时模式:光控
@@ -2235,10 +2304,8 @@ void ResetParamDefault_DC(void)
     rt_sprintf(device_status.tempture,"%d",-15);
     device_status.clt_time = 6;    //收集时间
     device_status.dattim = 10;      //数据上传间隔
-    #if LAMP_EN == 0
     device_status.startBar = 20;    //定时开始时间
     device_status.stopBar = 0;      //定时结束时间
-    #endif
     device_status.heattime = 8;    //加热时间
     device_status.shake_ws = 1;     //针对开关
     #if TG_MODULE == 0
@@ -2246,11 +2313,7 @@ void ResetParamDefault_DC(void)
     #else
     device_status.shake_sec = 2;    //震动时间,s
     #endif
-    #if LAMP_EN == 1
-    device_status.sunBar = 3;       //光控定时时长
-    #else
     device_status.sunBar = 4;
-    #endif
     device_status.tph = 70;         //高温保护阈值
     device_status.tpl = -5;          //低温保护阈值
     device_status.timeSwitch = 0;   //定时模式

+ 5 - 0
Application_cbd_apm32f1/applications/hmi.h

@@ -18,6 +18,11 @@
 #define MAX_SIZE 1024
 #define HMI_UART_RXBUFFER_SIZE 512  //
 extern rt_device_t serial;   /*串口设备句柄*/
+/* 串口4在 OTA 升级前已被关闭(见 control.c 的 uart_stop_for_ota)。
+   置 1 后 HMI_WRITE / send_raw_to_hmi 直接 return —— 不能只靠 serial 判空,
+   因为 rt_device_close() 释放的是 serial_v2 内部的 rx/tx fifo, 设备指针
+   本身仍非空, 继续 rt_device_write 会解引用已释放的 tx_fifo 而 HardFault。 */
+extern rt_uint8_t g_hmi_port_closed;
 extern uint8_t dbg_flag;
 extern uint8_t DBG_EN;  //是否使能调试打印
 

+ 5 - 0
Application_cbd_apm32f1/applications/main.c

@@ -21,6 +21,11 @@
 #include "beep.h"
 #include "hmi.h"
 
+/* P3-2: memtrace() 在 rt-thread/src/mem.c 里定义(并已 MSH_CMD_EXPORT),
+   但 rtthread.h / finsh.h 都没有它的原型 -> 隐式声明。
+   GCC14+ 默认 -Werror=implicit-function-declaration 会直接编不过, 这里补声明。 */
+extern int memtrace(int argc, char **argv);
+
 /* device_status 的**唯一真实定义**。
    其余 .c 一律通过 control.h 里的 extern 声明引用, 不要再写第二份定义。 */
 Device_Status_typedef device_status;

+ 52 - 5
Application_cbd_apm32f1/applications/param_backup.c

@@ -42,6 +42,11 @@ static param_persist_t g_last_saved;
 static uint8_t         g_have_saved     = 0;
 static rt_tick_t       g_last_save_tick = 0;
 
+/* ★ 上次落盘**失败**的时刻(0 = 没有待退避的失败)。
+   flash 真的坏了时, 原来每 PARAM_POLL_TICKS 就会重试一次完整擦写,
+   既加速磨损又刷爆串口。失败后退避 PARAM_FAIL_BACKOFF_TICKS 再试。 */
+static rt_tick_t       g_fail_backoff_tick = 0;
+
 /* 回读校验缓冲,避免占用大栈 */
 static uint8_t g_rb_buf[sizeof(param_persist_t)];
 
@@ -331,7 +336,7 @@ int param_backup_read(param_persist_t *out, uint32_t *seq)
 
 int param_backup_write(const param_persist_t *in)
 {
-    const struct fal_partition *target;
+    const struct fal_partition *target = RT_NULL;   /* ★ 显式初始化, 配合下面的空指针兜底 */
     param_snapshot_hdr_t ha, hb;
     uint32_t sa = 0, sb = 0, next_seq;
     int ra = -1, rb = -1, ret;
@@ -370,12 +375,12 @@ int param_backup_write(const param_persist_t *in)
     }
 
     /* 优先写"无效或更旧"的槽,保证另一槽始终是上一版可用数据 */
-    if (ra != 0)
+    if (ra != 0 && g_part_a != RT_NULL)
     {
         target   = g_part_a;
         next_seq = (rb == 0) ? (sb + 1) : (g_last_seq + 1);
     }
-    else if (rb != 0)
+    else if (rb != 0 && g_part_b != RT_NULL)
     {
         target   = g_part_b;
         next_seq = sa + 1;
@@ -385,6 +390,23 @@ int param_backup_write(const param_persist_t *in)
         target   = (sa <= sb) ? g_part_a : g_part_b;
         next_seq = ((sa > sb) ? sa : sb) + 1;
     }
+    /* ★ 单分区降级(param_a / param_b 只建起来一个)时, 上面两个分支可能把
+       target 指到那个为 NULL 的分区, 紧接着 target->name 就是空指针解引用
+       -> 多数情况直接 Bus Fault; 躲过去也是"参数永远存不进去"
+       (下面 LOG 前也做了判空)。这里补一道兜底。 */
+    if (target == RT_NULL)
+    {
+        target = (g_part_a != RT_NULL) ? g_part_a : g_part_b;
+    }
+    if (target == RT_NULL)
+    {
+        LOG_E("[param] no usable partition, save aborted");
+        if (g_lock != RT_NULL)
+        {
+            rt_mutex_release(g_lock);
+        }
+        return -RT_ERROR;
+    }
     /* seq 必须严格递增,防止回绕后被误判为旧数据 */
     if (next_seq <= g_last_seq)
     {
@@ -690,6 +712,18 @@ static int param_flush_impl(int force)
         g_have_saved     = 1;
         g_last_save_tick = rt_tick_get();
         g_dirty = 0;
+        g_fail_backoff_tick = 0;      /* ★ 写成功了就清除退避 */
+    }
+    else
+    {
+        /* ★ 写失败(g_dirty 保持 1、g_last_save_tick 不更新)时, 原来会在下一个
+           PARAM_POLL_TICKS 立刻再走一次完整的"擦除 4KB + 写 + 回读":
+           flash 真的坏了时就是每 200ms 一次擦除 + 一条 LOG_E, 既加速磨损又刷爆串口,
+           而且每次擦写阻塞 40~100ms, 低优先级的本线程会反复占用 SPI 总线,
+           拖慢 EasyFlash 和其它 flash 访问。
+           这里失败后置一个退避时间戳, 到期前不再重试。 */
+        g_fail_backoff_tick = rt_tick_get();
+        LOG_E("[param] save FAILED(%d), backoff %d ms", ret, PARAM_FAIL_BACKOFF_TICKS);
     }
 
     if (g_lock != RT_NULL)
@@ -719,6 +753,12 @@ static void param_autosave_entry(void *parameter)
         {
             continue;
         }
+        /* ★ 上一次落盘失败后的退避窗口: 到期前不重试(见 param_flush_impl) */
+        if (g_fail_backoff_tick != 0
+            && ((rt_tick_get() - g_fail_backoff_tick) < (rt_tick_t)PARAM_FAIL_BACKOFF_TICKS))
+        {
+            continue;
+        }
         /* 静默期: 距最后一次变更超过 PARAM_QUIET_TICKS 才落盘,
            把"一条参数一次擦写"合并成"一批变更一次擦写" */
         if ((rt_tick_get() - g_dirty_tick) < PARAM_QUIET_TICKS)
@@ -755,10 +795,17 @@ int param_backup_start(void)
 #ifdef RT_USING_FINSH
 #include <finsh.h>
 
+/* ★ P2-11 修法: 调试命令**不要**直接把落盘用的共享静态区 g_work 当读取目标。
+   param_backup_read() 内部读完就释放 g_lock, 命令拿到指针后才去 param_unpack() /
+   rt_kprintf —— 这期间落盘线程可能正在 param_pack(&g_work), 读到半新半旧的参数。
+   改成各用一份**私有**静态快照(同样是 820 字节, 不能放栈上), 与 g_work 完全隔离。 */
+static param_persist_t g_dbg_dump;
+static param_persist_t g_dbg_restore;
+
 static void param_dump(void)
 {
     /* 820 字节走静态工作区, 不放栈上(tshell 栈也未必够, 且 main 栈只有 2KB) */
-    param_persist_t *snap = &g_work;
+    param_persist_t *snap = &g_dbg_dump;
     uint32_t seq = 0;
 
     if (param_backup_read(snap, &seq) != 0)
@@ -793,7 +840,7 @@ MSH_CMD_EXPORT(param_save_now, force save device_status to backup partition);
 
 static void param_restore(void)
 {
-    param_persist_t *snap = &g_work;
+    param_persist_t *snap = &g_dbg_restore;   /* 私有缓冲, 不与 g_work 抢 */
 
     if (param_backup_read(snap, RT_NULL) != 0)
     {

+ 8 - 0
Application_cbd_apm32f1/applications/param_backup.h

@@ -42,6 +42,14 @@
 #define PARAM_MIN_SAVE_TICKS       (10 * 1000)
 #endif
 
+/* ★ 落盘**失败**后的退避时长。flash 擦写失败(接触不良/写保护/坏块)时,
+   原来每 PARAM_POLL_TICKS(200ms) 就会重试一次完整的"擦除 4KB + 写 + 回读",
+   既加速磨损又刷爆调试串口, 每次还要阻塞 40~100ms 占着 SPI 总线。
+   失败后至少退避这么久再试。 */
+#ifndef PARAM_FAIL_BACKOFF_TICKS
+#define PARAM_FAIL_BACKOFF_TICKS   (60 * 1000)
+#endif
+
 /* ====================== 需要持久化的参数集合 ======================
  * 与 EasyFlash 中实际读写的 key 一一对应,新增参数需同步修改:
  *   本结构体 + param_pack() + param_unpack()

+ 34 - 8
Application_cbd_apm32f1/applications/sample_mb_master.c

@@ -12,6 +12,13 @@
 #include <user_mb_app.h>
 #include "control.h"
 #include "hmi.h"
+/* ★ 引入 rtdbg.h 才能用 LOG_x。原来本文件只有 rt_kprintf,
+   P2-12 把每 5s 刷屏的两行降级成 LOG_D。 */
+#define DBG_ENABLE
+#define DBG_COLOR
+#define DBG_TAG "mbmst"
+#define DBG_LVL  DBG_LOG
+#include <rtdbg.h>   //must after of DBG_LVL, DBG_TAG or other options
 #ifdef PKG_MODBUS_MASTER_SAMPLE
 #define SLAVE_ADDR      MB_SAMPLE_TEST_SLAVE_ADDR
 #define PORT_NUM        MB_MASTER_USING_PORT_NUM
@@ -49,7 +56,11 @@ extern eMBMasterReqErrCode _485_play(USHORT *Buffer,USHORT NREGS)
                                                                   REGISTER_ADDRESS,   /* register start address */
                                                                   NREGS,     /* register total number */
                                                                   Buffer,                /* data to be written */
-                                                                  RT_WAITING_FOREVER); /* timeout */
+                                                                  /* ★ 原来用 RT_WAITING_FOREVER: 485 从机掉线/接线松动/地址不符
+                                                                     (现场最常见的故障)时, 主站会无限等待应答,
+                                                                     调用线程永久挂起 -> 485 采集流程卡死, 温湿度不再更新。
+                                                                     改成有限超时, 由调用方按错误计数重试/降级。 */
+                                                                  3000);               /* timeout (tick) */
     return _code_ret;
 }
 
@@ -86,11 +97,12 @@ static void send_thread_entry(void *parameter)
             for(int i=0;i<3;i++){
                 rt_kprintf("usMRegInBuf:%d-%u\n",i,usMRegInBuf[0][i]);
             }
-            rt_sprintf(device_status.voltage_sun,"%d.%d",usMRegInBuf[0][0]/100,usMRegInBuf[0][0]%100/10);
+            rt_snprintf(device_status.voltage_sun, sizeof(device_status.voltage_sun),
+                        "%d.%d",(int)(usMRegInBuf[0][0]/100),(int)(usMRegInBuf[0][0]%100/10));
             //太阳能板电压
             HMI_WRITE("menu.g0.txt=\"太阳能板电压:%sV\"",device_status.voltage_sun);
         }else{
-            rt_sprintf(device_status.voltage_sun,"%s","0.0");
+            rt_snprintf(device_status.voltage_sun, sizeof(device_status.voltage_sun), "%s", "0.0");
         }
         #endif
         if(device_status.sensor_485_sta!=200){
@@ -106,16 +118,28 @@ static void send_thread_entry(void *parameter)
                 //温度=25并且湿度=30不更新,否则会导致屏幕上显示空
     //            if((int)usMRegHoldBuf[0][0]/10!=25&&(int)usMRegHoldBuf[0][1]/10!=30)
     //            {
-                    rt_sprintf(device_status.tempture,"%d.%d",(int)usMRegHoldBuf[0][0]/100, (unsigned int)usMRegHoldBuf[0][0] % 100);
-                    rt_sprintf(device_status.humidity,"%d.%d",(int)usMRegHoldBuf[0][1]/100, (unsigned int)usMRegHoldBuf[0][1] % 100);
+                /* ★ P2-12: 改 rt_snprintf 限长(原来 tempture/humidity 是 rt_sprintf,
+                   从机寄存器值不受控;虽然两个数组现在都有 12 字节,但仍走 sizeof 兜底)。
+                   另外"拼好再一次性写入"避免读到半新半旧的串。 */
+                    {
+                        char tbuf[12], hbuf[12];
+                        rt_snprintf(tbuf, sizeof(tbuf), "%d.%d",
+                                    (int)usMRegHoldBuf[0][0]/100, (int)(usMRegHoldBuf[0][0] % 100));
+                        rt_snprintf(hbuf, sizeof(hbuf), "%d.%d",
+                                    (int)usMRegHoldBuf[0][1]/100, (int)(usMRegHoldBuf[0][1] % 100));
+                        rt_snprintf(device_status.tempture, sizeof(device_status.tempture), "%s", tbuf);
+                        rt_snprintf(device_status.humidity, sizeof(device_status.humidity), "%s", hbuf);
+                    }
     //                sprintf(device_status.tempture,"%0.01f",(float)usMRegHoldBuf[0][0]/100);
     //                sprintf(device_status.humidity,"%0.01f",(float)usMRegHoldBuf[0][1]/100);
     //            }
                     //rt_thread_delay(1000);
             }
         }
-        rt_kprintf("slave data-tem:%d,hum:%d\n",usMRegHoldBuf[0][0],usMRegHoldBuf[0][1]);//0代表从机ID=1
-        rt_kprintf("slave data-tem:%s,hum:%s\n",device_status.tempture,device_status.humidity);//0代表从机ID=1
+        /* ★ P2-12: 原来每 5s 无条件 rt_kprintf 刷两行,占调试口带宽还拖慢接收。
+           降为 LOG_D(DBG_LVL 调到 DEBUG 才输出)。 */
+        LOG_D("slave data-tem:%d,hum:%d",usMRegHoldBuf[0][0],usMRegHoldBuf[0][1]);
+        LOG_D("slave data-tem:%s,hum:%s",device_status.tempture,device_status.humidity);
         rt_thread_delay(5000);
         /* Record the number of errors */
         if (error_code != 0)
@@ -152,7 +176,9 @@ 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);
+    /* ★ 栈 512 -> 1024: mb_master_poll 里跑 freemodbus 状态机 + 串口收发回调,
+       512 太紧(栈溢出不会有任何提示, 只有 hard fault / 数据停更)。 */
+    tid1 = rt_thread_create("md_m_poll", mb_master_poll, RT_NULL, 1024, MB_POLL_THREAD_PRIORITY, 10);
     if (tid1 != RT_NULL)
     {
         rt_thread_startup(tid1);

+ 8 - 1
Application_cbd_apm32f1/applications/selfcheck.c

@@ -35,6 +35,12 @@ static int calculate_average(int arr[], int n) {
     return average;
 }
 
+/* ★ 拍照超时回调。
+   定时器在 selfcheck_init() 里以 RT_TIMER_FLAG_SOFT_TIMER 创建(原来是 HARD_TIMER),
+   因为本回调会调 HMI_WRITE(), 而 HMI_WRITE() 内部有 rt_thread_mdelay(1)
+   —— HARD_TIMER 的回调是在 SysTick 中断里执行的, 在 ISR 里挂起线程会触发
+   RT-Thread 调度器断言 / 直接锁死, 表现就是自检拍照阶段反复重启。
+   改成 SOFT_TIMER 后回调运行在 timer 线程上下文, 可以安全调用线程 API。 */
 static void t_takephoto_callback(void *parameter)
 {
 //    rt_timer_delete(timer_takephoto);
@@ -328,7 +334,8 @@ 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|RT_TIMER_FLAG_HARD_TIMER);
+    /* ★ 必须是 SOFT_TIMER: 回调里调 HMI_WRITE() -> rt_thread_mdelay(), ISR 里不能挂起线程 */
+    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!");

+ 84 - 21
Application_cbd_apm32f1/applications/sht30_collect.c

@@ -17,6 +17,7 @@
 #include "math.h"
 #include <string.h>
 #include "sys_monitor.h"
+#include "dtu_uart2.h"
 #define DBG_ENABLE
 #define DBG_COLOR
 #define DBG_TAG "control"
@@ -25,11 +26,11 @@
 
 //温湿度
 #define THREAD_PRIORITY         21      //线程优先级
-#define THREAD_STACK_SIZE       1024    //栈大小
+#define THREAD_STACK_SIZE       2048    //栈大小 (P2-8: 1024 装不下 sprintf("%.2f") 的软浮点 dtoa 峰值)
 #define THREAD_TIMESLICE        5       //时间片
 //电压,电流
 #define P_THREAD_PRIORITY       13      //线程优先级
-#define P_THREAD_STACK_SIZE     1024    //栈大小
+#define P_THREAD_STACK_SIZE     2048    //栈大小 (P2-8: 同上, 还额外调了 log())
 #define P_THREAD_TIMESCLICE     5       //时间片
 //ADC
 #define ADC_DEV_NAME "adc1"     /*ADC设备名称*/
@@ -46,9 +47,11 @@
 
 
 /* device_status 已收敛为全工程唯一定义(在 main.c), 此处不再重复定义, 见 control.h 的 extern 声明 */
-System_stats_t system_status;
+/* system_status 已收敛为全工程唯一定义(在 sys_monitor.c), 见 sys_monitor.h 的 extern 声明 */
 
-rt_device_t serial_485;   /*串口设备句柄*/
+/* serial_485(串口5/485句柄) 已收敛为唯一定义(在 dtu_uart2.c),
+   此处改用 dtu_uart2.h 的 extern 声明 —— 原来两处各有一份定义,
+   靠 -fcommon 合并才能链接通过, 去掉 -fcommon 就会 multiple definition。 */
 struct  serial_configure uart_config_485 = RT_SERIAL_CONFIG_DEFAULT;  /*初始化配置参数*/
 
 rt_uint32_t adc0_value,adc1_value,in_adc_17,adc13_value,adc14_value,adc16_value;
@@ -98,6 +101,13 @@ MovingAverageFilter* moving_average_filter_init(int size) {
 
 // 更新滑动平均滤波器
 rt_uint16_t moving_average_filter_update(MovingAverageFilter* filter, rt_uint16_t newValue) {
+    /* ★ 堆不足时 moving_average_filter_init() 返回 NULL(见上面 82 行),
+       调用点 Power_ReadCheck / adc_collect 原来不判空就直接用 ->
+       filter->sum 落在 0 地址附近 -> hard fault, 电压电流采样全停、欠压保护失效。
+       这里兜底: 句柄无效就直接返回原值。 */
+    if (filter == NULL || filter->buffer == NULL || filter->bufferSize == 0) {
+        return newValue;
+    }
     filter->sum -= filter->buffer[filter->currentIndex];
     filter->buffer[filter->currentIndex] = newValue;
     filter->sum += newValue;
@@ -119,6 +129,13 @@ void moving_average_filter_free(MovingAverageFilter* filter) {
 int UART_485_INIT(void)
 {
     serial_485  = rt_device_find(UART_485);
+    /* ★ 找不到设备时 serial_485 是 NULL, 原来不判空就直接
+       rt_device_control / rt_device_open -> 解引用空对象 hard fault */
+    if (serial_485 == RT_NULL)
+    {
+        LOG_E("UART_485_INIT: device %s not found!", UART_485);
+        return -RT_ERROR;
+    }
     /*修改串口配置参数*/
     uart_config_485.baud_rate = BAUD_RATE_9600;  //修改波特率9600
     uart_config_485.data_bits = DATA_BITS_8;     //数据位8
@@ -247,32 +264,44 @@ static void Power_ReadCheck(void *parameter)
     MovingAverageFilter* filter = moving_average_filter_init(10);
     //MovingAverageFilter* filter_hi = moving_average_filter_init(10);
     MovingAverageFilter* filter_v = moving_average_filter_init(10);
+    /* ★ 堆不足时上面返回 NULL; 判空后仍然继续跑(moving_average_filter_update
+       内部已兜底直接返回原值), 好过整个采样线程崩掉。 */
+    if (filter == NULL || filter_v == NULL)
+    {
+        LOG_E("Power_ReadCheck: moving average filter alloc failed!");
+    }
     rt_thread_delay(1000);
     while(1)
     {
         #if PCB_V1 == 0
         rt_uint16_t _24v_current_int = moving_average_filter_update(filter,Read_Real_Current());
-        if(_24v_current_int-2430>0)
+        /* ★ P2-7: 全部改 rt_snprintf 限长写入。字段已从 8 字节放宽到 16 字节
+           (原来 power[8] 装 "25000.00" 必溢出 1 字节, 踩掉紧邻字段)。 */
+        if(_24v_current_int>2430)
         {
-            sprintf(device_status.power,"%.2f",(float)(_24v_current_int-2400)/0.4);
+            rt_snprintf(device_status.power, sizeof(device_status.power),
+                        "%.2f",(double)((float)(_24v_current_int-2400)/0.4));
         }else {
-            sprintf(device_status.power,"0.0");
+            rt_snprintf(device_status.power, sizeof(device_status.power), "0.00");
         }
 
         //消除误差
-        if(Read_Heat_Current()-2450<10)
+        int _heat_current = Read_Heat_Current();
+        if(_heat_current-2450<10)
         {
-            sprintf(device_status.heat_power,"%.f",0.0);
+            rt_snprintf(device_status.heat_power, sizeof(device_status.heat_power), "0.00");
         }
         else
         {
             //rt_uint16_t _heat_current_int = moving_average_filter_update(filter_hi,Read_Heat_Current());
-            sprintf(device_status.heat_power,"%.2f",(float)(Read_Heat_Current()-2450)/0.1);     //2481-2465
+            rt_snprintf(device_status.heat_power, sizeof(device_status.heat_power),
+                        "%.2f",(double)((float)(_heat_current-2450)/0.1));     //2481-2465
         }
         #else
 //        rt_uint16_t _24v_current_int = moving_average_filter_update(filter,Read_Real_Current());
-//        sprintf(device_status.power,"%.2f",(float)_24v_current_int/10);
-        sprintf(device_status.power,"%.2f",(float)(moving_average_filter_update(filter, (float)Read_Real_Current()/100*2.5))+20.0);
+//        rt_snprintf(device_status.power, sizeof(device_status.power),"%.2f",(double)_24v_current_int/10);
+        rt_snprintf(device_status.power, sizeof(device_status.power),"%.2f",
+                    (double)((float)(moving_average_filter_update(filter, (float)Read_Real_Current()/100*2.5))+20.0));
         #endif
         //LOG_I("负载电流:%s,加热电流:%s",device_status.power,device_status.heat_power);
 #if QIANYA == 1
@@ -304,16 +333,46 @@ static void Power_ReadCheck(void *parameter)
         //
         if(device_status.dtype==3)
         {
-            RV = 10000 * (4096 - Read_Ntc_Voltage()) / Read_Ntc_Voltage();
-            if(TempCalculate(RV, 3950, 10000)-TempCalculate(RV, 3950, 10000)>10)
+            /* ★ P2-6 三个问题一次修掉:
+               ① 原来 `10000*(4096-Read_Ntc_Voltage())/Read_Ntc_Voltage()` —
+                  ADC 读数为 0 时除零(本工具链 __aeabi_uidiv 通常返回 0, 温度被兜成 25℃;
+                  若链接带 __div0 断言的变体则直接 Hard Fault);
+               ② Read_Ntc_Voltage() 一行里被调用两次, 每次内部有 filter_Mid()
+                  的 6×10ms 阻塞 → 一个 10ms 周期的线程里卡 120ms;
+               ③ 原异常判断 `TempCalculate(RV,3950,10000)-TempCalculate(RV,3950,10000)>10`
+                  是**同一个表达式相减, 恒等于 0**, 永远进不了 LOG_E 分支, 是死代码。
+               现在: 只采样一次 → 先判读数合法 → 用 RV 做区间检查代替恒假判断。 */
+            int ntc_adc = Read_Ntc_Voltage();
+
+            if (ntc_adc <= 0 || ntc_adc >= 4096)
             {
-                LOG_E("temp value err!!!!");
+#if 0
+                /* 传感器断线/短路/采样失败: 保持上一次的有效值, 不写 25℃ 覆盖 */
+                LOG_E("NTC adc out of range: %d (0..4095), keep last value %d",
+                      ntc_adc, (int)device_status.heattem);
+#endif
+                device_status.heattem = 25;
             }
-            else {
-                device_status.heattem = TempCalculate(RV, 3950, 10000);
-                if(device_status.heattem>160)
+            else
+            {
+                RV = 10000 * (4096 - ntc_adc) / ntc_adc;
+                if (RV <= 0)
+                {
+                    LOG_E("NTC resistance calc invalid: adc=%d rv=%d", ntc_adc, RV);
+                }
+                else
                 {
-                    device_status.heattem = 25;
+                    int heattem_new = TempCalculate(RV, 3950, 10000);
+                    /* 物理上加热仓 NTC 不会低于 -40℃ 或高于 160℃(原代码的兜底上限),
+                       超出即认为采样链路有问题, 保留旧值并告警 —— 这才是有效的异常检测。 */
+                    if (heattem_new < -40 || heattem_new > 160)
+                    {
+                        LOG_E("temp value err! adc=%d rv=%d calc=%d", ntc_adc, RV, heattem_new);
+                    }
+                    else
+                    {
+                        device_status.heattem = heattem_new;
+                    }
                 }
             }
         }
@@ -325,9 +384,13 @@ static void Power_ReadCheck(void *parameter)
 
         //rt_sprintf(device_status.voltage,"%d.%02d",filter_voltage()/100,filter_voltage()%100);
         rt_uint16_t in_voltage_int = moving_average_filter_update(filter_v,Read_Real_Voltage());
-        sprintf(device_status.voltage,"%d.%02d",in_voltage_int/100,in_voltage_int%100);
+        /* ★ P2-7: voltage 原来只有 6 字节, "39.80" 正好 6 字节零余量 → 改 16 + snprintf */
+        rt_snprintf(device_status.voltage, sizeof(device_status.voltage),
+                    "%d.%02d",(int)(in_voltage_int/100),(int)(in_voltage_int%100));
         //LOG_D("voltage is:%sV",device_status.voltage);
-        sprintf(device_status.fuse_voltage, "%d.%02d",Read_Fuse_Voltage()/100,Read_Fuse_Voltage()%100);
+        int _fuse_v = Read_Fuse_Voltage();
+        rt_snprintf(device_status.fuse_voltage, sizeof(device_status.fuse_voltage),
+                    "%d.%02d", _fuse_v/100, _fuse_v%100);
         rt_thread_mdelay(10);
     }
 }

+ 6 - 0
Application_cbd_apm32f1/applications/sys_monitor.c

@@ -20,6 +20,12 @@
 rt_thread_t tid_sys_monitor = RT_NULL;
 
 /* device_status 已收敛为全工程唯一定义(在 main.c), 此处不再重复定义, 见 control.h 的 extern 声明 */
+
+/* ★ system_status 的**唯一真实定义**在本文件。
+   另外 4 个 .c(control.c / dtu_uart2.c / hmi.c / sht30_collect.c)里的同名定义
+   已删除, 一律改用 sys_monitor.h 的 extern 声明。
+   原写法靠 -fcommon 合并 5 个 tentative definition, 换 -fno-common 或加初值就
+   multiple definition —— 和 device_status 当年踩的是同一个坑。 */
 System_stats_t system_status;
 
 

+ 7 - 0
Application_cbd_apm32f1/applications/sys_monitor.h

@@ -69,6 +69,13 @@ typedef struct
 
 } System_stats_t;
 
+/* ★ system_status 的唯一定义在 sys_monitor.c。
+   历史写法: 在 5 个 .c 里各写一行 `System_stats_t system_status;`,
+   靠 -fcommon 把 5 个 tentative definition 合并成一个 COMMON 符号。
+   只要谁给它加个初值、或工程换成 -fno-common 编译, 立刻 multiple definition
+   —— 这正是 device_status 已经踩过并修掉的同款坑。
+   现在统一 extern 声明, 其余 .c 一律删掉自己的定义。 */
+extern System_stats_t system_status;
 
 int Sys_Motor_Task(void);
 

+ 17 - 1
Application_cbd_apm32f1/drivers/board.h

@@ -191,9 +191,25 @@ extern "C"
 
 /*#define BSP_USING_PWM1*/
 /*#define BSP_USING_PWM2*/
-/*#define BSP_USING_PWM3*/
 #define BSP_USING_PWM3
 #define BSP_USING_PWM8
+
+/* ★ 必须同时声明通道, 否则 drv_pwm.c 的 pwm_get_channel() 得到 channel = 0,
+   stm32_hw_pwm_init() 里 4 个 if(device->channel & 0x0x) 全不成立,
+   HAL_TIM_PWM_ConfigChannel() 一次都不会被调用 —— PWM 输出只能靠 board.c 里
+   MX_TIM3_Init()/MX_TIM8_Init() 的残留配置, 属于隐式耦合。
+   下面的通道号与实际用点严格对应:
+     TIM3(设备 "pwm3"): CH1 蜂鸣器/步进脉冲(beep.h BEEP_PWM_CH=1)
+                        CH2 清扫左电机(control.c pwm_on(2,...))
+                        CH3 清扫右电机(control.c pwm_on(3,...))
+                        CH4 PB1 清洁刷电机(control.h PB1_TIM3_CH=4)
+     TIM8(设备 "pwm8"): CH2 PC7 / CH3 PC8(control.h PC7_TIM3_CH/PC8_TIM3_CH) */
+#define BSP_USING_PWM3_CH1
+#define BSP_USING_PWM3_CH2
+#define BSP_USING_PWM3_CH3
+#define BSP_USING_PWM3_CH4
+#define BSP_USING_PWM8_CH2
+#define BSP_USING_PWM8_CH3
 /*-------------------------- PWM CONFIG END --------------------------*/
 
 /*-------------------------- ADC CONFIG BEGIN --------------------------*/

+ 44 - 3
Application_cbd_apm32f1/drivers/drv_adc.c

@@ -44,6 +44,12 @@ struct stm32_adc
 
 static struct stm32_adc stm32_adc_obj[sizeof(adc_config) / sizeof(adc_config[0])];
 
+/* ★ ADC 外设访问互斥锁: stm32_get_adc_value() 里的
+   "配通道 -> 启动 -> 等转换 -> 取值"必须串行化, 否则多通道采样会互相串。
+   ⚠️ 必须定义在 stm32_get_adc_value() **之前** —— 原来放在文件末尾
+      (stm32_adc_init() 之后), 报 'adc_lock' undeclared。 */
+static struct rt_mutex adc_lock;
+
 static rt_err_t stm32_adc_enabled(struct rt_adc_device *device, rt_uint32_t channel, rt_bool_t enabled)
 {
     ADC_HandleTypeDef *stm32_adc_handler;
@@ -157,12 +163,22 @@ static rt_err_t stm32_get_adc_value(struct rt_adc_device *device, rt_uint32_t ch
 
     stm32_adc_handler = device->parent.user_data;
 
+    /* ★ ADC 外设是全局单例: 两个线程同时 rt_adc_read() 会互相改写 ADC_ChanConf
+       (Channel/Rank), 结果就是"传感值串通道"——把 A 通道的值报成 B 通道的。
+       这里用一把静态互斥锁把"配通道 -> 启动 -> 等转换 -> 取值"整段保护起来。 */
+    if (rt_mutex_take(&adc_lock, rt_tick_from_millisecond(500)) != RT_EOK)
+    {
+        LOG_E("adc busy, channel %d read dropped", channel);
+        return -RT_EBUSY;
+    }
+
     rt_memset(&ADC_ChanConf, 0, sizeof(ADC_ChanConf));
 
 #ifndef ADC_CHANNEL_16
     if (channel == 16)
     {
         LOG_E("ADC channel must not be 16.");
+        rt_mutex_release(&adc_lock);
         return -RT_ERROR;
     }
 #endif
@@ -190,6 +206,7 @@ static rt_err_t stm32_get_adc_value(struct rt_adc_device *device, rt_uint32_t ch
 #else
         LOG_E("ADC channel must be between 0 and 18.");
 #endif
+        rt_mutex_release(&adc_lock);
         return -RT_ERROR;
     }
     ADC_ChanConf.Rank = 1;
@@ -209,17 +226,35 @@ static rt_err_t stm32_get_adc_value(struct rt_adc_device *device, rt_uint32_t ch
     ADC_ChanConf.OffsetNumber = ADC_OFFSET_NONE;
     ADC_ChanConf.SingleDiff = LL_ADC_SINGLE_ENDED;
 #endif
-    HAL_ADC_ConfigChannel(stm32_adc_handler, &ADC_ChanConf);
+    /* ★ 原来这三个 HAL 调用的返回值全被丢弃: 配置/启动失败时会静默继续,
+       超时后仍去取 DR, 读到的是上一次通道的残留值, 而日志里什么都没有。 */
+    if (HAL_ADC_ConfigChannel(stm32_adc_handler, &ADC_ChanConf) != HAL_OK)
+    {
+        LOG_E("HAL_ADC_ConfigChannel failed, ch %d", channel);
+        rt_mutex_release(&adc_lock);
+        return -RT_ERROR;
+    }
 
     /* start ADC */
-    HAL_ADC_Start(stm32_adc_handler);
+    if (HAL_ADC_Start(stm32_adc_handler) != HAL_OK)
+    {
+        LOG_E("HAL_ADC_Start failed, ch %d", channel);
+        rt_mutex_release(&adc_lock);
+        return -RT_ERROR;
+    }
 
     /* Wait for the ADC to convert */
-    HAL_ADC_PollForConversion(stm32_adc_handler, 100);
+    if (HAL_ADC_PollForConversion(stm32_adc_handler, 100) != HAL_OK)
+    {
+        LOG_E("ADC conversion timeout, ch %d", channel);
+        rt_mutex_release(&adc_lock);
+        return -RT_ETIMEOUT;
+    }
 
     /* get ADC value */
     *value = (rt_uint32_t)HAL_ADC_GetValue(stm32_adc_handler);
 
+    rt_mutex_release(&adc_lock);
     return RT_EOK;
 }
 
@@ -229,6 +264,10 @@ static const struct rt_adc_ops stm_adc_ops =
     .convert = stm32_get_adc_value,
 };
 
+/* ★ ADC 外设访问互斥锁: stm32_get_adc_value() 里的
+   "配通道 -> 启动 -> 等转换 -> 取值"必须串行化, 否则多通道采样会互相串。 */
+static struct rt_mutex adc_lock;
+
 static int stm32_adc_init(void)
 {
     int result = RT_EOK;
@@ -236,6 +275,8 @@ static int stm32_adc_init(void)
     char name_buf[5] = {'a', 'd', 'c', '0', 0};
     int i = 0;
 
+    rt_mutex_init(&adc_lock, "adc_lock", RT_IPC_FLAG_FIFO);
+
     for (i = 0; i < sizeof(adc_config) / sizeof(adc_config[0]); i++)
     {
         /* ADC init */

+ 32 - 0
Application_cbd_apm32f1/drivers/drv_common.c

@@ -11,6 +11,10 @@
 #include "drv_common.h"
 #include "board.h"
 
+/* HAL_Delay 的"tick 不动"兜底阈值: 连续这么多次循环 tick 都没变化,
+   就认为系统 tick 还没启动, 直接返回而不是死等。 */
+#define HAL_DELAY_NO_TICK_GUARD  1000000u
+
 #ifdef RT_USING_FINSH
 #include <finsh.h>
 static void reboot(uint8_t argc, char **argv)
@@ -62,8 +66,36 @@ void HAL_ResumeTick(void)
 {
 }
 
+/* P3-6: 原来这里是空实现, HAL 内部所有依赖 HAL_Delay 的上电/复位时序被静默跳过
+   (例如 HAL_RCC_OscConfig 的 LSE 起振等待、FLASH 编程等待等)。
+   ⚠️ 不能简单写成 rt_thread_mdelay():
+      ① 本文件开头的 hw_board_init() 在**调度器启动之前**就调用了 HAL_Init(),
+         此时 rt_thread_mdelay 会永久挂起 -> 整机起不来;
+      ② 某些 HAL 内部会在中断上下文调用它。
+   HAL_GetTick() 本文件已重定义为 rt_tick_get()*1000/RT_TICK_PER_SECOND, 用 tick
+   差值忙等对两种上下文都安全。
+   ⚠️ 但 rt_hw_systick_init() 之前 rt_tick 根本不涨(恒为 0), 此时忙等会死循环;
+   所以额外做一个"tick 不动就放弃"的兜底 —— 宁可延时不精确, 也不能卡死在启动阶段。 */
 void HAL_Delay(__IO uint32_t Delay)
 {
+    uint32_t start = HAL_GetTick();
+    uint32_t last  = start;
+    uint32_t guard = 0;
+
+    while ((HAL_GetTick() - start) < Delay)
+    {
+        uint32_t now = HAL_GetTick();
+
+        if (now != last)
+        {
+            last  = now;
+            guard = 0;               /* tick 在走, 正常计时 */
+        }
+        else if (++guard > HAL_DELAY_NO_TICK_GUARD)
+        {
+            break;                  /* tick 根本没在跑(启动早期), 不再死等 */
+        }
+    }
 }
 
 /* re-implement tick interface for STM32 HAL */

+ 13 - 1
Application_cbd_apm32f1/drivers/drv_flash_f1.c

@@ -92,6 +92,9 @@ int stm32_flash_write(rt_uint32_t addr, const rt_uint8_t *buf, size_t size)
         return -RT_EINVAL;
     }
 
+    /* ★ 同擦除: 编程期间也要屏蔽中断(取指被挂起时 ISR 无法响应)。 */
+    rt_enter_critical();
+
     HAL_FLASH_Unlock();
 
     while (addr < end_addr)
@@ -114,6 +117,7 @@ int stm32_flash_write(rt_uint32_t addr, const rt_uint8_t *buf, size_t size)
     }
 
     HAL_FLASH_Lock();
+    rt_exit_critical();
 
     if (result != RT_EOK)
     {
@@ -148,6 +152,13 @@ int stm32_flash_erase_bank(uint32_t bank, rt_uint32_t addr, size_t size)
         return -RT_EINVAL;
     }
 
+    /* ★ 片内 Flash 擦除期间必须屏蔽中断。
+       STM32F1 是单 Bank: 擦一页要 20~40ms, 这段时间里 CPU 取指/取向量都被挂起,
+       所有 ISR 事实上停摆。uart2 开了 1024 字节的 DMA 环形缓冲(115200bps),
+       40ms 足够把它灌满 -> DTU 报文丢帧; 同时丢约 30 个 tick, 超时判断整体漂移。
+       (drv_usart_v2.c 的 DMA 接收注释里也把"片内 flash 擦写长时间关中断"列为已知场景) */
+    rt_enter_critical();
+
     HAL_FLASH_Unlock();
 
     /* Fill EraseInit structure*/
@@ -155,7 +166,7 @@ int stm32_flash_erase_bank(uint32_t bank, rt_uint32_t addr, size_t size)
     EraseInitStruct.PageAddress = GetPage(addr);
     EraseInitStruct.NbPages     = (size + FLASH_PAGE_SIZE - 1) / FLASH_PAGE_SIZE;
     EraseInitStruct.Banks       = bank;
-    
+
     if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
     {
         result = -RT_ERROR;
@@ -164,6 +175,7 @@ int stm32_flash_erase_bank(uint32_t bank, rt_uint32_t addr, size_t size)
 
 __exit:
     HAL_FLASH_Lock();
+    rt_exit_critical();
 
     if (result != RT_EOK)
     {

+ 26 - 2
Application_cbd_apm32f1/drivers/drv_rtc.c

@@ -100,7 +100,13 @@ static rt_err_t set_rtc_time_stamp(time_t time_stamp)
 //    LOG_D("set rtc time.");
 //    HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR1, BKUP_REG_DATA);
 
-    RTC_WriteTimeCounter(&RTC_Handler,time_stamp);
+    /* ★ P3-8: RTC_WriteTimeCounter() 无论成功失败原来都返回 RT_EOK,
+       上层(如 setSystemTime / 参数下发校时)会以为写成功了。判一下返回值。 */
+    if (RTC_WriteTimeCounter(&RTC_Handler, time_stamp) != HAL_OK)
+    {
+        LOG_E("RTC_WriteTimeCounter failed");
+        return -RT_ERROR;
+    }
     return RT_EOK;
 }
 
@@ -122,7 +128,25 @@ static void rt_rtc_init(void)
     RCC_OscInitStruct.LSEState = RCC_LSE_ON;
     RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
 #endif
-    HAL_RCC_OscConfig(&RCC_OscInitStruct);
+    /* ★ P3-8: LSE 起振超时 时 HAL_RCC_OscConfig() 返回 HAL_TIMEOUT 并**静默回退到 LSI**,
+       原来返回值被丢掉 -> 日志上看不出 RTC 用的是哪个时钟源,
+       现场表现为"时间偶尔走慢/重启后丢时间"却查不到原因。 */
+    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
+    {
+#ifndef BSP_RTC_USING_LSI
+        LOG_E("LSE oscillator start FAILED, RTC has fallen back to LSI (time accuracy degraded)");
+#else
+        LOG_E("LSI oscillator start FAILED");
+#endif
+    }
+    else
+    {
+#ifdef BSP_RTC_USING_LSI
+        LOG_D("rtc clock source: LSI");
+#else
+        LOG_D("rtc clock source: LSE");
+#endif
+    }
 }
 
 static rt_err_t rt_rtc_config(struct rt_device *dev)

+ 16 - 2
Application_cbd_apm32f1/drivers/drv_usart_v2.c

@@ -383,7 +383,7 @@ static rt_size_t stm32_transmit(struct rt_serial_device     *serial,
             {
                 /* 仍失败: 主动上报 TX_DMADONE, 防止 serial_v2 框架永久阻塞在 tx_cpt 上
                  * (阻塞期间持有应用层互斥锁, 会导致该串口发送整体瘫痪) */
-                LOG_E("%s tx dma start failed, drop %d bytes", uart->config->name, size);
+                LOG_E("%s tx dma start failed, drop %lu bytes", uart->config->name, (unsigned long)size);
                 rt_hw_serial_isr(serial, RT_SERIAL_EVENT_TX_DMADONE);
                 return 0;
             }
@@ -418,11 +418,18 @@ static void dma_recv_isr(struct rt_serial_device *serial, rt_uint8_t isr_flag)
     /* 无论 recv_len 是否为 0 都必须同步计数, 否则后续事件全部错算 */
     uart->dma_rx.remaining_cnt = counter;
 
+    /* 先开中断, 再上报事件。
+       ★ 原来 rt_hw_serial_isr() 是在关中断区间里调的: serial_v2.c 里它会在
+         RX_DMADONE 分支执行 rt_completion_done() 并调用应用注册的 rx_indicate 回调,
+         这两者都跑在"中断全关"的状态下 —— 回调里只要出现任何阻塞调用就是死锁;
+         即便不阻塞, 也会把关中断窗口拉成回调的执行时长(与片内 flash 擦写叠加时
+         DMA 环形缓冲被冲掉 -> 丢帧)。 */
+    rt_hw_interrupt_enable(level);
+
     if (recv_len)
     {
         rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_DMADONE | (recv_len << 8));
     }
-    rt_hw_interrupt_enable(level);
 
     UNUSED(isr_flag);
 }
@@ -1093,6 +1100,13 @@ void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
             if (rx_fifo != RT_NULL &&
                 HAL_UART_Receive_DMA(huart, rx_fifo->buffer, uart->serial.config.rx_bufsz) == HAL_OK)
             {
+                /* ★ 必须同时复位 ringbuffer 的读写索引。
+                   serial_v2 直接把 rx_fifo->buffer 当环形缓冲用, 硬件 DMA 写指针与
+                   软件 rb.write_index 必须始终同相位。上面把 DMA 复位到了 buffer[0]
+                   (NDTR = bufsz), 如果 rb.write_index 还停在故障前的 N,
+                   自愈后每次 IDLE 都按"从 0 开始"算长度, 实际字节却在 [N, N+k)
+                   -> 读到重复旧数据/错位, DTU 协议解析持续报校验错且**不会自愈**。 */
+                rt_ringbuffer_reset(&rx_fifo->rb);
                 uart->dma_rx.remaining_cnt = uart->serial.config.rx_bufsz;
             }
         }

Разница между файлами не показана из-за своего большого размера
+ 705 - 0
Application_cbd_apm32f1/readme.md


+ 4 - 1
Application_cbd_apm32f1/rtconfig.h

@@ -18,7 +18,10 @@
 #define IDLE_THREAD_STACK_SIZE 256
 #define RT_USING_TIMER_SOFT
 #define RT_TIMER_THREAD_PRIO 4
-#define RT_TIMER_THREAD_STACK_SIZE 512
+/* ★ 512 -> 1024: selfcheck 的拍照超时定时器改为 SOFT_TIMER 后, 回调运行在 timer 线程,
+   而该回调会调 HMI_WRITE() -> rt_vsnprintf(), 软格式化本身就要好几百字节栈,
+   512 不够用(栈溢出不会有任何提示, 只有 hard fault)。 */
+#define RT_TIMER_THREAD_STACK_SIZE 1024
 
 /* kservice optimization */
 

+ 581 - 0
Application_cbd_apm32f1/固件代码审计与优化报告_2026-09-28.md

@@ -0,0 +1,581 @@
+# 孢子仪 2.x 控制器固件 — 静态代码审计与优化报告
+
+> 生成日期:2026-09-28
+> 审计方式:**纯静态分析,未修改任何源代码,未编译**
+> 工程:`Application_cbd_apm32f1`(RT-Thread 4.1.1 + Cortex-M3 / STM32F103 兼容 APM32F1)
+
+---
+
+## 一、审计范围与生效配置
+
+### 1.1 参与编译的代码(已核实,死代码不报)
+
+| 项目 | 实际生效值 | 依据 |
+|---|---|---|
+| 串口驱动 | **仅 `drivers/drv_usart_v2.c`** | `RT_USING_SERIAL_V2` 已定义;`RT_USING_SERIAL_V1`、`RT_USING_SERIAL_X` **均未定义**,`drv_usart.c` / `drv_usartX.c` 整文件被宏挡住,是死代码 |
+| 串口分配 | uart1=调试(console)、**uart2=DTU 通讯(RX DMA)**、uart4=屏幕(RX DMA)、uart5=485 | `drivers/board.h:69/74/83/89/96/98` |
+| `RT_NAME_MAX` | 8(内核只保留前 7 字符) | `rtconfig.h:8` |
+| `RT_TICK_PER_SECOND` | 1000 | `rtconfig.h:12` |
+| `RT_USING_HEAP` / `RT_USING_TIMER_SOFT` / `RT_USING_WDT` | 均开启 | `rtconfig.h:47/19/110` |
+| `RT_MAIN_THREAD_STACK_SIZE` | 4096 | `rtconfig.h:72` |
+| 编译期开关 | `MATCH_DEVICE 0`、`PCB_V1 1`、`LAMP_EN 0`、`UART_TEST_EN 0` | `control.h:19/20/21/23` |
+
+分析对象:`applications/` 全部业务代码 + `drivers/` 中生效的驱动 + `packages/` 中被引用的部分,`lwjson.c`(第三方 DOM 解析器,本项目未使用)仅作死代码结论。
+
+### 1.2 缺陷分级统计
+
+| 分级 | 数量 | 说明 |
+|---|---|---|
+| **P0 致命** | 4 | 可远程触发或必然触发的死机 / 崩溃 |
+| **P1 严重** | 18 | 缓冲区溢出、死锁、内存泄漏、中断上下文违规 |
+| **P2 中等** | 15 | 竞态、判空缺失、栈余量不足、逻辑失效 |
+| **P3 优化** | 8 | 死代码、命名误导、格式串不匹配、可维护性 |
+| **待上机确认** | 6 | 静态无法定论,需实测 |
+| 合计 | **51**(其中正式缺陷 45 条) | — |
+
+---
+
+## 二、P0 致命(4 条)
+
+### P0-1 硬件定时器回调在中断上下文调用 `HMI_WRITE()`,内部执行 `rt_thread_mdelay()`
+
+**位置**:`applications/selfcheck.c:38-47`(回调体)、`applications/selfcheck.c:331`(定时器创建)
+**佐证**:`applications/hmi.c:129-148`(`HMI_WRITE` 实现)
+
+```c
+// selfcheck.c:331
+timer_takephoto = rt_timer_create("t_takephoto",t_takephoto_callback,RT_NULL, 100000,
+                                  RT_TIMER_FLAG_ONE_SHOT|RT_TIMER_FLAG_HARD_TIMER);
+// selfcheck.c:38-46
+static void t_takephoto_callback(void *parameter)
+{
+    LOG_E("拍照超时!");
+    device_status.C01 |= (1<<2);
+    device_status.C01 |= (1<<3);
+    HMI_WRITE("selfcheck.t4.bco=63488");
+```
+```c
+// hmi.c:145-146
+    rt_device_write(serial, 0, str, str_length + sizeof(hmi_hex));
+    rt_thread_mdelay(1);    //2025-0308
+```
+
+**触发条件**:`RT_TIMER_FLAG_HARD_TIMER` 的回调在 **SysTick 中断**里被 `rt_timer_check()` 直接调用。自检流程 `selfcheck(1)` 启动该定时器(`selfcheck.c:279`),若 100 秒内未等到拍照完成,回调必执行一次。
+
+**后果**:中断里调用线程挂起 API,触发 RT-Thread 调度器断言(`Function[rt_thread_mdelay] shall not be used in ISR`)或直接在 ISR 内挂起;表现为自检拍照阶段整机停死 → 5s 看门狗复位 → 反复重启。即使不断言,`rt_device_write` 在串口发送完成量上等待也会死锁在中断里。
+
+**建议**:把 `RT_TIMER_FLAG_HARD_TIMER` 改为 `RT_TIMER_FLAG_SOFT_TIMER`;回调内只置标志 / 发信号量,屏幕刷新交给线程上下文。
+
+---
+
+### P0-2 主数据上传路径把 JSON 字符串当格式串传入 `DTU_Write()`,且未判 NULL
+
+**位置**:`applications/dtu_uart2.c:3222-3229`
+
+```c
+void UpLoad_Data(void)
+{
+    char *updata = makeJson();
+    DTU_Write(updata);
+    rt_free(updata);
+}
+```
+`DTU_Write` 的签名是 `void DTU_Write(char *fmt, ...)`,内部 `rt_vsnprintf(dtu_str, sizeof-1, fmt, ap)`。
+
+**触发条件**:
+1. JSON 内容里出现 `%`(`deviceId`、`project`、`photolink`、`driver` 等字段均由平台/RTU 下发,长度与内容不完全可控)→ `vsnprintf` 把它当格式说明符解析,越界读栈上的可变参数;
+2. `makeJson()` 在 cJSON 分配失败时返回 NULL(`dtu_uart2.c:1482/1505/1730`)→ `vsnprintf` 收到 NULL 格式串。
+
+**后果**:这是**调用最频繁的一条路径**(每个上报周期、每次参数变更、每次平台查询都走)。触发后轻则上传一串乱码导致平台解析失败,重则 Hard Fault 复位;表现为"设备偶发重启,重启前刚上报过数据"。
+
+**建议**:改成 `DTU_Write("%s", updata);` 并在前面加 `if (updata == RT_NULL) return;`。**同类写法还见于** `dtu_uart2.c:1334`(`DTU_Write(temp)`)、`:1344`(`DTU_Write(temp1)`)、`:1453`(`DTU_Write(temp)`)、`:1962`/`:1970`(`DTU_Write(read_record)`)、`:1846`(`UART_TEST_EN` 分支,当前关闭)。
+
+---
+
+### P0-3 平台下发 JSON 的字段未判空即解引用(远端可控空指针)
+
+**位置**:`applications/dtu_uart2.c:2086-2088`、`:2223-2224`、`:2540`、`:2597`、`:2628-2629`
+
+```c
+// :2086-2088
+type = cJSON_GetObjectItem(item_ext,"type");
+cJSON *time_s = cJSON_GetObjectItem(item_ext,"time");
+if(strstr(type->valuestring,"rtu_off_on")!=RT_NULL)       //RTU重新上电
+```
+```c
+// :2540
+LOG_I("参数同步:lat:%s lng:%s",lat->valuestring,lng->valuestring);
+```
+```c
+// :2597
+if(strstr(device_status.lat,lat->valuestring)==NULL)
+```
+
+**触发条件**:`item_ext` 未判空(`cJSON_GetObjectItem(NULL, …)` 解引用空对象),`type` / `lat` / `lng` 也未判空。平台只需下发 `{"cmd":"ctrl"}`(不带 `ext`)或 `{"cmd":"synchronization"}`(不带 `lat`/`lng`),`cJSON_GetObjectItem` 返回 NULL,下一行 `->valuestring` 即在地址 0 附近取指。
+
+**后果**:Cortex-M3 上 0 地址被别名映射到 flash,多数情况读出野值后传给 `strstr`/日志 → Bus Fault / Hard Fault;**任何能下发 MQTT/串口指令的一方都能让设备立刻死机复位**,且日志无有效线索。
+
+**建议**:所有 `cJSON_GetObjectItem` 结果在使用 `->valuestring` / `->valueint` 前统一判空(建议封装 `static const char* cj_str(cJSON* root, const char* key, const char* def)`,判空 + 判 `type==cJSON_String` + 返回默认值)。
+
+---
+
+### P0-4 把 `char` 变量当 `%s` 传入日志
+
+**位置**:`applications/dtu_uart2.c:308`(uart2 接收线程)、`applications/dtu_uart2.c:356`(uart5 接收线程)
+
+```c
+LOG_W("invalid JSON byte:%s[%x]",ch,ch);
+```
+`ch` 声明为 `char ch;`(`dtu_uart2.c:287`)。
+
+**触发条件**:只要 uart2 上出现**任何**非 JSON 首字符的字节(线路噪声、RTU 打印的非 JSON 日志、半帧残留),`lwjson_stream_parse` 返回 `lwjsonERRJSON`/`WAITFIRSTCHAR`,立即走到这一行。
+
+**后果**:`%s` 把 `ch` 的整数值(如 0x41、0x0A)当作指针去读字符串。轻则打印一段 flash 里的乱码,重则 Bus Fault。现场表现是"串口干扰大一点就死机 / 打印一堆乱码"。
+
+**建议**:改成 `LOG_W("invalid JSON byte: 0x%02x", (unsigned char)ch);`
+
+---
+
+## 三、P1 严重(18 条)
+
+### P1-1 远端可控字符串无长度限制写入定长数组成员(一类,10+ 处)
+
+**位置**:`applications/dtu_uart2.c` 全文,典型如下
+
+```c
+// :1914  alarm_tg[12]
+rt_sprintf(device_status.alarm_tg, "%s", s_time->valuestring);
+// :2544  csq[8]
+rt_sprintf(device_status.csq,"%s",csq->valuestring);
+// :2633  driver_4g[64]
+sprintf(device_status.driver_4g,"%s",driver_4g->valuestring);
+// :2011  photolink[128]
+rt_sprintf(device_status.photolink,"%s",photolink->valuestring);
+// :2025  qianming[128]
+sprintf(device_status.qianming,"%s",item_checkself->valuestring);
+// 同类还有 :2493 link_ip[32] / :2502 imei[32] / :2515 iccid[32] /
+//          :2568 net[8] / :2576 sim[8] / :2584 gps[8] / :2588 gps_state[8] /
+//          :2601-2602 lat/lng[32] / :2635 project[32] / :2652 mqttcfg2[64] /
+//          :2398 humidity[12] / :2413 tempture[12]
+```
+
+**为什么是问题**:`rt_sprintf` 不做长度检查。目标数组尺寸见 `control.h:176-204`,其中 `csq/net/sim/gps/gps_state` 只有 **8 字节**、`alarm_tg` 12 字节。源串长度完全由平台下发的 JSON 决定。
+
+**后果**:越界写会踩坏 `Device_Status_typedef` 里**相邻的字段**(该结构体是全局单例,字段紧密排布)。典型表现:设备 ID / 平台地址 / 时间字符串莫名变化、屏幕上出现串字段、参数落盘后读出乱码,重则 Hard Fault。属于**可远程触发的全局变量溢出**。
+
+**建议**:全部改为 `rt_snprintf(dst, sizeof(dst), "%s", src)`;或统一封装 `set_status_str(dst, sizeof dst, src)`。**本地来源的同类问题见** `hmi.c:812`(`alarm_tg`)、`hmi.c:835`(`rt_sprintf(device_status.deviceId,"10300101%s",value_str)`,`deviceId[32]`,8 字节前缀 + 屏输入可溢出)、`sht30_collect.c:328`。
+
+---
+
+### P1-2 `char res[30]` 装 `"Fuse is fusing:"` + `fuse_voltage[32]`
+
+**位置**:`applications/dtu_uart2.c:541-542`
+
+```c
+static char res[30];
+sprintf(res, "Fuse is fusing:%s",device_status.fuse_voltage);
+```
+`fuse_voltage` 为 `char[32]`(`control.h:191`),前缀 15 字符。
+
+**后果**:最多写入 15+31+1 = **47 字节**到 30 字节的 static 缓冲,越界 17 字节,直接破坏 .bss 中相邻的静态变量。该路径在每个上报周期、`fuse_voltage < 1` 时执行。
+
+**建议**:`char res[64]` + `snprintf`。
+
+---
+
+### P1-3 `char utos[5]` 写入 uint16 字段
+
+**位置**:`applications/dtu_uart2.c:1461`(声明)、`:1687`、`:1717`
+
+```c
+char utos[5];
+...
+rt_sprintf(utos, "%d",device_status.shake_sec);      // :1687  shake_sec 为 uint16_t
+rt_sprintf(utos, "%d",device_status.dattim);         // :1717  dattim 为 uint16_t
+```
+`dattim`/`shake_sec` 在 `control.h:159-160` 为 `uint16_t`,十进制最大 5 字符 + NUL = **6 字节 > 5**。
+
+**触发条件**:`parse_param_to_mcu()`(`:1198-1202`、`:1174-1178`)从 RTU 同步参数时**无范围校验**地赋值 `device_status.dattim = value->valueint;`,只要 RTU 侧下发 >9999 的值即溢出。
+
+**后果**:栈上 1 字节越界(DTU 线程栈 4096)。ARM 上局部变量越界常踩到相邻的 `cJSON*` 指针,导致后续 `cJSON_Delete` 解引用野指针 Hard Fault。
+
+**建议**:`utos` 扩到 12 字节;并在 `parse_param_to_mcu` 里对每个字段补范围校验(与 `paramconf` 分支已有的 1~120 / 1~1000 校验保持一致)。
+
+---
+
+### P1-4 `char buf[7]` 配 `%-6s` 格式化 `alarm_tg[12]`
+
+**位置**:`applications/control.c:2161-2170`
+
+```c
+char buf[7] = {0};
+// 拷贝闹钟字符串(保证安全截断)
+rt_sprintf(buf, "%-6s", device_status.alarm_tg);
+```
+
+**为什么是问题**:`%-6s` 的 6 是**最小宽度**,不是截断宽度。源串 `alarm_tg[12]` 超过 6 字符时会完整写出 12+1 字节。
+
+**触发条件**:`work_mode==1`(预制模式)分支每秒执行一次;`alarm_tg` 由平台 `alarm` 指令(`:1914`)或屏幕(`hmi.c:812`)写入,长度不受控。
+
+**后果**:`work_loop_thread`(栈 2048)栈溢出 6 字节 → 破坏栈上 `tm_tg_run` 等变量或返回地址,Hard Fault。
+
+**建议**:`rt_snprintf(buf, sizeof(buf), "%-6.6s", device_status.alarm_tg);`(精度 `.6` 才是截断)。
+
+---
+
+### P1-5 `driver[64]` 由两个远端可控串拼成,随后再 `strcat`
+
+**位置**:`applications/dtu_uart2.c:1487-1496`、`:1520-1521`
+
+```c
+rt_sprintf(device_status.driver,"%s-%s",VERSION_HK_2000W,device_status.driver_4g);
+...
+if(strstr(device_status.driver,"485")==RT_NULL)
+    strcat(device_status.driver,".485");
+```
+`driver[64]`、`driver_4g[64]`(`control.h:183-184`),`driver_4g` 由 `:2633` 无界写入。
+
+**后果**:`driver_4g` 只要超过约 49 字符,拼接即溢出 64 字节;`strcat` 再追加 4 字节会二次越界。溢出破坏 `driver_4g` / `driver_bl` / `driver_compile` 等相邻字段。
+
+**建议**:`rt_snprintf` + 写入前用 `rt_strncpy(driver_4g, src, sizeof(driver_4g)-1)` 限长;`strcat` 改为 `strncat`。
+
+---
+
+### P1-6 `DTU_Write("%s", makeJson_xxx(...))` 内存未释放(长期运行耗尽堆)
+
+**位置**:`applications/dtu_uart2.c:1906`、`:1918`、`:2016`、`:2028`、`:2143`、`:2229`(及 `:2230` 的重复分配)、`:2246`、`:2297`、`hmi.c:2182-2183` 等
+
+```c
+DTU_Write("%s",makeJson_Warn(temp, "switch mode"));      // :1906 —— 返回值无处释放
+...
+DTU_Write("%s",makeJson_platform("8.136.98.49"));        // :2229
+rt_free(makeJson_platform("8.136.98.49"));               // :2230 —— 分配了第二份,只释放这一份
+```
+`makeJson_*` 内部用 `cJSON_PrintUnformatted` 分配(`cJSON_PrintUnformatted` → `rt_malloc`),每一条几十到上百字节。
+
+**后果**:每条未配对的调用泄漏一块堆。`DTU_Write` 每秒级被调用,堆(片内 + 外部)在**数小时到数天**内被耗尽,随后 `cJSON_CreateObject` 返回 NULL,P0-2/P1-3 的崩溃路径被同时打开。这是"设备跑几天就不正常"的典型成因。
+
+**建议**:统一改写成 `char *p = makeJson_Warn(...); if (p) { DTU_Write("%s", p); rt_free(p); }`;`:2229-2230` 改成只分配一次。
+
+---
+
+### P1-7 删除线程时不释放其持有的 mutex,后续 `DTU_Write` 永久死锁
+
+**位置**:`applications/dtu_uart2.c:2310`、`:1886`;mutex 定义在 `:56`,加锁在 `:248`
+
+```c
+// :2308-2311(升级分支)
+if (dtu_send_data != RT_NULL)
+{
+    rt_thread_delete(dtu_send_data);     /* 停 uart2 发送线程 */
+    dtu_send_data = RT_NULL;
+}
+// :248
+rt_mutex_take(&dtu_write_mutex, RT_WAITING_FOREVER);
+```
+
+**触发条件**:`rt_thread_delete()` **不会**释放该线程已持有的 mutex。若删除瞬间 `dtu_send_data` 正停在 `rt_mutex_take` 之后、`rt_mutex_release` 之前(正在 `rt_device_write`),mutex 的 owner 指向一个已被销毁的线程。
+
+**后果**:此后任何线程调用 `DTU_Write()` 都会在 `RT_WAITING_FOREVER` 上永久挂起 —— 上报、预警、应答全部停摆,看门狗 5s 后复位,且复位后同样场景可再次触发。
+
+**建议**:删除前先 `rt_mutex_control(&dtu_write_mutex, RT_IPC_CMD_RESET, RT_NULL)`;或改为"置退出标志 + `rt_thread_mdelay` 等其自行退出"而不是强删。
+
+---
+
+### P1-8 把栈上局部数组地址存入全局 `const char *coll_time[10]`
+
+**位置**:`applications/dtu_uart2.c:1632-1639`
+
+```c
+char ct1[10],ct2[10];
+rt_sprintf(ct1,"%d-%d",device_status.collecting_sh1,device_status.collecting_eh1);
+rt_sprintf(ct2,"%d-%d",device_status.collecting_sh2,device_status.collecting_eh2);
+device_status.coll_time[0] = ct1;
+device_status.coll_time[1] = ct2;
+cJSON *data_clt = cJSON_CreateStringArray(device_status.coll_time,2);
+```
+`coll_time` 是 `const char *coll_time[10]`(`control.h:172`)。
+
+**后果**:函数返回后 `coll_time[0]/[1]` 成为**悬垂指针**。当前紧接着的 `cJSON_CreateStringArray` 恰好还在作用域内所以能工作,但只要别处(持久化、日志、屏幕、另一分支)读取 `device_status.coll_time[i]`,拿到的是已被复用的栈内存 → 随机字符串或 Hard Fault。这也是 `Device_Status_typedef` **不能整体 memcpy 做持久化**的根因(指针字段)。
+
+**建议**:`coll_time` 改成 `char coll_time[10][16]` 二维数组;持久化只用 `param_persist_t`。
+
+---
+
+### P1-9 片内 Flash 擦写全程未屏蔽中断
+
+**位置**:`drivers/drv_flash_f1.c:151-166`
+
+```c
+HAL_FLASH_Unlock();
+...
+if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
+```
+
+**后果**:STM32F1 单 Bank,页擦除 20~40ms 期间取指被挂起,所有 ISR 实际停摆。uart2 开了 1024 字节 DMA 环形缓冲(115200bps),40ms 足以灌满 → **DTU 报文丢帧**;同时丢失约 30 个 tick,超时判断漂移。
+
+**建议**:`HAL_FLASH_Unlock()` 前 `rt_enter_critical()`,`HAL_FLASH_Lock()` 后 `rt_exit_critical()`;多页擦除拆成单页循环,页间主动让出。
+
+---
+
+### P1-10 关中断区间内调用 `rt_hw_serial_isr()`(会唤醒线程并执行应用回调)
+
+**位置**:`drivers/drv_usart_v2.c:409-425`
+
+```c
+level = rt_hw_interrupt_disable();
+counter = __HAL_DMA_GET_COUNTER(&(uart->dma_rx.handle));
+...
+if (recv_len)
+{
+    rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_DMADONE | (recv_len << 8));
+}
+rt_hw_interrupt_enable(level);
+```
+
+**后果**:`serial_v2.c:1497` 的 `rt_completion_done()` 与 `:1501` 的应用 `rx_indicate` 回调都在中断全关的状态下执行。回调里若有任何阻塞调用即死锁;即便不阻塞,关中断窗口 = 回调执行时长,与 P1-9 叠加时 DMA 缓冲被冲掉。
+
+**建议**:只把 `counter` 采样和 `remaining_cnt` 更新留在关中断区,`rt_hw_serial_isr()` 移到 `rt_hw_interrupt_enable(level)` 之后。
+
+---
+
+### P1-11 串口错误回调重启 RX DMA 但不同步 ringbuffer 写索引
+
+**位置**:`drivers/drv_usart_v2.c:1088-1098`
+
+```c
+if (HAL_DMA_GetState(&uart->dma_rx.handle) != HAL_DMA_STATE_BUSY)
+{
+    struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)uart->serial.serial_rx;
+    if (rx_fifo != RT_NULL &&
+        HAL_UART_Receive_DMA(huart, rx_fifo->buffer, uart->serial.config.rx_bufsz) == HAL_OK)
+    {
+        uart->dma_rx.remaining_cnt = uart->serial.config.rx_bufsz;
+```
+
+**后果**:DMA 被复位到 `buffer[0]`,但 `rx_fifo->rb.write_index` 仍停在故障前的 N。自愈后每次 IDLE 都按"从 0 开始"算长度 → 读到重复旧数据/错位字节,DTU 协议解析持续报校验错,**且不会自行恢复**。
+
+**建议**:重启 DMA 前 `rt_ringbuffer_reset(&rx_fifo->rb)` 并把 read/write index 与 mirror 一并清零。
+
+---
+
+### P1-12 ADC 转换无互斥、HAL 返回值全部忽略
+
+**位置**:`drivers/drv_adc.c:212-221`
+
+```c
+HAL_ADC_ConfigChannel(stm32_adc_handler, &ADC_ChanConf);
+HAL_ADC_Start(stm32_adc_handler);
+HAL_ADC_PollForConversion(stm32_adc_handler, 100);
+*value = (rt_uint32_t)HAL_ADC_GetValue(stm32_adc_handler);
+```
+
+**后果**:`stm32_adc_handler` 是全局单例,两个线程同时 `rt_adc_read()` 会互相改写通道配置 → **传感值串通道**;`PollForConversion` 超时后仍取 DR,读到上一通道残留值。HAL 报错时无日志。
+
+**建议**:加静态 mutex 包裹;`if (HAL_ADC_PollForConversion(...) != HAL_OK) return -RT_ERROR;`
+
+---
+
+### P1-13 param_backup 单分区降级时把 NULL 分区当写入目标并解引用 `->name`
+
+**位置**:`applications/param_backup.c:373-382`、`:402`、`:406`
+
+```c
+if (ra != 0)
+{
+    target   = g_part_a;      // 若只找到 param_b,g_part_a == RT_NULL
+    next_seq = (rb == 0) ? (sb + 1) : (g_last_seq + 1);
+}
+else if (rb != 0)
+{
+    target   = g_part_b;      // 若只找到 param_a,g_part_b == RT_NULL
+    ...
+}
+LOG_E("[param] save to %s FAILED(%d)", target->name, ret);
+```
+`param_backup.c:238-241` 明确允许"只找到一个分区"的降级运行。
+
+**后果**:每一次落盘都会解引用空分区指针 → 多数情况直接 Bus Fault;即便躲过也是**参数永远存不进去**(`g_dirty` 不清),表现为"改了参数掉电就丢"。
+
+**建议**:`target` 初始化为 `RT_NULL`,两个分支后补 `if (target == RT_NULL) target = (g_part_a ? g_part_a : g_part_b);`;LOG 前判空。
+
+---
+
+### P1-14 滑动平均滤波器创建失败未判空即解引用
+
+**位置**:`applications/sht30_collect.c:247-249`、`:275`、`:82-90`
+
+```c
+MovingAverageFilter* filter = moving_average_filter_init(10);
+MovingAverageFilter* filter_v = moving_average_filter_init(10);
+...
+sprintf(device_status.power,"%.2f",(float)(moving_average_filter_update(filter, ...))+20.0);
+```
+`moving_average_filter_init` 在堆不足时返回 NULL(同文件 `:82-90` 自己就写了这个分支)。
+
+**后果**:`filter->sum -= ...` 落在 0 地址附近 → Hard Fault。这是 `Power_ReadCheck` 线程(10ms 周期),一崩就是**电压电流采样全停、欠压/掉电保护失效**。
+
+**建议**:两处 init 后判空并 `return`;`moving_average_filter_update` 开头加 `if (!filter || !filter->buffer) return newValue;`
+
+---
+
+### P1-15 beep.c 多个 PWM 入口在句柄为 NULL 时直接调用
+
+**位置**:`applications/beep.c:172-176`、`:246-258`、`:288-291`
+
+```c
+init_pwm3();
+rt_pwm_set(pwm_device, BEEP_PWM_CH, freq, freq/2);
+if(init_tim2()==0)
+    rt_pwm_enable(pwm_device, BEEP_PWM_CH);
+```
+`init_pwm3()` / `beep_init()` / `pwm8_init()` 失败时只打印并返回 `-RT_ERROR`,三处调用点全部忽略返回值。
+
+**后果**:`rt_pwm_set(NULL, ...)` 解引用空 `struct rt_device_pwm` → Hard Fault。表现为"一按蜂鸣 / 卷带 / 清扫就死机并复位"。
+
+**建议**:调用前统一 `if (pwm_device == RT_NULL && init_pwm3() != 0) return -RT_ERROR;`
+
+---
+
+### P1-16 中断回调里调用 `rt_kprintf` / `rt_device_close` / `rt_pwm_disable`
+
+**位置**:`applications/beep.c:25-31`(hwtimer 超时回调)、`:180-184`/`:190`(GPIO 中断回调)
+
+```c
+static rt_err_t timeout_cb(rt_device_t dev, rt_size_t size)
+{
+    rt_kprintf("this is hwtimer timeout callback fucntion!\n");
+    rt_kprintf("tick is :%d !\n", rt_tick_get());
+    rt_pwm_disable(pwm_device, BEEP_PWM_CH);
+    rt_device_close(dev);
+```
+
+**后果**:`rt_kprintf` 走 console 设备 `rt_device_write`,`rt_device_close` / `rt_pwm_disable` 均可能取锁 —— 中断里等待即死锁,5s 后看门狗复位。表现为"电机限位触发或蜂鸣定时到期时随机死机"。
+
+**建议**:回调只做 `rt_sem_release()` / 置 volatile 标志,打印与 `rt_pwm_disable` 移到线程。
+
+---
+
+### P1-17 Modbus 主站写请求使用 `RT_WAITING_FOREVER`
+
+**位置**:`applications/sample_mb_master.c:48-52`
+
+```c
+eMBMasterReqErrCode _code_ret = eMBMasterReqWriteMultipleHoldingRegister(SLAVE_ADDRESS,
+                                    REGISTER_ADDRESS, NREGS, Buffer, RT_WAITING_FOREVER);
+```
+
+**后果**:485 从机掉线 / 接线松动 / 地址不符(现场最常见故障)→ 调用线程**永久挂起**,485 采集流程卡死,温湿度数据不再更新。
+
+**建议**:改为有限超时(如 `3000`),并按同文件 `:121-128` 已有的 `error_count` 逻辑重试/降级。
+
+---
+
+### P1-18 从 RTU 同步参数时无范围校验,且 `deviceId` 取错字段
+
+**位置**:`applications/dtu_uart2.c:1204-1208`、`:1098-1214` 整段
+
+```c
+value = cJSON_GetObjectItem(Params,"deviceId");
+if(value!=NULL){
+    rt_snprintf(device_status.deviceId, sizeof(device_status.deviceId),"%s",value->string);
+    ef_set_env_blob("deviceId", &device_status.deviceId, sizeof(device_status.deviceId));
+}
+```
+1. `value->string` 是 **key 名**(恒为 `"deviceId"`),取字符串值应为 `value->valuestring` → 设备编码被写成字面量 `"deviceId"`(北大荒编码丢失)。
+2. 整段所有 `device_status.X = value->valueint` 均无范围校验(`dattim`、'shake_sec'、'sunBar'、'tpl'…),越界值直接落 EasyFlash,并打开 P1-3 的栈溢出路径。
+
+**建议**:`value->valuestring`;并对每个字段套用与 `paramconf` 分支相同的范围校验后再写 flash。
+
+---
+
+## 四、P2 中等(15 条)
+
+| # | 位置 | 问题 / 后果 | 建议 |
+|---|---|---|---|
+| P2-1 | `sys_monitor.c:23`、`sht30_collect.c:49`(另见 `hmi.c:57`、`dtu_uart2.c:44`、`control.c:40`) | `System_stats_t system_status` 在 5 个 .c 里各定义一次,靠 `-fcommon` 合并。GCC10 起默认 `-fno-common`,任何人加个初值就变强定义 → **链接期 multiple definition**。这正是 `device_status` 刚修掉的同类坑 | 在 `sys_monitor.h` 加 `extern`,只保留一处定义 |
+| P2-2 | `hmi.c:134`(`static char str[MAX_SIZE]`) | `HMI_WRITE` 用**静态 1024 字节缓冲且无锁**,被 dtu 接收线程、workloop、selfcheck、屏幕线程等并发调用 → 格式化内容互相覆盖,屏幕串显/乱码 | 加静态 mutex,或改用线程本地/栈上缓冲 |
+| P2-3 | `dtu_uart2.c:331-376` + `:62` | uart5 接收线程与 uart2 接收线程**共用同一个全局 `lwparser`**,无锁。当前 `MATCH_DEVICE 0`(`:627`)未创建该线程,属休眠缺陷;一旦开启即双线程破坏解析状态机 | 各线程独立 parser 实例 |
+| P2-4 | `dtu_uart2.c:728-731`、`:891-894`、`:918-922`、`:948-952`、`:978-982`、`:1502-1506` | `makeJson_*` 在子对象创建失败分支 `return NULL` 时**未 `cJSON_Delete` 父对象** → OOM 路径泄漏 | 失败分支补 `cJSON_Delete(parent)` |
+| P2-5 | `dtu_uart2.c:2480-2482` | `photo_sta` 同时被当 Number(`:2477` 用 `->valueint`)和 String(`:2482` 用 `atoi(value_commn->valuestring)`)使用。是 Number 时 `valuestring == NULL` → `atoi(NULL)` 崩溃 | 先判 `type`,再决定取哪个字段 |
+| P2-6 | `sht30_collect.c:305-318` | NTC:`10000*(4096-Read_Ntc_Voltage())/Read_Ntc_Voltage()` **可能除零**;`TempCalculate(RV,…)-TempCalculate(RV,…)>10` 同参相减**恒为 0**,异常检测是死代码;`Read_Ntc_Voltage()` 在一行内被调用两次,每次内部含 6×10ms 阻塞 | 先取值判 `<=0` 再算;有效性判断改为区间检查;采样结果存局部变量复用 |
+| P2-7 | `sht30_collect.c:328` / `:257` / `:265` / `:270` | `voltage[6]` 装 `"39.80"` **零余量**;`PCB_V1==0` 分支(当前未编译)下 `heat_power[8]` 装 `"25000.00"` **必溢出** | 全改 `snprintf`;`heat_power`/`power` 扩到 ≥16 |
+| P2-8 | `sht30_collect.c:32`、`:585`、`:275` | 1024 字节栈的线程里使用 `%f`(软浮点 dtoa 峰值 500~800B)并调用含 `log()` 的 `TempCalculate` | 栈提到 2048 或改整数拼装 `%d.%02d` |
+| P2-9 | `sht30_collect.c:121`、`:134` | `rt_device_find("uart5")` 未判空即 `rt_device_control` / `rt_device_open` | 补判空并 `return -RT_ERROR` |
+| P2-10 | `param_backup.c:686-698`、`:712-729` | 落盘失败时 `g_dirty` 不清、`g_last_save_tick` 不更新 → 每 200ms 一次完整 4KB 擦写 + 一条 LOG_E,**加速 flash 磨损并刷爆串口** | 失败后置退避时间戳(如 10s)并重试 1~2 次 |
+| P2-11 | `param_backup.c:794-804` | `param_restore/param_dump` 在**锁外**使用共享静态区 `g_work`(`param_backup_read` 在 `:327` 已释放锁)→ 与落盘线程的 `param_pack(&g_work)` 竞争,读到半新半旧参数 | 锁内读到私有缓冲,出锁后再 unpack/打印 |
+| P2-12 | `sample_mb_master.c:155`、`:109-110`、`:117-118` | `md_m_poll` 栈仅 512 且跑 freemodbus 状态机;`device_status.tempture/humidity` 由 485 线程多步字符串写入、被落盘/温控/上传并发读,**无同步** → 读到撕裂串;每 5s 无条件 `rt_kprintf` 刷屏 | 栈≥1024;拼好串后一次性写入;日志降为 `LOG_D` |
+| P2-13 | `dtu_uart2.c:1990` | `rt_timer_stop(timer_takephoto)` 未判空;`timer_takephoto` 在 `selfcheck.c:24` 初值 `RT_NULL`,只有 `selfcheck_init` 执行过才非 NULL | 补 `if (timer_takephoto != RT_NULL)`;同处 `:1976` 的 `timer_uart2` 同理 |
+| P2-14 | `hmi.c:2105-2139`、`:2145` | 开机在 **main 线程**里做最长 180s + 10s 的阻塞等待(`while(atoi(device_status.net)==1)`),期间 `Workstatus_check` / `Work_Loop_Task` / `dtu_send_data_start` 全部延后 | 把联网等待移到独立线程,不要阻塞 main |
+| P2-15 | `dtu_uart2.c:244-248` | `DTU_Write` 里用 `rt_object_get_type(&dtu_write_mutex...)` 做懒初始化,**非线程安全**:两个线程同时首次调用可能重复 `rt_mutex_init` | 改为在 `dtu_data_play()` 里显式初始化,或加 `rt_enter_critical` 保护 |
+
+---
+
+## 五、P3 优化(8 条)
+
+| # | 位置 | 问题 | 建议 |
+|---|---|---|---|
+| P3-1 | `applications/lwjson.c:484/502/743` | DOM 解析器(`lwjson_init/parse/find`)全工程无调用,只有流式解析器在用,仍参与编译 | 从构建中排除 `lwjson.c`,只保留 `lwjson_stream.c` |
+| P3-2 | `main.c:49` | `memtrace(0, NULL)` 无原型声明(隐式声明),GCC14+ 默认 `-Werror=implicit-function-declaration` 会编不过 | 加 `extern int memtrace(int, char**);` 或改 `rt_memory_info()` |
+| P3-3 | `dtu_uart2.c:417-433` | `hasElementGreaterThan400()` 实现的是 `arr[i] < LAMP_CURRENT`,与函数名("大于")相反;`hasElementGreater_lessThan400` 亦然。当前调用点靠"取反"恰好正确,但极易被后人改错 | 按语义重命名并修正比较方向 |
+| P3-4 | `dtu_uart2.c:2843-2881` | `atoi(&ivalue[3])<<8 | atoi(&ivalue[2])` 用**移位拼十进制数**,正确与否完全依赖目标字段是 `uint8_t` 被截断的巧合 | 改成 `sscanf(ivalue, "%hhu-%hhu", &sh, &eh)` |
+| P3-5 | `drv_pwm.c:361-507` + `board.h` | `board.h` 只定义 `BSP_USING_PWM3/PWM8`,**没有** `BSP_USING_PWM3_CH*`,`pwm_get_channel()` 得到 0 → `HAL_TIM_PWM_ConfigChannel` 一次都不调用,输出全靠 `MX_TIM3_Init` 的残留配置 | 补 `#define BSP_USING_PWM3_CH1` 等 |
+| P3-6 | `drv_common.c:65-67` | `HAL_Delay()` 是空实现,HAL 内部依赖它的上电/复位时序被静默跳过 | 实现为 `rt_thread_mdelay(Delay)` |
+| P3-7 | `drv_usart_v2.c:386` | `LOG_E("%s tx dma start failed, drop %d bytes", …)` 用 `%d` 打 `rt_size_t`(unsigned long),长包显示负数误导定位 | 改 `%lu` |
+| P3-8 | `drv_rtc.c:125`、`:103-104` | `HAL_RCC_OscConfig` 在 LSE 起振超时时返回 `HAL_TIMEOUT` 并回退 LSI,返回值被丢弃;`set_rtc_time_stamp` 无论成败都返回 `RT_EOK` | 两处判返回值并向上透传 |
+
+---
+
+## 六、待上机确认(静态无法定论,6 项)
+
+1. **syswatch 看门狗对长阻塞的容忍度**:`dtu_uart2.c:588` 的 `rt_thread_mdelay(60000)`(RTU 断电重启等待)与 `hmi.c:2105` 的最长 180s 开机等待,是否会被 syswatch(5s WDT)判定为异常并复位?需确认 syswatch 的 mode 与登记线程列表。
+2. **TIM3 资源冲突**:`pwm_config.h` 把 PWM3 映射到 TIM3,`tim_config.h` 把 hwtimer timer3 也映射到 TIM3。若应用层同时 open "pwm3" 与 "timer3",PSC/ARR 会互相覆盖。需确认 hwtimer 是否真被调用。
+3. **`MovingAverageFilter.sum` 为 `rt_uint16_t`**(`sht30_collect.c:76`),10 点累加上限 65535;当前被滤量(电压≈3980、电流≈4950)余量不足 30%,改量程/换采样系数后会静默回绕。
+4. **除零实际行为**:本工具链 `__aeabi_uidiv` 除 0 通常返回 0(不 trap),故 P2-6 按"温度被兜成 25℃"描述;若链接的是带 `__div0` 断言的变体则会直接 Hard Fault。
+5. **`sht30_collect.c:275` 把 float 实参传给 `rt_uint16_t` 形参**(`(float)Read_Real_Current()/100*2.5` 被截断),功率显示精度是否有意为之。
+6. **`selfcheck()` 单次执行累计阻塞约 70s+**,且由业务线程内直接调用;需确认这 70s 内喂狗与 Work_Loop 停摆不会引发误复位。
+
+---
+
+## 七、修复优先级分批建议
+
+**第一批(立即,改法都在 1~3 行,能止住现场死机)**
+- P0-1 `selfcheck.c:331` 改 `SOFT_TIMER`
+- P0-4 `dtu_uart2.c:308/356` 改 `%02x`
+- P0-2 `dtu_uart2.c:3225` 改 `DTU_Write("%s", updata)` + 判空
+- P1-15 / P1-16 `beep.c` 判空 + 回调只置标志
+- P1-2 `res[30]`→64;P1-4 `%-6.6s`
+
+**第二批(远程可达的输入面收口,建议同一版本完成)**
+- P0-3 所有 `cJSON_GetObjectItem` 结果判空(建议做统一封装)
+- P1-1 所有 `rt_sprintf(x,"%s",远端串)` 改 `rt_snprintf`
+- P1-5 driver 拼接限长;P1-8 `coll_time` 改二维数组
+- P1-18 `value->string` → `valuestring` + 补范围校验
+- P1-3 `utos[5]` 扩容
+
+**第三批(稳定性 / 寿命)**
+- P1-6 内存泄漏全量收口(建议写一个 `dtu_write_json(char*)` 包装自动 free)
+- P1-7 删线程前 reset mutex
+- P1-9 / P1-10 / P1-11 / P1-12 驱动层临界区与返回值
+- P1-13 / P1-14 / P1-17 判空与超时
+- P2 全部(尤其 P2-1 `-fcommon` 隐患、P2-2 HMI_WRITE 加锁、P2-10 flash 磨损)
+
+**第四批(清理)**
+- P3 全部
+
+---
+
+## 八、附录:已核实"不是问题"的项(避免误报)
+
+| 排查项 | 结论与依据 |
+|---|---|
+| `free` / `rt_free` 混用 | **不是缺陷**。newlib 的 `syscalls.c:39/76` 已把 `malloc/free` 重定向到 `rt_malloc/rt_free`(`RT_USING_HEAP` 已开) |
+| `sizeof(指针)` 误当字段长度 | 未发现。持久化字段在 `param_persist_t` 与 `Device_Status_typedef` 两侧都是数组 |
+| `param_persist_t` 对齐 | 实测 820 字节、4 的倍数,A/B 分区 `hdr.len` 校验跨版本成立 |
+| `rt_device_read(dev, -1, &ch, 1)` 的 `-1` | `-1` 是 `pos` 参数,`serial_v2` 不使用 `pos`,**不是**读长度 |
+| `drv_usart.c` / `drv_usartX.c` | 整文件被 `RT_USING_SERIAL_V1` / `RT_USING_SERIAL_X` 挡住,是死代码,未列入缺陷 |
+| `lwjson.c` 的解析逻辑 | 只作"死代码"结论(P3-1),未逐个走查其内部实现 |
+
+---
+
+*本报告基于 2026-09-28 的工作区快照静态推导。行号以审计时的文件内容为准,若源文件后续被修改请以实际内容复核。标注"待上机确认"的项需要实测数据支撑,不建议仅凭本报告直接改行为。*