2 Commits 2364fd0331 ... eb0ad2efeb

Autor SHA1 Mensagem Data
  zhunk eb0ad2efeb add md 3 weeks atrás
  zhunk 14b7d3809c bootv1.3.5&app2.62 3 weeks atrás

+ 32 - 0
Application_cbd_apm32f1/.workbuddy/memory/2026-10-28.md

@@ -0,0 +1,32 @@
+# 2026-10-28
+
+## 只读分析:参数改完重启就丢失(用户要求不改代码,未动源码/readme)
+
+结论:写侧 2 条路(EF 立即写 + A/B 快照延迟写),读侧只有 1 条(Check_ParamConfig 逐 key 读 EF,
+快照仅在 `param_check_health()!=0` 时整包回灌)→ "写而不读"必然丢,快照不是正常读取源。
+
+确定性缺陷(已 grep 验证全工程无回读):
+1. `collecting_sh1/eh1/sh2/eh2` 写入 5 处(hmi.c:2349/2359/2369/2379、3299-3302、3650-3653、
+   dtu_uart2.c:3564-3573、param_backup.c:606-609),**开机读块 hmi.c:3326-3378 没有这 4 个 key**
+   → 每次重启 RAM 恒为 0,开机日志 hmi.c:3493 必打 `孢子仪采集时间:[0-0,0-0]`。
+   二次破坏:开机 `param_mark_dirty()` 把 0 写进快照 → 两槽都变 0 → 健康自检失败回写时 EF 也被清零。
+2. `vol`(音量)同样只写不读(hmi.c:2512/2577 连 EF 都不写,只进快照)→ 重启回 0;
+   dtu_uart2.c:2761 还拿 `vol==0` 当特殊值塞 111。
+3. 只改 RAM 不写 EF:hmi.c:2584(测报灯 thsp)、2659(setshake_sec 震动时间)。
+4. 孢子仪两个分支提前 `return`(hmi.c:2407 saveClockSet、2550 saveSystemSet)→ 跳过函数末尾
+   `param_mark_dirty()`(2873)→ 快照不刷新,后续一旦回灌就把新值退回很老的一版。
+5. 快照回写 key 用错:`param_write_back_to_easyflash()` 把 heatvalue 写 "jheat"(param_backup.c:589),
+   孢子仪开机优先读 "heatvalue"(hmi.c:3340-3343);`ResetParamDefault()` dtype==7 也只写 jheat(hmi.c:3654)
+   → 培养温度"回写/恢复出厂"都改不动。
+6. `sync_param`(RTU)无条件覆盖 RAM+EF(dtu_uart2.c:2489-2493 → parse_param_to_mcu),
+   `dtu_param_sync_on_rtu_params()` 只保护状态机不保护写入。
+7. 既有机理仍在:EF NG `set_env` 先删旧再建新(ef_env.c:1434-1446)中间掉电丢 key;iSave 丢 → 全量回出厂(hmi.c:3217)。
+8. 条件性:dtype 只由屏幕 `SwversionV*` 帧设置(hmi_switch_version 1826-1967,V4/V41/… 一律强写 dtype=3),
+   孢子仪若被判成 3,培养温度改走 jheat 分支读不到 "heatvalue"。
+
+现场判定(无需改码):开机日志 `孢子仪采集时间:[...]`;msh `printenv` / `getvalue collecting_sh1` /
+`getvalue heatvalue` / `param_dump` / `param_stat`;改参数后不重启先 `printenv` 看 EF 是否已变(变了=读侧问题);
+改完 10s 内 vs 30s 后重启对比(快照节流 PARAM_MIN_SAVE_TICKS=10s)。
+
+修复方向(未实施):补齐 5 个 key 的回读;2584/2659 补 ef_set_env_blob;统一 heatvalue 单一 key;
+去掉 2407/2550 的提前 return;快照与 EF 由"仅救急"改为按 seq 比对,消除双真相源。

+ 140 - 0
Application_cbd_apm32f1/.workbuddy/memory/2026-10-30.md

@@ -0,0 +1,140 @@
+# 2026-10-30 参数存储对齐 master:param_backup → param_mirror(2.58 → 2.59)
+
+## 做了什么
+- 删除 `applications/param_backup.c/.h`(877+211 行),新增 `param_mirror.c/.h`,以 master 当前版为基准:
+  easyflash 分区尾部 0x12000/0x13000 两槽、41 字节 packed payload(20 个标量)、
+  先写旧槽再写新槽、内容未变则跳过、`pm_mtx` 互斥、含 `DBG_ENABLE` 与 `param_mirror_erase_all()`。
+- FAL 表删除 `param_a`(128K)/`param_b`(132K) 两个分区;镜像改落 `easyflash` 分区内
+  (ENV 64KB + 本工程未启用日志区 → 0x12000/0x13000 均为空闲)。
+- hmi.c `Check_ParamConfig`:iSave 丢失 → `param_mirror_load` + `mirror_to_device_status`;
+  正常分支先载镜像再逐条读 EF(EF 覆盖镜像,master 语义);默认值分支末尾 `param_mirror_sync`。
+  移除 param_backup 的整包健康自检/回写 EF、延迟落盘线程、`param_flush_force`。
+- 全部 `param_mark_dirty()` → `param_mirror_sync()`:hmi 12 处、control 1 处、dtu 2 处。
+- `reboot_time` 改每 10 次开机落盘(同步 master 1.85;mirror payload 不含 rebootcnt)。
+- dtu_uart2.c 新增 `eraseflash` 指令(env/chip 两档,confirm=ERASE,start/done 回执,成功后复位),
+  实现 `dtu_erase_param_area`(镜像→ENV→日志,顺序不可变)、`dtu_erase_chip`(按 erase_gran 分块+喂狗)。
+
+## 本分支适配(刻意偏离 master)
+- 不在 param_mirror.c 定义 `device_status`(本工程唯一定义在 main.c;master 靠 -fcommon 合两份)。
+- 补 `__packed` 宏(本工程只有 CMSIS `__PACKED`,无 STM32 HAL)。
+- `mirror_part()` 双重门控 `fal_init_check()` + `nor_flash0_is_ready()`。
+- `EF_USING_LOG` 未开启(rtconfig 无 PKG_EASYFLASH_LOG)→ erase 的日志清理用 `#ifdef EF_USING_LOG`。
+- dtu_uart2.c 节名改 `DBG_SECTION_NAME "dtu"`:新 include 的 spi_flash_sfud.h 会 `#define DBG_TAG "SFUD"`,
+  rtdbg 的 DBG_SECTION_NAME 是 DBG_TAG 别名 → 会被劫持(构建期实测出现 redefined 告警)。
+- 编译期布局自检 `sizeof(param_payload_t)==41`,改动字段会直接编译失败。
+
+## 验证
+- 全量重编 170 命令 0 失败:text **254012** / data 2772 / bss **43632**,bin **256784B**。
+- 固件内已确认含 `param mirror loaded/erased/save failed`、`flash erase start:%s`、
+  `flash erase %s:%s`、版本串 2.59.41(HK)/2.59.4(2000W)/2.59.1(ZP)/2.59.1(GK)。
+- 分支吞噬脚本校验:17 个 strstr 分支,eraseflash 位于第 6(mvs_photo 之后、reboot 之前),双向无吞噬。
+
+## 待上机
+首次升级开机、清 iSave 后镜像恢复、eraseflash 两档回执与重启、连续改参数是否卡顿。
+
+---
+
+# 2026-10-30(二)同步 master 10-15:参数变更→待办备份到 RTU(2.59 → 2.60)
+
+## 做了什么
+- dtu_uart2.c:删除三态一次性状态机(`PARAM_SYNC_IDLE/WAIT/DONE` 宏、`s_rtu_rx_ok`、
+  `s_param_sync_state/retry/start/last`、`dtu_param_sync_poll()`、`dtu_param_sync_on_rtu_params()`);
+  新增 master 待办机制(`s_json_rx_cnt`/`s_param_recover_pending`/`s_param_backup_pending`/
+  `s_recover_sent_tick`/`s_param_solicit_end` + `RTU_COMM_FRESH_TICK`=15s / `PARAM_SOLICIT_TICK`=2min /
+  `BACKUP_AFTER_RECOVER_TICK`=30s + `dtu_rtu_comm_ready()` / `dtu_request_param_backup()` /
+  `dtu_param_pending_service()` / `dtu_param_on_rtu_params()`)。
+- 接收处 `s_rtu_rx_ok=1` → `s_json_rx_cnt++`;主循环 `dtu_param_sync_poll()` → `dtu_param_pending_service()`。
+- 发送线程入口:`iFlag==1` → 置恢复待办 + 2 分钟 getinfo 探测窗口。
+- dtu_uart2.h 声明 `dtu_request_param_backup()`;param_mirror.c include dtu_uart2.h,
+  `param_mirror_sync()` 写镜像成功后调 `dtu_request_param_backup()`(持 pm_mtx 时只赋 volatile 标志)。
+
+## 关键语义
+- **备份触发 = 镜像内容真的变了**(param_mirror_sync 提前 return 时不置位)→ 开机不再无条件备份,
+  只有屏幕/平台/版本切换/恢复出厂/转盘记位等真实变更才发。
+- 恢复优先于备份;恢复发送后 30s 内抑制备份(防默认值覆盖 RTU 权威副本)。
+- RTU 未就绪:不发帧,每 2s 发 getinfo 探测(限时 2 分钟),待办保留到就绪后补发。
+
+## 与 master 差异(刻意)
+- `s_last_json_rx_tick` 保留本分支"线程启动无条件重置"(master 是 `if(s_json_rx_cnt==0)` 才重置);
+  不影响就绪判定,因为 `dtu_rtu_comm_ready()` 首判据是 `s_json_rx_cnt != 0`。
+- 多一个 `dtu_param_on_rtu_params()`(master 无):收到 sync_param 时取消恢复待办 + 清 iFlag。
+
+## 验证
+- 全量重编 170 命令 0 失败:text **253660** / data 2772 / bss **43632**,bin **256432B**
+  (比 2.59 的 254012/256784B 净减 text 352B —— 删状态机收益大于新增)。
+- 告警 60 条,与 2.59 完全一致(无新增);param_mirror.c 仍 0 条。
+- 固件含 6 条新中文日志 + 版本串 2.60.41(HK)/2.60.4(2000W)/2.60.1(ZP)/2.60.1(GK)。
+
+## 能力变化(要注意)
+- 开机不再无条件备份;恢复请求不再重发(master 机制是"发出即完成",靠 sync_param 回传收尾)。
+- 恢复只在发送线程启动那一刻读 iFlag,运行期参数被改坏不会再次触发。
+
+---
+
+# 2026-10-30(三)远程擦除指令并入 cmd=ctrl(2.60 → 2.61)
+
+## 改动
+- 指令:`{"cmd":"eraseflash","ext":{...}}` → **`{"cmd":"ctrl","ext":{"target":"env|chip","confirm":"ERASE"}}`**。
+  ext 结构与两档行为不变。
+- dtu_uart2.c:删除独立 `else if (strstr(cmd_s,"eraseflash"))` 分支;把 target 判定与执行
+  (含 `rt_hw_cpu_reset()`)搬到 `ctrl` 分支**首位**,用 `const char *erase_target = cj_getstr(item_ext,"target",RT_NULL)`
+  分流;注释与指令示例同步改为 cmd=ctrl。
+- control.h:2.60 → 2.61。**jjk-5 一并跟随为 2.61.4**(用户已把它从 2.58.4 改到 2.60.4,建立"跟主序列"新约定)。
+
+## 🔴 关键坑(本次的核心)
+顶层命令链是 `strstr(cmd_s,...)` 顺序链,`"ctrl"` 分支在 `"eraseflash"` 之前。
+**只把独立分支的模式改成 "ctrl" 会被更靠前的 ctrl 分支吞掉 → 擦除永远不可达**。
+正解:删独立分支 + 并入 ctrl 内部,且必须在所有 `strstr(type_s,...)` 子分支之前
+(擦除指令无 type 字段,放后面会走到链尾静默丢弃)。
+
+另一个设计要点:**只要 ext 出现 target 就一律交给 dtu_flash_erase_exec()**,
+不要写成"仅 target==env/chip 才进入"——否则未知 target 会静默消失、平台收不到拒绝回执。
+
+## 校验(脚本)
+- 顶层分支 17→16,eraseflash 已不在列表。
+- ctrl 内 target 判定偏移 801 < 首个 strstr(type_s) 偏移 1212。
+- 19 个 type 子分支全部走 type 字段,与 target 无交集;前置/后置双向无吞噬。
+- 旧指令 `{"cmd":"eraseflash"}` 现在**无匹配分支 → 静默丢弃**,平台侧必须同步改 ctrl。
+
+## 构建
+全量 170 命令 0 失败:text **253636** / bss 43632 / bin **256408B**(比 2.60 减 text 24B)。
+告警 60 条无新增。版本串 2.61.41(HK)/2.61.4(2000W)/2.61.1(ZP)/2.61.1(GK)(jjk-5 分支未编译)。
+
+
+
+---
+
+# 2026-10-30(四)chip 档擦除失败修复(2.61 → 2.62)
+
+## 上板故障(用户贴的日志)
+```
+[E/SFUD] ERROR: Flash device norflash0 not found!
+[E/dtu] 擦除失败:找不到 SPI Flash 设备 norflash0
+→ flash erase failed:chip (0s)
+```
+
+## 根因
+`NOR_FLASH_DEV_NAME` = fal_cfg.h 的 **FAL 设备名 "norflash0"**;
+SFUD 注册名是 rtconfig 的 `FAL_USING_NOR_FLASH_DEV_NAME` = **"W25Q16"**
+(`fal_flash_sfud_port.c:181` `rt_sfud_flash_probe(FAL_USING_NOR_FLASH_DEV_NAME, "spi10")`)。
+2.59 移植时照抄了 hmi.c 的写法(hmi.c 那处本身就是错的),于是 chip 档永远找不到设备。
+
+## 修复
+- `dtu_erase_chip()` 改走 FAL 设备层:`const struct fal_flash_dev *dev = &nor_flash0;`
+  → `nor_flash0_is_ready()` 门控 → `dev->blk_size` 作粒度 → 64KB 对齐分块 → `dev->ops.erase()`
+  返回擦除字节数(port 层成功返回 size、失败 -1)→ 每块喂狗。
+  完全不查名字,`dtu_uart2.o` 对 sfud 的引用降为 **0**,同时删掉 `#include <spi_flash_sfud.h>`。
+- 同类 bug 一并修:hmi.c(t10 调试页外挂Flash)、sys_monitor.c(top 的 [Flash] 外部)
+  的 `rt_sfud_flash_find_by_dev_name(NOR_FLASH_DEV_NAME)` → `FAL_USING_NOR_FLASH_DEV_NAME`;
+  sys_monitor 失败分支两个名字都打印。
+- control.h 2.61 → 2.62(jjk-5 跟随 2.62.4)。
+
+## 验证
+- 全量 170 命令 0 失败:text **253780** / bss 43632 / bin **256552B**(比 2.61 +136B)。
+- 告警 60 条无新增;确认 `dev->ops.erase == RT_NULL` 未触发 distinct-pointer 告警。
+- 符号级:dtu_uart2.o 重定位含 `nor_flash0`(ABS32)+`nor_flash0_is_ready`,sfud 符号数 0;
+  hmi.o 已无 "norflash0" 字符串;固件含「开始整片擦除/整片擦除完成/SPI Flash 未就绪/未注册 erase 操作」。
+
+## 待上机
+chip 档应打印 `开始整片擦除 W25Q16: 容量 16777216 字节, 粒度 4096, 分块 65536`,
+约 2~4 分钟(256 块)后完成并重启,期间看门狗不复位。

File diff suppressed because it is too large
+ 27 - 5
Application_cbd_apm32f1/.workbuddy/memory/MEMORY.md


+ 3 - 3
Application_cbd_apm32f1/applications/control.c

@@ -27,7 +27,7 @@
 #define DBG_LEVEL         DBG_LOG
 #include <rtdbg.h> //must after of DBG_LVL, DBG_TAG or other options
 #include "sys_monitor.h"
-#include "param_backup.h"
+#include "param_mirror.h"
 //工作检测
 #define WORK_CHECK_THREAD_PRIORITY        23      //线程优先级
 #define WORK_CHECK_THREAD_STACK_SIZE      1024    //栈大小
@@ -1018,8 +1018,8 @@ void ctr_turn(uint8_t v,uint8_t sta)
         //保存位置
         device_status.run_sta = sta;
         ef_set_env_blob("run_sta", &device_status.run_sta, sizeof(device_status.run_sta));
-        /* 转盘位置变了, 同步进备份分区(掉电后能恢复到正确仓位) */
-        param_mark_dirty();
+        /* 转盘位置变了, 同步进参数镜像(掉电后能恢复到正确仓位) */
+        param_mirror_sync();
     }
     turn_cnt = 0;
     rt_pin_write(TURN_ZP_R, OFF);

+ 7 - 7
Application_cbd_apm32f1/applications/control.h

@@ -19,7 +19,7 @@
 #define MATCH_DEVICE     0             //比赛设备1-开启 0-关闭
 #define SENSOR_EN        0             //温湿度:0关闭,1打开
 #define UART_TEST_EN     0             ///串口测试0-关闭,1-启用
-#define TG_MODULE        0             //推杆电机结构模块化控制
+#define TG_MODULE        1             //推杆电机结构模块化控制
 #define DINGZHI_0722     0             //控制一个电机每天12点20工作12秒
 #define QINGSAO_IO       1             //调整清扫顺序20250801
 #define WENKONG          1             //温控功能1-开启 0-关闭
@@ -34,24 +34,24 @@
 #endif
 ////////////////////////////////////////////////////////////////
 
-#define VERSION_HK          "2.58.41(HK)"            //4.0海康-1200W
+#define VERSION_HK          "2.62.41(HK)"            //4.0海康-1200W
 #if TG_MODULE == 0
     #if JINGJIKUAN == 0
-        #define VERSION_HK_2000W    "2.58.4(2000W)"         //4.0水稻
+        #define VERSION_HK_2000W    "2.62.4(2000W)"         //4.0水稻
     #else
-        #define VERSION_HK_2000W    "2.58.4(jjk-5)"           //经济款
+        #define VERSION_HK_2000W    "2.62.4(jjk-5)"           //经济款
     #endif
 #else
     #if MATCH_DEVICE == 1
         #define VERSION_HK_2000W    "3.3.4(TG)"             //推杆结构比赛设备
     #else
-        #define VERSION_HK_2000W    "2.58.4(TG)"            //推杆结构
+        #define VERSION_HK_2000W    "2.62.4(TG)"            //推杆结构
     #endif
 #endif
 
 
-#define VERSION_ZP          "2.58.1(ZP)"            //1.0转盘
-#define VERSION_GK          "2.58.1(GK)"            //1.0高空
+#define VERSION_ZP          "2.62.1(ZP)"            //1.0转盘
+#define VERSION_GK          "2.62.1(GK)"            //1.0高空
 
 extern rt_event_t event_485_play;
 

+ 400 - 135
Application_cbd_apm32f1/applications/dtu_uart2.c

@@ -24,14 +24,19 @@
 #include "beep.h"
 #include <selfcheck.h>
 #include <user_mb_app.h>
-#include "param_backup.h"
+#include "param_mirror.h"
 
 #define DBG_ENABLE
 #define DBG_COLOR
-#define DBG_TAG "dtu"
+/* 直定义节名而不是 DBG_TAG:本文件曾 include spi_flash_sfud.h(已改为走 FAL 设备层、
+ * 不再需要),该头会经 sfud_cfg.h 抢先 `#define DBG_TAG "SFUD"`;rtdbg.h 把
+ * DBG_SECTION_NAME 定义为 DBG_TAG 的别名,会在展开时被劫持成 "SFUD"(并使能告警)。
+ * 直定义即固定为 "dtu",将来再引入组件头文件也不会被改写。 */
+#define DBG_SECTION_NAME    "dtu"
 #define DBG_LEVEL   DBG_LOG
 #include <rtdbg.h> //must after of DBG_LVL, DBG_TAG or other options
 #include <lwjson.h>
+#include <fal.h>                /* 远程擦除 Flash:分区查找/擦除 + nor_flash0 设备操作 */
 #include "sys_monitor.h"
 /* [BZY-OTA-PATCH] 运行时OTA全局静默开关(实现在 rt-thread/src/kservice.c) */
 extern void rt_console_mute(rt_uint8_t enable);
@@ -86,40 +91,36 @@ static rt_tick_t s_last_json_rx_tick = 0;   /* 上次收到完整JSON数据的
 
 #define JSON_RX_TIMEOUT_TICK    (2ULL * 3600 * RT_TICK_PER_SECOND)  /* 2小时超时(tick数) */
 
-/* ================= 开机参数同步(备份/恢复)一次性任务 =================
- * 原实现在发送线程入口无条件调用一次:
- *   iFlag==0 -> backup_param_to_rtu()   把 MCU 参数写给 RTU
- *   iFlag==1 -> recover_param_from_rtu() 参数异常, 向 RTU 要备份参数
- * 但线程启动那一刻 RTU 往往还没起来(MCU 先起、RTU 后起; 或 RTU 正在被断电重启),
- * 发出去的帧没有接收方: 备份丢包、恢复请求无人应答, 参数就永久停在默认值,
- * 而"只执行一次"又导致永不重试。
- * 现改为三态状态机(见 dtu_param_sync_poll):
- *   IDLE -> 先等 RTU 首个完整 JSON(链路真的通了)再发(最多等 PARAM_SYNC_WAIT_MS);
- *           超时说明 RTU 一直沉默, 先盲发一帧, 转 WAIT
- *   WAIT -> RTU 已就绪但未确认: 按 PARAM_SYNC_RETRY_MS 重发, 超 PARAM_SYNC_RETRY_MAX 次放弃;
- *           RTU 仍未就绪: 按 PARAM_SYNC_PROBE_MS 盲发(不提前放弃, 等它后面起来)
- *   DONE -> 本次上电不再执行(保证"只执行一次")
- */
-#define PARAM_SYNC_IDLE         0u
-#define PARAM_SYNC_WAIT         1u
-#define PARAM_SYNC_DONE         2u
-#define PARAM_SYNC_WAIT_MS      120000u   /* 等 RTU 就绪的最长时间(ms) */
-#define PARAM_SYNC_RETRY_MS     15000u    /* RTU 已就绪但未确认时的重发间隔(ms) */
-#define PARAM_SYNC_RETRY_MAX    4u        /* RTU 已就绪时的重发次数上限 */
-#define PARAM_SYNC_PROBE_MS     60000u    /* RTU 沉默(未就绪)时的盲发间隔(ms) */
+/* ==================== 参数恢复/备份的待办机制(同步 master 2026-10-15) ====================
+ * 缺陷原状(本分支旧实现的两处问题):
+ *   ① recover 与 backup 都在发送线程启动时按 iFlag 判定后"一次性"发送——RTU 尚未
+ *      启动(其 Linux 启动需 3~10s)或通信未建立时命令即丢失,恢复失败后只能等下次
+ *      上电重试;
+ *   ② 触发条件错误:只要 iFlag==0(本地参数正常)每次开机都备份一次,而参数真正发生
+ *      变更(屏幕/云端修改、版本切换等)时反而从不备份,RTU 侧副本长期滞后。
+ * 现机制(与 master 同一套):
+ *   ① 恢复条件 = iFlag==1(EF 与镜像两份都异常,已落默认值),且必须确认 RTU
+ *      "已启动且通信正常"(收到过完整 JSON 且最近 15s 仍活跃)后才发送;
+ *   ② 备份条件 = 参数内容确有变更(param_mirror_sync 实际写镜像是唯一变更汇聚点,
+ *      经 dtu_request_param_backup() 请求),同样等 RTU 就绪后执行;
+ *   ③ 未就绪时由 dtu_param_pending_service() 主动用 getinfo 探测(限时 2 分钟),
+ *      待办标志保留到 RTU 就绪为止(RTU 晚到也补发)。
+ * 注:旧的三态一次性状态机(PARAM_SYNC_IDLE/WAIT/DONE + dtu_param_sync_poll)已整体
+ *     移除,本机制天然支持"开机后任意时刻的参数变更"。 */
+static volatile rt_uint32_t s_json_rx_cnt = 0;           /* 收到的完整 JSON 帧计数(RTU 通信"曾经正常"的判据) */
+static volatile rt_uint8_t  s_param_recover_pending = 0; /* 1=两份都异常,待 RTU 就绪后从 RTU 恢复参数 */
+static volatile rt_uint8_t  s_param_backup_pending  = 0; /* 1=参数有变更,待 RTU 就绪后备份到 RTU */
+static rt_tick_t            s_recover_sent_tick  = 0;    /* 上次发送 recover 的时刻(备份抑制窗口起点) */
+static rt_tick_t            s_param_solicit_end  = 0;    /* 主动探测 RTU 通信的截止时刻(0=不探测) */
+#define RTU_COMM_FRESH_TICK       (15UL * RT_TICK_PER_SECOND)    /* "通信正常"的新鲜度窗口:15s */
+#define PARAM_SOLICIT_TICK        (120UL * RT_TICK_PER_SECOND)   /* 主动探测时限:2 分钟 */
+#define BACKUP_AFTER_RECOVER_TICK (30UL * RT_TICK_PER_SECOND)    /* 恢复后备份抑制窗口:30s */
 
 /* 上报线程等联网成功(net=="0")的最长时间: 未联网就上报, 平台根本收不到,
    首包丢了还得等一个完整 dattim 周期才会重发 —— 所以先等网, 最多 3 分钟。 */
 #define DTU_NET_WAIT_MS         180000u
 
-static volatile uint8_t s_rtu_rx_ok = 0;      /* 本次上电是否已收到过 RTU 的完整 JSON */
-static uint8_t  s_param_sync_state = PARAM_SYNC_IDLE;
-static uint8_t  s_param_sync_retry = 0;
-static rt_tick_t s_param_sync_start = 0;      /* 线程启动时刻(等待超时基准) */
-static rt_tick_t s_param_sync_last  = 0;      /* 上次发出请求的时刻(重发基准) */
-
-static void dtu_param_sync_poll(void);
-static void dtu_param_sync_on_rtu_params(void);
+static void dtu_param_pending_service(void);   /* 前向声明:供发送线程入口/主循环引用 */
 
 /* ★ 接收批量读的块大小。
    原来接收线程是 rt_device_read(dev, -1, &ch, 1) —— 一次系统调用只取 1 字节。
@@ -628,7 +629,7 @@ static void dtu_feed_block(lwjson_stream_parser_t *parser,
                      if (uart2_tick)
                      {
                          s_last_json_rx_tick = rt_tick_get();   /* 记录收到完整JSON的时间 */
-                         s_rtu_rx_ok = 1;                       /* RTU 已起来且链路正常 */
+                         s_json_rx_cnt++;                       /* RTU 通信计数:参数恢复/备份的就绪判据 */
                      }
                      *accum_len = 0;
                      /* ★ 原来写 sizeof(accum_buf): accum_buf 是形参指针, 只清了 4 字节 */
@@ -918,6 +919,269 @@ void dtu_request_report(void)
     rt_event_send(&s_dtu_send_evt, DTU_EVT_REPORT);
 }
 
+/* ==================== 远程 Flash 擦除(同步 master 1.86,指令并入 cmd=ctrl) ====================
+ * 指令(RTU 透传下发,解析见 parseDtu 的 "ctrl" 分支里 target 字段判定):
+ *   {"cmd":"ctrl","ext":{"target":"env"}}                     安全档(默认)
+ *   {"cmd":"ctrl","ext":{"target":"chip","confirm":"ERASE"}}  危险档,需强确认
+ * 注:2026-10-30 按要求由独立的 {"cmd":"eraseflash",...} 改为复用 cmd=ctrl,
+ *     靠 ext.target 与其它 ctrl 子指令(type 字段)区分。
+ *
+ * 两档范围差异极大:
+ *   env  —— 只擦"参数存储":参数镜像两槽 + EasyFlash ENV 区 + EF 日志区。
+ *           等价 msh 的 resetenv + 镜像清理,耗时 <1s,不碰任何固件区。
+ *   chip —— 片外 SPI NOR 整片擦除(本板 16MB),会连带擦掉 fm_area 与 df_area,
+ *           其中 df_area 是 OTA 回滚副本。
+ *           耗时数十秒~数分钟,必须带 confirm="ERASE"。
+ *
+ * 安全边界:片内 Flash(bl / app,固件自身所在的 onchip_flash)**任何档位都不擦**,
+ * 故本指令不存在把设备擦成砖的路径;最坏结果是参数回出厂默认 + 丢失回滚副本。
+ *
+ * 并发:擦除在 DTU 接收线程同步执行,期间 uart2 的 RTU 数据来不及读(可能丢帧、
+ * RTU 侧超时重试),属破坏性维护操作的预期代价;故先回执 start 再执行。
+ * ========================================================================== */
+
+#define DTU_ERASE_PART_NAME   "easyflash"   /* 片外 NOR 上承载 ENV/镜像/日志的分区 */
+
+/* 喂狗:整片擦除耗时可达数十秒,绝不能依赖 idle 钩子(擦除线程若长时间不让出 CPU
+ * 会停喂)。sfud 的忙等待用的是 rt_thread_delay,正常会让出,这里再显式兜一层。 */
+static void dtu_wdt_feed(void)
+{
+    static rt_device_t wdt_dev = RT_NULL;
+
+    if (wdt_dev == RT_NULL)
+    {
+        wdt_dev = rt_device_find("wdt");
+    }
+    if (wdt_dev != RT_NULL)
+    {
+        rt_device_control(wdt_dev, RT_DEVICE_CTRL_WDT_KEEPALIVE, RT_NULL);
+    }
+}
+
+/* 擦"参数存储"三块:镜像 → ENV → 日志。
+ * 顺序有讲究:镜像必须最先擦 —— 否则重启后 Check_ParamConfig 走 iSave 丢失路径时,
+ * param_mirror_load() 会把旧参数整份搬回来,"恢复出厂"就落空了。 */
+static int dtu_erase_param_area(void)
+{
+    const struct fal_partition *part;
+    int ret = RT_EOK;
+
+    /* ★ FAL 没建表成功时 fal_partition_find() 会撞 assert(init_ok) 死循环,
+       本分支所有分区查找前都必须先过这道门(见 fal_cfg.h 的说明)。 */
+    if (fal_init_check() != 1)
+    {
+        LOG_E("擦除失败:FAL 未初始化");
+        return -RT_ERROR;
+    }
+
+    part = fal_partition_find(DTU_ERASE_PART_NAME);
+    if (part == RT_NULL)
+    {
+        LOG_E("擦除失败:找不到 FAL 分区 %s", DTU_ERASE_PART_NAME);
+        return -RT_ERROR;
+    }
+
+    /* ① 参数镜像两槽(内部同时清 RAM 缓存,见 param_mirror_erase_all 注释) */
+    if (param_mirror_erase_all() != RT_EOK)
+    {
+        LOG_W("擦除参数镜像失败(继续擦 ENV)");
+        ret = -RT_ERROR;
+    }
+
+    /* ② EasyFlash ENV 区:整块擦掉,且**不写默认 key**。
+     * 不调用 ef_env_set_default() 的原因:它写入的是字符串型默认值("20"/"0xAA"…),
+     * 而本工程用 ef_get_env_blob 按二进制读取,读出来会是 ASCII 码而不是数值。
+     * 直接擦干净,重启后由 Check_ParamConfig() 用代码内的默认值重新填充,语义最干净。 */
+    if (fal_partition_erase(part, 0, ENV_AREA_SIZE) < 0)
+    {
+        LOG_E("擦除 ENV 区失败(0~%u)", (unsigned)ENV_AREA_SIZE);
+        ret = -RT_ERROR;
+    }
+    else
+    {
+        LOG_I("ENV 区已擦除(%u 字节)", (unsigned)ENV_AREA_SIZE);
+    }
+
+    /* ③ EF 日志区(起始 = ENV 区之后)。
+     * 本工程 rtconfig.h 未定义 PKG_EASYFLASH_LOG,EF_USING_LOG 关闭、日志区整体不存在,
+     * 因此这一步按条件编译处理(master 打开了日志区,故其原实现无条件清理)。
+     * 若将来开启日志功能:先确认 EasyFlash 可用(easyflash_init 幂等),若 EF 从未
+     * 初始化成功,日志区起始地址还没算出来,直接调 ef_log_clean() 会用 0 地址去擦。 */
+#ifdef EF_USING_LOG
+    if (easyflash_init() == EF_NO_ERR)
+    {
+        ef_log_clean();
+    }
+    else
+    {
+        LOG_W("EasyFlash 未就绪,跳过日志区清理(ENV 区已整块擦除,不影响结果)");
+    }
+#endif
+
+    return ret;
+}
+
+/* 片外 SPI NOR 整片擦除。按擦除粒度对齐分块,每块擦完喂一次狗。
+ *
+ * 🔴 2026-10-30 上板实测修复:原实现用 rt_sfud_flash_find_by_dev_name(NOR_FLASH_DEV_NAME),
+ *    而 NOR_FLASH_DEV_NAME 是 fal_cfg.h 里的 **FAL 设备名** "norflash0";SFUD 在
+ *    rt_hw_spi_flash_init() 里注册用的名字是 rtconfig 的 FAL_USING_NOR_FLASH_DEV_NAME
+ *    (本工程实际为 "W25Q16")。两者根本不同名 → 查找恒返回 NULL,chip 档必然失败,
+ *    现场日志正是:SFUD "Flash device norflash0 not found!" → "找不到 SPI Flash 设备"。
+ *    现改为直接走 FAL flash 设备层:norflash0 是全局 struct fal_flash_dev(fal_cfg.h 已
+ *    extern 声明),不需要任何名字查找;且与 ENV 区/参数镜像的擦除走同一层,错误码一致
+ *    (port 层 ops.erase 内部已做 nor_flash0_is_ready() 判空,不会解空指针)。
+ *    hmi.c(t10 调试页)与 sys_monitor.c(top 命令)里的同类名字误用已一并修正。 */
+static int dtu_erase_chip(void)
+{
+    const struct fal_flash_dev *dev = &nor_flash0;
+    uint32_t gran, chunk, offset;
+
+    if (nor_flash0_is_ready() != 1)
+    {
+        LOG_E("擦除失败:SPI Flash 未就绪(%s)", dev->name);
+        return -RT_ERROR;
+    }
+    if (dev->ops.erase == RT_NULL || dev->len == 0)
+    {
+        LOG_E("擦除失败:FAL 设备 %s 未注册 erase 操作", dev->name);
+        return -RT_ERROR;
+    }
+
+    gran = (uint32_t)dev->blk_size;
+    if (gran == 0)
+    {
+        gran = 4096;        /* 兜底:驱动未填粒度时按 4KB 处理 */
+    }
+    /* 分块取 64KB 并向下对齐到 gran(4KB 粒度 → 64KB;64KB 粒度 → 64KB) */
+    chunk = 64UL * 1024UL;
+    if (chunk < gran)
+    {
+        chunk = gran;
+    }
+    chunk -= (chunk % gran);
+    if (chunk == 0)
+    {
+        chunk = gran;
+    }
+
+    LOG_W("开始整片擦除 %s: 容量 %u 字节, 粒度 %u, 分块 %u",
+          dev->name, (unsigned)dev->len, (unsigned)gran, (unsigned)chunk);
+
+    for (offset = 0; offset < dev->len; offset += chunk)
+    {
+        uint32_t len = (uint32_t)dev->len - offset;
+
+        if (len > chunk)
+        {
+            len = chunk;
+        }
+        len -= (len % gran);        /* 尾块向下对齐到擦除粒度 */
+        if (len == 0)
+        {
+            break;                  /* 剩余不足一块(容量非粒度整数倍),已无可擦 */
+        }
+        if (dev->ops.erase((long)offset, len) != (int)len)
+        {
+            LOG_E("整片擦除失败于偏移 0x%08x (%u 字节)", (unsigned)offset, (unsigned)len);
+            return -RT_ERROR;
+        }
+        dtu_wdt_feed();
+    }
+
+    LOG_W("整片擦除完成: %u 字节", (unsigned)dev->len);
+    return RT_EOK;
+}
+
+/* 远程擦除入口:解析 target/confirm → 回执 start → 执行 → 回执结果。
+ * 返回 1 = 成功且需重启;0/-1 = 未执行或失败(均已回执,调用方不重启)。 */
+static int dtu_flash_erase_exec(cJSON *ext)
+{
+    /* ★ 本工程铁律:平台下发 JSON 一律不可信,取值只走 cj_getstr,
+       绝不直接碰 ->valuestring(非 String 节点该成员为 NULL)。 */
+    const char *target  = cj_getstr(ext, "target", "env");  /* 缺省为安全档 */
+    const char *confirm = cj_getstr(ext, "confirm", RT_NULL);
+    char msg[96];
+    char *json;
+    rt_tick_t t0;
+    int is_chip = 0;
+    int err;
+
+    if (target == RT_NULL || target[0] == '\0')
+    {
+        target = "env";
+    }
+
+    /* target 白名单:不认识的档位一律拒绝,绝不做"猜你想要擦哪"的兜底 */
+    if (rt_strcmp(target, "env") == 0)
+    {
+        is_chip = 0;
+    }
+    else if (rt_strcmp(target, "chip") == 0)
+    {
+        is_chip = 1;
+        /* 强确认:整片擦除不可撤销,且会带走 fm_area / df_area */
+        if (confirm == RT_NULL || rt_strcmp(confirm, "ERASE") != 0)
+        {
+            json = makeJson_Warn("flash erase rejected: need confirm=ERASE", "device");
+            if (json != RT_NULL)
+            {
+                DTU_Write("%s", json);
+                rt_free(json);
+            }
+            LOG_W("拒绝整片擦除:缺少 confirm=ERASE");
+            return -1;
+        }
+    }
+    else
+    {
+        rt_snprintf(msg, sizeof(msg), "flash erase rejected: unknown target %s", target);
+        json = makeJson_Warn(msg, "device");
+        if (json != RT_NULL)
+        {
+            DTU_Write("%s", json);
+            rt_free(json);
+        }
+        LOG_W("拒绝擦除:未知 target=%s", target);
+        return -1;
+    }
+
+    /* 先回执 start:擦除期间本线程无法处理其它下行指令,避免平台误判设备无响应 */
+    rt_snprintf(msg, sizeof(msg), "flash erase start:%s", target);
+    json = makeJson_Warn(msg, "device");
+    if (json != RT_NULL)
+    {
+        DTU_Write("%s", json);
+        rt_free(json);
+    }
+    LOG_W("收到远程擦除指令: target=%s", target);
+
+    t0  = rt_tick_get();
+    err = is_chip ? dtu_erase_chip() : dtu_erase_param_area();
+
+    rt_snprintf(msg, sizeof(msg), "flash erase %s:%s (%us)",
+                (err == RT_EOK) ? "done" : "failed", target,
+                (unsigned)((rt_tick_get() - t0) / RT_TICK_PER_SECOND));
+    json = makeJson_Warn(msg, "device");
+    if (json != RT_NULL)
+    {
+        DTU_Write("%s", json);
+        rt_free(json);
+    }
+
+    if (err != RT_EOK)
+    {
+        LOG_E("%s", msg);
+        return -1;
+    }
+    LOG_I("%s", msg);
+
+    /* 两档都需重启:参数区已清空 / 整片已空,重启后由 Check_ParamConfig 按
+     * "ENV 无 iSave" 路径重建全套默认参数。注意 version_type 会回到默认 4,
+     * 机型需由屏幕 Swversion 握手(hmi_switch_version)或平台参数下发恢复。 */
+    return 1;
+}
+
 /*入口函数-指令发送*/
 static void dtu_thread_entry_send(void *parameter)
 {
@@ -927,18 +1191,22 @@ static void dtu_thread_entry_send(void *parameter)
     static uint8_t record_current = 0;
     static uint8_t lamp_sta_cnt = 0;
 
-    /* ★ 原来在这里直接 backup/recover:
-         此刻 RTU 可能还没启动(或正在被断电重启), 发出去没人接 —— 备份丢包、
-         恢复请求无应答, 参数永久停在默认值且不再重试。
-       改成登记起始时刻, 由 dtu_param_sync_poll() 在 RTU 链路通了之后执行,
-       且整个上电周期只执行一次(状态机 DONE)。 */
-    s_param_sync_start = rt_tick_get();
-    s_param_sync_state = PARAM_SYNC_IDLE;
-    s_param_sync_retry = 0;
+    /* ---- 参数恢复/备份的待办决策(同步 master 2026-10-15,详见文件前部说明) ----
+     * 不再在此"盲发":两者都必须等 dtu_rtu_comm_ready() 成立(RTU 已启动且
+     * 通信正常)后由 dtu_param_pending_service() 执行,未就绪时先主动探测。 */
+    if(device_status.iFlag == 1)
+    {
+        s_param_recover_pending = 1;    /* 两份都异常:待 RTU 就绪后从 RTU 恢复参数 */
+        s_param_solicit_end = rt_tick_get() + PARAM_SOLICIT_TICK;
+        LOG_W("参数两份均异常(已用默认值),等待 RTU 通信正常后执行恢复");
+    }
     device_status.num_updata = 0;
     rt_thread_delay(5000);
     /* RTU 通信看门狗从线程启动时开始计时:
-     * 原实现只在"曾经收到过 JSON"后才计时,RTU 完全无输出(波特率错、模块故障)时保护失效 */
+     * 原实现只在"曾经收到过 JSON"后才计时,RTU 完全无输出(波特率错、模块故障)时保护失效。
+     * ⚠️ 这里刻意保留本分支的"无条件重置"语义(master 是"仅在从未收到过时重置"):
+     *    两者只是看门狗起点不同,不影响 dtu_rtu_comm_ready() 的判定——该函数第一个
+     *    判据就是 s_json_rx_cnt != 0,所以这段人造初值不会被当成"RTU 活跃"。 */
     s_last_json_rx_tick = rt_tick_get();
     /* 开机首次上报,随后启动周期定时器 */
     dtu_periodic_report();
@@ -949,8 +1217,8 @@ static void dtu_thread_entry_send(void *parameter)
     {
         rt_err_t evt_ret;
 
-        /* 开机参数备份/恢复(一次性):等 RTU 就绪后执行一次, 未确认则按间隔重发 */
-        dtu_param_sync_poll();
+        /* 参数恢复/备份待办:RTU 通信就绪即执行(无待办时为空判定,开销可忽略) */
+        dtu_param_pending_service();
 
         /* 1 秒超时用于维护数据上传倒计时与周期打印;有事件时立即唤醒处理 */
         evt_ret = rt_event_recv(&s_dtu_send_evt,
@@ -1668,8 +1936,8 @@ void parse_param_to_mcu(cJSON* Params)
     }else{
         LOG_E("Params is NULL!");
     }
-    /* 平台下发的一批参数处理完, 同步落一份整包快照到备份分区 */
-    param_mark_dirty();
+    /* 平台下发的一批参数处理完, 同步写一份参数镜像(内容未变化则不擦写) */
+    param_mirror_sync();
 }
 
 //备份MCU参数到RTU
@@ -1792,125 +2060,102 @@ void recover_param_from_rtu(void)
     dtu_write_json(makeJsonRpc2_0("recover_param", NULL, 1));
 }
 
-/* RTU 回传了一批参数(sync_param): 若本次上电的参数恢复还在等应答,
-   说明 RTU 已收到请求并把备份参数发回来了 —— 恢复完成, 清 iFlag 并终结一次性任务。
+/* ==================== 参数恢复/备份:就绪判定与延迟执行(同步 master 2026-10-15) ==================== */
 
-   (平台正常下发参数时状态机多半处于 DONE/IDLE, 这里直接返回, 不干扰。) */
-static void dtu_param_sync_on_rtu_params(void)
+/* RTU 通信就绪判定:至少收到过一帧完整 JSON,且最近 15s 内仍活跃——
+ * 前者证明 RTU 已启动(其 Linux 启动后才会向 MCU 输出 JSON),后者证明链路当前正常。 */
+static rt_bool_t dtu_rtu_comm_ready(void)
 {
-    if (s_param_sync_state != PARAM_SYNC_WAIT)
+    if (s_json_rx_cnt == 0)
     {
-        return;
+        return RT_FALSE;
     }
+    return ((rt_tick_get() - s_last_json_rx_tick) < RTU_COMM_FRESH_TICK) ? RT_TRUE : RT_FALSE;
+}
 
-    s_param_sync_state = PARAM_SYNC_DONE;
-
-    if (device_status.iFlag != 0)
-    {
-        device_status.iFlag = 0;    /* 参数已从 RTU 恢复, 本上电不再请求 */
-        LOG_I("[param] 已从RTU恢复备份参数, 开机一次性恢复完成");
-    }
-    else
-    {
-        LOG_I("[param] 开机参数备份已得到RTU响应");
-    }
+/* 外界接口:参数内容发生变更时(param_mirror_sync 实际写镜像处)请求备份到 RTU。
+ * 仅置待办标志,实际发送由发送线程在 RTU 通信正常后执行(不阻塞调用者)。 */
+void dtu_request_param_backup(void)
+{
+    s_param_backup_pending = 1;
 }
 
-/* 开机参数备份/恢复的一次性任务: 由发送线程每轮循环调用(约 1s), 非阻塞。
-   规则: RTU 就绪(收到过完整 JSON)后才正式发送; RTU 一直不就绪时按 60s 盲发等待它起来;
-         恢复请求未收到 sync_param 应答则重发, 超限放弃;
-         无论成功、放弃还是已完成, 都置 DONE, 保证一个上电周期只执行一次。 */
-static void dtu_param_sync_poll(void)
+/* 参数恢复/备份的延迟执行器(发送线程主循环每次调用,约 1s 一次):
+ *  - 恢复优先:iFlag==1(两份都异常)→ RTU 就绪后发送 recover_param_from_rtu;
+ *    发送后 30s 内抑制备份,避免把本地默认值覆盖到 RTU 的恢复副本上;
+ *  - 备份其次:参数变更待办 → RTU 就绪后发送 backup_param_to_rtu;
+ *  - 未就绪:限时(2 分钟)主动 getinfo 探测;待办保留到 RTU 就绪后补发。 */
+static void dtu_param_pending_service(void)
 {
-    rt_tick_t now = rt_tick_get();
-    rt_tick_t interval;
+    static rt_tick_t last_poke_tick = 0;
 
-    if (s_param_sync_state == PARAM_SYNC_DONE)
+    if (!s_param_recover_pending && !s_param_backup_pending)
     {
-        return;         /* 本上电的一次性任务已结束, 不再执行 */
+        return;
     }
 
-    if (s_param_sync_state == PARAM_SYNC_IDLE)
+    if (!dtu_rtu_comm_ready())
     {
-        /* RTU 尚未启动时发送的帧没有接收方: 先等链路通;
-           最多等 PARAM_SYNC_WAIT_MS, 之后按盲发处理(RTU 可能一直沉默) */
-        if (s_rtu_rx_ok == 0 &&
-            (now - s_param_sync_start) < rt_tick_from_millisecond(PARAM_SYNC_WAIT_MS))
-        {
-            return;
-        }
-
-        if (device_status.iFlag == 0)
+        /* RTU 未就绪:主动探测(限时),期间不发恢复/备份 */
+        if (s_param_solicit_end != 0 &&
+            (rt_int32_t)(rt_tick_get() - s_param_solicit_end) < 0 &&
+            (rt_tick_get() - last_poke_tick) >= (2UL * RT_TICK_PER_SECOND))
         {
-            backup_param_to_rtu();
-            LOG_I("[param] 开机参数备份到RTU(RTU %s)",
-                  s_rtu_rx_ok ? "已就绪" : "未就绪, 先盲发");
-            if (s_rtu_rx_ok)
+            char *ri;
+            last_poke_tick = rt_tick_get();
+            ri = makeJson_ReadInfo();
+            if (ri != RT_NULL)
             {
-                s_param_sync_state = PARAM_SYNC_DONE;   /* 链路已通, 备份发出即完成 */
-                return;
+                DTU_Write("%s", ri);
+                rt_free(ri);
             }
+            LOG_I("参数待办:探测 RTU 通信(getinfo)...");
         }
-        else
-        {
-            recover_param_from_rtu();
-            LOG_I("[param] 参数异常, 请求RTU下发备份参数(RTU %s)",
-                  s_rtu_rx_ok ? "已就绪" : "未就绪, 先盲发");
-        }
-
-        s_param_sync_state = PARAM_SYNC_WAIT;
-        s_param_sync_retry = 0;
-        s_param_sync_last  = now;
-        return;
-    }
-
-    /* ---------------- PARAM_SYNC_WAIT ---------------- */
-
-    /* 备份请求曾在"RTU 未就绪"时盲发过: 链路一通就补发一帧最新参数, 然后完成 */
-    if (s_rtu_rx_ok && device_status.iFlag == 0)
-    {
-        backup_param_to_rtu();
-        LOG_I("[param] RTU 就绪, 补发一次开机参数备份, 完成");
-        s_param_sync_state = PARAM_SYNC_DONE;
         return;
     }
 
-    /* RTU 已就绪但没等到应答: 15s 一次, 最多 4 次;
-       RTU 一直未就绪: 60s 盲发一次 —— 它后面(耗电模式结束/断电重启完成)起来就能收到 */
-    interval = rt_tick_from_millisecond(s_rtu_rx_ok ? PARAM_SYNC_RETRY_MS
-                                                    : PARAM_SYNC_PROBE_MS);
-    if ((now - s_param_sync_last) < interval)
+    /* 恢复优先 */
+    if (s_param_recover_pending)
     {
+        LOG_W("RTU 通信正常,执行参数恢复(recover_param_from_rtu)");
+        recover_param_from_rtu();
+        s_param_recover_pending = 0;
+        s_param_backup_pending  = 0;    /* 恢复将带回权威副本,取消本地备份请求 */
+        s_recover_sent_tick     = rt_tick_get();
         return;
     }
 
-    if (s_rtu_rx_ok)
+    /* 备份:恢复后的抑制窗口内暂缓 */
+    if (s_param_backup_pending)
     {
-        if (s_param_sync_retry >= PARAM_SYNC_RETRY_MAX)
+        if (s_recover_sent_tick != 0 &&
+            (rt_tick_get() - s_recover_sent_tick) < BACKUP_AFTER_RECOVER_TICK)
         {
-            LOG_E("[param] RTU 未确认%s请求, 放弃本次(保持当前参数, 下次上电再试)",
-                  device_status.iFlag ? "恢复" : "备份");
-            s_param_sync_state = PARAM_SYNC_DONE;
             return;
         }
-        s_param_sync_retry++;
-        LOG_W("[param] 重发%s请求 %d/%d", device_status.iFlag ? "恢复" : "备份",
-              s_param_sync_retry, PARAM_SYNC_RETRY_MAX);
-    }
-    else
-    {
-        LOG_W("[param] RTU 仍未就绪, 重新盲发%s请求", device_status.iFlag ? "恢复" : "备份");
+        LOG_I("参数发生变更,执行备份到 RTU(backup_param_to_rtu)");
+        backup_param_to_rtu();
+        s_param_backup_pending = 0;
     }
+}
 
-    if (device_status.iFlag == 0)
+/* RTU 回传了一批参数(sync_param):本地参数已是 RTU 的权威副本。
+ * ① 若恢复请求还没来得及发出(RTU 抢在 getinfo 探测之前把参数推回来),取消待办;
+ * ② 清 iFlag:参数不再是"默认值兜底"状态(与开机 Check_ParamConfig 的置位语义对齐)。
+ * 平台正常下发参数时两者本来就是 0/已清,这里不改变任何行为。
+ * 只在确实有待办/异常时才打印,避免平台周期性下发参数时刷日志。 */
+static void dtu_param_on_rtu_params(void)
+{
+    if (s_param_recover_pending)
     {
-        backup_param_to_rtu();
+        s_param_recover_pending = 0;
+        LOG_I("[param] 已从RTU恢复备份参数(recover_param 应答收到)");
     }
-    else
+    if (device_status.iFlag != 0)
     {
-        recover_param_from_rtu();
+        device_status.iFlag = 0;
+        LOG_I("[param] 参数异常标志已清除(RTU 回传参数)");
     }
-    s_param_sync_last = now;
 }
 
 void upload_sys_monitor_info(void)
@@ -2489,8 +2734,8 @@ int parseDtu(char *json_string)
                   if(strcmp(method_s,"sync_param")==0){
                       if(PARAMS!=NULL&&PARAMS->type==cJSON_Object){
                           parse_param_to_mcu(PARAMS);
-                          /* 开机"参数恢复"的一次性任务: 收到 RTU 回传的参数即视为恢复完成 */
-                          dtu_param_sync_on_rtu_params();
+                          /* 收到 RTU 回传的参数:视为参数恢复完成(清异常标志/取消待办) */
+                          dtu_param_on_rtu_params();
                       }
                   }else if (strcmp(method_s, "upgradehmi") == 0) {
                       if(PARAMS !=NULL&&PARAMS->type==cJSON_Object){
@@ -2726,7 +2971,24 @@ int parseDtu(char *json_string)
                   /* ★ 用 cj_getstr 取: item_ext 为 NULL / 没有 type / type 不是字符串 都返回 "" */
                   type_s = cj_getstr(item_ext,"type","");
                   cJSON *time_s = cJSON_GetObjectItem(item_ext,"time");
-                  if(strstr(type_s,"rtu_off_on")!=RT_NULL)       //RTU重新上电
+                  /* ★ 远程 Flash 擦除:{"cmd":"ctrl","ext":{"target":"env|chip","confirm":"ERASE"}}
+                   * 2026-10-30 由原 {"cmd":"eraseflash",...} 改到本分支(cmd 值改为 ctrl)。
+                   * 必须放在所有 type 子分支**之前**:
+                   *   ① 这些指令没有 type 字段(type_s 为空串),若放在后面会一直走到链尾静默丢弃;
+                   *   ② 只要 ext 里出现 target 字段就一律按擦除指令处理,档位白名单与
+                   *      "未知 target 拒绝并回执" 都交给 dtu_flash_erase_exec 内部判定,
+                   *      不做"猜你要擦哪"的兜底(与 master 的拒绝语义保持一致)。 */
+                  const char *erase_target = cj_getstr(item_ext,"target",RT_NULL);
+                  if (erase_target != RT_NULL)
+                  {
+                      if (dtu_flash_erase_exec(item_ext) > 0)
+                      {
+                          /* 两档都需重启:等回执发完再复位,避免报文被截断 */
+                          rt_thread_delay(2000);
+                          rt_hw_cpu_reset();
+                      }
+                  }
+                  else if(strstr(type_s,"rtu_off_on")!=RT_NULL)       //RTU重新上电
                   {
                       LOG_W("DTU 12V Power down");
                       RTU_Power_Off_Safe();
@@ -2904,6 +3166,9 @@ int parseDtu(char *json_string)
                   dtu_write_json(makeJson_Warn("mvs_takephoto","control"));
                   rt_thread_delay(2000);
               }
+              /* 远程 Flash 擦除已并入上面的 "ctrl" 分支(指令改为
+               * {"cmd":"ctrl","ext":{"target":"env|chip","confirm":"ERASE"}}),
+               * 此处不再有独立的 strstr 分支。 */
               else if (strstr(cmd_s,"reboot")!=RT_NULL)
               {
                   char *restart = makeJson_Warn("sysrem will restart","control");
@@ -3913,8 +4178,8 @@ int parseDtu(char *json_string)
           }
         cJSON_Delete(root);
     }
-    /* 一帧平台指令处理完, 若有参数变更则由落盘线程合并写入备份分区 */
-    param_mark_dirty();
+    /* 一帧平台指令处理完, 若有参数变更则同步进参数镜像(内容未变则不擦写) */
+    param_mirror_sync();
     return 0;
 }
 

+ 4 - 0
Application_cbd_apm32f1/applications/dtu_uart2.h

@@ -95,5 +95,9 @@ char* makeJsonRpc2_0(const char* method, cJSON* params, int id);
 
 void backup_param_to_rtu(void);
 void recover_param_from_rtu(void);
+/* 参数内容发生变更时请求备份到 RTU(同步 master 2026-10-15)。
+ * 仅置待办标志、不阻塞调用者;实际发送由 DTU 发送线程在 RTU 通信正常后执行
+ * (见 dtu_param_pending_service)。唯一调用点:param_mirror.c 的 param_mirror_sync()。 */
+void dtu_request_param_backup(void);
 void dtu_uart2_reinit_rx(void);
 #endif /* APPLICATIONS_INC_DTU_UART2_H_ */

+ 4 - 4
Application_cbd_apm32f1/applications/fal_cfg.h

@@ -54,15 +54,15 @@ extern int fal_init_check(void);
 */
 /* 注意: easyflash 分区起始地址必须保持 0,且不得小于 ENV_AREA_SIZE(64KB),
    否则老设备升级后原有 ENV 读不出来,参数会全部回出厂。
-   param_a / param_b 是新增的参数双备份区(各 4KB = 1 个 sector),
-   落在原 easyflash 分区内从未使用过的 128KB 之后,不影响已有数据。 */
+   2026-10-30(同步 master param_mirror):原 param_a / param_b 两个独立备份分区已删除。
+   参数镜像改为落在 easyflash 分区内部、ENV 区(64KB)与日志区(8KB)之后的
+   0x12000 / 0x13000 两个扇区(见 param_mirror.h 的 MIRROR_BASE_OFFSET)。
+   老设备 flash 里残留的 param_a/param_b 数据不再被引用,不影响启动。 */
 #define FAL_PART_TABLE                                                               \
 {                                                                                    \
     {FAL_PART_MAGIC_WORD,        "bl",     "onchip_flash",                           0,                       200*1024,       0}, \
     {FAL_PART_MAGIC_WORD,        "app",     "onchip_flash",                          200*1024,                312*1024,       0}, \
     {FAL_PART_MAGIC_WORD, "easyflash",     FAL_USING_NOR_FLASH_DEV_NAME,             0,                       128*1024,      0}, \
-    {FAL_PART_MAGIC_WORD,  "param_a",     FAL_USING_NOR_FLASH_DEV_NAME,             128*1024,                4*1024,        0}, \
-    {FAL_PART_MAGIC_WORD,  "param_b",     FAL_USING_NOR_FLASH_DEV_NAME,             132*1024,                4*1024,        0}, \
     {FAL_PART_MAGIC_WORD,  "fm_area",     FAL_USING_NOR_FLASH_DEV_NAME,             3*1024*1024,             512*1024,      0}, \
     {FAL_PART_MAGIC_WORD,  "df_area",     FAL_USING_NOR_FLASH_DEV_NAME,             3*1024*1024 + 512*1024,  512*1024,      0}, \
 }

+ 75 - 98
Application_cbd_apm32f1/applications/hmi.c

@@ -41,7 +41,7 @@
 #include "selfcheck.h"
 #include <user_mb_app.h>
 #include "sys_monitor.h"
-#include "param_backup.h"
+#include "param_mirror.h"
 
 #define HMI_THREAD_PRIORITY         5          //线程优先级
 #define HMI_THREAD_STACK_SIZE       2048        //线程栈空间大小
@@ -1745,7 +1745,10 @@ static void hmi_refresh_debug1(void)
      *   ① 型号表命中 → "W25Q128 16MB"(原样保留);
      *   ② 型号为空 → "Winbond EF4018 16MB"(厂商名 + JEDEC ID + 容量,信息全部实读自芯片);
      *   ③ 厂商也未知 → "JEDEC EF4018 16MB"。 */
-    nor = rt_sfud_flash_find_by_dev_name(NOR_FLASH_DEV_NAME);
+    /* ★ 2026-10-30 修复:这里原来传 NOR_FLASH_DEV_NAME("norflash0"),那是 **FAL 设备名**;
+     * SFUD 注册用的是 rtconfig 的 FAL_USING_NOR_FLASH_DEV_NAME(本机 "W25Q16"),
+     * 两者不同名 → 查找恒返回 NULL,调试页一直显示"未检测到外挂Flash"。 */
+    nor = rt_sfud_flash_find_by_dev_name(FAL_USING_NOR_FLASH_DEV_NAME);
     if (nor != RT_NULL)
     {
         const char *vendor = dbg1_flash_vendor(nor->chip.mf_id);
@@ -1836,7 +1839,7 @@ static void hmi_switch_version(const char *frame)
             ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
             ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
             MA_save();
-            param_mark_dirty();
+            param_mirror_sync();
         }
         else {
 
@@ -1853,7 +1856,7 @@ static void hmi_switch_version(const char *frame)
             ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
             ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
             MA_save();
-            param_mark_dirty();
+            param_mirror_sync();
         }
         else {
 
@@ -1873,7 +1876,7 @@ static void hmi_switch_version(const char *frame)
             ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
             ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
             MA_save();
-            param_mark_dirty();
+            param_mirror_sync();
         }
         else {
 
@@ -1891,7 +1894,7 @@ static void hmi_switch_version(const char *frame)
             ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
             ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型+
             MA_save();
-            param_mark_dirty();
+            param_mirror_sync();
         }
         return;
     }
@@ -1906,7 +1909,7 @@ static void hmi_switch_version(const char *frame)
             ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
             ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型+
             MA_save();
-            param_mark_dirty();
+            param_mirror_sync();
         }
         return;
     }
@@ -1922,7 +1925,7 @@ static void hmi_switch_version(const char *frame)
             ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型+
             DTU_Write("SwversionV41");
             MA_save();
-            param_mark_dirty();
+            param_mirror_sync();
         }
         else {
 
@@ -1944,7 +1947,7 @@ static void hmi_switch_version(const char *frame)
             ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
             ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
             MA_save();
-            param_mark_dirty();
+            param_mirror_sync();
         }
         else {
 
@@ -1961,7 +1964,7 @@ static void hmi_switch_version(const char *frame)
             ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
             DTU_Write("SwversionV7");
             MA_save();
-            param_mark_dirty();
+            param_mirror_sync();
         }
     }
 }
@@ -2869,8 +2872,8 @@ static void HMI_Decode(void)
     }else if(strstr(rx_buffer,"UMOUNT_UPAN")!=NULL){
             dtu_write_json(makeJsonRpc2_0("UMOUNT_UPAN", NULL, 1));
     }
-    /* 一屏指令处理完, 若有参数变更则由落盘线程合并写入备份分区 */
-    param_mark_dirty();
+    /* 一屏指令处理完, 若有参数变更则同步进参数镜像(内容未变则不擦写) */
+    param_mirror_sync();
 }
 
 
@@ -3148,17 +3151,8 @@ void Check_ParamConfig(void)
     time_t now = time(RT_NULL);
     static struct tm tm;
     gmtime_r(&now, &tm);
-    /* 双分区参数备份: 上电先把 param_a / param_b 里有效的那份读出来备用。
-       ★ 必须是 static: param_persist_t 有 820 字节,而 main 线程栈只有 2048,
-         这个函数里还有第二个(param 自检用的 cur),两个放栈上再加调用栈必爆。 */
-    static param_persist_t param_boot_snap;
-    uint32_t        param_boot_seq = 0;
-    int             param_boot_snap_ok = 0;
     int             ef_ok = 0;              /* EasyFlash 是否可用 */
-    int             up_flag_ef   = 0;       /* 通道①: EasyFlash 里的升级请求 */
-    int             up_flag_snap = 0;       /* 通道②: 参数快照里的升级请求 */
-    int             up_flag_bkp  = 0;       /* 通道③: RTC 备份寄存器里的升级请求 */
-    int             up_request   = 0;       /* 三通道裁决结果 */
+    int             up_flag_ef   = 0;       /* EasyFlash 里的升级请求(iSave 丢失时保留) */
 
     /* ★ flash 健康检查门控(2026-09-24 加固)
        SPI flash 探测失败(虚焊/击穿/SPI 不通)时, 原链路会一路"假装正常":
@@ -3184,33 +3178,36 @@ void Check_ParamConfig(void)
         up_flag_ef = (device_status.update_flag != 0) ? 1 : 0;
         ef_get_env_blob("iSave", &device_status.iSave, sizeof(device_status.iSave), NULL); //判断是否用户配置了程序
         device_status.rebootcnt++;
-        /* ★ 原代码在这里立即 ef_set_env_blob("reboot_time") 落 flash。
-           这是每次开机必然执行的一笔写,正好落在上电/复位最不稳的时刻:
-           写一半被复位,该条 env 下次启动会被判成 ENV_ERR_HDR 而永久丢失;
-           若这一笔又触发 GC,中断的搬移会让整个 sector 被 format,成片丢参数。
-           开机计数改为随参数快照一起延迟落盘(param_mark_dirty),
-           计数照样保存,但消掉了开机瞬间这个高危 flash 写窗口。 */
+        /* ★ 原实现每次开机都写一条 reboot_time。EasyFlash 是追加式 KV,每次写占
+           一条记录并推动扇区轮换/GC,属持续写放大,而且正好落在上电/复位最不稳的
+           时刻。同步 master 1.85:每 10 次落盘一次(落盘值 1,11,21…,断电最多倒退
+           9 次计数)。
+           ⚠️ param_mirror 的 payload 不含 rebootcnt(与 master 布局一致),
+           所以这条计数只能走 EasyFlash,不能再依赖参数快照延迟落盘。 */
+        if ((device_status.rebootcnt % 10) == 1)
+        {
+            ef_set_env_blob("reboot_time", &device_status.rebootcnt, sizeof(device_status.rebootcnt));
+        }
         LOG_I("REBOOT_TIME:%d-%d-%d",device_status.rebootcnt,device_status.iSave,device_status.update_flag);
     }
     else {
         LOG_E("easyflash init ERRPR!!!");
     }
-    if(param_backup_init()==RT_EOK)
-    {
-        param_boot_snap_ok = (param_backup_read(&param_boot_snap, &param_boot_seq) == 0);
-        LOG_I("[param] boot snapshot %s, seq=%d",
-              param_boot_snap_ok ? "VALID" : "NONE", (int)param_boot_seq);
-    }
     /* ★ iSave 是整机参数的唯一哨兵: 它一旦丢失, 下面这个分支会把全部参数
-       刷成出厂值(现场表现为"重启后参数全没")。这里先用备份分区抢救一次,
-       把"丢一条 iSave -> 全量回出厂"拦在前面。 */
-    if(ef_ok && (device_status.iSave != FLASH_FLAG) && param_boot_snap_ok
-       && (param_boot_snap.iSave == FLASH_FLAG))
+       刷成出厂值(现场表现为"重启后参数全没")。这里先用参数镜像抢救一次,
+       把"丢一条 iSave -> 全量回出厂"拦在前面(与 master 同一策略)。
+       镜像无效时不做任何事, 继续走下面的默认值分支。 */
+    if (device_status.iSave != FLASH_FLAG)
     {
-        LOG_W("[param] iSave lost in easyflash, recover from backup seq=%d", (int)param_boot_seq);
-        param_unpack(&param_boot_snap);
-        param_write_back_to_easyflash(&param_boot_snap);
-        param_mark_dirty();
+        param_payload_t boot_mirror;
+        if (param_mirror_load(&boot_mirror) == RT_EOK)
+        {
+            LOG_W("iSave lost but mirror is valid (seq=%u), recovering",
+                  (unsigned)boot_mirror.write_seq);
+            mirror_to_device_status(&boot_mirror);
+            /* iSave 现在已是 FLASH_FLAG;置 iFlag=0 与"正常读取用户配置"路径语义一致 */
+            device_status.iFlag = 0;
+        }
     }
 
     //保存默认配置
@@ -3246,9 +3243,10 @@ void Check_ParamConfig(void)
            走到这个分支只说明 iSave 这条 env 丢了(EasyFlash 局部损坏),
            并不代表升级请求是假的 —— 现场表现就是:
            参数丢了 -> 升级标志被顺手抹掉 -> 触发升级后重启静静跳过升级。
-           这里改为保留已读到的升级请求, 交给下面的三通道统一裁决。 */
-        device_status.update_flag = ((up_flag_ef != 0)
-                                     || (param_boot_snap_ok && param_boot_snap.update_flag != 0)) ? 1 : 0;
+           这里保留已从 EasyFlash 读到的升级请求。
+           ⚠️ param_mirror 的 payload 不含 update_flag(与 master 布局一致),
+           原先"参数快照里再存一份升级请求"的通道随 param_backup 一并移除。 */
+        device_status.update_flag = (up_flag_ef != 0) ? 1 : 0;
         /*孢子仪*/
         device_status.collecting_sh1 = 9;
         device_status.collecting_eh1 = 10;
@@ -3320,9 +3318,27 @@ void Check_ParamConfig(void)
         LOG_I("passwd:%d",device_status.passWord);
         LOG_I("alarm_tg:%s",device_status.alarm_tg);
 
+        /* 用刚刚写入 EF 的同一套默认值初始化参数镜像。
+           此后所有参数变更路径都会调用 param_mirror_sync() 保持镜像与 EF 同步。 */
+        param_mirror_sync();
+
     }//从easyflash读取参数配置
     else if (device_status.iSave==FLASH_FLAG) {
+        /* 先尝试从参数镜像恢复。镜像里有 20 个关键标量字段,单条 env 丢失时
+           不会直接露出过期默认值;镜像里没有的字段(imei/iccid/deviceId/
+           driver_bl/platform/env_t/env_h 等字符串)仍在下面从 EasyFlash 逐条读取。
+           ⚠️ 与 master 行为一致:下面的逐条读取会覆盖镜像值,镜像只对"读不到的键"生效。 */
+        param_payload_t mirror;
         device_status.iFlag = 0;
+        if (param_mirror_load(&mirror) == RT_EOK)
+        {
+            LOG_I("param mirror loaded (seq=%u)", (unsigned)mirror.write_seq);
+            mirror_to_device_status(&mirror);
+        }
+        else
+        {
+            LOG_W("param mirror unavailable, falling back to EF single-key");
+        }
         ef_get_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype),NULL);                             //设备类型
         ef_get_env_blob("dattim",&device_status.dattim,sizeof(device_status.dattim),NULL);                          //数据上传间隔
         ef_get_env_blob("stime", &device_status.clt_time, sizeof(device_status.clt_time), NULL);                    //收集时间
@@ -3378,45 +3394,10 @@ void Check_ParamConfig(void)
         ef_get_env_blob("alarm_tg",&device_status.alarm_tg,sizeof(device_status.alarm_tg),NULL);                    //闹钟                                               //光控计数
         device_status.work_done = 0;
 
-        /* ===== 参数健康自检 + 双分区恢复 =====
-           EasyFlash 读出来的结果先体检; 只要有关键项为 0(说明对应 env 已损坏/丢失),
-           就用备份分区的快照整包恢复, 并回写 EasyFlash 修好 flash 侧的坏条目。
-           这样"丢参数"只会被修复一次, 不会像原来那样每重启都丢一遍。 */
-        {
-            /* ★ 同 param_boot_snap: 820 字节必须走静态区, 不能放 main 线程栈上 */
-            static param_persist_t cur;
-            int perr;
-
-            param_pack(&cur);
-            perr = param_check_health(&cur);
-
-            if(perr != 0)
-            {
-                LOG_E("[param] easyflash param BROKEN, err=0x%02x", perr);
-                if(param_boot_snap_ok && (param_check_health(&param_boot_snap) == 0))
-                {
-                    uint32_t rc = device_status.rebootcnt;   /* 保留本次开机累加 */
-                    param_unpack(&param_boot_snap);
-                    if(rc > device_status.rebootcnt)
-                    {
-                        device_status.rebootcnt = rc;
-                    }
-                    LOG_W("[param] restored from backup seq=%d, write back to easyflash", (int)param_boot_seq);
-                    param_write_back_to_easyflash(&param_boot_snap);
-                }
-                else
-                {
-                    LOG_E("[param] no usable backup(seq=%d), fall back to factory patch", (int)param_boot_seq);
-                }
-            }
-            else if(param_boot_snap_ok && (param_boot_snap.rebootcnt > device_status.rebootcnt))
-            {
-                /* 两侧都正常时, 开机次数取较大者, 防止 reboot_time 这条 env 单独丢失 */
-                device_status.rebootcnt = param_boot_snap.rebootcnt;
-            }
-            /* 无论走哪条路, 都让快照侧保持最新 */
-            param_mark_dirty();
-        }
+        /* 说明:原 param_backup 在这里做"整包健康自检 + 双分区回写 EF",
+           已随 param_backup 一并移除。现在由上面开头的 param_mirror_load() 负责
+           iSave/关键标量的抢救,下面的补丁负责把明显不合理的 0 值修回可用值;
+           两者合并后仍能覆盖"单条 env 丢失"的现场故障。 */
 
         //丢参数的处理
         if(device_status.sunBar==0) device_status.sunBar = 4;
@@ -3436,9 +3417,9 @@ void Check_ParamConfig(void)
         if(device_status.work_mode>1) device_status.work_mode = 0;
 
         /* ★ 上面这段补丁原来只改 RAM 不落盘, 所以每次重启都要重复丢、重复修。
-           现在补一个 dirty 标记, 修正后的值会进备份分区, 下次开机再回写 EasyFlash,
-           把 flash 侧的错误值彻底修掉。 */
-        param_mark_dirty();
+           现在把修正后的值写进参数镜像(内容未变化时 param_mirror_sync 不擦写),
+           下次开机镜像恢复时即可带回修正值。 */
+        param_mirror_sync();
 
         /*设备类型,7孢子仪,3测报灯,默认设置测报灯*/
         if(device_status.dtype!=7)
@@ -3498,10 +3479,9 @@ void Check_ParamConfig(void)
         LOG_I("motor_active:%d",device_status.motor_active);
     }
 
-    /* 启动参数延迟落盘线程: 之后所有 param_mark_dirty() 的变更,
-       会在静默 500ms 后合并成一次 4KB 擦写写入备份分区,
-       把"改一条参数擦一次 flash"变成"一批改动擦一次"。 */
-    param_backup_start();
+    /* 同步 master:param_backup 的"延迟落盘线程"已取消。
+       param_mirror_sync() 在参数变更点同步写镜像,靠"内容未变化则跳过"抑制写放大,
+       不再需要常驻线程与 500ms 静默期。 */
     {
         device_status.update_flag = 0;
         //初始化联网状态
@@ -3657,10 +3637,8 @@ void ResetParamDefault(void)
     ef_set_env_blob("thsp", &device_status.thsp, sizeof(device_status.thsp));
     ef_set_env_blob("passWord", &device_status.passWord,sizeof(device_status.passWord));
     /* 恢复出厂是一次 24 连写, 最容易被打断导致只写一半。
-       这里同步落一份整包快照到备份分区, 保证出厂值也有可信副本。
-       用 force 版本跳过节流, 保证立刻生效。 */
-    param_mark_dirty();
-    param_flush_force();
+       这里同步写一份参数镜像, 保证出厂值也有可信副本(param_mirror_sync 立即落盘)。 */
+    param_mirror_sync();
     HMI_WRITE("play %d,%d,%d",1,5,0);
     DTU_Write("reset.mp3");
     rt_thread_delay(1000);
@@ -3710,9 +3688,8 @@ void ResetParamDefault_DC(void)
     ef_set_env_blob("thsp", &device_status.thsp, sizeof(device_status.thsp));
     ef_set_env_blob("passWord", &device_status.passWord,sizeof(device_status.passWord));
     ef_set_env_blob("heat_sw", &device_status.heat_sw,sizeof(device_status.heat_sw));
-    /* 同上, 18 连写后同步一份整包快照(force 立即生效) */
-    param_mark_dirty();
-    param_flush_force();
+    /* 同上, 18 连写后同步一份参数镜像(立即生效) */
+    param_mirror_sync();
     DTU_Write("reset.mp3");
     rt_thread_delay(1000);
 }

+ 0 - 877
Application_cbd_apm32f1/applications/param_backup.c

@@ -1,877 +0,0 @@
-/*
- * 参数双分区备份模块实现
- *
- * 依赖: FAL(param_a / param_b 两个 4KB 分区) + EasyFlash + device_status
- * 说明: 本模块不改动 EasyFlash 自身的写入路径,而是在其之上加一层
- *       "整包快照 + A/B 轮写 + CRC 校验",开机双向修复:
- *         - EasyFlash 丢了  -> 从快照恢复并回写 EasyFlash
- *         - 快照丢了/更旧   -> 从 EasyFlash 重建快照
- */
-#include "param_backup.h"
-
-#include <string.h>
-#include <fal.h>
-#include <easyflash.h>
-#include "control.h"
-
-#define DBG_ENABLE
-#define DBG_COLOR
-#define DBG_TAG "param"
-#define DBG_LVL DBG_LOG
-#include <rtdbg.h>
-
-/* device_status 由 control.h 的 extern 声明提供, 唯一定义在 main.c, 本模块只引用 */
-
-/* ===================== 内部状态 ===================== */
-static const struct fal_partition *g_part_a = RT_NULL;
-static const struct fal_partition *g_part_b = RT_NULL;
-
-static rt_mutex_t  g_lock       = RT_NULL;   /* 保护落盘过程,避免多线程同时擦写 */
-static rt_thread_t g_tid        = RT_NULL;
-static uint8_t     g_dirty      = 0;
-static rt_tick_t   g_dirty_tick = 0;
-static uint32_t    g_last_seq   = 0;         /* 最近一次成功写入/读出的 seq */
-
-/* ★ 存储不可用(SPI flash 探测失败/分区表建不起来)时置 1。
-   此时 mark_dirty / flush 一律直接返回失败, 否则落盘线程会每隔几秒就重试一次
-   并打一条 LOG_E, 把串口刷爆, 也让业务线程白等锁。 */
-static uint8_t     g_disabled   = 0;
-
-/* 落盘节流用: 上次成功写入的内容与时刻 */
-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)];
-
-/* ★ 静态工作区 —— 极其重要,别改成局部变量!
-   sizeof(param_persist_t) = 820 字节。两个就是 1640 字节,而
-     - main 线程栈 RT_MAIN_THREAD_STACK_SIZE = 2048
-     - 落盘线程栈 = 1024
-   Check_ParamConfig() 跑在 main 线程,里面放 2 个 param_persist_t
-   再调 param_backup_read()(内部又 2 个)栈峰值超过 3.2KB —— 必爆栈 hard fault。
-   所以模块内部凡是需要临时 param_persist_t 的地方,一律用这块静态区,
-   并且必须在 g_lock 保护下使用(多线程共用)。 */
-static param_persist_t g_work;
-
-/* 快照头在分区内的偏移 */
-#define PARAM_HDR_SIZE    ((uint32_t)sizeof(param_snapshot_hdr_t))
-#define PARAM_TOTAL_SIZE  (PARAM_HDR_SIZE + (uint32_t)sizeof(param_persist_t))
-
-/* ===================== CRC32 (IEEE 802.3, 多项式 0xEDB88320 反射) ===================== */
-static uint32_t crc32_calc(const uint8_t *data, uint32_t len)
-{
-    uint32_t crc = 0xFFFFFFFFu;
-    uint32_t i, j;
-
-    for (i = 0; i < len; i++)
-    {
-        crc ^= data[i];
-        for (j = 0; j < 8; j++)
-        {
-            if (crc & 1u)
-            {
-                crc = (crc >> 1) ^ 0xEDB88320u;
-            }
-            else
-            {
-                crc >>= 1;
-            }
-        }
-    }
-    return crc ^ 0xFFFFFFFFu;
-}
-
-/* ===================== 分区槽操作 ===================== */
-
-/* 只读快照头 */
-static int slot_read_hdr(const struct fal_partition *part, param_snapshot_hdr_t *hdr)
-{
-    if (part == RT_NULL || hdr == RT_NULL)
-    {
-        return -1;
-    }
-    memset(hdr, 0, sizeof(*hdr));
-    if (fal_partition_read(part, 0, (uint8_t *)hdr, PARAM_HDR_SIZE) < 0)
-    {
-        return -2;
-    }
-    return 0;
-}
-
-/* 读一个槽,校验 magic / version / len / crc,全部通过才认为有效 */
-static int slot_read(const struct fal_partition *part, param_persist_t *out, uint32_t *seq)
-{
-    param_snapshot_hdr_t hdr;
-    uint32_t crc;
-
-    if (part == RT_NULL || out == RT_NULL)
-    {
-        return -1;
-    }
-    if (slot_read_hdr(part, &hdr) != 0)
-    {
-        return -2;
-    }
-    if (hdr.magic != PARAM_MAGIC)
-    {
-        return -3;                       /* 空槽或未格式化 */
-    }
-    if (hdr.version != PARAM_VERSION)
-    {
-        return -4;                       /* 固件升级后结构变化,旧快照作废 */
-    }
-    if (hdr.len != sizeof(param_persist_t))
-    {
-        return -5;
-    }
-    if (fal_partition_read(part, PARAM_HDR_SIZE, (uint8_t *)out, hdr.len) < 0)
-    {
-        return -6;
-    }
-    crc = crc32_calc((const uint8_t *)out, hdr.len);
-    if (crc != hdr.crc32)
-    {
-        LOG_W("[param] %s CRC bad(0x%08x != 0x%08x)", part->name, crc, hdr.crc32);
-        return -7;                       /* 写一半掉电,本槽作废,用另一槽 */
-    }
-    if (seq)
-    {
-        *seq = hdr.seq;
-    }
-    return 0;
-}
-
-/* 写一个槽: 擦除整区 -> 写头 -> 写体 -> 回读校验 */
-static int slot_write(const struct fal_partition *part, const param_persist_t *data, uint32_t seq)
-{
-    param_snapshot_hdr_t hdr;
-    uint32_t crc;
-
-    if (part == RT_NULL || data == RT_NULL)
-    {
-        return -1;
-    }
-
-    hdr.magic    = PARAM_MAGIC;
-    hdr.version  = PARAM_VERSION;
-    hdr.seq      = seq;
-    hdr.len      = sizeof(param_persist_t);
-    hdr.crc32    = crc32_calc((const uint8_t *)data, sizeof(param_persist_t));
-    hdr.reserved = 0;
-
-    /* 1. 擦除整个分区(4KB)。此时另一分区仍是上一版完整数据,中断不会两边都毁 */
-    if (fal_partition_erase_all(part) < 0)
-    {
-        LOG_E("[param] erase %s FAILED", part->name);
-        return -2;
-    }
-    /* 2. 写头 */
-    if (fal_partition_write(part, 0, (const uint8_t *)&hdr, PARAM_HDR_SIZE) < 0)
-    {
-        LOG_E("[param] write hdr %s FAILED", part->name);
-        return -3;
-    }
-    /* 3. 写体 */
-    if (fal_partition_write(part, PARAM_HDR_SIZE, (const uint8_t *)data, hdr.len) < 0)
-    {
-        LOG_E("[param] write body %s FAILED", part->name);
-        return -4;
-    }
-    /* 4. 回读校验,确认真的落进去了(NOR 写失败很隐蔽) */
-    memset(g_rb_buf, 0, sizeof(g_rb_buf));
-    if (fal_partition_read(part, PARAM_HDR_SIZE, g_rb_buf, hdr.len) < 0)
-    {
-        LOG_E("[param] readback %s FAILED", part->name);
-        return -5;
-    }
-    crc = crc32_calc(g_rb_buf, hdr.len);
-    if (crc != hdr.crc32)
-    {
-        LOG_E("[param] readback %s mismatch(0x%08x != 0x%08x)", part->name, crc, hdr.crc32);
-        return -6;
-    }
-    return 0;
-}
-
-/* ===================== 对外: 初始化 / 读 / 写 ===================== */
-
-int param_backup_init(void)
-{
-    /* ★ 闸门①: FAL 必须先建表成功。
-       fal_partition_find() 第一行就是 assert(init_ok), fal_init() 失败时
-       它是死循环 —— 2026-09-24 上板实测 "(init_ok) has assert failed at
-       fal_partition_find." 就是从这里进去的(降级启动分支照常调了本函数)。
-       查 fal_init_check() 是最省事也最可靠的门控。 */
-    if (fal_init_check() != 1)
-    {
-        LOG_E("[param] FAL NOT initialized, param backup disabled");
-        g_disabled = 1;
-        return -RT_ERROR;
-    }
-
-    /* ★ 闸门②: norflash0 芯片本身要可用。
-       FAL 建表成功不代表 flash 是好的 —— 为了让 FAL 不被单个坏设备拖垮,
-       nor_flash0.len 在探测失败时仍保留标称容量(见 fal_flash_sfud_port.c),
-       所以分区照样找得到, 但读写一律返回 -1。不在这里闸掉的话, 落盘线程会
-       每隔 PARAM_POLL_TICKS 重试一次并打一条 LOG_E, 把串口刷爆。 */
-    if (!nor_flash0_is_ready())
-    {
-        LOG_E("[param] SPI flash NOT ready, param backup disabled");
-        g_disabled = 1;
-        return -RT_ERROR;
-    }
-
-    g_part_a = fal_partition_find(PARAM_PART_A_NAME);
-    g_part_b = fal_partition_find(PARAM_PART_B_NAME);
-
-    if (g_part_a == RT_NULL && g_part_b == RT_NULL)
-    {
-        LOG_E("[param] partition %s / %s NOT found", PARAM_PART_A_NAME, PARAM_PART_B_NAME);
-        /* 一个分区都找不到 = SPI flash 不可用(探测失败或分区表没建起来)。
-           置 disabled, 后续完全不再尝试落盘。 */
-        g_disabled = 1;
-        return -RT_ERROR;
-    }
-    g_disabled = 0;
-    if (g_part_a == RT_NULL || g_part_b == RT_NULL)
-    {
-        LOG_W("[param] only one partition found, backup degraded");
-    }
-
-    if (g_lock == RT_NULL)
-    {
-        g_lock = rt_mutex_create("param_lk", RT_IPC_FLAG_PRIO);
-        if (g_lock == RT_NULL)
-        {
-            LOG_E("[param] create mutex FAILED");
-            return -RT_ENOMEM;
-        }
-    }
-
-    /* 上电先摸清当前有效快照的 seq,后续写入在其基础上递增。
-       这里只关心 seq,payload 直接复用静态工作区(不占栈)。 */
-    {
-        uint32_t sa = 0, sb = 0, ra, rb;
-
-        if (g_lock != RT_NULL)
-        {
-            rt_mutex_take(g_lock, RT_WAITING_FOREVER);
-        }
-        ra = (g_part_a != RT_NULL) ? slot_read(g_part_a, &g_work, &sa) : -1;
-        rb = (g_part_b != RT_NULL) ? slot_read(g_part_b, &g_work, &sb) : -1;
-        if (g_lock != RT_NULL)
-        {
-            rt_mutex_release(g_lock);
-        }
-
-        if (ra == 0 && rb == 0)
-        {
-            g_last_seq = (sa > sb) ? sa : sb;
-        }
-        else if (ra == 0)
-        {
-            g_last_seq = sa;
-        }
-        else if (rb == 0)
-        {
-            g_last_seq = sb;
-        }
-        else
-        {
-            g_last_seq = 0;
-        }
-        LOG_I("[param] init ok. A=%s(seq %u) B=%s(seq %u)",
-              (ra == 0) ? "ok" : "bad", (unsigned)sa,
-              (rb == 0) ? "ok" : "bad", (unsigned)sb);
-    }
-    return RT_EOK;
-}
-
-int param_backup_read(param_persist_t *out, uint32_t *seq)
-{
-    uint32_t sa = 0, sb = 0;
-    int ra, rb, ret = -2;
-
-    if (out == RT_NULL)
-    {
-        return -1;
-    }
-    /* g_work 是多线程共用的静态区,必须加锁 */
-    if (g_lock != RT_NULL)
-    {
-        rt_mutex_take(g_lock, RT_WAITING_FOREVER);
-    }
-
-    /* 只用一个缓冲: 先读 A 槽,再读 B 槽,谁 seq 大谁是最终赢家。
-       这样 820 字节的 param_persist_t 只出现一次,且不在栈上。 */
-    ra = (g_part_a != RT_NULL) ? slot_read(g_part_a, &g_work, &sa) : -1;
-    if (ra == 0)
-    {
-        *out = g_work;
-        if (seq) *seq = sa;
-        ret = 0;
-    }
-
-    rb = (g_part_b != RT_NULL) ? slot_read(g_part_b, &g_work, &sb) : -1;
-    if (rb == 0 && (ra != 0 || sb > sa))
-    {
-        *out = g_work;
-        if (seq) *seq = sb;
-        ret = 0;
-    }
-
-    if (g_lock != RT_NULL)
-    {
-        rt_mutex_release(g_lock);
-    }
-    return ret;                                      /* -2 = 两槽都无效 */
-}
-
-int param_backup_write(const param_persist_t *in)
-{
-    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;
-
-    if (in == RT_NULL)
-    {
-        return -1;
-    }
-    if (g_part_a == RT_NULL && g_part_b == RT_NULL)
-    {
-        return -2;
-    }
-    if (g_lock != RT_NULL)
-    {
-        rt_mutex_take(g_lock, RT_WAITING_FOREVER);
-    }
-
-    /* 只举手之劳读头,判断哪一槽更旧 */
-    if (g_part_a != RT_NULL)
-    {
-        if (slot_read_hdr(g_part_a, &ha) == 0 && ha.magic == PARAM_MAGIC
-            && ha.version == PARAM_VERSION && ha.len == sizeof(param_persist_t))
-        {
-            sa = ha.seq;
-            ra = 0;
-        }
-    }
-    if (g_part_b != RT_NULL)
-    {
-        if (slot_read_hdr(g_part_b, &hb) == 0 && hb.magic == PARAM_MAGIC
-            && hb.version == PARAM_VERSION && hb.len == sizeof(param_persist_t))
-        {
-            sb = hb.seq;
-            rb = 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 && g_part_b != RT_NULL)
-    {
-        target   = g_part_b;
-        next_seq = sa + 1;
-    }
-    else
-    {
-        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)
-    {
-        next_seq = g_last_seq + 1;
-    }
-    if (next_seq == 0)
-    {
-        next_seq = 1;
-    }
-
-    ret = slot_write(target, in, next_seq);
-    if (ret == 0)
-    {
-        g_last_seq = next_seq;
-        LOG_D("[param] saved to %s, seq=%u", target->name, (unsigned)next_seq);
-    }
-    else
-    {
-        LOG_E("[param] save to %s FAILED(%d)", target->name, ret);
-    }
-
-    if (g_lock != RT_NULL)
-    {
-        rt_mutex_release(g_lock);
-    }
-    return ret;
-}
-
-/* ===================== device_status <-> param_persist_t ===================== */
-
-void param_pack(param_persist_t *dst)
-{
-    if (dst == RT_NULL)
-    {
-        return;
-    }
-    memset(dst, 0, sizeof(*dst));
-
-    dst->iSave              = device_status.iSave;
-    dst->dtype              = device_status.dtype;
-    dst->version_type       = device_status.version_type;
-    dst->Power_Type         = device_status.Power_Type;
-
-    dst->ds                 = device_status.ds;
-    dst->timeSwitch         = device_status.timeSwitch;
-    dst->run_sta            = device_status.run_sta;
-    dst->cul_time           = device_status.cul_time;
-
-    dst->motor_active       = device_status.motor_active;
-    dst->heat_sw            = device_status.heat_sw;
-    dst->cold_sw            = device_status.cold_sw;
-    dst->wind_sw            = device_status.wind_sw;
-
-    dst->collecting_sh1     = device_status.collecting_sh1;
-    dst->collecting_eh1     = device_status.collecting_eh1;
-    dst->collecting_sh2     = device_status.collecting_sh2;
-    dst->collecting_eh2     = device_status.collecting_eh2;
-
-    dst->handle_bugger      = device_status.handle_bugger;
-    dst->work_mode          = device_status.work_mode;
-    dst->shake_ws           = device_status.shake_ws;
-    dst->tph                = device_status.tph;
-
-    dst->tpl                = device_status.tpl;
-    dst->clt_time           = device_status.clt_time;
-    dst->heattime           = device_status.heattime;
-    dst->heatvalue          = device_status.heatvalue;
-
-    dst->sunBar             = device_status.sunBar;
-    dst->startBar           = device_status.startBar;
-    dst->stopBar            = device_status.stopBar;
-    dst->vol                = device_status.vol;
-
-    dst->stop_in_bootloader = device_status.stop_in_bootloader;
-    dst->update_flag        = device_status.update_flag;
-
-    dst->dattim             = device_status.dattim;
-    dst->shake_sec          = device_status.shake_sec;
-    dst->thsp               = device_status.thsp;
-
-    dst->passWord           = device_status.passWord;
-    dst->rebootcnt          = device_status.rebootcnt;
-
-    strncpy(dst->tempture,       device_status.tempture,       sizeof(dst->tempture) - 1);
-    strncpy(dst->humidity,       device_status.humidity,       sizeof(dst->humidity) - 1);
-    strncpy(dst->mqttcfg1,       device_status.mqttcfg1,       sizeof(dst->mqttcfg1) - 1);
-    strncpy(dst->deviceId,       device_status.deviceId,       sizeof(dst->deviceId) - 1);
-    strncpy(dst->imei,           device_status.imei,           sizeof(dst->imei) - 1);
-    strncpy(dst->iccid,          device_status.iccid,          sizeof(dst->iccid) - 1);
-    strncpy(dst->lat,            device_status.lat,            sizeof(dst->lat) - 1);
-    strncpy(dst->lng,            device_status.lng,            sizeof(dst->lng) - 1);
-    strncpy(dst->alarm_tg,       device_status.alarm_tg,       sizeof(dst->alarm_tg) - 1);
-    strncpy(dst->driver_bl,      device_status.driver_bl,      sizeof(dst->driver_bl) - 1);
-    strncpy(dst->driver_compile, device_status.driver_compile, sizeof(dst->driver_compile) - 1);
-}
-
-void param_unpack(const param_persist_t *src)
-{
-    if (src == RT_NULL)
-    {
-        return;
-    }
-
-    device_status.iSave              = src->iSave;
-    device_status.dtype              = src->dtype;
-    device_status.version_type       = src->version_type;
-    device_status.Power_Type         = src->Power_Type;
-
-    device_status.ds                 = src->ds;
-    device_status.timeSwitch         = src->timeSwitch;
-    device_status.run_sta            = src->run_sta;
-    device_status.cul_time           = src->cul_time;
-
-    device_status.motor_active       = src->motor_active;
-    device_status.heat_sw            = src->heat_sw;
-    device_status.cold_sw            = src->cold_sw;
-    device_status.wind_sw            = src->wind_sw;
-
-    device_status.collecting_sh1     = src->collecting_sh1;
-    device_status.collecting_eh1     = src->collecting_eh1;
-    device_status.collecting_sh2     = src->collecting_sh2;
-    device_status.collecting_eh2     = src->collecting_eh2;
-
-    device_status.handle_bugger      = src->handle_bugger;
-    device_status.work_mode          = src->work_mode;
-    device_status.shake_ws           = src->shake_ws;
-    device_status.tph                = src->tph;
-
-    device_status.tpl                = src->tpl;
-    device_status.clt_time           = src->clt_time;
-    device_status.heattime           = src->heattime;
-    device_status.heatvalue          = src->heatvalue;
-
-    device_status.sunBar             = src->sunBar;
-    device_status.startBar           = src->startBar;
-    device_status.stopBar            = src->stopBar;
-    device_status.vol                = src->vol;
-
-    device_status.stop_in_bootloader = src->stop_in_bootloader;
-    device_status.update_flag        = src->update_flag;
-
-    device_status.dattim             = src->dattim;
-    device_status.shake_sec          = src->shake_sec;
-    device_status.thsp               = src->thsp;
-
-    device_status.passWord           = src->passWord;
-    device_status.rebootcnt          = src->rebootcnt;
-
-    strncpy(device_status.tempture,       src->tempture,       sizeof(device_status.tempture) - 1);
-    strncpy(device_status.humidity,       src->humidity,       sizeof(device_status.humidity) - 1);
-    strncpy(device_status.mqttcfg1,       src->mqttcfg1,       sizeof(device_status.mqttcfg1) - 1);
-    strncpy(device_status.deviceId,       src->deviceId,       sizeof(device_status.deviceId) - 1);
-    strncpy(device_status.imei,           src->imei,           sizeof(device_status.imei) - 1);
-    strncpy(device_status.iccid,          src->iccid,          sizeof(device_status.iccid) - 1);
-    strncpy(device_status.lat,            src->lat,            sizeof(device_status.lat) - 1);
-    strncpy(device_status.lng,            src->lng,            sizeof(device_status.lng) - 1);
-    strncpy(device_status.alarm_tg,       src->alarm_tg,       sizeof(device_status.alarm_tg) - 1);
-    strncpy(device_status.driver_bl,      src->driver_bl,      sizeof(device_status.driver_bl) - 1);
-    strncpy(device_status.driver_compile, src->driver_compile, sizeof(device_status.driver_compile) - 1);
-}
-
-int param_write_back_to_easyflash(const param_persist_t *src)
-{
-    int n = 0;
-
-    if (src == RT_NULL)
-    {
-        return 0;
-    }
-
-    /* 与 param_check_health / Check_ParamConfig 读取的 key 一一对应 */
-    n += (ef_set_env_blob("iSave",        &src->iSave,        sizeof(src->iSave))        == EF_NO_ERR);
-    n += (ef_set_env_blob("ds",           &src->ds,           sizeof(src->ds))           == EF_NO_ERR);
-    n += (ef_set_env_blob("stime",        &src->clt_time,     sizeof(src->clt_time))     == EF_NO_ERR);
-    n += (ef_set_env_blob("startBar",     &src->startBar,     sizeof(src->startBar))     == EF_NO_ERR);
-    n += (ef_set_env_blob("stopBar",      &src->stopBar,      sizeof(src->stopBar))      == EF_NO_ERR);
-    n += (ef_set_env_blob("timeSwitch",   &src->timeSwitch,   sizeof(src->timeSwitch))   == EF_NO_ERR);
-    n += (ef_set_env_blob("sunBar",       &src->sunBar,       sizeof(src->sunBar))       == EF_NO_ERR);
-    n += (ef_set_env_blob("jtime",        &src->heattime,     sizeof(src->heattime))     == EF_NO_ERR);
-    n += (ef_set_env_blob("jheat",        &src->heatvalue,    sizeof(src->heatvalue))    == EF_NO_ERR);
-    n += (ef_set_env_blob("tph",          &src->tph,          sizeof(src->tph))          == EF_NO_ERR);
-    n += (ef_set_env_blob("tpl",          &src->tpl,          sizeof(src->tpl))          == EF_NO_ERR);
-    n += (ef_set_env_blob("shake_ws",     &src->shake_ws,     sizeof(src->shake_ws))     == EF_NO_ERR);
-    n += (ef_set_env_blob("shake_sec",    &src->shake_sec,    sizeof(src->shake_sec))    == EF_NO_ERR);
-    n += (ef_set_env_blob("thsp",         &src->thsp,         sizeof(src->thsp))         == EF_NO_ERR);
-    n += (ef_set_env_blob("passWord",     &src->passWord,     sizeof(src->passWord))     == EF_NO_ERR);
-    n += (ef_set_env_blob("dattim",       &src->dattim,       sizeof(src->dattim))       == EF_NO_ERR);
-    n += (ef_set_env_blob("version_type", &src->version_type, sizeof(src->version_type)) == EF_NO_ERR);
-    n += (ef_set_env_blob("dtype",        &src->dtype,        sizeof(src->dtype))        == EF_NO_ERR);
-    n += (ef_set_env_blob("env_t",        src->tempture,      sizeof(src->tempture))     == EF_NO_ERR);
-    n += (ef_set_env_blob("env_h",        src->humidity,      sizeof(src->humidity))     == EF_NO_ERR);
-    n += (ef_set_env_blob("platform",     src->mqttcfg1,      sizeof(src->mqttcfg1))     == EF_NO_ERR);
-    n += (ef_set_env_blob("cul_time",     &src->cul_time,     sizeof(src->cul_time))     == EF_NO_ERR);
-    n += (ef_set_env_blob("motor_active", &src->motor_active, sizeof(src->motor_active)) == EF_NO_ERR);
-    n += (ef_set_env_blob("heat_sw",      &src->heat_sw,      sizeof(src->heat_sw))      == EF_NO_ERR);
-    n += (ef_set_env_blob("cold_sw",      &src->cold_sw,      sizeof(src->cold_sw))      == EF_NO_ERR);
-    n += (ef_set_env_blob("collecting_sh1", &src->collecting_sh1, sizeof(src->collecting_sh1)) == EF_NO_ERR);
-    n += (ef_set_env_blob("collecting_eh1", &src->collecting_eh1, sizeof(src->collecting_eh1)) == EF_NO_ERR);
-    n += (ef_set_env_blob("collecting_sh2", &src->collecting_sh2, sizeof(src->collecting_sh2)) == EF_NO_ERR);
-    n += (ef_set_env_blob("collecting_eh2", &src->collecting_eh2, sizeof(src->collecting_eh2)) == EF_NO_ERR);
-    n += (ef_set_env_blob("run_sta",      &src->run_sta,      sizeof(src->run_sta))      == EF_NO_ERR);
-    n += (ef_set_env_blob("Power_Type",   &src->Power_Type,   sizeof(src->Power_Type))   == EF_NO_ERR);
-    n += (ef_set_env_blob("deviceId",     src->deviceId,      sizeof(src->deviceId))     == EF_NO_ERR);
-    n += (ef_set_env_blob("handle_bugger",&src->handle_bugger,sizeof(src->handle_bugger))== EF_NO_ERR);
-    n += (ef_set_env_blob("work_mode",    &src->work_mode,    sizeof(src->work_mode))    == EF_NO_ERR);
-    n += (ef_set_env_blob("alarm_tg",     src->alarm_tg,      sizeof(src->alarm_tg))     == EF_NO_ERR);
-    n += (ef_set_env_blob("imei",         src->imei,          sizeof(src->imei))         == EF_NO_ERR);
-    n += (ef_set_env_blob("iccid",        src->iccid,         sizeof(src->iccid))        == EF_NO_ERR);
-    n += (ef_set_env_blob("lat",          src->lat,           sizeof(src->lat))           == EF_NO_ERR);
-    n += (ef_set_env_blob("lng",          src->lng,           sizeof(src->lng))           == EF_NO_ERR);
-    n += (ef_set_env_blob("driver_bl",    src->driver_bl,     sizeof(src->driver_bl))     == EF_NO_ERR);
-    n += (ef_set_env_blob("reboot_time",  &src->rebootcnt,    sizeof(src->rebootcnt))     == EF_NO_ERR);
-    n += (ef_set_env_blob("vol",          &src->vol,          sizeof(src->vol))           == EF_NO_ERR);
-
-    return n;
-}
-
-int param_check_health(const param_persist_t *p)
-{
-    int err = 0;
-
-    if (p == RT_NULL)
-    {
-        return -1;
-    }
-    if (p->iSave != 2)                  /* FLASH_FLAG == 2 */
-    {
-        err |= PARAM_ERR_ISAVE;
-    }
-    if (p->tph       == 0) { err |= PARAM_ERR_TPH; }
-    if (p->thsp      == 0) { err |= PARAM_ERR_THSP; }
-    if (p->dattim    == 0) { err |= PARAM_ERR_DATTIM; }
-    if (p->sunBar    == 0) { err |= PARAM_ERR_SUNBAR; }
-    if (p->clt_time  == 0) { err |= PARAM_ERR_CLTIME; }
-    if (p->heattime  == 0) { err |= PARAM_ERR_HEATTIME; }
-    if (p->heatvalue == 0) { err |= PARAM_ERR_HEATVALUE; }
-
-    return err;
-}
-
-/* ===================== 延迟落盘 ===================== */
-
-void param_mark_dirty(void)
-{
-    /* 故意不加锁: 这里只写两个对齐的字长变量,Cortex-M3 上单字读写本身是原子的。
-       加锁反而会让业务线程在落盘线程擦写 4KB 的 ~100ms 里被卡住。 */
-    if (g_disabled)
-    {
-        return;                          /* 存储不可用,别让落盘线程反复重试 */
-    }
-    g_dirty_tick = rt_tick_get();
-    g_dirty      = 1;
-}
-
-/* force==0: 走节流(内容相同不写 / 最小间隔内推迟)
-   force!=0: 立即写,跳过节流 */
-static int param_flush_impl(int force)
-{
-    int ret;
-
-    if (g_disabled)
-    {
-        return -2;                       /* 存储不可用: 静默失败,不重试不刷屏 */
-    }
-
-    /* 本函数可能被业务线程(恢复出厂等)和落盘线程同时调用,
-       g_work 是共用静态区,所以全程持锁。
-       注: RT-Thread 的 mutex 支持同线程递归 take(hold++),
-       因此下面再调 param_backup_write() 内部加锁不会死锁。 */
-    if (g_lock != RT_NULL)
-    {
-        rt_mutex_take(g_lock, RT_WAITING_FOREVER);
-    }
-
-    param_pack(&g_work);
-
-    /* 节流①: 内容没变就不擦写。屏幕每秒刷帧都会 mark_dirty,
-       没有这道闸 4KB sector 几天就写穿了 */
-    if (!force && g_have_saved && (memcmp(&g_last_saved, &g_work, sizeof(g_work)) == 0))
-    {
-        g_dirty = 0;
-        if (g_lock != RT_NULL) rt_mutex_release(g_lock);
-        return 0;
-    }
-    /* 节流②: 两次落盘最小间隔 */
-    if (!force && g_have_saved
-        && ((rt_tick_get() - g_last_save_tick) < (rt_tick_t)PARAM_MIN_SAVE_TICKS))
-    {
-        if (g_lock != RT_NULL) rt_mutex_release(g_lock);
-        return 1;                        /* dirty 保留,下个周期再试 */
-    }
-
-    ret = param_backup_write(&g_work);
-    if (ret == 0)
-    {
-        g_last_saved     = g_work;
-        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)
-    {
-        rt_mutex_release(g_lock);
-    }
-    return ret;
-}
-
-int param_flush(void)
-{
-    return param_flush_impl(0);
-}
-
-int param_flush_force(void)
-{
-    return param_flush_impl(1);
-}
-
-static void param_autosave_entry(void *parameter)
-{
-    while (1)
-    {
-        rt_thread_mdelay(PARAM_POLL_TICKS);
-
-        if (g_dirty == 0)
-        {
-            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)
-        {
-            continue;
-        }
-        param_flush();
-    }
-}
-
-int param_backup_start(void)
-{
-    if (g_tid != RT_NULL)
-    {
-        return RT_EOK;                   /* 已启动 */
-    }
-    /* 栈不能给 1024: 线程里会调 param_flush() -> fal 擦写 + LOG 打印,
-       rt_kprintf 的 vsnprintf 本身就要好几百字节栈。 */
-    g_tid = rt_thread_create("param_sv",
-                             param_autosave_entry, RT_NULL,
-                             2048,
-                             20,         /* 低优先级,不抢业务线程 */
-                             20);
-    if (g_tid == RT_NULL)
-    {
-        LOG_E("[param] create autosave thread FAILED");
-        return -RT_ERROR;
-    }
-    rt_thread_startup(g_tid);
-    return RT_EOK;
-}
-
-/* ===================== 调试命令 ===================== */
-#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_dbg_dump;
-    uint32_t seq = 0;
-
-    if (param_backup_read(snap, &seq) != 0)
-    {
-        rt_kprintf("no valid snapshot\n");
-        return;
-    }
-    rt_kprintf("seq       : %u\n",   (unsigned)seq);
-    rt_kprintf("iSave     : %d\n",   snap->iSave);
-    rt_kprintf("dtype     : %d\n",   snap->dtype);
-    rt_kprintf("ver_type  : %d\n",   snap->version_type);
-    rt_kprintf("rebootcnt : %d\n",   (int)snap->rebootcnt);
-    rt_kprintf("tph/tpl   : %d/%d\n", snap->tph, snap->tpl);
-    rt_kprintf("thsp      : %d\n",   snap->thsp);
-    rt_kprintf("dattim    : %d\n",   snap->dattim);
-    rt_kprintf("sunBar    : %d\n",   snap->sunBar);
-    rt_kprintf("clt/heat  : %d/%d\n", snap->clt_time, snap->heattime);
-    rt_kprintf("start/stop: %d/%d\n", snap->startBar, snap->stopBar);
-    rt_kprintf("imei      : %s\n",   snap->imei);
-    rt_kprintf("deviceId  : %s\n",   snap->deviceId);
-    rt_kprintf("platform  : %s\n",   snap->mqttcfg1);
-    rt_kprintf("health    : 0x%x\n", param_check_health(snap));
-}
-MSH_CMD_EXPORT(param_dump, dump param snapshot from backup partition);
-
-static void param_save_now(void)
-{
-    int ret = param_flush_force();
-    rt_kprintf("param_flush_force ret=%d\n", ret);
-}
-MSH_CMD_EXPORT(param_save_now, force save device_status to backup partition);
-
-static void param_restore(void)
-{
-    param_persist_t *snap = &g_dbg_restore;   /* 私有缓冲, 不与 g_work 抢 */
-
-    if (param_backup_read(snap, RT_NULL) != 0)
-    {
-        rt_kprintf("no valid snapshot to restore\n");
-        return;
-    }
-    param_unpack(snap);
-    rt_kprintf("restored to RAM. run 'param_save_ef' to fix easyflash\n");
-}
-MSH_CMD_EXPORT(param_restore, restore device_status from backup partition);
-
-static void param_save_ef(void)
-{
-    int n;
-
-    if (g_lock != RT_NULL) rt_mutex_take(g_lock, RT_WAITING_FOREVER);
-    param_pack(&g_work);
-    n = param_write_back_to_easyflash(&g_work);
-    if (g_lock != RT_NULL) rt_mutex_release(g_lock);
-    rt_kprintf("write back %d items to easyflash\n", n);
-}
-MSH_CMD_EXPORT(param_save_ef, write device_status back to easyflash);
-
-/* ★ 存储链路体检(2026-09-24 上板定位用)。
-   现场报"丢参数/起不来"时先敲这个: 一眼看出是 FAL 没建表、flash 没探测到,
-   还是分区/快照的问题, 不用猜。 */
-static void param_stat(void)
-{
-    rt_kprintf("fal_init_check   : %d   (1=FAL 建表成功, 0=所有 fal_partition_find 会断言死循环)\n",
-               fal_init_check());
-    rt_kprintf("nor_flash0_ready : %d   (0=SPI flash 未探测到, 已走降级 RAM 参数)\n",
-               nor_flash0_is_ready());
-    rt_kprintf("param_a / param_b: %s / %s\n",
-               g_part_a ? g_part_a->name : "NULL", g_part_b ? g_part_b->name : "NULL");
-    rt_kprintf("g_disabled       : %d\n", (int)g_disabled);
-    rt_kprintf("last_seq         : %u\n", (unsigned)g_last_seq);
-    rt_kprintf("dirty            : %d\n", (int)g_dirty);
-}
-MSH_CMD_EXPORT(param_stat, show param storage health (FAL/flash/partitions));
-#endif /* RT_USING_FINSH */

+ 0 - 211
Application_cbd_apm32f1/applications/param_backup.h

@@ -1,211 +0,0 @@
-/*
- * 参数双分区备份模块 (EasyFlash 掉参兜底)
- *
- * 背景: EasyFlash V4.1.0 NG 模式下 ef_set_env_blob() 会立即落 flash,
- *       写在 ENV_PRE_WRITE 阶段掉电/复位的条目,下次启动会被判为
- *       ENV_ERR_HDR 而永久丢失;GC 搬移中断则整个 sector 被 format,
- *       成片丢参数。本模块用 A/B 双分区 ping-pong + CRC32 + 递增序号,
- *       保证任意时刻至少有一份完整可用的参数快照。
- *
- * 设计要点:
- *   1. 两个独立 4KB 分区交替写入,写 A 时 B 保留上一版,写一半掉电也不影响 B
- *   2. 每条快照带 seq(递增) + CRC32,启动时取 seq 最大且 CRC 通过的那份
- *   3. 只持久化"值字段",不含指针(Device_Status_typedef 里有 const char* 数组,
- *      直接 memcpy 整个结构体会把无效指针写进 flash,恢复后必然跑飞)
- *   4. 延迟落盘: 参数变更只置 dirty,静默期结束后才写,合并连续修改、大幅减少擦写
- */
-#ifndef APPLICATIONS_PARAM_BACKUP_H_
-#define APPLICATIONS_PARAM_BACKUP_H_
-
-#include <rtthread.h>
-
-/* ============================ 分区配置 ============================ */
-#define PARAM_PART_A_NAME          "param_a"
-#define PARAM_PART_B_NAME          "param_b"
-
-#define PARAM_MAGIC                0x5041524Du   /* "PARM" */
-#define PARAM_VERSION              2u            /* 结构版本,变更 param_persist_t 时必须 +1
-                                                    v2: 删除 json_w_clock/reset/platform 三个 128B 字段 */
-
-/* 参数变更后的静默期(tick),期间无新变更才真正落盘。RT_TICK_PER_SECOND=1000 */
-#ifndef PARAM_QUIET_TICKS
-#define PARAM_QUIET_TICKS          (500)
-#endif
-
-/* 落盘线程周期(tick) */
-#ifndef PARAM_POLL_TICKS
-#define PARAM_POLL_TICKS           (200)
-#endif
-
-/* 两次落盘之间的最小间隔。屏幕每秒刷帧都会调到 param_mark_dirty(),
-   没有这道闸会把 4KB sector 在几天内写穿(W25Q 寿命约 10 万次擦写)。 */
-#ifndef PARAM_MIN_SAVE_TICKS
-#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()
- * ================================================================== */
-typedef struct
-{
-    /* --- 标量 --- */
-    uint8_t  iSave;              /* iSave      存储标志位, 必须 == FLASH_FLAG(2) */
-    uint8_t  dtype;              /* dtype      设备类型 7-孢子仪 3-测报灯 */
-    uint8_t  version_type;       /* version_type */
-    uint8_t  Power_Type;         /* Power_Type 供电类型 */
-
-    uint8_t  ds;                 /* ds         开关机状态 */
-    uint8_t  timeSwitch;         /* timeSwitch 0-光控 1-时控 */
-    uint8_t  run_sta;            /* run_sta    孢子仪运行状态 */
-    uint8_t  cul_time;           /* cul_time   培养时间 */
-
-    uint8_t  motor_active;       /* motor_active */
-    uint8_t  heat_sw;            /* heat_sw    加热开关 */
-    uint8_t  cold_sw;            /* cold_sw    制冷开关 */
-    uint8_t  wind_sw;            /* wind_sw    风机开关 */
-
-    uint8_t  collecting_sh1;     /* collecting_sh1 */
-    uint8_t  collecting_eh1;     /* collecting_eh1 */
-    uint8_t  collecting_sh2;     /* collecting_sh2 */
-    uint8_t  collecting_eh2;     /* collecting_eh2 */
-
-    uint8_t  handle_bugger;      /* handle_bugger 排虫模式 */
-    uint8_t  work_mode;          /* work_mode  0-正常 1-预制 */
-    uint8_t  shake_ws;           /* shake_ws   震动开关 */
-    uint8_t  tph;                /* tph        高温保护 */
-
-    int8_t   tpl;                /* tpl        低温保护(有符号) */
-    uint8_t  clt_time;           /* stime      收集时间 */
-    uint8_t  heattime;           /* jtime      加热时间 */
-    uint8_t  heatvalue;          /* jheat      加热温度 */
-
-    uint8_t  sunBar;             /* sunBar     光控定时时长 */
-    uint8_t  startBar;           /* startBar   定时开始 */
-    uint8_t  stopBar;            /* stopBar    定时结束 */
-    uint8_t  vol;                /* vol        音量 */
-
-    uint8_t  stop_in_bootloader; /* stop_in_bootloader */
-    uint8_t  update_flag;        /* update_flag */
-    uint8_t  rsv0;               /* 对齐填充 */
-    uint8_t  rsv1;
-
-    uint16_t dattim;             /* dattim     数据上传间隔 */
-    uint16_t shake_sec;          /* shake_sec  震动时间 */
-    uint16_t thsp;               /* thsp       熄屏时间 */
-    uint16_t rsv2;
-
-    int      passWord;           /* passWord */
-    rt_uint32_t rebootcnt;       /* reboot_time 开机次数 */
-
-    /* --- 字符串 --- */
-    char     tempture[12];       /* env_t      环境温度 */
-    char     humidity[12];       /* env_h      环境湿度 */
-    char     mqttcfg1[64];       /* platform   平台地址 */
-    char     deviceId[32];       /* deviceId   设备编码 */
-    char     imei[32];           /* imei */
-    char     iccid[32];          /* iccid */
-    char     lat[32];            /* lat */
-    char     lng[32];            /* lng */
-    char     alarm_tg[12];       /* alarm_tg   闹钟 */
-    char     driver_bl[64];      /* driver_bl  BL版本 */
-    char     driver_compile[64]; /* driver_compile */
-} param_persist_t;
-
-/* 快照头,必须 4 字节对齐 */
-typedef struct
-{
-    uint32_t magic;
-    uint32_t version;
-    uint32_t seq;                /* 递增序号,取最大且 CRC 通过者 */
-    uint32_t len;                /* payload 长度,应 == sizeof(param_persist_t) */
-    uint32_t crc32;              /* payload 的 CRC32 */
-    uint32_t reserved;
-} param_snapshot_hdr_t;
-
-/* ============================== API ============================== */
-
-/**
- * 初始化: 查找 param_a / param_b 分区并读出有效快照
- * @return RT_EOK 成功(至少找到一个可用分区); 其它 失败
- */
-int  param_backup_init(void);
-
-/**
- * 读取当前最新的有效快照
- * @param out   输出参数
- * @param seq   输出该快照的序号,可为 RT_NULL
- * @return 0 成功(有有效快照); <0 无有效快照
- */
-int  param_backup_read(param_persist_t *out, uint32_t *seq);
-
-/**
- * 立即写入一份新快照(ping-pong,写到较旧的那个分区)
- * @param in 待保存的参数
- * @return 0 成功; <0 失败
- */
-int  param_backup_write(const param_persist_t *in);
-
-/**
- * 把当前 device_status 打包成 param_persist_t
- */
-void param_pack(param_persist_t *dst);
-
-/**
- * 把 param_persist_t 还原到 device_status
- */
-void param_unpack(const param_persist_t *src);
-
-/**
- * 把 device_status 写回 EasyFlash(用于从快照恢复后修复 flash)
- * @return 实际写成功的条目数
- */
-int  param_write_back_to_easyflash(const param_persist_t *src);
-
-/**
- * 检查 EasyFlash 读出的参数是否健康
- * @param p 待检查的参数
- * @return 0 健康; >0 异常(位掩码, 见 PARAM_ERR_*)
- */
-#define PARAM_ERR_ISAVE      (1u << 0)   /* iSave 哨兵丢失 -> 会触发全量出厂重置 */
-#define PARAM_ERR_TPH        (1u << 1)
-#define PARAM_ERR_THSP       (1u << 2)
-#define PARAM_ERR_DATTIM     (1u << 3)
-#define PARAM_ERR_SUNBAR     (1u << 4)
-#define PARAM_ERR_CLTIME     (1u << 5)
-#define PARAM_ERR_HEATTIME   (1u << 6)
-#define PARAM_ERR_HEATVALUE  (1u << 7)
-int  param_check_health(const param_persist_t *p);
-
-/**
- * 标记参数已变更,延迟落盘线程会在静默期后写 flash。
- * 这是本模块推荐的写入方式(替代直接在业务里调 ef_set_env_blob 后不管)。
- */
-void param_mark_dirty(void);
-
-/**
- * 立即落盘(会阻塞,擦除 4KB 约 40~100ms)。
- * 内部有两道节流: ①内容与上次完全相同则不写 ②距上次落盘不足 PARAM_MIN_SAVE_TICKS 则推迟。
- * @return 0 已写入或无需写入; 1 因最小间隔被推迟(dirty 保留); <0 写入失败
- */
-int  param_flush(void);
-
-/**
- * 强制落盘,跳过节流。仅用于恢复出厂等必须立刻生效的场景。
- */
-int  param_flush_force(void);
-
-/**
- * 启动延迟落盘线程
- */
-int  param_backup_start(void);
-
-#endif /* APPLICATIONS_PARAM_BACKUP_H_ */

+ 440 - 0
Application_cbd_apm32f1/applications/param_mirror.c

@@ -0,0 +1,440 @@
+/*
+ * 参数防丢镜像 (param_mirror) 实现 —— 与 master 分支保持同一套实现
+ *
+ * 位于 FAL "easyflash" 分区内,A/B 两个槽,每槽一个 flash 扇区(本板 4096 字节)。
+ *
+ * 与旧 param_backup(独立 param_a/param_b 双分区 + 820 字节整包快照 + 落盘线程)
+ * 的差异(按 master 对齐):
+ *   1. 不再占用独立 FAL 分区,镜像槽固定在 easyflash 分区 0x12000 / 0x13000;
+ *   2. 只镜像 20 个标量配置字段(param_payload_t),字符串字段仍只走 EasyFlash;
+ *   3. 不再有延迟落盘线程:参数变更点直接 param_mirror_sync() 同步写;
+ *      靠"内容未变化则跳过"抑制写放大(每条 JSON / 每次握手都不会擦扇区)。
+ */
+
+/* 日志配置块必须在任何 include 之前: 组件的头文件(如 sfud_cfg.h)会抢先
+ * #include <rtdbg.h>,而该头带 include guard,一旦先引入就会把本文件的日志等级
+ * 钉死;DBG_ENABLE 若在 rtdbg.h 之后定义,LOG_x 会整体退化成空宏(master 1.86
+ * 修的正是这个坑)。 */
+#define DBG_ENABLE
+#define DBG_COLOR
+#define DBG_TAG     "param_mirror"
+#define DBG_LVL     DBG_LOG
+#include <rtdbg.h>
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <fal.h>
+#include <easyflash.h>       /* ef_calc_crc32():复用 EasyFlash 的 CRC32,不另建表 */
+#include <string.h>
+#include "param_mirror.h"
+#include "control.h"
+#include "dtu_uart2.h"       /* dtu_request_param_backup:参数变更 → 备份到 RTU 的触发接口 */
+
+#define MIRROR_PART_NAME      "easyflash"
+#define MIRROR_MAGIC          0x50415242U   /* 'PARB' */
+
+/* 头部占每槽前 16 字节,payload 紧随其后 */
+#define HDR_SIZE              16U
+
+/* 编译期布局自检:packed 结构必须是 16 字节头 + 25 字节配置体 = 41 字节。
+   以后增删字段会在此处编译失败,提醒同步 bump PARAM_PAYLOAD_VER 并复查
+   crc32 覆盖范围(HDR_SIZE 之后的全部字节),避免"字段加了但 CRC 还是老长度"。 */
+typedef char param_payload_layout_check[(sizeof(param_payload_t) == 41) ? 1 : -1];
+
+/* device_status 由 control.h 的 extern 声明提供,唯一定义在 main.c,本模块只引用 */
+
+static const struct fal_partition *s_part = RT_NULL;
+
+/* ---- 防写放大 / 并发保护 ----
+ * 1) 内容未变化时直接跳过(避免每条 JSON / 每次同步都擦写 2 个扇区,耗尽 Flash 寿命);
+ * 2) 用互斥锁串行化多线程的镜像读写(HMI / DTU / 工作流程线程都会调用)。
+ */
+static struct rt_mutex s_mirror_lock;
+static rt_bool_t        s_mirror_lock_ready = RT_FALSE;
+static param_payload_t  s_last_payload;
+static rt_bool_t        s_last_valid = RT_FALSE;
+
+static void mirror_lock(void)
+{
+    if (!s_mirror_lock_ready)
+    {
+        rt_base_t level = rt_hw_interrupt_disable();
+        if (!s_mirror_lock_ready)
+        {
+            if (rt_mutex_init(&s_mirror_lock, "pm_mtx", RT_IPC_FLAG_PRIO) == RT_EOK)
+            {
+                s_mirror_lock_ready = RT_TRUE;
+            }
+        }
+        rt_hw_interrupt_enable(level);
+    }
+    if (s_mirror_lock_ready)
+    {
+        rt_mutex_take(&s_mirror_lock, RT_WAITING_FOREVER);
+    }
+}
+
+static void mirror_unlock(void)
+{
+    if (s_mirror_lock_ready)
+    {
+        rt_mutex_release(&s_mirror_lock);
+    }
+}
+
+/* 取分区句柄(惰性查找 + 门控)。
+ * ★ 本分支加固:FAL 没建表成功时 fal_partition_find() 会撞 assert(init_ok) 死循环
+ *   (见 fal_def.h),SPI flash 探测失败时必须先挡掉,返回 NULL 让上层按"无镜像"处理。 */
+static const struct fal_partition *mirror_part(void)
+{
+    if (s_part != RT_NULL)
+    {
+        return s_part;
+    }
+    /* ★ 本分支加固:FAL 没建表成功时 fal_partition_find() 会撞 assert(init_ok) 死循环;
+       SPI flash 物理探测失败时分区表照样建得出来,但读写全返回 -1(降级启动)。
+       两道门都过不了就直接返回 NULL,让上层按"无镜像"处理,而不是去擦一块坏 flash。 */
+    if (fal_init_check() != 1 || nor_flash0_is_ready() != 1)
+    {
+        return RT_NULL;
+    }
+    s_part = fal_partition_find(MIRROR_PART_NAME);
+    return s_part;
+}
+
+/* 只比较配置体(跳过 magic/version/write_seq/crc32 头部) */
+static rt_bool_t payload_body_equal(const param_payload_t *a, const param_payload_t *b)
+{
+    return (rt_memcmp((const rt_uint8_t *)a + HDR_SIZE,
+                      (const rt_uint8_t *)b + HDR_SIZE,
+                      sizeof(param_payload_t) - HDR_SIZE) == 0) ? RT_TRUE : RT_FALSE;
+}
+
+static uint32_t calc_crc32(const void *buf, size_t size)
+{
+    /* 复用 EasyFlash 自带的 CRC32(ef_calc_crc32),避免本模块再引一张表 */
+    return ef_calc_crc32(0, buf, size);
+}
+
+static int slot_read(uint32_t slot_addr, param_payload_t *out)
+{
+    const struct fal_partition *part = mirror_part();
+
+    if (part == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+    return (fal_partition_read(part, slot_addr, (uint8_t *)out,
+                               sizeof(param_payload_t)) > 0)
+           ? RT_EOK : -RT_ERROR;
+}
+
+static int slot_write(uint32_t slot_addr, const param_payload_t *in)
+{
+    const struct fal_partition *part = mirror_part();
+
+    if (part == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+    if (fal_partition_erase(part, slot_addr, MIRROR_SLOT_SIZE) < 0)
+    {
+        return -RT_ERROR;
+    }
+    if (fal_partition_write(part, slot_addr, (const uint8_t *)in,
+                            sizeof(param_payload_t)) < 0)
+    {
+        return -RT_ERROR;
+    }
+    return RT_EOK;
+}
+
+static bool slot_is_valid(const param_payload_t *p)
+{
+    const uint8_t *body;
+    size_t body_len;
+
+    if (p->magic != MIRROR_MAGIC)
+    {
+        return false;
+    }
+    if (p->version != PARAM_PAYLOAD_VER)
+    {
+        return false;
+    }
+    /* crc32 覆盖 16 字节头部之后的全部配置字段 */
+    body     = (const uint8_t *)p + HDR_SIZE;
+    body_len = sizeof(param_payload_t) - HDR_SIZE;
+    return (calc_crc32(body, body_len) == p->crc32) ? true : false;
+}
+
+int param_mirror_load(param_payload_t *dst)
+{
+    param_payload_t a, b;
+    bool va, vb;
+
+    if (dst == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+    if (mirror_part() == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    va = (slot_read(MIRROR_SLOT_A_ADDR, &a) == RT_EOK) && slot_is_valid(&a);
+    vb = (slot_read(MIRROR_SLOT_B_ADDR, &b) == RT_EOK) && slot_is_valid(&b);
+
+    if (!va && !vb)
+    {
+        return -RT_ERROR;
+    }
+    if (va && !vb)
+    {
+        *dst = a;
+    }
+    else if (!va && vb)
+    {
+        *dst = b;
+    }
+    else
+    {
+        /* 两槽都有效:取 write_seq 更大的那份 */
+        *dst = (a.write_seq >= b.write_seq) ? a : b;
+    }
+
+    /* 记录已加载内容:后续 param_mirror_sync() 内容相同则跳过擦写(防写放大) */
+    s_last_payload = *dst;
+    s_last_valid   = RT_TRUE;
+    return RT_EOK;
+}
+
+/* 擦除两个镜像槽(供远程擦除 Flash 指令使用)。
+ * 关键:擦完必须把 s_last_valid 清掉 —— 否则后续 param_mirror_sync() 会因
+ * "内容与上次相同"直接 return,镜像将永久为空,防丢保护静默失效。 */
+int param_mirror_erase_all(void)
+{
+    const struct fal_partition *part = mirror_part();
+
+    if (part == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    mirror_lock();
+
+    /* 两槽各占一个 4KB 扇区且相邻,但分两次擦以兼容 blk_size 校验 */
+    if (fal_partition_erase(part, MIRROR_SLOT_A_ADDR, MIRROR_SLOT_SIZE) < 0)
+    {
+        LOG_W("mirror erase slot A failed");
+        mirror_unlock();
+        return -RT_ERROR;
+    }
+    if (fal_partition_erase(part, MIRROR_SLOT_B_ADDR, MIRROR_SLOT_SIZE) < 0)
+    {
+        LOG_W("mirror erase slot B failed");
+        mirror_unlock();
+        return -RT_ERROR;
+    }
+
+    s_last_valid = RT_FALSE;    /* 清 RAM 缓存:下一次 sync 必定重新落盘 */
+    mirror_unlock();
+
+    LOG_I("param mirror erased (slot A/B)");
+    return RT_EOK;
+}
+
+int param_mirror_save(const param_payload_t *src)
+{
+    param_payload_t a, b, newer, older, out;
+    uint32_t newer_addr = 0, older_addr = 0, next_seq = 1;
+    uint8_t *body;
+    size_t   body_len;
+    bool va, vb;
+
+    if (src == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+    if (mirror_part() == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    /* 读两个槽,按 write_seq 判断哪个更旧 */
+    va = (slot_read(MIRROR_SLOT_A_ADDR, &a) == RT_EOK) && slot_is_valid(&a);
+    vb = (slot_read(MIRROR_SLOT_B_ADDR, &b) == RT_EOK) && slot_is_valid(&b);
+
+    if (!va && !vb)
+    {
+        /* 冷启动:两槽都空。先写 B 再写 A */
+        newer_addr = MIRROR_SLOT_B_ADDR;
+        older_addr = MIRROR_SLOT_A_ADDR;
+        next_seq   = 1;
+    }
+    else if (va && !vb)
+    {
+        newer      = a;
+        newer_addr = MIRROR_SLOT_A_ADDR;
+        older_addr = MIRROR_SLOT_B_ADDR;
+        next_seq   = newer.write_seq + 1;
+    }
+    else if (!va && vb)
+    {
+        newer      = b;
+        newer_addr = MIRROR_SLOT_B_ADDR;
+        older_addr = MIRROR_SLOT_A_ADDR;
+        next_seq   = newer.write_seq + 1;
+    }
+    else
+    {
+        /* 两槽都有效 */
+        if (a.write_seq >= b.write_seq)
+        {
+            newer = a; newer_addr = MIRROR_SLOT_A_ADDR;
+            older = b; older_addr = MIRROR_SLOT_B_ADDR;
+        }
+        else
+        {
+            newer = b; newer_addr = MIRROR_SLOT_B_ADDR;
+            older = a; older_addr = MIRROR_SLOT_A_ADDR;
+        }
+        next_seq = newer.write_seq + 1;
+    }
+
+    /* 组记录:除 magic/version/seq/crc32 外沿用调用方 payload */
+    out           = *src;
+    out.magic     = MIRROR_MAGIC;
+    out.version   = PARAM_PAYLOAD_VER;
+    out.write_seq = next_seq;
+
+    /* crc32 只覆盖 16 字节头部之后的配置体 */
+    body     = (uint8_t *)&out + HDR_SIZE;
+    body_len = sizeof(param_payload_t) - HDR_SIZE;
+    out.crc32 = calc_crc32(body, body_len);
+
+    /* 先写较旧的槽,再写较新的槽。
+     * 若两次写之间掉电,加载器仍能在"原来的较新槽"里找到一份有效副本
+     * (seq = next_seq - 1)。 */
+    if (slot_write(older_addr, &out) != RT_EOK)
+    {
+        LOG_W("mirror write older slot (0x%08x) failed", older_addr);
+        return -RT_ERROR;
+    }
+    if (slot_write(newer_addr, &out) != RT_EOK)
+    {
+        LOG_W("mirror write newer slot (0x%08x) failed", newer_addr);
+        /* 仍可接受:加载器能回落到上一次的副本 */
+    }
+    return RT_EOK;
+}
+
+void param_mirror_pack_defaults(param_payload_t *out)
+{
+    if (out == RT_NULL)
+    {
+        return;
+    }
+    memset(out, 0, sizeof(*out));
+    /* magic/version 先填好,后续真正保存时由 param_mirror_save() 覆盖;
+     * write_seq 保持 0,首次保存时再分配。 */
+    out->magic   = MIRROR_MAGIC;
+    out->version = PARAM_PAYLOAD_VER;
+}
+
+/* 下面三个函数是 device_status(定义在 control.h) 与镜像布局之间的桥。
+ * 放在本文件而不是 hmi.c,任何需要同步参数的文件都能直接调用
+ * param_mirror_sync(),不必依赖 hmi.c 内部符号。 */
+
+static void device_status_to_mirror(param_payload_t *out)
+{
+    /* 整块清零,保证头部(magic/version/seq/crc32)干净,
+     * 随后由 param_mirror_save() 覆盖 */
+    memset(out, 0, sizeof(*out));
+    out->iSave         = device_status.iSave;
+    out->dtype         = device_status.dtype;
+    out->ds            = device_status.ds;
+    out->clt_time      = device_status.clt_time;
+    out->heattime      = device_status.heattime;
+    out->heatvalue     = device_status.heatvalue;
+    out->thsp          = device_status.thsp;
+    out->sunBar        = device_status.sunBar;
+    out->startBar      = device_status.startBar;
+    out->stopBar       = device_status.stopBar;
+    out->timeSwitch    = device_status.timeSwitch;
+    out->tph           = device_status.tph;
+    out->tpl           = device_status.tpl;
+    out->shake_ws      = device_status.shake_ws;
+    out->shake_sec     = device_status.shake_sec;
+    out->passWord      = device_status.passWord;
+    out->dattim        = device_status.dattim;
+    out->version_type  = device_status.version_type;
+    out->Power_Type    = device_status.Power_Type;
+    out->handle_bugger = device_status.handle_bugger;
+}
+
+uint32_t mirror_to_device_status(const param_payload_t *in)
+{
+    if (in == RT_NULL)
+    {
+        return 0;
+    }
+    device_status.iSave         = in->iSave;
+    device_status.dtype         = in->dtype;
+    device_status.ds            = in->ds;
+    device_status.clt_time      = in->clt_time;
+    device_status.heattime      = in->heattime;
+    device_status.heatvalue     = in->heatvalue;
+    device_status.thsp          = in->thsp;
+    device_status.sunBar        = in->sunBar;
+    device_status.startBar      = in->startBar;
+    device_status.stopBar       = in->stopBar;
+    device_status.timeSwitch    = in->timeSwitch;
+    device_status.tph           = in->tph;
+    device_status.tpl           = in->tpl;
+    device_status.shake_ws      = in->shake_ws;
+    device_status.shake_sec     = in->shake_sec;
+    device_status.passWord      = in->passWord;
+    device_status.dattim        = in->dattim;
+    device_status.version_type  = in->version_type;
+    device_status.Power_Type    = in->Power_Type;
+    device_status.handle_bugger = in->handle_bugger;
+    return in->write_seq;
+}
+
+/* 注意:本函数内的局部变量不要命名为 p —— rtdbg.h 在文件作用域定义了
+ * `struct tm *p`,任何 LOG_* 展开都会与之冲突(本项目已两次踩坑)。 */
+void param_mirror_sync(void)
+{
+    param_payload_t payload;
+
+    device_status_to_mirror(&payload);
+
+    mirror_lock();
+
+    /* 内容未变化:直接跳过。避免每条 JSON(心跳/查询应答) 都触发
+     * 两次 4KB 扇区擦除,既保护 Flash 寿命也避免阻塞串口接收线程。 */
+    if (s_last_valid && payload_body_equal(&payload, &s_last_payload))
+    {
+        mirror_unlock();
+        return;
+    }
+
+    if (param_mirror_save(&payload) != RT_EOK)
+    {
+        LOG_W("param mirror save failed");
+        mirror_unlock();
+        return;
+    }
+
+    s_last_payload = payload;
+    s_last_valid   = RT_TRUE;
+
+    /* 同步 master 2026-10-15:参数内容确有变更 → 请求 DTU 线程把最新参数备份到 RTU。
+     * 本函数是所有参数变更路径的唯一汇聚点(屏幕设置、平台下发、版本切换、恢复出厂…),
+     * 实际发送由 dtu_param_pending_service() 在 RTU 通信正常后执行,这里只置待办、
+     * 不阻塞调用者,也不会与"恢复"抢跑(恢复优先,且恢复后 30s 内抑制备份)。 */
+    dtu_request_param_backup();
+
+    mirror_unlock();
+}

+ 147 - 0
Application_cbd_apm32f1/applications/param_mirror.h

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2026, BZY
+ *
+ * 参数防丢镜像 (param_mirror) —— 与 master 分支保持同一套实现
+ *
+ * 在 FAL "easyflash" 分区的尾部固定偏移处保存一份关键配置的打包副本,
+ * 与 EasyFlash 自身的 ENV/日志区完全独立,用于兜底:
+ *   - ENV 扇区位翻转 / 擦写失效
+ *   - ef_set_env_blob() 过程中掉电造成的半写条目
+ *
+ * 每个槽占一个 4096 字节扇区,布局:
+ *
+ *   offset  field
+ *   ------  -------------------------------------------------
+ *   0x00    magic         (0x50415242 'PARB')
+ *   0x04    version       (layout version,布局不兼容变更时必须 +1)
+ *   0x08    write_seq     (单调递增,用于挑选最新副本)
+ *   0x0C    crc32         (只覆盖 payload)
+ *   0x10    payload       (param_payload_t,packed)
+ *
+ *   Slot A  : MIRROR_SLOT_A_ADDR  .. + MIRROR_SLOT_SIZE
+ *   Slot B  : MIRROR_SLOT_B_ADDR  .. + MIRROR_SLOT_SIZE
+ *
+ * ⚠️ 偏移与 EasyFlash 的区域尺寸强耦合,改 ENV_AREA_SIZE / LOG_AREA_SIZE 必须同步改
+ *    MIRROR_BASE_OFFSET(见下方注释)。
+ */
+
+#ifndef APPLICATIONS_PARAM_MIRROR_H_
+#define APPLICATIONS_PARAM_MIRROR_H_
+
+#include <rtthread.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/* 本工程用 APM32 标准库,未提供 STM32 HAL 的 __packed 宏(只有 CMSIS 的 __PACKED),
+   这里补一个等价定义,保证镜像布局与 master 逐字节一致。 */
+#ifndef __packed
+#define __packed    __attribute__((__packed__))
+#endif
+
+/* 参与镜像的配置字段(打包副本)。
+ * 该结构只允许"追加",不得调整/删除已有字段顺序;布局变化必须 bump
+ * PARAM_PAYLOAD_VER,必要时保留旧版本的转换代码。
+ *
+ * 注意:本结构只覆盖"标量配置",字符串类字段(imei/iccid/deviceId/platform/
+ * driver_bl/env_t/env_h 等)仍只存 EasyFlash —— 与 master 一致。 */
+typedef struct __packed {
+    /* 头部:版本与登记信息,不属于配置字段 */
+    uint32_t magic;          /* 'PARB' */
+    uint32_t version;        /* PARAM_PAYLOAD_VER */
+    uint32_t write_seq;      /* 单调递增序号 */
+    uint32_t crc32;          /* 只覆盖其后的配置字段 */
+
+    uint8_t  iSave;
+    uint8_t  dtype;
+    uint8_t  ds;
+    uint8_t  clt_time;
+    uint8_t  heattime;
+    uint8_t  heatvalue;
+    uint16_t thsp;
+    uint8_t  sunBar;
+    uint8_t  startBar;
+    uint8_t  stopBar;
+    uint8_t  timeSwitch;
+    uint8_t  tph;
+    int8_t   tpl;
+    uint8_t  shake_ws;
+    uint8_t  shake_sec;      /* 注意:本字段为 8 位(与 master 布局一致),取值范围 0~255 秒 */
+    int      passWord;
+    uint16_t dattim;
+    uint8_t  version_type;
+    uint8_t  Power_Type;
+    uint8_t  handle_bugger;
+} param_payload_t;
+
+#define PARAM_PAYLOAD_VER     0x00010001U   /* 布局不兼容变更时必须 +1 */
+
+/* 镜像槽布局(每槽一个 4096 字节扇区)。
+ * 必须排在 ENV 区(以及开启时的日志区)之后,且落在 "easyflash" FAL 分区内部:
+ *
+ *   ENV   0x00000 ~ 0x10000  (ENV_AREA_SIZE = EF_ERASE_MIN_SIZE * 16 = 64KB)
+ *   LOG   0x10000 ~ 0x12000  (LOG_AREA_SIZE = 8KB;仅 EF_USING_LOG 开启时存在)
+ *   镜像A 0x12000 (1 个扇区) | 镜像B 0x13000 (1 个扇区)
+ *
+ * 本工程 rtconfig.h 未定义 PKG_EASYFLASH_LOG,日志区实际不存在,0x10000~0x12000
+ * 属于空闲区;镜像仍从 0x12000 开始,与 master 布局保持逐字节一致,方便两边互刷。
+ *
+ * ⚠️ ef_log.c 的日志区起始 = EF_START_ADDR + ENV_AREA_SIZE。ENV_AREA_SIZE 一旦调整,
+ *    日志区会跟着前移/后移,MIRROR_BASE_OFFSET 必须同步修改,否则镜像会落进日志区
+ *    被互相破坏。当前 "easyflash" 分区为 0~128KB,镜像区在其范围内。 */
+#define MIRROR_SECTOR_SIZE    4096U
+#define MIRROR_BASE_OFFSET    (64UL * 1024UL + 8UL * 1024UL)  /* 0x12000 */
+#define MIRROR_SLOT_SIZE      MIRROR_SECTOR_SIZE
+#define MIRROR_SLOT_A_ADDR    (MIRROR_BASE_OFFSET)
+#define MIRROR_SLOT_B_ADDR    (MIRROR_BASE_OFFSET + MIRROR_SLOT_SIZE)
+
+/**
+ * 读取最新的有效镜像副本到 dst。
+ * 同时尝试 A/B 两槽,取 write_seq 更大且 CRC 正确的那份。
+ *
+ * @return RT_EOK 找到有效副本;-RT_ERROR 两槽都不可用
+ */
+int param_mirror_load(param_payload_t *dst);
+
+/**
+ * 擦除两个镜像槽,并让 RAM 里的"上次写入内容"缓存失效。
+ *
+ * ⚠️ 必须清缓存:本模块用 s_last_payload/s_last_valid 抑制写放大,
+ * 若只擦 Flash 不清缓存,后续 param_mirror_sync() 会因"内容未变化"直接返回,
+ * 镜像将永久为空、防丢保护静默失效。
+ *
+ * @return RT_EOK 成功
+ */
+int param_mirror_erase_all(void);
+
+/**
+ * 原子写入镜像:先写较旧的槽并回读校验,再写另一个槽。
+ * write_seq 自增,下次 load 会优先取到新写入的副本。
+ *
+ * @return RT_EOK 成功
+ */
+int param_mirror_save(const param_payload_t *src);
+
+/**
+ * 把 device_status 的相关字段打包进 out。
+ * 供 Check_ParamConfig() 用默认值初始化镜像。
+ */
+void param_mirror_pack_defaults(param_payload_t *out);
+
+/**
+ * 便捷接口:把当前 device_status 打包并写入镜像。
+ * 任何修改持久化配置的代码路径都应调用它,保证镜像与 EF 同步。
+ *
+ * 实现在 param_mirror.c;在 Check_ParamConfig() 之前调用也是安全的。
+ */
+void param_mirror_sync(void);
+
+/**
+ * 把镜像字段还原到 device_status。
+ * 开机时 iSave 丢失、但镜像完好的情况下用于抢救参数。
+ *
+ * @return 成功时返回镜像的 write_seq,失败返回 0
+ *         (例如 CRC 不匹配 —— 调用方应回落到默认值)
+ */
+uint32_t mirror_to_device_status(const param_payload_t *in);
+
+#endif /* APPLICATIONS_PARAM_MIRROR_H_ */

+ 8 - 3
Application_cbd_apm32f1/applications/sys_monitor.c

@@ -108,8 +108,11 @@ static void sys_mon_show_screen(void)
         rt_kprintf("[RAM] 堆信息不可用\n");
     }
 
-    /* ---- 外部 Flash 参数(SFUD) ---- */
-    nor = rt_sfud_flash_find_by_dev_name(NOR_FLASH_DEV_NAME);
+    /* ---- 外部 Flash 参数(SFUD) ----
+       ★ 2026-10-30 修复:原来传 NOR_FLASH_DEV_NAME("norflash0"),那是 FAL 设备名;
+       SFUD 的注册名是 rtconfig 的 FAL_USING_NOR_FLASH_DEV_NAME(本机 "W25Q16"),
+       不同名 → 恒返回 NULL,top 里外部 Flash 一直显示"未找到"。 */
+    nor = rt_sfud_flash_find_by_dev_name(FAL_USING_NOR_FLASH_DEV_NAME);
     if (nor != RT_NULL)
     {
         rt_kprintf("[Flash] 外部:%s %s 容量:%uKB 擦除:%uB JEDEC:%02X-%02X-%02X\n",
@@ -120,7 +123,9 @@ static void sys_mon_show_screen(void)
     }
     else
     {
-        rt_kprintf("[Flash] 外部:%s 未找到(未初始化?)\n", NOR_FLASH_DEV_NAME);
+        /* 打印用 FAL 设备名 + SFUD 注册名两个都给出:现场排查时经常分不清这两者 */
+        rt_kprintf("[Flash] 外部:%s(SFUD名:%s) 未找到(未初始化?)\n",
+                   NOR_FLASH_DEV_NAME, FAL_USING_NOR_FLASH_DEV_NAME);
     }
     onchip = fal_flash_device_find("onchip_flash");
     if (onchip != RT_NULL)

+ 354 - 0
Application_cbd_apm32f1/readme.md

@@ -1,3 +1,357 @@
+# 2026-10-30(四)修复 chip 档擦除失败:FAL 设备名 ≠ SFUD 设备名(版本 2.61 → 2.62)
+
+版本变更(control.h):2.61 → **2.62**
+
+- `VERSION_HK` 2.62.41(HK) | `VERSION_HK_2000W` 2.62.4(2000W) | 2.62.4(jjk-5) | 2.62.4(TG) | `VERSION_ZP` 2.62.1(ZP) | `VERSION_GK` 2.62.1(GK)
+
+- 比赛设备 `(TG)` 3.3.4 仍为独立序列,保持不动。
+
+## 一、故障现象(2026-10-30 11:16 上板实测)
+
+```
+[W/dtu] parseData:{"cmd":"ctrl","ext":{"target":"chip","confirm":"ERASE"}}
+[D/dtu] DTU_Write:{"cmd":"warn","ext":{"status":"flash erase start:chip","type":"device"}}
+[W/dtu] 收到远程擦除指令: target=chip
+[E/SFUD] ERROR: Flash device norflash0 not found!
+[E/dtu] 擦除失败:找不到 SPI Flash 设备 norflash0
+[D/dtu] DTU_Write:{"cmd":"warn","ext":{"status":"flash erase failed:chip (0s)","type":"device"}}
+```
+
+chip 档在 0 秒内失败;env 档走的是 FAL 分区接口,不受影响。
+
+## 二、根因
+
+`norflash0` 是 **FAL 设备名**,不是 SFUD 设备名:
+
+| 名字 | 来源 | 实际值 | 用途 |
+|---|---|---|---|
+| `NOR_FLASH_DEV_NAME` | `applications/fal_cfg.h` | `"norflash0"` | FAL `struct fal_flash_dev` 的名字 |
+| `FAL_USING_NOR_FLASH_DEV_NAME` | `rtconfig.h`(Kconfig 生成) | `"W25Q16"` | **SFUD 注册名** |
+
+`rt_hw_spi_flash_init()` 里的注册调用是
+`rt_sfud_flash_probe(FAL_USING_NOR_FLASH_DEV_NAME, "spi10")` —— 即 SFUD 里只有 **"W25Q16"** 这一个设备。
+
+而 `dtu_erase_chip()` 写的是 `rt_sfud_flash_find_by_dev_name(NOR_FLASH_DEV_NAME)`,等价于查 `"norflash0"` → 恒返回 `NULL` → chip 档必然失败。(2.59 移植时照抄了 hmi.c 的写法,而 hmi.c 那处本身也是错的。)
+
+## 三、修复
+
+### 1. `dtu_uart2.c: dtu_erase_chip()` —— 改为走 FAL 设备层,彻底不查名字
+
+`norflash0` 是全局 `struct fal_flash_dev`(`fal_cfg.h` 已 `extern` 声明),直接引用即可:
+
+```c
+const struct fal_flash_dev *dev = &nor_flash0;
+if (nor_flash0_is_ready() != 1) { ... return -RT_ERROR; }     /* 物理探测失败的门控 */
+gran  = dev->blk_size ? dev->blk_size : 4096;                  /* init 时已置为 sfud erase_gran */
+chunk = 向下对齐到 gran(64KB,或 gran 更大时取 gran);
+for (offset = 0; offset < dev->len; offset += chunk) {
+    len = min(chunk, dev->len - offset);  len -= len % gran;   /* 尾块向下对齐 */
+    if (len == 0) break;
+    if (dev->ops.erase((long)offset, len) != (int)len) { 失败 }
+    dtu_wdt_feed();                                            /* 每块擦完喂狗 */
+}
+```
+
+优点:
+
+- **不需要任何名字查找**,同名问题从根上消失;
+- 与 ENV 区、参数镜像的擦除**走同一层**(FAL),错误码语义一致(port 层 `ops.erase` 成功返回擦除字节数,失败返回 -1);
+- port 层 `erase()` 内部已有 `nor_flash0_is_ready()` 判空,不会在 SPI flash 故障时解空指针;
+- 顺带删掉 `#include <spi_flash_sfud.h>`(`dtu_uart2.o` 现在对 sfud 的引用数为 **0**),也就不再有 `sfud_cfg.h` 的 `DBG_TAG "SFUD"` 劫持风险(`DBG_SECTION_NAME "dtu"` 的直定义保留作双保险)。
+
+### 2. 同类名字误用一并修正(同一根因,属既有缺陷)
+
+| 文件 | 位置 | 原行为 |
+|---|---|---|
+| `hmi.c` | t10 调试页「外挂Flash」 | `rt_sfud_flash_find_by_dev_name(NOR_FLASH_DEV_NAME)` 恒 NULL → 调试页一直显示"未检测到外挂Flash" |
+| `sys_monitor.c` | `top` 命令的 `[Flash] 外部:` | 同上 → 一直显示"未找到(未初始化?)" |
+
+两处改为 `FAL_USING_NOR_FLASH_DEV_NAME`;`sys_monitor.c` 的失败分支同时打印两个名字(`norflash0(SFUD名:W25Q16)`),避免现场再把两者混淆。
+
+## 四、验证(已执行)
+
+- 全量重编(touch 1947 源文件 → 170 条命令):**0 失败**;text **253772B** / data 2772 / bss 43632,`rtthread.bin` **256544B**(相对 2.61 的 253636 / 256408B 增 text 136B,为设备层擦除的分块/对齐代码)。
+- 告警 **60 条**,与 2.61 完全一致,**无新增**(特别确认没有 `comparison of distinct pointer types` —— `dev->ops.erase == RT_NULL` 判空未触发告警)。
+- 目标文件符号级证据:
+  - `dtu_uart2.o` 重定位中已出现 `nor_flash0`(ABS32)与 `nor_flash0_is_ready`,
+    **不再出现任何 sfud 符号**(`objdump -r | grep -c sfud` = **0**);
+  - `hmi.o` 中已无 `"norflash0"` 字符串、保留 `"W25Q16"`;
+  - `sys_monitor.o` 保留一处 `"norflash0"`,仅用于失败分支的说明文字。
+
+## 五、待上机验证(未执行)
+
+1. `{"cmd":"ctrl","ext":{"target":"chip","confirm":"ERASE"}}` → 应先回 `start:chip`,串口打印
+   `开始整片擦除 W25Q16: 容量 16777216 字节, 粒度 4096, 分块 65536`,随后约 2~4 分钟(256 块)后
+   `整片擦除完成` → 回执 `done:chip` → 设备重启。**期间看门狗不得复位**。
+2. 重启后 `Check_ParamConfig` 按"ENV 无 iSave"重建默认参数;`fm_area`/`df_area` 已被清空,OTA 回滚副本丢失属预期。
+3. `{"cmd":"ctrl","ext":{"target":"env"}}` 回归:仍应 <1s 完成并重启(该路径未改动)。
+4. 屏幕 t10 调试页「外挂Flash」应显示真实型号与容量(修复前恒"未检测到");串口 `top` 的 `[Flash] 外部:` 同理。
+5. 无 confirm 下发 chip → 仍应被拒绝且不重启。
+
+## 六、备注
+
+- `NOR_FLASH_DEV_NAME("norflash0")` 这个宏本身没错,它是 **FAL** 设备名,用于 `fal_flash_device_find()` / `FAL_PART_TABLE` 之外的场合;错在拿它去查 SFUD。本次没有删除该宏。
+- 若将来 SPI flash 型号改动导致 `FAL_USING_NOR_FLASH_DEV_NAME` 变化,chip 档擦除**不需要跟着改**(已不依赖名字);但 hmi/sys_monitor 的信息显示会自动跟随 rtconfig,同样无需改代码。
+
+# 2026-10-30(三)远程擦除指令并入 cmd=ctrl(版本 2.60 → 2.61)
+
+版本变更(control.h):2.60 → **2.61**
+
+- `VERSION_HK` 2.61.41(HK) | `VERSION_HK_2000W` 2.61.4(2000W) | 2.61.4(TG) | `VERSION_ZP` 2.61.1(ZP) | `VERSION_GK` 2.61.1(GK)
+
+- 经济款 `(jjk-5)` 2.61.4:沿用本次并行把 jjk-5 对齐主版本序列的做法(原 2.58.4 → 2.60.4 → 本次 2.61.4);比赛设备 `(TG)` 3.3.4 仍为独立序列,保持不动。
+
+## 一、指令变更
+
+| 项 | 旧(2.59/2.60) | 新(2.61) |
+|---|---|---|
+| 安全档 | `{"cmd":"eraseflash","ext":{"target":"env"}}` | `{"cmd":"ctrl","ext":{"target":"env"}}` |
+| 危险档 | `{"cmd":"eraseflash","ext":{"target":"chip","confirm":"ERASE"}}` | `{"cmd":"ctrl","ext":{"target":"chip","confirm":"ERASE"}}` |
+
+**cmd 值由 `eraseflash` 改为 `ctrl`,ext 结构(target / confirm)与两档行为完全不变。**
+
+## 二、为什么不能只改字符串匹配(关键)
+
+顶层命令链是 `strstr(cmd_s, ...)` 的顺序链,`"ctrl"` 分支排在 `"eraseflash"` **之前**:
+
+```
+takephoto → shake → ctrl → platform → mvs_photo → eraseflash → reboot → ...
+```
+
+若只是把独立分支的模式从 `"eraseflash"` 改成 `"ctrl"`,请求会先被更靠前的 `ctrl` 分支吃掉(`ctrl` 分支只判 `ext.type`,擦除指令没有 `type` 字段),擦除逻辑**永远不可达** —— 这正是本工程历史上出现过的"过宽前置分支吞掉后续分支"缺陷。
+
+因此改为:**删除独立分支,把擦除并入 `ctrl` 分支内部,放在所有 `type` 子分支之前**,用 `ext.target` 与其它 ctrl 子指令区分。
+
+```c
+else if (strstr(cmd_s,"ctrl")!=RT_NULL)
+{
+    type_s = cj_getstr(item_ext,"type","");
+    cJSON *time_s = cJSON_GetObjectItem(item_ext,"time");
+    const char *erase_target = cj_getstr(item_ext,"target",RT_NULL);   /* 新增 */
+    if (erase_target != RT_NULL)
+    {
+        if (dtu_flash_erase_exec(item_ext) > 0) { rt_thread_delay(2000); rt_hw_cpu_reset(); }
+    }
+    else if(strstr(type_s,"rtu_off_on")!=RT_NULL) { ... }   /* 原有 19 个 type 子分支 */
+    ...
+}
+```
+
+放置要点:
+
+1. **必须在第一个 `strstr(type_s,...)` 之前**:擦除指令没有 `type` 字段(`type_s` 为空串),放在后面会一路走到链尾静默丢弃。
+2. **只要 `ext` 里出现 `target` 字段就一律交给 `dtu_flash_erase_exec()`**,档位白名单与"未知 target 拒绝并回执"都在函数内部判定 —— 保留 master 的拒绝语义,不做"猜你要擦哪"的兜底。若写成"仅当 target 是 env/chip 才进入",未知 target 会静默消失在 type 链尾、平台收不到拒绝回执。
+3. `target` 字段全工程仅本指令使用(已 grep 确认),不会与 19 个 `type` 子指令冲突。
+
+## 三、行为对照
+
+| 下发内容 | 结果 |
+|---|---|
+| `{"cmd":"ctrl","ext":{"target":"env"}}` | 擦镜像两槽 → ENV 区 → EF 日志区(本工程未启用日志区,条件编译跳过)→ 回执 done → 重启 |
+| `{"cmd":"ctrl","ext":{"target":"env","confirm":"xxx"}}` | env 档不校验 confirm,正常执行(与改前一致) |
+| `{"cmd":"ctrl","ext":{"target":"chip"}}` | 拒绝并回执 `flash erase rejected: need confirm=ERASE`,**不重启** |
+| `{"cmd":"ctrl","ext":{"target":"chip","confirm":"ERASE"}}` | 整片擦除(分块+喂狗)→ 回执 done → 重启 |
+| `{"cmd":"ctrl","ext":{"target":"flash"}}` | 未知档位 → 回执 `flash erase rejected: unknown target flash`,不重启 |
+| `{"cmd":"ctrl","ext":{"type":"takephoto"}}` | 原有 ctrl 子指令,行为不变(无 target 字段,走 type 链) |
+| `{"cmd":"eraseflash",...}`(旧指令) | **不再生效**,无匹配分支 → 静默丢弃(平台侧须同步改 ctrl) |
+
+## 四、改动清单
+
+- `applications/dtu_uart2.c`
+  - 删除独立 `else if (strstr(cmd_s,"eraseflash"))` 分支(原位于 `mvs_photo` 与 `reboot` 之间)。
+  - `ctrl` 分支内新增 `erase_target` 判定及其执行块(含复位)。
+  - `dtu_flash_erase_exec()` 头部注释、`eraseflash` 指令示例同步改为 `cmd=ctrl`。
+- `applications/control.h`:版本号 2.60 → 2.61。
+
+## 五、验证(已执行)
+
+- CLI 增量 + 全量重编:**0 失败**;权威尺寸 **text 253636B / data 2772B / bss 43632B**,`rtthread.bin` **256408B**(相对 2.60 的 253660 / 256432B 减 text 24B —— 少一个 strstr 分支判定)。
+- 告警:与 2.60 一致,无新增。
+- **分支结构机器化校验**(脚本 `patch` 后即时跑):
+  - 顶层 cmd 分支由 17 个降为 16 个,`eraseflash` 已不在列表中:`takephoto, shake, ctrl, platform, mvs_photo, reboot, reset, update, read, poweron, poweroff, log, sensor, color, synchronization, paramconf`;
+  - `ctrl` 分支内 `target` 判定位置(偏移 801)**早于**首个 `strstr(type_s,...)`(偏移 1212);
+  - 前置分支(takephoto/shake)均不匹配 `ctrl`,`ctrl` 也不吞任何后置分支;
+  - `ctrl` 的 19 个 type 子分支(rtu_off_on/takephoto/turn/paichong/debug_on/debug_off/led_on/led_off/lamp_off/lamp_on/heat_on/heat_off/up_door_open/up_door_close/down_door_open/down_door_close/clear_on/route_off/selfcheck)全部走 `type` 字段,与 `target` 无交集。
+
+## 六、待上机验证(未执行)
+
+1. `{"cmd":"ctrl","ext":{"target":"env"}}` → 两条回执(start/done)+ 设备重启 + 参数回出厂。
+2. `{"cmd":"ctrl","ext":{"target":"chip"}}`(无 confirm)→ 拒绝回执,**设备不重启**。
+3. `{"cmd":"ctrl","ext":{"target":"chip","confirm":"ERASE"}}` → 擦除期间看门狗不复位,完成后重启。
+4. `{"cmd":"ctrl","ext":{"type":"led_on"}}` 等原有子指令回归:确认并入擦除判定后仍正常工作(无 target 字段,走 type 链)。
+5. 平台侧确认已把旧的 `cmd=eraseflash` 全部替换为 `cmd=ctrl`;未替换的下发将无任何响应。
+
+# 2026-10-30(二)参数变更同步到 RTU:一次性开机同步 → 待办机制(版本 2.59 → 2.60)
+
+版本变更(control.h):2.59 → **2.60**
+
+- `VERSION_HK` 2.60.41(HK) | `VERSION_HK_2000W` 2.60.4(2000W) | 2.60.4(TG) | `VERSION_ZP` 2.60.1(ZP) | `VERSION_GK` 2.60.1(GK)
+
+- 经济款 `(jjk-5)` 2.58.4、比赛设备 `(TG)` 3.3.4 为独立版本序列,保持不动。
+
+## 一、同步 master 2026-10-15:参数变更 → 待办备份到 RTU
+
+### 1. 原实现的两个缺陷(本分支 2.59 之前)
+
+1. **只在上电时同步一次**:`dtu_thread_entry_send()` 入口按 `iFlag` 判定后,由 `dtu_param_sync_poll()` 三态状态机(`PARAM_SYNC_IDLE/WAIT/DONE`)发一次备份或恢复请求。**参数真正发生变更时(屏幕改设置、平台下发、版本切换)从不备份**,RTU 侧副本长期滞后。
+2. **触发条件反了**:只要 `iFlag==0`(本地参数正常),每次开机都无条件备份一遍 —— 每次上电擦 2 个扇区写镜像并多发一帧整包参数,而真正需要同步的变更反而漏掉。
+
+### 2. 现机制(与 master 同一套)
+
+- **唯一变更汇聚点**:`param_mirror_sync()` 是所有参数变更路径的必经之处(屏幕设置、平台下发、Swversion 版本切换、恢复出厂、转盘记位)。它在**真正写入镜像成功后**调用 `dtu_request_param_backup()` 置待办标志;内容未变化时提前 return,不会置位 —— 天然做到"只有变更才备份"。
+
+- **RTU 就绪判定** `dtu_rtu_comm_ready()`:`s_json_rx_cnt != 0`(收到过完整 JSON,证明 RTU 已启动)**且** `now - s_last_json_rx_tick < 15s`(链路当前仍活跃)。
+
+- **待办执行器** `dtu_param_pending_service()`:发送线程主循环每轮调用(约 1s 一次,无待办时是两个标志的空判定)。优先级与规则:
+  1. **恢复优先**:`s_param_recover_pending`(`iFlag==1`,EF 与镜像两份都异常已落默认值)→ RTU 就绪后发 `recover_param_from_rtu()`;发送后记录 `s_recover_sent_tick`,并取消备份待办(恢复会带回权威副本)。
+  2. **备份其次**:`s_param_backup_pending` → RTU 就绪后发 `backup_param_to_rtu()`;若距上次恢复发送不足 **30s** 则暂缓(`BACKUP_AFTER_RECOVER_TICK`),避免把本地默认值覆盖掉 RTU 的恢复副本。
+  3. **未就绪**:不发任何恢复/备份帧,改为**限时 2 分钟**每 2s 主动发 `getinfo`(`makeJson_ReadInfo`)探测 RTU 通信;待办标志一直保留到 RTU 就绪后补发(RTU 晚启动、耗电模式唤醒都能补上)。
+
+- 发送线程入口:`if (device_status.iFlag == 1)` → 置恢复待办 + 设置 2 分钟探测窗口,并打印"参数两份均异常(已用默认值),等待 RTU 通信正常后执行恢复"。
+
+### 3. 代码改动清单
+
+- `applications/dtu_uart2.c`
+  - 删除:`PARAM_SYNC_IDLE/WAIT/DONE`、`PARAM_SYNC_WAIT_MS/RETRY_MS/RETRY_MAX/PROBE_MS`、`s_rtu_rx_ok`、`s_param_sync_state/retry/start/last`、`dtu_param_sync_poll()`、`dtu_param_sync_on_rtu_params()`。
+  - 新增:`s_json_rx_cnt`、`s_param_recover_pending`、`s_param_backup_pending`、`s_recover_sent_tick`、`s_param_solicit_end`、宏 `RTU_COMM_FRESH_TICK/PARAM_SOLICIT_TICK/BACKUP_AFTER_RECOVER_TICK`、`dtu_rtu_comm_ready()`、`dtu_request_param_backup()`、`dtu_param_pending_service()`、`dtu_param_on_rtu_params()`。
+  - 接收处:`s_rtu_rx_ok = 1` → `s_json_rx_cnt++`(保留 `s_last_json_rx_tick` 刷新)。
+  - 主循环:`dtu_param_sync_poll()` → `dtu_param_pending_service()`。
+  - `sync_param` 分支:`dtu_param_sync_on_rtu_params()` → `dtu_param_on_rtu_params()`。
+
+- `applications/dtu_uart2.h`:新增 `void dtu_request_param_backup(void);` 声明。
+
+- `applications/param_mirror.c`:include `dtu_uart2.h`;`param_mirror_sync()` 写镜像成功后调用 `dtu_request_param_backup()`(在 `pm_mtx` 内,只赋一个 volatile 标志,不阻塞)。
+
+## 二、与 master 的两处刻意差异
+
+1. **`s_last_json_rx_tick` 保持本分支的"无条件重置"**:master 是 `if (s_json_rx_cnt == 0) s_last_json_rx_tick = rt_tick_get();`,本分支是线程启动时无条件置当前时刻(原注释说明:master 那种写法在 RTU 完全无输出时 2 小时看门狗保护失效)。两者不冲突——`dtu_rtu_comm_ready()` 的第一个判据就是 `s_json_rx_cnt != 0`,所以这段人造初值不会被误判成"RTU 活跃"。
+
+2. **保留 `dtu_param_on_rtu_params()` 钩子**(master 无):收到 RTU 回传的 `sync_param` 时取消恢复待办并清 `iFlag`。master 靠"待办一次性 + 下次开机 iFlag 重新计算"达到同样效果,本分支多一个显式清理,语义更直观且不改变 master 的行为。
+
+## 三、能力变化(需知悉)
+
+- **开机不再无条件备份**:以前每次上电都往 RTU 发一帧整包参数;现在只有"镜像内容发生变化"才备份。若希望开机强制同步一次,需要人为触发一次参数变更(或在 `Check_ParamConfig` 里显式置待办)。
+- **恢复请求不再重发**:旧实现重发最多 4 次(仅限开机那一次);master 机制是"发出即视为完成",靠恢复后 RTU 回传 `sync_param` 收尾。若 RTU 收到请求但回传丢包,本次上电不会重试(下次开机 iFlag 仍为 1 时会再恢复)。
+- **恢复的触发窗口**:只在发送线程启动那一刻读 `iFlag`。运行期间参数被改坏不会再次触发恢复(与 master 一致)。
+
+## 四、验证(已执行)
+
+- CLI 全量重编(touch 1947 源文件 → 170 条命令):**0 失败**。
+- 权威尺寸:**text 253660B / data 2772B / bss 43632B**,`rtthread.bin` **256432B**(arm-none-eabi-gcc 6.3.1)。相对 2.59(254012/2772/43632,bin 256784B)**净减 text 352B** —— 删除三态状态机与重复日志的收益大于新增待办机制。
+- 告警:60 条,与 2.59 完全一致(无新增);`param_mirror.c` 仍 0 条。
+- 固件字符串核对:`参数待办:探测 RTU 通信`、`参数发生变更,执行备份到 RTU`、`执行参数恢复`、`参数两份均异常`、`已从RTU恢复备份参数`、`参数异常标志已清除` 均已进入镜像。
+- 源码级核对:全工程已无 `PARAM_SYNC_*` / `s_rtu_rx_ok` / `dtu_param_sync_poll` / `dtu_param_sync_on_rtu_params` 引用(仅历史注释保留)。
+
+## 五、待上机验证(未执行)
+
+1. **变更即备份**:屏幕改一项参数(如加热时间)→ 串口应见 `参数发生变更,执行备份到 RTU(backup_param_to_rtu)`,RTU 侧收到整包参数;重复设置同一值不应再发(镜像内容未变)。
+2. **RTU 晚启动**:设备先上电、RTU 后上电(或 RTU 被断电重启)→ 待办期间应每 2s 见 `参数待办:探测 RTU 通信(getinfo)...`,RTU 起来后自动补发备份,无需重启设备。
+3. **恢复路径**:擦掉 EF 的 iSave 与镜像(或下发 `eraseflash env` 后让参数回默认),重启 → 串口见 `参数两份均异常(已用默认值),等待 RTU 通信正常后执行恢复`,RTU 就绪后发 `recover_param`,RTU 回传 `sync_param` 后见 `已从RTU恢复备份参数`,参数恢复为 RTU 副本。
+4. **恢复后不覆盖**:恢复完成后 30s 内即使有参数变更,也不应立刻备份(避免默认值覆盖 RTU 副本)。
+5. **看门狗回归**:RTU 全程无输出时,2 小时 `JSON_RX_TIMEOUT_TICK` 到点仍能触发 `DTU_EVT_RTU_WDT`(确认本次改动未破坏原有看门狗起点)。
+
+# 2026-10-30 参数存储对齐 master:param_backup → param_mirror(版本 2.58 → 2.59)
+
+版本变更(control.h):2.58 → **2.59**
+
+- `VERSION_HK` 2.59.41(HK) | `VERSION_HK_2000W` 2.59.4(2000W) | 2.59.4(TG) | `VERSION_ZP` 2.59.1(ZP) | `VERSION_GK` 2.59.1(GK)
+
+- 经济款 `(jjk-5)` 2.58.4、比赛设备 `(TG)` 3.3.4 为独立版本序列,保持不动;当前配置 `TG_MODULE=0`、`JINGJIKUAN=0`,实机上报 **2.59.4(2000W)**。
+
+## 一、删除 param_backup,改用 master 的 param_mirror
+
+### 1. 文件增删
+
+- 新增 `applications/param_mirror.c` / `param_mirror.h`(以 master 分支当前版本为基准,含 1.86 的 `DBG_ENABLE` 修复与 `param_mirror_erase_all()`)。
+- 删除 `applications/param_backup.c` / `param_backup.h`(原文件已备份到 `C:\Users\Administrator\.workbuddy\backups\param_backup_20261030\`)。
+- `Debug/applications/subdir.mk` 同步把 `param_backup` 改为 `param_mirror`(IDE Refresh + Clean + Build 会按 .cproject 重新生成,内容应一致)。
+
+### 2. 存储布局(与 master 逐字节一致)
+
+- 镜像不再占用独立 FAL 分区,改为落在 `easyflash` 分区内部尾部;`fal_cfg.h` 已删除 `param_a` / `param_b` 两个分区(老设备 flash 上残留的数据不再被引用,不影响启动)。
+
+- 实际布局:ENV 区 `0x00000~0x10000`(`ENV_AREA_SIZE = EF_ERASE_MIN_SIZE*16 = 64KB`)| 日志区 `0x10000~0x12000`(本工程 `PKG_EASYFLASH_LOG` 未定义,`EF_USING_LOG` 关闭,该段实际为空闲)| 镜像槽 A `0x12000`、槽 B `0x13000`(各 1 个 4KB 扇区)。
+
+- ⚠️ 偏移强耦合 `ENV_AREA_SIZE`:今后调整 ENV 区大小必须同步修改 `param_mirror.h` 的 `MIRROR_BASE_OFFSET`,否则镜像会落进日志区被互相破坏。
+
+### 3. 镜像内容与写入策略
+
+- `param_payload_t`:`magic('PARB')` + `version(0x00010001)` + `write_seq` + `crc32` + **20 个标量字段**(iSave/dtype/ds/clt_time/heattime/heatvalue/thsp/sunBar/startBar/stopBar/timeSwitch/tph/tpl/shake_ws/shake_sec/passWord/dattim/version_type/Power_Type/handle_bugger),`__packed`,共 41 字节。
+
+- 写:A/B 轮写,先写较旧槽并回读校验、再写较新槽;`write_seq` 自增,掉电在两次写之间仍能读到上一份有效副本。CRC32 直接复用 `ef_calc_crc32()`,不另建表。
+
+- 写放大抑制:`param_mirror_sync()` 先比较"配置体"(跳过 16 字节头),内容未变化直接返回,**不会**因为每条 JSON / 每屏刷新就擦扇区。
+
+- 并发:`param_mirror_sync()` / `param_mirror_erase_all()` 用 `pm_mtx` 互斥(HMI、DTU、工作流程线程都会调用)。
+
+### 4. 开机流程改造(`hmi.c: Check_ParamConfig`)
+
+- iSave 丢失:先 `param_mirror_load()`,有效则 `mirror_to_device_status()` 整包回填并把 `iFlag` 置 0,不再直接回出厂值(与 master 同一策略)。
+
+- iSave 正常:进入读取分支后先载入镜像,再按原有 key 逐条 `ef_get_env_blob()`。**与 master 行为一致:逐条读取会覆盖镜像值,镜像只对"读不到的键"生效**;字符串字段(imei/iccid/deviceId/platform/driver_bl/env_t/env_h 等)本来就不在镜像里,仍只走 EF。
+
+- 默认值分支写完 EF 后调用 `param_mirror_sync()` 用同一套出厂值初始化镜像;"丢参数补丁"块之后也改为 `param_mirror_sync()`(原先只改 RAM,重启会重复丢)。
+
+- 所有 `param_mark_dirty()` 调用点(hmi 12 处、control 1 处、dtu 2 处)统一改为 `param_mirror_sync()`;`param_flush_force()` 删除(同步写本身就是立即生效);`param_backup_start()` 及 500ms 静默期落盘线程整体移除。
+
+- `reboot_time` 同步 master 1.85:改为每 10 次开机落盘一次(落盘值 1,11,21…)。原因:`param_payload_t` 不含 `rebootcnt`,这条计数不能再靠参数快照延迟落盘,逐次写又会持续放大 EF 写次数。
+
+### 5. 随 param_backup 一并移除的能力(需知悉)
+
+- 整包 820 字节快照(含全部字符串字段)→ 现在镜像只保护 20 个标量;EF 若整片丢失,字符串仍需平台重新下发。
+- 开机"参数健康自检 + 从快照整包回写 EF"(`param_check_health` / `param_write_back_to_easyflash`)→ 移除;现由"镜像抢救 + 零值补丁"覆盖单条 env 丢失场景。
+- `param_dump` / `param_save_now` / `param_restore` / `param_save_ef` / `param_stat` 五条 msh 调试命令 → 随模块删除。
+- 参数快照里的 `update_flag` 第二通道 → 升级请求仍保留 EF 通道(`up_flag_ef`),但不再有快照副本。
+
+## 二、新增远程擦除 Flash 指令(同步 master 1.86)
+
+- 指令(RTU 透传下发):
+  `{"cmd":"eraseflash","ext":{"target":"env"}}`(安全档,默认)
+  `{"cmd":"eraseflash","ext":{"target":"chip","confirm":"ERASE"}}`(危险档,需强确认)
+
+- `target="env"`:只擦参数存储,顺序**必须**是 镜像两槽 → ENV 区(64KB) → EF 日志区。镜像最先擦的原因:否则重启后走 iSave 丢失路径时 `param_mirror_load()` 会把旧参数整份搬回来,"恢复出厂"落空。故意不调用 `ef_env_set_default()`——它写入的是字符串型默认值,而本工程用 `ef_get_env_blob` 按二进制读,读出来会是 ASCII 码。
+
+- `target="chip"`:片外 SPI NOR 整片擦除,按 `erase_gran` 对齐分块(64KB),每块擦完显式喂狗;会连带擦掉 `fm_area` / `df_area`(OTA 回滚副本)。片内 Flash(bl/app)任何档位都不擦,不存在把设备擦成砖的路径。
+
+- 回执:`flash erase start:<target>` → 执行 → `flash erase done|failed:<target> (<秒>s)`,成功后 `rt_hw_cpu_reset()`(先回 start 是因为擦除期间接收线程无法处理其它下行指令)。
+
+- 分支位置:插在 `mvs_photo` 与 `reboot` 之间(破坏性指令前置)。已逐一核对前置 5 个 `strstr` 分支(takephoto/shake/ctrl/platform/mvs_photo)均不匹配 `eraseflash`,且本分支不吞后续 reboot/reset/update/read/poweron/poweroff/sensor/color/synchronization/paramconf。
+
+- 与 master 的差异:本工程 `EF_USING_LOG` 未开启(`PKG_EASYFLASH_LOG` 未定义),日志区清理一步用 `#ifdef EF_USING_LOG` 包起来;master 打开了日志区,故其原实现是无条件 `ef_log_clean()`。
+
+- 安全门控:`fal_partition_find()` 前先查 `fal_init_check()`(否则撞 `assert(init_ok)` 死循环);整片擦除用 `NOR_FLASH_DEV_NAME`("norflash0")取 sfud 句柄,与 hmi/sys_monitor 取值方式一致。
+
+## 三、本分支刻意保留的适配(与 master 不同之处)
+
+- `param_mirror.c` **不重复定义** `device_status`(本工程唯一定义在 `main.c`,master 那边靠 `-fcommon` 合并两份 tentative definition,不能照搬)。
+- 补 `#define __packed __attribute__((__packed__))`:本工程用 APM32 标准库,没有 STM32 HAL 的 `__packed` 宏(只有 CMSIS 的 `__PACKED`)。
+- `mirror_part()` 双重门控:`fal_init_check() != 1` 或 `nor_flash0_is_ready() != 1` 直接返回 NULL —— SPI flash 物理探测失败时分区表仍建得出来,不能让镜像模块去擦一块坏 flash(降级启动路径)。
+- 日志配置块放在所有 include 之前;`dtu_uart2.c` 的节名改用 `DBG_SECTION_NAME "dtu"` 直定义——新增的 `spi_flash_sfud.h` 会 `#define DBG_TAG "SFUD"`,而 `rtdbg.h` 把 `DBG_SECTION_NAME` 定义为 `DBG_TAG` 的别名,会被劫持成 "SFUD"(构建期已实测出现该告警,改直定义后消除)。
+- `dtu_uart2.c` 的 ext 取值一律走 `cj_getstr()`,不碰 `->valuestring`(平台下发 JSON 不可信铁律)。
+
+## 四、验证(已执行)
+
+- CLI 全量重编(`build_full_warn.py`:touch 1947 个源文件 → 170 条命令):**0 失败**。
+- 权威尺寸:**text 254012B / data 2772B / bss 43632B**,`rtthread.bin` **256784B**(arm-none-eabi-gcc 6.3.1)。
+- 告警:`param_mirror.c` 0 条;`dtu_uart2.c` 保留既有的 `ymodem_ota` 隐式声明、`link_ip`/`lng_s` 未使用三条;构建期新出现的 `DBG_TAG redefined` 已通过改用 `DBG_SECTION_NAME` 消除。
+- 源码级核对:全工程已无 `param_backup` / `param_persist_t` / `param_mark_dirty` / `param_flush*` / `param_pack/unpack` / `param_check_health` 引用(仅注释中保留历史说明)。
+
+## 五、待上机验证(未执行)
+
+1. 老固件升级后首次开机:EF 有 iSave、镜像区为 0xFF → 应正常读 EF,日志出现镜像写入;断电重启参数保持。
+2. 人为清掉 EF 的 iSave(或下发 `eraseflash env`)后重启:应从镜像恢复全部 20 个标量,且**不**回出厂值。
+3. `{"cmd":"eraseflash","ext":{"target":"env"}}`:应看到 start/done 两条回执、设备重启、参数回出厂(机型靠屏幕 Swversion 握手恢复)。
+4. 不带 `confirm` 下发 `target="chip"`:应被拒绝且**不**重启;带 `confirm="ERASE"` 才执行,擦除期间看门狗不复位。
+5. 屏幕/平台连续改参数:每次变更会擦 2 个扇区(约 40~100ms,HMI 线程同步执行),确认界面无可感知卡顿;同一批设置只写一次(内容未变则跳过)。
+6. `eraseflash` 与 reboot/reset/update 等指令混合下发,确认无分支吞噬。
+
+## 六、风险与未同步项
+
+- 镜像只覆盖 20 个标量:字符串类参数仍是"单点"存于 EF,EF 整片损坏时需平台重新下发(master 亦如此)。
+- `param_*` 五条调试命令随模块删除;现场排查改用串口日志(`param mirror ...`)与 `fal` / `ef` 原生命令。
+- master 2026-10-15 的"参数变更 → 待办备份到 RTU(`dtu_request_param_backup` + `dtu_param_pending_service`)"未同步:本分支仍是开机一次性 `dtu_param_sync_poll()` 机制,`param_mirror_sync()` 内不触发 RTU 备份。
+- 本分支 EasyFlash 未开启日志区,`eraseflash` 的日志清理步骤为空实现(条件编译)。
+
 # 2026-10-25 关闭清扫PWM 版本 2.57 → 2.58
 # 2026-10-20 开机联网检测线程未退出时 HMI 侧不再重复发 read —— 版本 2.55 → 2.56
 

+ 1 - 1
Application_cbd_apm32f1/rt-thread/components/fal/samples/porting/fal_flash_sfud_port.c

@@ -94,7 +94,7 @@ static int init(void)
 
            正确做法: 保留 len(默认 8MB)让 FAL 正常建表、init_ok 正常置 1;
            真正的安全闸是 nor_flash0_ready —— read/write/erase 一律返回 -1,
-           上层(hmi.c / param_backup.c)据此降级, 而不是让整条链路崩在断言上。 */
+           上层(hmi.c / param_mirror.c)据此降级, 而不是让整条链路崩在断言上。 */
         nor_flash0_ready = 0;
 
         /* 诊断: 区分"SPI 设备压根没挂上"和"挂上了但芯片不响应", 现场好定位 */

+ 145 - 0
CBD_FOTA_BootLoader/.workbuddy/memory/2026-10-29.md

@@ -0,0 +1,145 @@
+# 2026-10-29
+
+## 任务:修复「bootloader 里 Flash 正常、跳转 APP 后 SFUD 探不到、EasyFlash 逐扇区格式化导致 APP 起不来」
+
+### 现象(用户日志)
+- bootloader 段:`[SFUD] Find a Winbond flash chip. Size is 4194304 bytes` + FAL/EasyFlash 全正常,版本 1.3.1。
+- 5s 倒计时后 78 个 `#`(= 78×4KB = 312KB,即 fm_area→app 的整包搬运/或 app→df_area 备份),随即跳转。
+- APP 段:`Read SFDP parameter header information failed` → `This flash device is not found or not support`
+  → `ERROR: SPI flash probe failed by SPI device spi10` → FAL 里 w25q16m 设备为空
+  → EasyFlash 对 3MB 环境区逐个 4KB 扇区「检查 header-格式化-擦-写-读」四次 assert 全失败 → 启动被拖成分钟级。
+
+### 排查(关键:两工程逐文件对比,排除法)
+- `drivers/drv_spi.c`(含 `stm32_spi_init` 强制 `State=HAL_SPI_STATE_RESET` 后再 `HAL_SPI_Init`)、
+  `drivers/board.c::HAL_SPI_MspInit`(PA5/PA7=AF_PP、PA6=INPUT、SPI1 时钟)、
+  CS 引脚(都是 `rt_hw_spi_device_attach("spi1","spi10",GPIOA,GPIO_PIN_4)`)、FAL 移植层、分区表:
+  **bootloader 与 Application_CBD 完全一致**。
+- 速度差异方向相反:bootloader `RT_SFUD_SPI_MAX_HZ=50MHz`(72/64MHz→/2≈32MHz),
+  APP `=24MHz`(→/4=18MHz)→ **APP 更慢,排除"速度过快"**。
+- 时钟源不同(bootloader `clk_init(HSI…)`,APP `SystemClock_Config()` HSE×9),但 SPI 预分频由
+  `RT_SFUD_SPI_MAX_HZ` 夹住,两侧都远低于 W25Q 上限,非致因。
+- 结论:**只有"交接瞬间的外设/芯片状态"变化**。`HAL_DeInit()` 实测(libraries/STM32F1xx_HAL_Driver/Src/
+  stm32f1xx_hal.c:175)先 `__HAL_RCC_APB2_FORCE_RESET()`(GPIOA/SPI1/AFIO 复位 → PA4/PA5/PA7 变浮空输入,
+  ODR=0),`HAL_MspDeInit` 为空实现;到 APP 的 `HAL_SPI_MspInit` 重新配置引脚之间有几十毫秒悬空窗口。
+  悬空 /CS 被噪声拉低 + 时钟线毛刺会被 Flash 当指令打入(0xB9 深度掉电 / 0x38 QPI),
+  之后标准 SPI 只能读到 0xFF/0x00 —— 与 APP 侧日志完全吻合。本次跳转前刚做过 312KB 的 Flash 搬运,
+  正好处于最不利时序。
+
+### 改动(v1.3.2 / COMPILE 20261029)
+- `applications/rt_fota.c`
+  - 新增 `rt_fota_spi_flash_quiesce()`:等 SR.BUSY 清零(≤1s)→ 0xFF×8 逃逸 QPI/连续读 →
+    0xAB 释放深度掉电 → 0x66/0x99 器件复位 → 读 JEDEC ID 打印自检
+    (`SPI flash handover: SR=0x00 JEDEC ID=0xEF4015`)。**放在 `__disable_irq()` 之前**
+    (rt_spi_* 依赖总线互斥量与 `rt_thread_mdelay`)。
+  - 新增 `rt_fota_spi_pins_safe_state()`:**在 HAL_DeInit/HAL_RCC_DeInit 之后**(否则被 APB2 复位冲掉)
+    先写 BSRR=0xF0 再改 CRL:PA4 推挽输出高(不选中),PA5/6/7 上拉输入。
+    APP 的 `HAL_GPIO_Init` 不改 ODR,因此 /CS 从跳转到 SFUD 探测全程高电平。
+  - 去掉重复的第二次 `HAL_DeInit()`。
+- `applications/sys_config.h`:`RT_FOTA_SW_VERSION` 1.3.1 → 1.3.2;`main.c`:COMPILE → 20261029。
+- `readme.md`:新增「版本说明 2026-10-29(第七次)」。
+
+### 验证
+- 全量重编(`D:\RT-ThreadStudio\workspace\.bl_src_backups\build_bl.py`)0 失败 0 告警;
+  text 168716 / data 2132 / bss 8560 / bin **170848**B(v1.3.1 基线 170016B)。
+- 反汇编核对 `rt_fota_start_application`:`quiesce` → `cpsid i` → NVIC/SysTick 清理 →
+  `HAL_DeInit` → `HAL_RCC_DeInit` → `pins_safe_state` → `msr MSP` → `msr CONTROL` → `cpsie i` → 跳转,顺序正确。
+- `rt_fota_spi_pins_safe_state` 反汇编:APB2ENR|=4、BSRR=0xF0、CRL 清 bit19:16 置 0x30000(PA4 输出 PP)、
+  清 bit31:20 置 0x88800000(PA5/6/7 上拉输入),与源码意图一致。
+
+### 待上机验证
+1. 串口看跳转前是否打印 `SPI flash handover: SR=0x00 JEDEC ID=0xEF4015`(读不到即总线/芯片异常)。
+2. 跳转后 APP 的 SFUD 是否恢复正常(不再出现 SFDP/JEDEC 失败与 EasyFlash 逐扇区格式化)。
+3. 若仍失败:APP 侧再加兜底(探测失败时强制 `HAL_SPI_MspInit` + 重试一次),
+   并核对 APP 当前 `rtconfig.h`(`FAL_USING_NOR_FLASH_DEV_NAME "MYFLASH16"` / `PKG_USING_FAL_LATEST_VERSION`
+   与设备上运行固件打印的 `w25q16m` / FAL v0.5.0 不一致,说明设备上的 APP 不是当前工作树编出来的)。
+
+### 备份
+`D:\RT-ThreadStudio\workspace\.bl_src_backups\backup_20261029_1606_batch6\`(rt_fota.c / sys_config.h / main.c / readme.md / rtthread.bin)
+
+---
+
+## 任务 2:长耗时 Flash 操作喂狗(v1.3.3)
+
+### 判断依据
+- IWDG 由 syswatch 在启动阶段开启:`syswatch_wdt_startup()` → `WDT_SET_TIMEOUT(10)` + `WDT_START`;
+  `drv_wdt.c` 用 `IWDG_PRESCALER_256`、`Reload = 10 * LSI_VALUE(40000) / 256 = 1562` → **超时 10s**。
+  IWDG 一旦启动无法停止,只能靠喂狗续命。
+- 原来 backup/restore/擦除都是「整块」交给 FAL:`fal_partition_erase(df_area, 4KB, 312KB)` 在 NOR 上
+  要逐 4KB 扇区擦 78 次 —— W25Q 单扇区擦除 tSE 典型 45ms / 最大 400ms,一次调用就是 3.5s(典型)/
+  **31s(最坏)**,中途无任何喂狗机会 → 10s 超时必然复位;复位后 DR2 残留 0xDEAD 会再触发回滚,放大故障。
+- 已排除 syswatch 主动复位这一路:`syswatch_check_timeout` 只在 syswatch 线程每秒循环里自增 sec_cnt,
+  且每次切到 idle 线程就清零;backup 中有大量阻塞 I/O 让出 CPU,`SYSWATCH_EXCEPT_TIMEOUT=60s` 不会命中。
+  所以复位来源就是 IWDG 硬件超时。
+
+### 改动(v1.3.3 / COMPILE 20261029)
+- `rt_fota.c` 新增 `rt_fota_wdt_feed()`(导出到 `rt_fota.h`):
+  **只有 `IWDG->PR`/`IWDG->RLR` 非复位值 0 时才喂** —— IWDG 只要写一次 KR(0xAAAA) 就启动且无法停止,
+  对未启动的 IWDG 喂狗会把 10s 看门狗凭空带进 APP 运行期。每次读两个寄存器判断,不做一次性缓存。
+- `rt_fota.c` 新增 `rt_fota_erase_chunked(part, addr, size)`:按 4KB 分块擦、每块后喂狗。
+  4KB 同时是 NOR 扇区粒度与 onchip 页(2KB)的整数倍,两种介质都安全(onchip 驱动
+  `stm32_flash_erase_bank` 内部再按 16 页分块关中断,传 4KB 即 2 页)。
+- 调用点:`rt_fota_backup_app_to_df`(擦头后 / 读 CRC 循环 / 擦数据区 / 写循环,写循环喂在 HMI_WRITE 之前)、
+  `rt_fota_restore_app_from_df`(读循环 / 擦 APP / 写循环)、`rt_fota_erase_app_part`(升级擦 APP)、
+  `rt_fota_write_app_part`(升级搬运写)、msh `fota clone`、`main.c` 的 `eraseapp` / `erasedf_area`。
+- 时序核算:单块最坏 400ms(擦)+48ms(写 4KB=16 页×3ms) ≈ 450ms,对比 10s 超时有 20 倍以上余量。
+
+### 验证
+- 全量重编 0 失败 0 告警;text 169100 / data 2132 / bss 8568(+8,wdt_dev 静态句柄),bin **171232**B。
+- 反汇编 `rt_fota_wdt_feed`:`IWDG_BASE=0x40003000`,读 `[+4]`=PR、`[+8]`=RLR,两者为 0 直接返回;
+  否则 `rt_device_find("wdt")` + `rt_device_control(dev, 4, NULL)`(4 = `RT_DEVICE_CTRL_WDT_KEEPALIVE`,已核对 watchdog.h)✓
+- 符号表确认 `rt_fota_erase_chunked` / `rt_fota_wdt_feed` 均未被优化掉。
+
+### 备份
+`D:\RT-ThreadStudio\workspace\.bl_src_backups\backup_20261029_1630_batch7\`
+
+---
+
+## 任务 3:为什么"没触发升级、只断电重启"却跑 rt_fota_backup_app_to_df(v1.3.4)
+
+### 用户质疑(很关键,推翻了我上一轮的一个判断)
+上一轮我把日志里 78 个 `#` 判为"fm_area→app 的 312KB 搬运",用户指出**根本没下发升级包,只是断电重启**。
+
+### 真正的因果链(已逐行核对代码)
+backup 只有两个调用点:`main.c:181`(uart4 `backupapp` 命令)、`rt_fota_thread_entry` 的升级分支。
+排除了手动命令,就只能是**升级判定误入**:
+
+1. `rt_fota_part_fw_verify(fm_area)` 通过 —— fm_area 里确实躺着一个**完整有效的 RBL 包**
+   (校验很严:head CRC + `type=="RBL"` + app 分区存在 + 全包 body CRC,所以不是读到 0xFF 蒙过)
+2. `rt_fota_check_upgrade()` 比较 `fota_part_head.download_version` vs `current_version`(两者都来自
+   fm_area 的 RBL 头)→ 不等即"需升级"
+3. **唯一把 current 对齐成 download 的 `rt_fota_copy_version()` 在 `rt_fota_upgrade()` 之后**
+   → 只要 upgrade 失败/被打断,copy_version 永不执行 → 包永远"待升级"
+4. → **每次上电都重跑**:backup(312KB 读 + 擦 78 扇区 + 写 312KB) → upgrade(擦写 312KB) → …
+   而 backup 的擦除正好是上一批修的 IWDG 超时点 → 擦到一半复位 → 更不可能走到 copy_version
+   → **自锁死循环**
+
+所以顺序是:**某次升级没走完(很可能就是被 IWDG 打断)→ fm_area 包一直待升级 → 之后每次断电重启都重跑备份+升级**。
+
+### 放大因素(可观测性缺陷)
+`rt_fota_check_upgrade()` 的判据原本是 `LOG_D`,而 `DBG_LEVEL=DBG_INFO` → **根本不打印**。
+现场只能看到 backup 的打印,完全看不出"为什么升级",这也是我上一轮判断跑偏的原因之一。
+
+### 改动(v1.3.4 / COMPILE 20261029)
+- **升级重试熔断**:`fota_retry{cnt, ver[24]}` 存 EasyFlash(key `fota_retry`,掉电保持)。
+  `rt_fota_retry_allow()` 在 backup **之前**拦截:版本变化→计数归零(新包自动解禁);
+  `cnt >= 3` → 打印原因 + LED 回 shell 节奏 + 不再动 flash,直接跳 APP。
+  `rt_fota_retry_clear()` 仅在 upgrade + copy_version **都成功**后清零。
+  EF 记录被擦成 0xFF 时 cnt 会是垃圾值 → `cnt > 100` 视为无效并重置(防误永久禁用)。
+- `rt_fota_check_upgrade()` 判据改 `LOG_I` 并打印两侧版本;upgrade / copy_version 失败各自打印原因。
+- msh `fota retry` 查看熔断状态、`fota retry 0` 清零;`fota probe` 增加
+  `Applied version`(current_version) 与 `Upgrade pending`(YES/NO) 两行。
+
+### 验证
+- 全量重编 0 失败 0 告警;text 170644 / data 2132 / bss 8600,bin **172776**B。
+- 反汇编 `rt_fota_thread_entry` 顺序确认:
+  `fw_verify → check_upgrade → retry_allow → backup_app_to_df → upgrade → copy_version → retry_clear`
+  —— 熔断确实挡在 backup 之前。
+- `rt_fota_retry_allow` 反汇编:`cmp r3,#2` 即 `cnt>=3`(无符号),逻辑正确。
+
+### 现场处置建议(已写入 readme)
+`fota probe` 看 Upgrade pending → `fota retry` 看计数 → `fota retry 0` 后重新下发一次完整包(或擦 fm_area)。
+
+### 备份
+`D:\RT-ThreadStudio\workspace\.bl_src_backups\backup_20261029_1634_batch8\`
+
+

File diff suppressed because it is too large
+ 9 - 1
CBD_FOTA_BootLoader/.workbuddy/memory/MEMORY.md


+ 29 - 3
CBD_FOTA_BootLoader/applications/main.c

@@ -34,7 +34,7 @@
 #include <easyflash.h>
 
 #define BL_VERSION RT_FOTA_SW_VERSION
-#define COMPILE "20261013"
+#define COMPILE "20261029"
 
 #define RTU_DTU GET_PIN(B,13)
 #define Beep    GET_PIN(B, 4)
@@ -226,8 +226,21 @@ static void HMI_Decode(char *cmd,uint8_t cmd_len)
         fal_erase = fal_partition_find("app");
         if (fal_erase != RT_NULL)
         {
+            rt_uint32_t erased = 0, len;
             rt_kprintf("eraseapp: erase %s partition(%d bytes)...\n", fal_erase->name, fal_erase->len);
-            if (fal_partition_erase(fal_erase, 0, fal_erase->len) < 0)
+            /* 分块擦除 + 逐块喂狗:一次擦 312KB 的 onchip flash 需要数秒,
+             * 单次调用会长时间不给 IWDG 喂狗,导致擦到一半被看门狗复位 */
+            while (erased < (rt_uint32_t)fal_erase->len)
+            {
+                len = fal_erase->len - erased;
+                if (len > 4096)
+                    len = 4096;
+                if (fal_partition_erase(fal_erase, erased, len) < 0)
+                    break;
+                erased += len;
+                rt_fota_wdt_feed();
+            }
+            if (erased < (rt_uint32_t)fal_erase->len)
                 rt_kprintf("eraseapp failed!\n");
             else
                 rt_kprintf("eraseapp done.\n");
@@ -250,8 +263,21 @@ static void HMI_Decode(char *cmd,uint8_t cmd_len)
         fal_erase = fal_partition_find("df_area");
         if (fal_erase != RT_NULL)
         {
+            rt_uint32_t erased = 0, len;
             rt_kprintf("erasedf_area: erase %s partition(%d bytes)...\n", fal_erase->name, fal_erase->len);
-            if (fal_partition_erase(fal_erase, 0, fal_erase->len) < 0)
+            /* 分块擦除 + 逐块喂狗:512KB NOR 逐扇区擦最坏要几十秒,
+             * 一次性调用必然触发 IWDG 10s 超时复位 */
+            while (erased < (rt_uint32_t)fal_erase->len)
+            {
+                len = fal_erase->len - erased;
+                if (len > 4096)
+                    len = 4096;
+                if (fal_partition_erase(fal_erase, erased, len) < 0)
+                    break;
+                erased += len;
+                rt_fota_wdt_feed();
+            }
+            if (erased < (rt_uint32_t)fal_erase->len)
                 rt_kprintf("erasedf_area failed!\n");
             else
                 rt_kprintf("erasedf_area done.\n");

+ 368 - 10
CBD_FOTA_BootLoader/applications/rt_fota.c

@@ -162,6 +162,64 @@ static void rt_fota_bkp_dr2_write(rt_uint16_t value)
 	*(__IO uint16_t *)(BKP_BASE + 4 * 2) = value;
 }
 
+/* ===================== 长耗时 Flash 操作的看门狗喂狗 =====================
+ * 背景:IWDG 由 syswatch 在启动阶段开启(SYSWATCH_WDT_TIMEOUT=10s、LSI/256 分频),
+ *       一旦启动就无法停止,只能靠喂狗续命。而备份/恢复/擦除原来都是"整块"交给 FAL:
+ *       fal_partition_erase(df_area, 4KB, 312KB) 在 NOR 上要逐 4KB 扇区擦 78 次,
+ *       W25Q 单扇区擦除典型 45ms、最坏 400ms —— 一次调用可能 3.5s(典型)/ 31s(最坏),
+ *       中途没有任何喂狗机会,10s 超时必然复位(现象:备份/擦除做到一半板子重启,
+ *       重启后 DR2 残留 0xDEAD 还会触发回滚,进一步放大问题)。
+ * 对策:① rt_fota_wdt_feed() 供所有长耗时循环调用;
+ *       ② 大块擦除拆成 RT_FOTA_BACKUP_BLK_SIZE(4KB) 分块,每块后喂一次;
+ *       ③ 读/写循环每块喂一次。
+ *
+ * 安全:只有确认 IWDG 已启动(PR/RLR 非复位值 0)时才喂。IWDG 只要写入一次 KR
+ *       (0xAAAA)就会启动且无法停止,若在 bootloader 里误喂一个"未启动"的 IWDG,
+ *       会把一个 10s 看门狗凭空带进 APP 运行期,造成随机复位。
+ */
+#define RT_FOTA_WDT_DEV_NAME		"wdt"
+
+void rt_fota_wdt_feed(void)
+{
+	static rt_device_t wdt_dev = RT_NULL;
+
+	/* IWDG 未启动时 PR/RLR 保持复位值 0,直接返回:只要写一次 KR(0xAAAA)
+	 * 就会启动看门狗且无法停止,绝不能对"未启动"的 IWDG 喂狗。
+	 * 每次读两个寄存器(单周期访问)比缓存判断更稳,不受调用时机影响。 */
+	if ((IWDG->PR == 0) && (IWDG->RLR == 0))
+		return;
+
+	if (wdt_dev == RT_NULL)
+		wdt_dev = rt_device_find(RT_FOTA_WDT_DEV_NAME);
+
+	if (wdt_dev != RT_NULL)
+		rt_device_control(wdt_dev, RT_DEVICE_CTRL_WDT_KEEPALIVE, RT_NULL);
+}
+
+/* 分块擦除:把一次大块擦除拆成 chunk 大小的多次调用,块间喂狗。
+ * chunk 取 RT_FOTA_BACKUP_BLK_SIZE(4KB) = NOR 扇区粒度,对 onchip flash 亦按页对齐,
+ * 两种介质都安全。返回 0 成功,-1 失败(与 fal_partition_erase 语义一致)。 */
+static int rt_fota_erase_chunked(const struct fal_partition *part, rt_uint32_t addr, rt_size_t size)
+{
+	rt_uint32_t done = 0;
+	rt_size_t   len;
+
+	while (done < size)
+	{
+		len = size - done;
+		if (len > RT_FOTA_BACKUP_BLK_SIZE)
+			len = RT_FOTA_BACKUP_BLK_SIZE;
+
+		if (fal_partition_erase(part, addr + done, len) < 0)
+			return -1;
+
+		done += len;
+		rt_fota_wdt_feed();
+	}
+
+	return 0;
+}
+
 /* For shell */
 static rt_sem_t shell_sem = RT_NULL;
 static rt_device_t shell_dev = RT_NULL;
@@ -382,14 +440,126 @@ int rt_fota_check_upgrade(void)
 	if (rt_strcmp(fota_part_head.download_version, fota_part_head.current_version) != 0)
 	{
 		is_upgrade = 1;
-		LOG_D("Application need upgrade.");
+		/* v1.3.4:原为 LOG_D(DBG_LEVEL=DBG_INFO 时不输出),导致现场完全看不到
+		 * "为什么会跑升级/备份"。改为 LOG_I 并把两侧版本都打出来,一眼可判 */
+		LOG_I("Application need upgrade: fm_area[%s] != app[%s].",
+		      fota_part_head.download_version, fota_part_head.current_version);
 		goto __exit_check_upgrade;
 	}
 
+	LOG_I("No upgrade: fm_area[%s] == app[%s].",
+	      fota_part_head.download_version, fota_part_head.current_version);
+
 __exit_check_upgrade:
 	return is_upgrade;
 }
 
+/* ===================== v1.3.4:升级重试熔断 =====================
+ * 为什么需要(现场问题:没有下发升级包,断电重启却反复执行 backup):
+ *   rt_fota_check_upgrade() 只比较 fm_area 里 RBL 头的 download_version 与
+ *   current_version;而把 current_version 对齐成 download_version 的
+ *   rt_fota_copy_version() 位于 rt_fota_upgrade() **之后**。所以只要 upgrade
+ *   失败(擦写途中被 IWDG 复位、NOR 读写异常等),copy_version 就不会执行,
+ *   fm_area 里那个包始终"待升级"——
+ *   于是每次上电都重跑完整升级流程:先 rt_fota_backup_app_to_df() 备份 312KB
+ *   (读一遍 + 擦 78 扇区 + 写一遍),再擦写 312KB。表现为:
+ *     "没触发升级却每次启动都打印 rt_fota_backup_app_to_df!
+ *      并伴随长时间 # 输出、断电重启反复发生"。
+ * 对策:按"版本"记录连续失败次数。同一版本连续失败达到
+ *   RT_FOTA_UPGRADE_MAX_RETRY 次后不再自动升级,直接跳转 APP 并打印原因;
+ *   用户重新下发新包(版本变化)时计数自动归零,无需人工清标志。
+ *   记录存 EasyFlash(NOR,掉电保持);EF 不可用时退化为本次上电内计数。
+ */
+#define RT_FOTA_RETRY_EF_KEY			"fota_retry"
+#define RT_FOTA_UPGRADE_MAX_RETRY		3
+
+typedef struct
+{
+	rt_uint32_t cnt;		/* 同一版本连续失败次数 */
+	char        ver[24];	/* 上次尝试的 download_version */
+} rt_fota_retry_t;
+
+static rt_fota_retry_t fota_retry;
+static rt_bool_t fota_retry_loaded = RT_FALSE;
+
+static void rt_fota_retry_load(void)
+{
+	size_t saved_len = 0;
+
+	if (fota_retry_loaded)
+		return;
+
+	rt_memset(&fota_retry, 0, sizeof(fota_retry));
+	if (ef_get_env_blob(RT_FOTA_RETRY_EF_KEY, &fota_retry, sizeof(fota_retry), &saved_len) == 0)
+	{
+		/* 没有记录 or 读取失败:从头计数 */
+		rt_memset(&fota_retry, 0, sizeof(fota_retry));
+	}
+
+	/* EF 记录被擦成 0xFF 等异常时 cnt 可能是垃圾值(0xFFFFFFFF),
+	 * 直接判"已达上限"会把升级永久禁用,这里按无效记录重置。
+	 * 注意 ver 是空/0xFF 时必然与 download_version 不等,会走"新版本"分支归零,
+	 * 所以只需兜住 cnt 本身。 */
+	if (fota_retry.cnt > 100)
+	{
+		LOG_I("Retry: invalid record(cnt=0x%08X), reset.", fota_retry.cnt);
+		rt_memset(&fota_retry, 0, sizeof(fota_retry));
+	}
+
+	fota_retry_loaded = RT_TRUE;
+}
+
+static void rt_fota_retry_save(void)
+{
+	if (ef_set_env_blob(RT_FOTA_RETRY_EF_KEY, &fota_retry, sizeof(fota_retry)) != EF_NO_ERR)
+	{
+		LOG_I("Retry: save retry record failed (fallback to RAM only).");
+	}
+}
+
+/* 升级前的熔断检查:新版本自动清零;返回 RT_TRUE 表示"可以升级" */
+static rt_bool_t rt_fota_retry_allow(void)
+{
+	rt_fota_retry_load();
+
+	/* 版本不同 = 用户下发了新包,重新给满次数 */
+	if (rt_strcmp(fota_retry.ver, fota_part_head.download_version) != 0)
+	{
+		rt_strncpy(fota_retry.ver, fota_part_head.download_version, sizeof(fota_retry.ver) - 1);
+		fota_retry.ver[sizeof(fota_retry.ver) - 1] = '\0';
+		fota_retry.cnt = 0;
+	}
+
+	if (fota_retry.cnt >= RT_FOTA_UPGRADE_MAX_RETRY)
+	{
+		/* 达到上限:不再动 flash,保留现场供人工处理(msh: fota probe / dr2 0) */
+		rt_kprintf("Upgrade of version [%s] failed %d times, auto upgrade disabled.\n",
+		           fota_retry.ver, (int)fota_retry.cnt);
+		rt_kprintf("Fix the image or erase fm_area; a new version will re-enable it.\n");
+		rt_fota_signal_led_mode(led_shell_mode);
+		return RT_FALSE;
+	}
+
+	fota_retry.cnt++;
+	rt_fota_wdt_feed();
+	rt_fota_retry_save();
+
+	return RT_TRUE;
+}
+
+/* 升级完全成功(含版本对齐)后清零 */
+static void rt_fota_retry_clear(void)
+{
+	rt_fota_retry_load();
+	if (fota_retry.cnt == 0)
+		return;
+
+	fota_retry.cnt = 0;
+	rt_memset(fota_retry.ver, 0, sizeof(fota_retry.ver));
+	rt_fota_wdt_feed();
+	rt_fota_retry_save();
+}
+
 int rt_fota_copy_version(const char *part_name)
 {
 #define THE_NOR_FLASH_GRANULARITY		4096
@@ -468,7 +638,9 @@ int rt_fota_erase_app_part(void)
 	}
     
     LOG_I("Partition[%s] erase start:", part->name);
-	if (fal_partition_erase(part, 0, fota_part_head.raw_size) < 0)
+	/* 分块擦除 + 逐块喂狗:312KB 的 onchip 擦除按页进行(16 页一批关中断),
+	 * 单次调用可达数秒,与前面的 df_area 备份累加后容易撞 IWDG 10s 超时 */
+	if (rt_fota_erase_chunked(part, 0, fota_part_head.raw_size) < 0)
 	{
 		LOG_D("Partition[%s] erase failed!", part->name);
 		fota_res = RT_FOTA_PART_ERASE_ERR;
@@ -502,6 +674,8 @@ int rt_fota_write_app_part(int fw_pos, rt_uint8_t *fw_buf, int fw_len)
 		rt_fota_res = RT_FOTA_PART_WRITE_ERR;
 		goto __partition_write_exit;
 	}
+	/* 搬运循环里每块都写一次 app 分区,逐块喂狗(onchip 写 2KB/页,整包累计数秒) */
+	rt_fota_wdt_feed();
 __partition_write_exit:
 	if (rt_fota_res == RT_FOTA_NO_ERR)
 	{
@@ -560,6 +734,7 @@ __exit_read_decrypt:
 
 int rt_fota_upgrade(const char *part_name)
 {
+    rt_kprintf("rt_fota_upgrade:%s",part_name);
 	int fota_err = RT_FOTA_NO_ERR;
 	
 	const struct fal_partition *part;
@@ -945,6 +1120,124 @@ __exit_upgrade:
 	return fota_err;
 }
 
+/* ================== v1.3.2:跳转 APP 前的 SPI Flash 交接处理 ==================
+ * 现象:bootloader 内 SFUD 正常(打印 "Find a Winbond flash chip"),跳转后 APP 的
+ *       SFUD 探测失败("Read SFDP parameter header information failed" /
+ *       "This flash device is not found or not support"),FAL 里 w25q16m 设备为空,
+ *       EasyFlash 于是逐个 4KB 扇区做"检查-格式化",启动被拖死(表现为"读参数很慢")。
+ *
+ * 原因:原跳转序列里的 HAL_DeInit()/HAL_RCC_DeInit() 会复位 APB2(含 GPIOA、SPI1、
+ *       AFIO),/CS(PA4)、SCK(PA5)、MOSI(PA7) 变成浮空输入;从这一刻到 APP 里
+ *       HAL_SPI_MspInit 重新配置引脚,中间有几十毫秒"悬空窗口"。悬空的 /CS 一旦被
+ *       噪声拉低,悬空时钟线上的毛刺就会被 Flash 当成指令时打入(0xB9 = 深度掉电、
+ *       0x38 = QPI 等),此后标准 SPI 读只能得到 0xFF/0x00 —— 与 APP 侧现象完全一致。
+ *
+ * 对策(两步,缺一不可):
+ *   1) 跳转前让芯片回到"标准 SPI + 空闲"态:等 BUSY 清零 → 0xAB 释放深度掉电 →
+ *      0xFF 逃逸 QPI/连续读 → 0x66/0x99 复位器件;
+ *   2) 外设复位之后再固定引脚电平:/CS 推挽输出高(不选中),SCK/MOSI/MISO 上拉输入。
+ *      注意必须在 HAL_DeInit() 之后做,否则会被 APB2 复位冲掉。
+ * 另外顺手读一次 JEDEC ID 打印出来,交接是否健康一眼可见(读不到 = 总线/芯片已异常)。
+ */
+#define RT_FOTA_SPI_FLASH_DEV_NAME      "spi10"
+
+#define RT_FOTA_FLASH_CMD_READ_SR       0x05    /* 读状态寄存器 */
+#define RT_FOTA_FLASH_CMD_RELEASE_PD    0xAB    /* 释放深度掉电 / 读器件 ID */
+#define RT_FOTA_FLASH_CMD_READ_ID       0x9F    /* JEDEC ID */
+#define RT_FOTA_FLASH_CMD_RESET_EN      0x66    /* 复位使能 */
+#define RT_FOTA_FLASH_CMD_RESET         0x99    /* 复位器件 */
+
+static struct rt_spi_device *rt_fota_spi_flash_dev(void)
+{
+	return (struct rt_spi_device *)rt_device_find(RT_FOTA_SPI_FLASH_DEV_NAME);
+}
+
+/* 发 1 字节命令 + 读回数据(CS 由 SPI 框架自动拉低/释放) */
+static void rt_fota_spi_flash_cmd_recv(rt_uint8_t cmd, rt_uint8_t *rx, rt_size_t rx_len)
+{
+	struct rt_spi_device *dev = rt_fota_spi_flash_dev();
+
+	if ((dev == RT_NULL) || (rx == RT_NULL) || (rx_len == 0))
+		return;
+
+	rt_spi_send_then_recv(dev, &cmd, 1, rx, rx_len);
+}
+
+/* 只发 1 字节命令 */
+static void rt_fota_spi_flash_cmd(rt_uint8_t cmd)
+{
+	struct rt_spi_device *dev = rt_fota_spi_flash_dev();
+
+	if (dev == RT_NULL)
+		return;
+
+	rt_spi_send(dev, &cmd, 1);
+}
+
+/* 跳转前:把 SPI Flash 恢复到"标准 SPI + 空闲"状态 */
+static void rt_fota_spi_flash_quiesce(void)
+{
+	struct rt_spi_device *dev = rt_fota_spi_flash_dev();
+	rt_uint8_t status = 0xFF;
+	rt_uint8_t id[3] = {0, 0, 0};
+	rt_uint32_t start;
+	int i;
+
+	if (dev == RT_NULL)
+	{
+		rt_kprintf("SPI flash handover: %s not found, skip quiesce.\n", RT_FOTA_SPI_FLASH_DEV_NAME);
+		return;
+	}
+
+	/* 1) 等上一次写/擦除结束(BUSY=0),最长等 1s,避免复位指令打断写入 */
+	start = rt_tick_get();
+	do
+	{
+		status = 0xFF;
+		rt_fota_spi_flash_cmd_recv(RT_FOTA_FLASH_CMD_READ_SR, &status, 1);
+		if ((status & 0x01) == 0)
+			break;
+	} while ((rt_tick_get() - start) < rt_tick_from_millisecond(1000));
+
+	/* 2) 0xFF 逃逸(尽力而为):若芯片被噪声带入 QPI/连续读模式,需 0xFF 才能退出;
+	 *    标准 SPI 模式下 0xFF 是空操作,无副作用。真正的兜底是后面的 0x66/0x99 复位
+	 *    与"跳转后 /CS 保持高电平"(见 rt_fota_spi_pins_safe_state) */
+	for (i = 0; i < 8; i++)
+		rt_fota_spi_flash_cmd(0xFF);
+
+	/* 3) 释放深度掉电(0xB9 之后只有 0xAB 能被响应) */
+	rt_fota_spi_flash_cmd(RT_FOTA_FLASH_CMD_RELEASE_PD);
+	rt_thread_mdelay(1);                    /* tRES1,留足余量 */
+
+	/* 4) 器件复位(不支持的型号会忽略,无副作用) */
+	rt_fota_spi_flash_cmd(RT_FOTA_FLASH_CMD_RESET_EN);
+	rt_fota_spi_flash_cmd(RT_FOTA_FLASH_CMD_RESET);
+	rt_thread_mdelay(1);                    /* tRST */
+
+	/* 5) 交接自检:读 JEDEC ID,异常时提前暴露(正常应为 0xEF4015/0xEF4016 之类) */
+	rt_fota_spi_flash_cmd_recv(RT_FOTA_FLASH_CMD_READ_ID, id, 3);
+	rt_kprintf("SPI flash handover: SR=0x%02X JEDEC ID=0x%02X%02X%02X\n",
+	           status, id[0], id[1], id[2]);
+}
+
+/* 外设复位后:把 SPI 引脚固定为安全电平,杜绝 APP 启动前的悬空窗口 */
+static void rt_fota_spi_pins_safe_state(void)
+{
+	rt_uint32_t crl;
+
+	__HAL_RCC_GPIOA_CLK_ENABLE();
+
+	/* 先置 ODR 再改模式:切换成输出的瞬间即为高电平,不会把 Flash 选中一下 */
+	GPIOA->BSRR = GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7;
+
+	crl  = GPIOA->CRL;
+	crl &= ~(0xFUL << 16);                  /* PA4:/CS */
+	crl |=  (0x3UL << 16);                  /*   推挽输出 50MHz,ODR=1 → 不选中 */
+	crl &= ~(0xFFFUL << 20);                /* PA5/PA6/PA7:SCK/MISO/MOSI */
+	crl |=  (0x888UL << 20);                /*   上拉输入,杜绝悬空引入毛刺 */
+	GPIOA->CRL = crl;
+}
+
 int rt_fota_start_application(void)
 {
 	int fota_res = RT_FOTA_NO_ERR;
@@ -981,6 +1274,10 @@ int rt_fota_start_application(void)
 
 	LOG_I("Implement application now.");
 
+	/* v1.3.2:把 SPI Flash 恢复到标准 SPI 空闲态(必须放在关中断之前,
+	 * 因为 rt_spi_* 走总线互斥量/延时,关中断后会失去调度) */
+	rt_fota_spi_flash_quiesce();
+
 	__disable_irq();
 	/* 禁用并清除全部 NVIC 中断(原循环因 F1 无 FPU_IRQn 被注释,改用寄存器遍历),
 	 * 防止 APP 启动初期残留/挂起中断使用旧向量表或未初始化外设 */
@@ -1001,7 +1298,10 @@ int rt_fota_start_application(void)
 	/* 外设与时钟恢复到默认状态 */
 	HAL_DeInit();
 	HAL_RCC_DeInit();
-	HAL_DeInit();
+
+	/* v1.3.2:上面的 APB2 复位会把 GPIOA 打回浮空输入,这里重新固定 SPI 引脚电平,
+	 * 保证从此刻到 APP 配好引脚之间 /CS 始终为高、时钟/数据线不被噪声干扰 */
+	rt_fota_spi_pins_safe_state();
 
 	/* 向量表预先指向 APP(其 SystemInit 会先写回 0x08000000,此步保证交接窗口安全) */
 	SCB->VTOR = app_addr;
@@ -1178,6 +1478,7 @@ static rt_err_t rt_fota_check_ymodem_request(void)
  * 返回 RT_FOTA_NO_ERR 表示备份有效。 */
 int rt_fota_backup_app_to_df(void)
 {
+    rt_kprintf("rt_fota_backup_app_to_df!");
 	rt_fota_backup_head_t head;
 	const struct fal_partition *app_part;
 	const struct fal_partition *df_part;
@@ -1219,6 +1520,7 @@ int rt_fota_backup_app_to_df(void)
 		fota_res = RT_FOTA_PART_ERASE_ERR;
 		goto __exit_backup;
 	}
+	rt_fota_wdt_feed();
 
 	/* 2. 读取 APP 分区并计算数据 CRC32 */
 	extern rt_uint32_t rt_fota_step_crc(rt_uint32_t crc, rt_uint8_t *buf, rt_uint32_t len);
@@ -1239,12 +1541,14 @@ int rt_fota_backup_app_to_df(void)
 
 		crc = rt_fota_step_crc(crc, buf, read_len);
 		pos += read_len;
+		rt_fota_wdt_feed();
 		rt_kprintf("#");
 	}
 	crc ^= 0xffffffff;
 
-	/* 3. 擦除数据区 */
-	if (fal_partition_erase(df_part, RT_FOTA_BACKUP_HEAD_RSV, erase_len) < 0)
+	/* 3. 擦除数据区:分块擦除并逐块喂狗(整块 312KB 在 NOR 上最坏要擦 30s 以上,
+	 *    一次性调用必然触发 IWDG 10s 超时复位) */
+	if (rt_fota_erase_chunked(df_part, RT_FOTA_BACKUP_HEAD_RSV, erase_len) < 0)
 	{
 		LOG_I("Backup: erase data area failed.");
 		fota_res = RT_FOTA_PART_ERASE_ERR;
@@ -1274,6 +1578,9 @@ int rt_fota_backup_app_to_df(void)
 		}
 
 		pos += read_len;
+		/* 喂狗放在 HMI_WRITE 之前:串口屏是阻塞发送(每次十几 ms),
+		 * 78 块累计也有秒级,先确保看门狗被喂过 */
+		rt_fota_wdt_feed();
 		HMI_WRITE("debug.update.val=%d", (int)(pos * 100 / data_len));
 		rt_kprintf("#");
 	}
@@ -1309,6 +1616,7 @@ __exit_backup:
  * 返回 RT_FOTA_NO_ERR 表示恢复完成。 */
 int rt_fota_restore_app_from_df(int consume_backup)
 {
+    LOG_I("rt_fota_restore_app_from_df:%d", consume_backup);
 	rt_fota_backup_head_t head;
 	const struct fal_partition *app_part;
 	const struct fal_partition *df_part;
@@ -1380,6 +1688,7 @@ int rt_fota_restore_app_from_df(int consume_backup)
 
 		crc = rt_fota_step_crc(crc, buf, read_len);
 		pos += read_len;
+		rt_fota_wdt_feed();
 		rt_kprintf("#");
 	}
 	crc ^= 0xffffffff;
@@ -1391,8 +1700,9 @@ int rt_fota_restore_app_from_df(int consume_backup)
 		goto __exit_restore;
 	}
 
-	/* 3. 擦除 APP 分区并回写备份数据 */
-	if (fal_partition_erase(app_part, 0, app_part->len) < 0)
+	/* 3. 擦除 APP 分区并回写备份数据:分块擦除 + 逐块喂狗
+	 *    (自动回滚路径尤其关键:擦到一半被看门狗复位,会变成"回滚-复位"死循环) */
+	if (rt_fota_erase_chunked(app_part, 0, app_part->len) < 0)
 	{
 		LOG_I("Restore: erase [%s] failed.", app_part->name);
 		fota_res = RT_FOTA_PART_ERASE_ERR;
@@ -1421,6 +1731,7 @@ int rt_fota_restore_app_from_df(int consume_backup)
 		}
 
 		pos += read_len;
+		rt_fota_wdt_feed();
 		HMI_WRITE("debug.update.val=%d", (int)(pos * 100 / head.data_len));
 		rt_kprintf("#");
 	}
@@ -1560,6 +1871,12 @@ void rt_fota_thread_entry(void *arg)
 	if (rt_fota_check_upgrade() <= 0)
 		goto __exit_boot_entry;
 
+	/* v1.3.4:重试熔断——同一版本连续失败到上限后不再动 flash,直接跳 APP。
+	 * 否则 upgrade 失败会让 fm_area 永远处于"待升级"状态,每次上电都重跑
+	 * backup(312KB 读+擦+写) + 升级,形成"重启-升级-失败"循环 */
+	if (rt_fota_retry_allow() != RT_TRUE)
+		goto __exit_boot_entry;
+
 	/* enter to upgrade mode */
 	rt_fota_signal_led_mode(led_upgrade_mode);
 
@@ -1573,12 +1890,22 @@ void rt_fota_thread_entry(void *arg)
 	/* Implement upgrade, copy firmware partition to app partition */
 	fota_err = rt_fota_upgrade(RT_FOTA_FM_PART_NAME);
 	if (fota_err != RT_FOTA_NO_ERR)
+	{
+		LOG_I("Upgrade failed(%d), fm_area image kept for retry.", fota_err);
 		goto __exit_boot_entry;
+	}
 
 	/* Update new application verison in RBL file of firmware partition */
 	fota_err = rt_fota_copy_version(RT_FOTA_FM_PART_NAME);	
 	if (fota_err != RT_FOTA_NO_ERR)
+	{
+		LOG_I("Copy version failed(%d), fm_area stays pending upgrade.", fota_err);
 		goto __exit_boot_entry;
+	}
+
+	/* 升级 + 版本对齐都成功:清零熔断计数,下次上电不会再走升级分支 */
+	rt_fota_retry_clear();
+	rt_kprintf("Upgrade done, version[%s] applied.\n", fota_part_head.download_version);
 
 __exit_boot_entry:
 	/* Implement application */
@@ -1633,8 +1960,9 @@ void rt_fota_info(rt_uint8_t argc, char **argv)
     {
             [0]     = "fota probe                       - probe RBL file of partiton",
             [1]     = "fota show partition addr size    - show 'size' bytes starting at 'addr'",
-            [2]     = "fota clone des_part src_part     - clone src partition to des partiton",
-            [3]     = "fota exec                        - execute application program",
+            [2]     = "fota retry [0]                   - show or clear upgrade retry counter",
+            [3]     = "fota clone des_part src_part     - clone src partition to des partiton",
+            [4]     = "fota exec                        - execute application program",
     };
 
 	if (argc < 2)
@@ -1691,6 +2019,12 @@ void rt_fota_info(rt_uint8_t argc, char **argv)
 					}
 					LOG_I("| Algorithm mode     | %*.s |", 11, put_buf);
 					LOG_I("| Firmware version   | %*.s |", 11, fota_part_head.download_version);
+					/* v1.3.4:把 current_version 和"是否需升级"一并打出来。
+					 * 这两个字段不等就会在每次上电触发升级+备份,原来完全看不到 */
+					LOG_I("| Applied version    | %*.s |", 11, fota_part_head.current_version);
+					LOG_I("| Upgrade pending    | %11s |",
+					      (rt_strcmp(fota_part_head.download_version, fota_part_head.current_version) != 0)
+					      ? "YES" : "NO");
 					LOG_I("| Code raw size      | %11d |", fota_part_head.raw_size);
 	                LOG_I("| Code package size  | %11d |", fota_part_head.com_size);
 					LOG_I("| Build Timestamp    | %11d |", *((rt_uint32_t *)(&fota_part_head.fm_time[2])));			
@@ -1738,6 +2072,28 @@ void rt_fota_info(rt_uint8_t argc, char **argv)
 				rt_kprintf("%s partition is not exist!\n", part_name);
 			}
        	}
+		else if (!rt_strcmp(operator, "retry"))
+		{
+			/* v1.3.4:查看/清除升级重试熔断记录。
+			 * fota retry      - 查看连续失败次数与上次尝试的版本
+			 * fota retry 0    - 清零(熔断后想再试一次、或定位问题后强制重试) */
+			rt_fota_retry_load();
+			if (argc < 3)
+			{
+				rt_kprintf("Upgrade retry: cnt=%d/%d, last version=[%s]\n",
+				           (int)fota_retry.cnt, RT_FOTA_UPGRADE_MAX_RETRY, fota_retry.ver);
+				rt_kprintf("Auto upgrade is %s.\n",
+				           (fota_retry.cnt >= RT_FOTA_UPGRADE_MAX_RETRY) ? "DISABLED" : "enabled");
+			}
+			else
+			{
+				fota_retry.cnt = 0;
+				rt_memset(fota_retry.ver, 0, sizeof(fota_retry.ver));
+				rt_fota_wdt_feed();
+				rt_fota_retry_save();
+				rt_kprintf("Upgrade retry record cleared.\n");
+			}
+		}
 		else if (!rt_strcmp(operator, "clone"))
 		{
        		const char *dst_part_name = argv[2];
@@ -1758,7 +2114,8 @@ void rt_fota_info(rt_uint8_t argc, char **argv)
 			else
 			{
 				rt_kprintf("Clone %s partition to %s partition:\n", src_part_name, dst_part_name);
-				if (fal_partition_erase(dst_part, 0, dst_part->len) >= 0)
+				/* 分块擦除 + 逐块喂狗(dst 可能是 512KB NOR,整块擦会撞 IWDG 超时) */
+				if (rt_fota_erase_chunked(dst_part, 0, dst_part->len) >= 0)
 				{
 					int clone_pos = 0;
 					int clone_len = 0, clone_tol_len;
@@ -1784,6 +2141,7 @@ void rt_fota_info(rt_uint8_t argc, char **argv)
 							break;
 						}
 
+						rt_fota_wdt_feed();
 						rt_kprintf("#");
 						clone_pos += clone_len;
 					}

+ 3 - 0
CBD_FOTA_BootLoader/applications/rt_fota.h

@@ -55,3 +55,6 @@ int rt_fota_start_application(void);
 /* v1.3.0 升级回滚接口(main.c 的 uart4 屏幕命令 backupapp / dbg_restore / resetapp 亦使用) */
 int rt_fota_backup_app_to_df(void);
 int rt_fota_restore_app_from_df(int consume_backup);
+
+/* 喂 IWDG(仅在其已被 syswatch 启动时生效):供长耗时 flash 擦/写循环调用 */
+void rt_fota_wdt_feed(void);

+ 1 - 1
CBD_FOTA_BootLoader/applications/sys_config.h

@@ -5,7 +5,7 @@
 
 
 /* RT-FOTA module define */
-#define RT_FOTA_SW_VERSION      "1.3.1"
+#define RT_FOTA_SW_VERSION      "1.3.4"
 
 /* Enable Ymodem OTA */
 #define PKG_USING_YMODEM_OTA

+ 85 - 0
CBD_FOTA_BootLoader/readme.md

@@ -1,3 +1,88 @@
+# 版本说明 2026-10-29(第九次)
+	#define BL_VERSION "1.3.4"
+	#define COMPILE "20261029"
+	1、现场问题:**没有下发升级包,只是断电重启,每次启动都执行 rt_fota_backup_app_to_df 并伴随大量 #**
+	2、根因:升级判定只看 fm_area 里 RBL 头的两个版本字段——
+	   rt_fota_check_upgrade(): download_version != current_version → 判"需升级";
+	   而把 current_version 对齐成 download_version 的 rt_fota_copy_version() 位于
+	   rt_fota_upgrade() **之后**。只要 upgrade 失败(擦写途中被 IWDG 复位、NOR 读写异常等),
+	   copy_version 就不会执行,fm_area 里那个包永远"待升级"——
+	   于是每次上电都重跑完整流程:先 backup 备份 312KB(读一遍+擦 78 扇区+写一遍),
+	   再擦写 312KB。表现为"没触发升级却每次启动都跑备份",断电重启反复发生
+	3、放大因素:原判据用 LOG_D 输出(DBG_LEVEL=DBG_INFO 时不打印),现场完全看不到
+	   "为什么要升级",只能看到 backup 的打印,难以判断
+	4、rt_fota.c:新增升级重试熔断——按版本记录连续失败次数(存 EasyFlash,掉电保持):
+	   同一版本连续失败 3 次后不再自动升级,直接跳转 APP 并打印原因 + LED 回到 shell 节奏;
+	   用户重新下发新包(版本变化)时计数自动归零,无需人工清标志;
+	   EF 记录异常(如被擦成 0xFF 导致 cnt 为垃圾值)按无效记录重置,避免误判永久禁用
+	5、rt_fota.c:rt_fota_check_upgrade() 判据改 LOG_I 并打印两侧版本:
+	   "Application need upgrade: fm_area[x] != app[y]" / "No upgrade: fm_area[x] == app[y]"
+	6、rt_fota.c:upgrade / copy_version 失败时分别打印明确原因
+	   ("Upgrade failed(n), fm_area image kept for retry." / "Copy version failed(n), ..."),
+	   升级完全成功才清熔断计数并打印 "Upgrade done, version[x] applied."
+	7、rt_fota.c:新增 msh 子命令 `fota retry` 查看熔断状态、`fota retry 0` 清零;
+	   `fota probe` 增加 "Applied version"(current_version)与 "Upgrade pending"(YES/NO)两行,
+	   一条命令即可确认"是否被判为需升级、差在哪个版本"
+	8、全量重编 0 失败、0 告警;text 170640 / data 2132 / bss 8600,bin 172772B
+	   (v1.3.3 基线 171232B)
+	9、排查提示:现场若再出现"没升级却跑备份",先执行 `fota probe` 看 Upgrade pending,
+	   再 `fota retry` 看计数;根因是 fm_area 里残留未对齐版本的升级包,
+	   干净的处理是 `fota retry 0` 后再重新下发一次完整升级包(或擦掉 fm_area)
+
+# 版本说明 2026-10-29(第八次)
+	#define BL_VERSION "1.3.3"
+	#define COMPILE "20261029"
+	1、问题:备份/恢复/擦除等长耗时 Flash 操作会把 IWDG 拖到超时,做到一半整机复位。
+	   IWDG 由 syswatch 在启动阶段开启(SYSWATCH_WDT_TIMEOUT=10s、LSI/256 分频),
+	   启动后无法停止,只能靠喂狗续命;而原来这些操作都是"整块"交给 FAL:
+	   fal_partition_erase(df_area, 4KB, 312KB) 在 NOR 上要逐 4KB 扇区擦 78 次,
+	   W25Q 单扇区擦除典型 45ms、最坏 400ms —— 一次调用就是 3.5s(典型)/ 31s(最坏),
+	   中途没有任何喂狗机会。复位后 DR2 还残留 0xDEAD,会再触发回滚,进一步放大问题
+	2、rt_fota.c:新增 rt_fota_wdt_feed(),并导出到 rt_fota.h 供 main.c 复用。
+	   安全约束:只有确认 IWDG 已启动(PR/RLR 非复位值 0)才喂——IWDG 只要写一次 KR
+	   (0xAAAA) 就会启动且无法停止,对"未启动"的 IWDG 喂狗会把一个 10s 看门狗凭空
+	   带进 APP 运行期,造成随机复位。每次读 PR/RLR 判断(单周期),不做一次性缓存,
+	   不受调用时机影响
+	3、rt_fota.c:新增 rt_fota_erase_chunked(),把大块擦除拆成 4KB 分块,每块后喂狗。
+	   chunk=4KB 同时是 NOR 扇区粒度与 onchip 页(2KB)的整数倍,两种介质都安全
+	4、rt_fota_backup_app_to_df():擦头后喂狗;读 CRC 循环、写循环逐块喂狗(喂在
+	   HMI_WRITE 之前,串口屏阻塞发送 78 块累计也有秒级);擦数据区改用分块擦除
+	5、rt_fota_restore_app_from_df():同上(读循环/写循环喂狗,擦 APP 分区改分块)。
+	   自动回滚路径尤其关键——擦到一半被看门狗复位会变成"回滚-复位"死循环
+	6、rt_fota_erase_app_part()(升级擦 APP)、rt_fota_write_app_part()(升级搬运写)、
+	   msh `fota clone`:擦除改分块、循环内喂狗
+	7、main.c:uart4 维护命令 eraseapp / erasedf_area 改分块擦除 + 逐块喂狗
+	   (df_area 512KB NOR 逐扇区擦最坏几十秒,原来一次性调用必然超时)
+	8、全量重编 0 失败、0 告警;text 169100 / data 2132 / bss 8568,bin 171232B
+	   (v1.3.2 基线 170848B)
+
+# 版本说明 2026-10-29(第七次)
+	#define BL_VERSION "1.3.2"
+	#define COMPILE "20261029"
+	1、问题现象:bootloader 内 SFUD/FAL/EasyFlash 全部正常("Find a Winbond flash chip. Size is 4194304 bytes"),
+	   跳转 APP 后 APP 的 SFUD 探测失败——"Read SFDP parameter header information failed" +
+	   "This flash device is not found or not support" → "ERROR: SPI flash probe failed by SPI device spi10";
+	   FAL 中 w25q16m 设备为空,EasyFlash 于是对 3MB 环境区逐个 4KB 扇区"检查 header-格式化-擦-写-读",
+	   每个扇区刷 4 条 assert 失败,启动被拖成分钟级("读参数很慢、APP 起不来")
+	2、根因:原跳转序列 HAL_DeInit()/HAL_RCC_DeInit() 会复位 APB2(含 GPIOA/SPI1/AFIO),
+	   /CS(PA4)、SCK(PA5)、MOSI(PA7) 立刻变成浮空输入;到 APP 里 HAL_SPI_MspInit 重新配置引脚之间
+	   有几十毫秒"悬空窗口",悬空 /CS 被噪声拉低后,悬空时钟线上的毛刺会被 Flash 当成指令打入
+	   (0xB9 深度掉电 / 0x38 QPI 等),此后标准 SPI 读只能得到 0xFF/0x00,与 APP 侧日志完全吻合。
+	   本次日志里跳转前刚做过 78 个 4KB 块(312KB)的 fm_area→app 搬运,Flash 正处在刚被大量写入、
+	   引脚随即悬空的最不利时序上
+	   说明:两工程 drv_spi.c / board.c(HAL_SPI_MspInit) / CS 引脚(PA4) / FAL 移植层 / 分区表完全一致,
+	   APP 侧 SFUD 上限还更低(24MHz→18MHz vs 32MHz),故排除"速度过快"与"驱动不一致"
+	3、rt_fota.c:新增 rt_fota_spi_flash_quiesce(),跳转前(关中断之前,因 rt_spi_* 依赖互斥量/延时)
+	   把芯片恢复到"标准 SPI + 空闲":等状态寄存器 BUSY 清零(最长 1s)→ 0xFF×8 逃逸 QPI/连续读 →
+	   0xAB 释放深度掉电 → 0x66/0x99 器件复位 → 读 JEDEC ID 打印自检:
+	   "SPI flash handover: SR=0x00 JEDEC ID=0xEF4015"(读不到即为总线/芯片已异常)
+	4、rt_fota.c:新增 rt_fota_spi_pins_safe_state(),在 HAL_DeInit()/HAL_RCC_DeInit() 之后
+	   (必须在之后,否则被 APB2 复位冲掉)重新固定引脚:先置 ODR 再改 CRL,PA4 推挽输出高(不选中 Flash),
+	   PA5/PA6/PA7 上拉输入,彻底消除 APP 启动前的悬空窗口;APP 侧 HAL_GPIO_Init 不改 ODR,
+	   因此 /CS 从跳到 APP 到 SFUD 探测全程保持高电平
+	5、rt_fota.c:去掉原来重复调用的第二次 HAL_DeInit()(HAL_DeInit+HAL_RCC_DeInit 各一次即可)
+	6、全量重编 0 失败、0 告警;text 168716 / data 2132 / bss 8560,bin 170848B(v1.3.1 基线 170016B)
+
 # 版本说明 2026-10-13(第六次)
 	#define BL_VERSION "1.3.1"
 	#define COMPILE "20261013"