Browse Source

重大更新

zhunk 1 month atrás
parent
commit
e48d839133

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

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

+ 38 - 0
Application_CBD/.workbuddy/memory/2026-10-07.md

@@ -0,0 +1,38 @@
+# 2026-10-07 工作日志
+
+## 运行时 Ymodem 升级改造(update 指令不重启直进升级)
+- 需求:收到 RTU {"cmd":"update"} 不重启,关闭无关线程后直接 ymodem_ota(1,0);
+  升级期间 uart2 被设为调试口(console/finsh 切到 uart2),全程禁止打印日志
+  (日志字节会混入 Ymodem 固件数据流导致升级失败)。
+- 改动文件:
+  - applications/dtu_uart2.c:update 分支重写 + ota_upgrade_enter()/ota_upgrade
+    线程/uart2_prepare_for_ota();接收线程 suspend 挂起
+  - rt-thread/src/kservice.c:新增 rt_console_mute(),rt_kprintf/rt_kputs 前置判断
+    (代码中 [BZY-OTA-PATCH] 标记)
+  - hmi.c delete_hmi_thread()、sht30_collect.c thread_delete_adc()、
+    sample_mb_master.c delete_mb_thread():改 thread_delete_safe 重试+句柄置空
+  - sys_monitor.c/.h:新增 thread_delete_sysmonitor()
+- 关键设计决策:
+  - 不写 EF update_flag(仅 RAM 置1 供发送线程退出),防止下次开机误入第二次升级
+  - uart2 停干净:USART2 外设 FORCE/RESET → rt_device_close → 清 ACTIVATED
+    (否则 DMA 继续写已释放接收缓冲;下次 open 重走 init→HAL_UART_Init)
+  - 参考 control.c 的 RTU_Power_Off_Safe 思路,但不切 RTU 供电(升级文件经 RTU 转发)
+  - OTA 用独立 4KB 栈线程执行(避免叠加在 DTU 接收线程 2560 栈上)
+  - WDT 10s→25s(NorFlash 擦除期间空闲线程无法喂狗,防擦除阶段误复位)
+  - ymodem 失败/30s 无握手都会复位回正常固件(update_flag 未写 Flash)
+- 构建结果(gcc 6.3.1):text 245076 / data 2476 / bss 39884,链接零警告;
+  较上一版 text +720B(新增逻辑开销)。
+
+## 本机 CLI 构建方法(重要,踩坑记录)
+- 项目工具链 = arm-none-eabi-gcc 6.3.1,路径:
+  D:\RT-ThreadStudio\repo\Extract\ToolChain_Support_Packages\ARM\GNU_Tools_for_ARM_Embedded_Processors\6.3.1\bin
+- 坑1:直接 `make.exe all` 会解析到 F:\ToolChain\gcc-arm-none-eabi-10.3(该 10.3 与
+  RT-Thread 4.0.2 的 libc_signal.h 冲突,报 siginfo_t/sigval 重定义);在 PowerShell 里
+  前置 PATH 对 make 子进程无效(子进程拿到的是另一套 PATH,F:\ToolChain 依旧生效)。
+  make 3.81 与 BuildTools 4.2.1 都如此;env 的 make 会经 sh/MSYS 执行 recipe。
+- 绕过法(已验证可行):
+  1) `make.exe -n all` 导出完整命令清单(含编译/链接/objcopy/size 全量展开);
+  2) 逐条把行首 `arm-none-eabi-gcc` 换成 6.3.1 全路径,PowerShell 里用
+     `& $gcc @tokens`(tokens = 去引号后按空白切分)执行;
+  3) 工作目录=Debug,链接行/objcopy 行原样执行即可。
+- 产物:Debug/Application_CBD.bin(247552B,可烧录)+ Debug/Application_CBD.elf。

+ 133 - 0
Application_CBD/.workbuddy/memory/2026-10-08.md

@@ -0,0 +1,133 @@
+# 2026-10-08 工作日志
+
+## 版本号递增 + Readme 同步(承接 2026-10-07 的运行时 OTA 改动)
+- control.h 版本号(按用户确认的"全部 +1"):
+  - VERSION_HK 1.72.41(HK) → **1.73.41(HK)**
+  - VERSION_HK_2000W 1.72.40(2000W) → **1.73.40(2000W)**
+  - VERSION_ZP 1.72.1(ZP) → **1.73.1(ZP)**
+  - VERSION_GK 1.72.1(GK) → **1.73.1(GK)**
+  - VERSION_BZY(孢子仪)2.60 → **2.61**
+  - 三色光源(LAMP_EN=1)与 DZ 定制分支保持独立序列,未改动。
+- 重新构建(gcc 6.3.1):10 个文件重编(beep/control/dtu_uart2/hmi/main/param_mirror/
+  sample_mb_master/selfcheck/sht30_collect/sys_monitor)+ 链接 + objcopy,全部成功、链接零警告。
+  text 245084 / data 2476 / bss 39884(较 1.72.41 版 text +8B,仅版本字符串差异)。
+- 版本化镜像副本(按 readme 惯例):
+  - bin/Application_CBD-1.73.41-20261008.bin(247560B)
+  - Debug/Application_CBD-1.73.41-20261008.elf
+  - bin/ 里 2022 年的旧镜像 Application_CBD-1.47.41-20221128.bin 保留未动。
+- doc/readme.md 顶部条目补齐:版本 define 块 + 版本变更说明 + 新编译信息 + 镜像路径。
+
+## sys_monitor 取消后台线程,改为控制台命令(上午追加)
+- 需求:sys_monitor 不再在线程中运行,只在控制台输入指令后输出。
+- 改动:
+  - sys_monitor.c 重构:删除 sys_monitor_thread_entry / Sys_Motor_Task() / tid_sys_monitor /
+    thread_delete_sysmonitor();新增 sys_monitor_refresh()(现场采集 CPU 温度/利用率/max/
+    uptime,均非阻塞)与 MSH 命令 Msh_DisplaySysMonitor(手动输出全部统计);
+  - sys_monitor.h:上述两个函数声明替换为 sys_monitor_refresh();
+  - hmi.c:启动流程删除 Sys_Motor_Task() 调用;
+  - dtu_uart2.c:upload_sys_monitor_info() 上报前调用 sys_monitor_refresh()(保证平台
+    cpu_tempture/cpu_usage/system_uptime 字段新鲜);OTA 关闭线程列表移除"系统监控"项。
+- 构建(6.3.1):5 个文件重编 + 链接零警告;text 243752 / data 2468 / bss 39884
+  (较前版 text -1332B)。
+- 镜像覆盖更新(版本保持 1.73.41):bin/Application_CBD-1.73.41-20261008.bin(246220B)、
+  Debug/Application_CBD-1.73.41-20261008.elf。
+- readme:新增 2026-10-08 条目(说明版本不变、OTA 列表变化、cpu_usage_max 语义微调)。
+
+## DTU 发送线程重构(定时器周期上报 + 掉电检测移入 ADC 模块)
+- 需求:dtu_thread_entry_send 不区分联网状态;周期上报改定时器执行;掉电检测与
+  预警上报放到 ADC 模块(系统带备用电池)。
+- 改动:
+  - dtu_uart2.c:删除 net/gps/年份双分支与 num_updata 倒计时;新增 rt_event 事件集 +
+    两个软定时器——"du_report"(周期=dattim 分钟,到点发事件)与 "du_check"(1s:
+    雨控/温控异常提前上报 + RTU 看门狗 2h 无 JSON);回调只发事件,重活由发送线程
+    执行;每次上报后按最新 dattim 重排定时器;新增对外接口 dtu_request_report()
+    (hmi 设置时间处调用,替代原 num_updata=2);OTA 删除发送线程时同步停定时器;
+    事件/定时器对象声明提前到文件前部(delete_safe 引用);s_reporting 标志替代
+    原 num_updata==0 窗口判断(parseDtu 中 Beep 处)。
+  - sht30_collect.c:掉电检测块移入 Power_ReadCheck(电压采样处):<5V 持续 10s
+    (tick 防抖)确认 → power down 预警 → 上报最后一帧 → 5s 后关 Router/RTU;
+    >=12V 恢复;P_THREAD_STACK_SIZE 1536→2560(UpLoad_Data 栈需求)。
+  - hmi.c:num_updata=2 → dtu_request_report()。
+- 构建(6.3.1):7 文件重编 + 链接零警告;text 243496 / data 2468 / bss 39964。
+- 镜像覆盖:bin/Application_CBD-1.73.41-20261008.bin(245964B)。
+- 保留语义:屏幕休眠(上报后10s)、保险丝熔断预警、RTU 看门狗、开机首次上报延时;
+  num_updata 字段不再作倒计时(仅初始化,防 EF 布局变动)。
+
+## 数据上传倒计时 + 每10s周期打印(dtu_uart2.c)
+- 发送线程事件等待由"永久阻塞"改为 1 秒超时:每秒递减 device_status.num_updata
+  (重排定时器时重置为 dattim*60);每 10 秒 LOG_I 打印 "数据上传倒计时:%d S"。
+- 构建(6.3.1):text 243584 / data 2468 / bss 39964;镜像覆盖更新
+  bin/Application_CBD-1.73.41-20261008.bin(246052B)。
+- 现场调整记录:用户已自行收紧 send 线程(上报后 1s 返回、移除屏幕休眠、
+  移除 device_status.power_status);sht30 掉电状态机改为模块内局部变量
+  power_status(初值正常,规避了"开机电压正常误触发 RTU_Power_On_Restore"
+  的隐患);control.c 中 power_status 条件已删除;电压<12V 关外设分支的
+  Color_EN 条件已移除。readme(二)条目已按现状修正。
+
+## sys_monitor 升级为 top 式刷新界面(sys_monitor.c)
+- 需求:类似 linux top——输入命令后自动循环刷新 CPU/RAM/外部Flash/Flash参数/外设/
+  线程/工作状态/工作进度/数据上报进度;刷新间隔可调。
+- 实现要点:
+  - 命令签名 (int argc, char **argv):`top [间隔秒1-60,默认1] [次数,省略=持续]`;
+    MSH_CMD_EXPORT_ALIAS 别名导出 `top`;持续模式按 q/Ctrl+C 退出。
+  - 按键检测:控制台 uart1(INT_RX) 的 rt_device_read 非阻塞轮询(250ms 一次);
+    ANSI `\033[2J\033[H` 清屏原地刷新。
+  - 数据源:cpu_load_average / Get_Temprate / rt_memory_info;SFUD
+    (rt_sfud_flash_find_by_dev_name("MYFLASH16")) 取芯片名/JEDEC/容量/擦除粒度;
+    FAL (fal_get_partition_table / fal_flash_device_find) 取分区表与片内参数;
+    list_thread() 直接调用(extern long list_thread(void));device_status 取
+    工作/上报/外设字段。
+  - 坑:EasyFlash v4(本工程实际编译 ef_env.c)没有 ef_get_env_write_bytes 实现
+    (仅 legacy 文件有,且未参与链接)→ Flash 行已去除"EF 已用"字段。
+- 构建(6.3.1):text 245076 / data 2468 / bss 40004;镜像覆盖
+  bin/Application_CBD-1.73.41-20261008.bin(247544B)。
+- readme(二)条目新增第 5 点。
+
+## 修复:屏幕 Swversion 命令分包误切版本类型(hmi.c)
+- 现象(用户真机日志):"SwversionV43" 心跳间隙出现 "SwversionV4"(伴随
+  DTU_Write:SwversionV4、save),随后完整帧又切回 43(再次 save),
+  版本类型在 43(中端款)与 4(水稻)之间来回翻转、重复写 Flash。
+- 根因:串口分包 + strstr 前缀匹配——"SwversionV4" 是 V41/42/43 的真前缀,
+  残段 "SwversionV4"+"3" 的前段被误判为完整命令。同类隐患:V1 vs V11/V12。
+- 修复:新增 hmi_cmd_match()(完整相等 + 必须以 \r 结尾,兼容 \r\n);
+  V1/V4 两个分支改用它;残段无 \r 被拒绝(丢弃),等屏幕心跳完整帧。
+  其余 Swversion 分支无前缀冲突,保持原样。
+- 构建(6.3.1):text 245180 / data 2468 / bss 40004;镜像覆盖
+  bin/Application_CBD-1.73.41-20261008.bin(247648B)。readme 新增(三)条目。
+- 遗留提示:日志中高频打印(屏幕原始数据 getFullData/SwversionV43、每秒
+  "正在收集...剩余时间"、modbus 每 500ms 的 error+slave data)未处理,
+  用户如需降噪可后续处理。
+
+## JSONRPC 升级指令实现:写 RTC_BKP_DR2=0x5AA5 + 重启(dtu_uart2.c)
+- 需求:JSON(JSONRPC method="update")收到升级指令后,写 RTC_BKP_DR2=0x5AA5,
+  然后重启 MCU(由 bootloader 检测标志后进入升级流程)。
+- 实现(该分支原为空,是用户加的 TODO 注释):
+  使能 PWR/BKP 时钟 + 备份域写访问(DBP) → *(__IO uint16_t*)(BKP_BASE+4*2)=0x5AA5
+  → delay 100ms → rt_hw_cpu_reset()。与 main.c 的 boot_flag(同一寄存器)配对。
+- 构建(6.3.1):text 245356 / data 2468 / bss 40004;镜像覆盖
+  bin/Application_CBD-1.73.41-20261008.bin(247824B)。
+- 待确认:旧协议 {"cmd":"update"} 的"运行时直接 Ymodem"分支是否也统一改为
+  标志+重启(或删除运行时 OTA 逻辑)——用户未明确,保持未动。
+- readme 新增(四)条目。
+
+## 上报 bootloader 版本与编译时间(dtu_uart2.c makeJson)
+- 需求:UpLoad_Data 上报增加 bootloader 版本及编译时间。
+- 数据源确认:BL 工程(CBD_FOTA_BootLoader/main.c:317-318)每次启动写 EF:
+  driver_bl(BL_VERSION)、driver_compile(COMPILE = BL 编译时间)。
+  app 侧 device_status.driver_compile 内存值被 main.c 的 CompileTime 宏覆盖为
+  app 编译时间(屏幕调试页 t4 用)→ 上报必须现读 EF,不能复用内存变量。
+- 实现:makeJson() ext 新增 "blver"/"bltime"(现读 EF driver_bl/driver_compile,
+  局部 64B 缓冲先清零、按 size-1 读,保证字符串安全)。
+- 构建(6.3.1):text 245452 / data 2468 / bss 40004;镜像覆盖
+  bin/Application_CBD-1.73.41-20261008.bin(247920B)。
+- 提示:字段名(blver/bltime)如平台侧需调整,改 makeJson 一处即可。
+- readme 新增(五)条目。
+
+## JSONRPC 升级指令增加回复(dtu_uart2.c)
+- 需求:method=="update" 增加回复(原实现直接写标志重启、无应答)。
+- 实现:重启前先回 {"jsonrpc":"2.0","result":{"message":"success"},"id":请求id}
+  (结构与工程解析 RTU 回复的方式一致;id 从请求回填,缺失/非数字用 1);
+  回复后 delay 500ms 再写 BKP_DR2=0x5AA5 + rt_hw_cpu_reset()。
+  parseDtu 新增 ID 变量(cJSON_GetObjectItem(root,"id"))。
+- 构建(6.3.1):text 245636 / data 2468 / bss 40004;镜像覆盖
+  bin/Application_CBD-1.73.41-20261008.bin(248104B)。readme 新增(六)条目。

+ 26 - 0
Application_CBD/.workbuddy/memory/MEMORY.md

@@ -0,0 +1,26 @@
+# 项目长期约定(IOT_CBD_BZY_CTRL / Application_CBD)
+
+## 版本号(applications/control.h)
+- 版本宏:`VERSION_HK` / `VERSION_HK_2000W` / `VERSION_ZP` / `VERSION_GK` / `VERSION_BZY` /
+  `VERSION_XCT` / `VERSION_Robot`;`CompileTime` 自动取 `__DATE__`/`__TIME__`,不用手改。
+- **递增规则**(用户 2026-10-08 确认):功能改动 → 测报灯系列"中间版本号" +1,例如
+  `1.72.41(HK) → 1.73.41(HK)`、水稻 `1.72.40(2000W) → 1.73.40(2000W)`、
+  转盘/高空 `1.72.1 → 1.73.1`;孢子仪走独立序列 `2.60 → 2.61`。
+  版本号会被平台用于判断升级(`device_status.project` / `driver`),不要随意跳号。
+- 三色光源分支(`LAMP_EN=1`)与 DZ 定制分支(`DZ_260630_1`/`DZ_260623_2`/`DZ_260519`)是独立序列,
+  常规改动时保持不动(当前这几个宏都是 0,即未启用定制)。
+
+## 镜像命名与存放
+- 可烧录镜像:`bin/Application_CBD-<HK版本号>-<YYYYMMDD>.bin`
+- 带符号 elf:`Debug/Application_CBD-<HK版本号>-<YYYYMMDD>.elf`
+- `Debug/Application_CBD.bin` / `.elf` 是每次构建的默认产物名(会被覆盖),版本化副本需另存。
+
+## Readme(doc/readme.md)
+- **最新条目在文件顶部**,底部是 2021 年的老记录;追加新条目时插到最前面,不要覆盖既有内容。
+- 条目格式:标题 → 版本 define 块 → 版本/编译信息(text/data/bss + 镜像路径)→ 说明 → 编号条目。
+- 用户硬性要求:改动代码后必须同步更新该 readme。
+
+## 构建
+- 生产工具链 = arm-none-eabi-gcc 6.3.1(RT-Thread Studio 托管)。
+- CLI 构建方法与踩坑(make 子进程会解析到 F:\ToolChain 的 10.3)见技能 `rtthread-studio-cli-build`。
+- 参考尺寸:1.73.41(2026-10-08)text 245084 / data 2476 / bss 39884。

+ 6 - 35
Application_CBD/applications/control.c

@@ -1981,14 +1981,11 @@ void ResetInit(void)
     }
     }
     if(device_status.version_type!=6&&device_status.version_type!=7)
     if(device_status.version_type!=6&&device_status.version_type!=7)
     {
     {
-        device_status.work_done = 1;
+            device_status.work_done = 1;
            //1.打开路由器供电
            //1.打开路由器供电
-           if(device_status.power_status==1)
-           {
-               ctr_router(ON);
-               //2.打开相机供电
-               ctr_photo(ON);
-           }
+           ctr_router(ON);
+           //2.打开相机供电
+           ctr_photo(ON);
            //3.关闭镇流器
            //3.关闭镇流器
            ctr_lamp(OFF,1);
            ctr_lamp(OFF,1);
            #if LAMP_EN == 1
            #if LAMP_EN == 1
@@ -2083,14 +2080,10 @@ void ResetInit(void)
            #endif
            #endif
     }
     }
     else {
     else {
-        if(device_status.power_status==1)
-        {
             //1.打开路由器供电
             //1.打开路由器供电
             ctr_router(ON);
             ctr_router(ON);
-            ctr_RTU_DTU(ON);
             //2.打开相机供电
             //2.打开相机供电
             ctr_photo(ON);
             ctr_photo(ON);
-        }
         //5.关闭加热
         //5.关闭加热
         //6.关闭补光灯
         //6.关闭补光灯
         if(device_status.photo_ws==0){
         if(device_status.photo_ws==0){
@@ -2668,6 +2661,7 @@ void WorkTask(void)
             }
             }
             while(clt_time>1)
             while(clt_time>1)
             {
             {
+                device_status.collt_status = 1;
                 #if 0//LAMP_EN == 0
                 #if 0//LAMP_EN == 0
                     ctr_Fan_IN(ON);
                     ctr_Fan_IN(ON);
                 #endif
                 #endif
@@ -2709,6 +2703,7 @@ void WorkTask(void)
                     break;
                     break;
                 }
                 }
             }
             }
+            device_status.collt_status = 0;
             clt_time = 1;
             clt_time = 1;
             if(device_status.bat_status == 1 || device_status.temp_status == 1|| device_status.rain_status==1)
             if(device_status.bat_status == 1 || device_status.temp_status == 1|| device_status.rain_status==1)
             {
             {
@@ -2977,30 +2972,6 @@ static void Control_Heat_thread_entry(void *parameter)
             calorstat(device_status.heattime*60);
             calorstat(device_status.heattime*60);
             rt_thread_delay(10000);
             rt_thread_delay(10000);
         }
         }
-        else
-        {
-            LOG_I("Not calorstat!%d",device_status.selfcheck_ws);
-            if(device_status.selfcheck_ws==2)
-            {
-                static int total_seconds = 200;
-                static int current_second = 0;
-                while(current_second <= total_seconds)
-                {
-                    int process = (current_second * 100) / total_seconds;
-                    device_status.process = process / 100.0;
-                    LOG_I("process:%d",process);
-                    HMI_WRITE("selfcheck.s106.val=%d",process);
-                    rt_thread_delay(1000);
-                    current_second++;
-                    if(device_status.selfcheck_ws==0)
-                    {
-                        HMI_WRITE("selfcheck.s106.val=100");
-                        break;
-                    }
-                }
-                HMI_WRITE("selfcheck.s106.val=100");
-            }
-        }
         rt_thread_delay(1000);
         rt_thread_delay(1000);
     }
     }
 }
 }

+ 6 - 6
Application_CBD/applications/control.h

@@ -31,13 +31,13 @@
     #define VERSION_HK_2000W    "1.3led0.40(2000W)"       //水稻
     #define VERSION_HK_2000W    "1.3led0.40(2000W)"       //水稻
 #else
 #else
 #if DZ_260630_1 == 0
 #if DZ_260630_1 == 0
-     #define VERSION_HK          "1.72.41(HK)"            //4.0海康-1200W
+     #define VERSION_HK          "1.73.41(HK)"            //4.0海康-1200W
 #else
 #else
     #define VERSION_HK          "1.72.41(HK-DZ260630_1)"  //4.0海康-1200W
     #define VERSION_HK          "1.72.41(HK-DZ260630_1)"  //4.0海康-1200W
 #endif
 #endif
 #if DZ_260623_2 == 0
 #if DZ_260623_2 == 0
 #if DZ_260630_1 == 0
 #if DZ_260630_1 == 0
-    #define VERSION_HK_2000W    "1.72.40(2000W)"         //4.0水稻
+    #define VERSION_HK_2000W    "1.73.40(2000W)"         //4.0水稻
 #else
 #else
     #define VERSION_HK_2000W    "1.72.40(2000W-DZ260630_1)"         //4.0水稻
     #define VERSION_HK_2000W    "1.72.40(2000W-DZ260630_1)"         //4.0水稻
 #endif
 #endif
@@ -46,15 +46,15 @@
 #endif
 #endif
 #endif
 #endif
 #if DZ_260519 == 0
 #if DZ_260519 == 0
-#define VERSION_ZP          "1.72.1(ZP)"                //1.0转盘
+#define VERSION_ZP          "1.73.1(ZP)"                //1.0转盘
 #else
 #else
 #define VERSION_ZP          "DZ_260519"                 //1.0转盘
 #define VERSION_ZP          "DZ_260519"                 //1.0转盘
 #endif
 #endif
-#define VERSION_GK          "1.72.1(GK)"                //1.0高空
+#define VERSION_GK          "1.73.1(GK)"                //1.0高空
 
 
 #define VERSION_XCT         "1.13.6(HK)"                //吸虫塔-海康
 #define VERSION_XCT         "1.13.6(HK)"                //吸虫塔-海康
 #define VERSION_Robot       "1.0(robot)"                //展厅机器人
 #define VERSION_Robot       "1.0(robot)"                //展厅机器人
-#define VERSION_BZY         "2.60"                      //孢子仪
+#define VERSION_BZY         "2.61"                      //孢子仪
 
 
 #define CompileTime         sprintf(device_status.driver_compile,"%s-%s",__DATE__,__TIME__)              //编译时间,每次更新代码修改
 #define CompileTime         sprintf(device_status.driver_compile,"%s-%s",__DATE__,__TIME__)              //编译时间,每次更新代码修改
 /*********************************************************************/
 /*********************************************************************/
@@ -88,8 +88,8 @@ typedef struct  _packed
     /*测报灯*/
     /*测报灯*/
     uint8_t heat_sw;         //加热开关
     uint8_t heat_sw;         //加热开关
     uint8_t photo_ws;        //拍照
     uint8_t photo_ws;        //拍照
-    uint8_t power_status;    //电源
     uint8_t sun_test;        //光控测测试标志位
     uint8_t sun_test;        //光控测测试标志位
+    uint8_t collt_status;    //收集状态   0-关    1-开
     uint8_t heat_status;     //加热状态   0-关   1-开
     uint8_t heat_status;     //加热状态   0-关   1-开
     uint8_t lamp_status;     //灯管1状态   0-关   1-开
     uint8_t lamp_status;     //灯管1状态   0-关   1-开
     uint8_t lamp1_status;    //灯管2状态   0-关   1-开
     uint8_t lamp1_status;    //灯管2状态   0-关   1-开

+ 347 - 137
Application_CBD/applications/dtu_uart2.c

@@ -57,6 +57,14 @@ struct rx_msg
 static struct rt_semaphore rx_sem;    /* 用于接收消息的信号量 */
 static struct rt_semaphore rx_sem;    /* 用于接收消息的信号量 */
 static struct rt_mutex dtu_write_mutex;  /* DTU写互斥锁,防止多线程串口*/
 static struct rt_mutex dtu_write_mutex;  /* DTU写互斥锁,防止多线程串口*/
 
 
+/* 发送线程的事件集与两个软定时器(周期上报 / 1s检查):
+ * 供 dtu_send_thread_delete_safe() 与 dtu_data_play() 引用,故声明在文件前部 */
+static struct rt_event s_dtu_send_evt;        /* 发送线程事件集 */
+static struct rt_timer s_dtu_report_timer;    /* 周期上报定时器(dattim 分钟) */
+static struct rt_timer s_dtu_check_timer;     /* 1s 检查定时器:异常提前上报 + RTU 通信看门狗 */
+static uint8_t s_dtu_send_inited = 0;         /* 事件集/定时器是否已初始化 */
+static volatile uint8_t s_reporting = 0;      /* 1=正在执行一次上报(等效原 num_updata==0 窗口) */
+
 rt_thread_t dtu_recv_data = RT_NULL;
 rt_thread_t dtu_recv_data = RT_NULL;
 rt_thread_t dtu_send_data = RT_NULL;
 rt_thread_t dtu_send_data = RT_NULL;
 
 
@@ -87,6 +95,9 @@ void dtu_send_thread_delete_safe(void)
     {
     {
         if (thread_delete_safe(&dtu_send_data) == 0)
         if (thread_delete_safe(&dtu_send_data) == 0)
         {
         {
+            /* 线程已删除:停止上报/检查定时器,避免其继续向无人消费的事件集发事件 */
+            rt_timer_stop(&s_dtu_report_timer);
+            rt_timer_stop(&s_dtu_check_timer);
             LOG_I("dtu send thread deleted safely");
             LOG_I("dtu send thread deleted safely");
             return;
             return;
         }
         }
@@ -332,144 +343,187 @@ static void dtu_thread_entry_recv(void *parameter)
     }
     }
 }
 }
 
 
+/* ==================== DTU 周期上报(定时器驱动,2026-10-08 重构) ====================
+ * 本次重构三点:
+ *  1) 不再区分联网状态:原实现按 net/gps/时间分"正常上报"与"等待联网"双分支,
+ *     现统一为一条流程——线程启动后即按周期上报,网侧状态不影响上报节拍;
+ *  2) 周期上报改由软件定时器驱动(周期= dattim 分钟):到点由定时器发事件,
+ *     发送线程收到后执行"readinfo → 1s → UpLoad_Data → 保险丝检测";
+ *     每次上报后按最新 dattim 重排定时器(等效原"上报后重置倒计时"语义);
+ *  3) 掉电检测与预警上报移入 ADC 模块(sht30_collect.c Power_ReadCheck,
+ *     那里本就以 100ms 周期采集电压/电流并做欠压判断)。
+ * 保留项:雨控/温控异常提前上报、RTU 通信看门狗(2小时无JSON断电重启)、
+ *         上报后10秒屏幕休眠、保险丝熔断预警。 */
+#define DTU_EVT_REPORT      (1u << 0)   /* 到点执行一次数据上报 */
+#define DTU_EVT_RTU_WDT     (1u << 1)   /* RTU 通信看门狗超时:断电重启 RTU */
+
+/* 事件集/定时器对象与 s_reporting 的声明在文件前部变量区(供 delete_safe 引用) */
+
+/* 周期上报定时器回调:只发事件,重活留给发送线程 */
+static void dtu_report_timer_cb(void *parameter)
+{
+    rt_event_send(&s_dtu_send_evt, DTU_EVT_REPORT);
+}
+
+/* 1 秒检查定时器回调(运行在软件定时器线程,保持轻量):
+ * ① 雨控/温控进入异常时提前触发一次上报(原每秒检查的 check_i 逻辑,
+ *    仅 0→1 变化时触发一次,恢复正常后重新武装);
+ * ② RTU 通信看门狗:连续 2 小时未收到 JSON 触发 RTU 断电重启(先重置计时
+ *    再发事件,避免每秒反复触发;实际断电/重启动作由发送线程执行)。 */
+static void dtu_check_timer_cb(void *parameter)
+{
+    static uint8_t check_i = 0;
+
+    if(device_status.rain_status==1||device_status.temp_status==1)
+    {
+        if(check_i==0)
+        {
+            check_i = 1;
+            rt_event_send(&s_dtu_send_evt, DTU_EVT_REPORT);
+        }
+    }
+    else {
+        check_i = 0;
+    }
+
+    if(s_last_json_rx_tick != 0)
+    {
+        rt_tick_t elapsed = rt_tick_get() - s_last_json_rx_tick;
+        if(elapsed >= JSON_RX_TIMEOUT_TICK)
+        {
+            s_last_json_rx_tick = rt_tick_get();    /* 先重置,防止反复触发 */
+            rt_event_send(&s_dtu_send_evt, DTU_EVT_RTU_WDT);
+        }
+    }
+}
+
+/* 一次完整上报(在发送线程上下文执行):
+ * 拉取 RTU 状态(readinfo) → 1s(等 RTU 回复刷新设备信息) → 上报数据 → 保险丝熔断检测 */
+static void dtu_periodic_report(void)
+{
+    char *readinfo;
+    char *res_fuse_warn;
+
+    s_reporting = 1;    /* 标记上报窗口(parseDtu 收到同步数据时的提示音沿用此时机) */
+
+    readinfo = makeJson_ReadInfo();
+    DTU_Write("%s",readinfo);
+    rt_free(readinfo);
+    rt_thread_delay(1000);
+    UpLoad_Data();
+
+    if(atoi(device_status.fuse_voltage)<5)
+    {
+        rt_thread_delay(500);
+        static char res[30];
+        sprintf(res, "Fuse is fusing:%s",device_status.fuse_voltage);
+        res_fuse_warn = makeJson_Warn(res,"device");
+        DTU_Write("%s",res_fuse_warn);
+        rt_free(res_fuse_warn);
+    }
+
+    s_reporting = 0;
+}
+
+/* 按最新 dattim 重排周期上报定时器(单位分钟)。
+ * 每次上报后调用:从当前时刻重新计一个完整周期,
+ * 等价于原实现"上报完成后 num_updata = dattim*60"的语义。 */
+static void dtu_report_timer_reload(void)
+{
+    rt_tick_t period;
+
+    if(device_status.dattim==0) device_status.dattim=20;   //数据上传时间间隔设置为0?
+    period = (rt_tick_t)device_status.dattim * 60UL * RT_TICK_PER_SECOND;
+
+    /* 数据上传倒计时初值:距下次周期上报剩余秒数(发送线程每秒递减、每10s打印) */
+    device_status.num_updata = device_status.dattim * 60;
+
+    rt_timer_stop(&s_dtu_report_timer);
+    rt_timer_control(&s_dtu_report_timer, RT_TIMER_CTRL_SET_TIME, &period);
+    rt_timer_start(&s_dtu_report_timer);
+}
+
+/* 外部接口:请求尽快执行一次数据上报(屏幕设置时间后更新 RTU 时间等场景),
+ * 不阻塞调用者;上报完成后定时器会按最新 dattim 自动重排(原实现为 num_updata=2)。 */
+void dtu_request_report(void)
+{
+    if(s_dtu_send_inited == 0)
+    {
+        return;     /* 发送线程尚未初始化(异常路径),忽略本次请求 */
+    }
+    rt_event_send(&s_dtu_send_evt, DTU_EVT_REPORT);
+}
+
 /*入口函数-指令发送*/
 /*入口函数-指令发送*/
 static void dtu_thread_entry_send(void *parameter)
 static void dtu_thread_entry_send(void *parameter)
 {
 {
+    rt_uint32_t recved;
+    rt_uint8_t print_cnt = 0;   /* 倒计时打印节拍(每10s一行) */
+
     if(device_status.iFlag==0){
     if(device_status.iFlag==0){
         backup_param_to_rtu();
         backup_param_to_rtu();
     }else{
     }else{
         recover_param_from_rtu();
         recover_param_from_rtu();
     }
     }
-    device_status.power_status = 1;
     device_status.num_updata = 0;
     device_status.num_updata = 0;
     rt_thread_delay(10000);
     rt_thread_delay(10000);
     /* RTU 通信看门狗从线程启动时开始计时:
     /* RTU 通信看门狗从线程启动时开始计时:
      * 原实现只在“曾经收到过 JSON”后才计时,RTU 完全无输出(波特率错、模块故障)时保护失效 */
      * 原实现只在“曾经收到过 JSON”后才计时,RTU 完全无输出(波特率错、模块故障)时保护失效 */
     s_last_json_rx_tick = rt_tick_get();
     s_last_json_rx_tick = rt_tick_get();
-    static rt_uint16_t wait_i = 0;
-    static rt_uint8_t check_i = 0;
-    static rt_uint8_t power_i = 0;
+
+    /* 开机首次上报(不等联网、不区分联网状态),随后启动周期定时器 */
+    dtu_periodic_report();
+    dtu_report_timer_reload();
+    rt_timer_start(&s_dtu_check_timer);
+
     while(1)
     while(1)
     {
     {
-        if(device_status.update_flag==1) break;
-        time_t now_t;
-        time(&now_t);
-        static struct tm now_tm;   //现在
-        //获取当前时间戳
-        now_tm =*localtime(&now_t);
-        if(atoi(device_status.net)==0||atoi(device_status.gps)==1||(now_tm.tm_year+1900 >=2024))    //当前时间大于2024
+        rt_err_t evt_ret;
+
+        /* 1 秒超时用于维护数据上传倒计时与周期打印;有事件时立即唤醒处理 */
+        evt_ret = rt_event_recv(&s_dtu_send_evt,
+                                DTU_EVT_REPORT | DTU_EVT_RTU_WDT,
+                                RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                                rt_tick_from_millisecond(1000), &recved);
+        if (evt_ret == -RT_ETIMEOUT)
         {
         {
-                if(device_status.rain_status==1||device_status.temp_status==1)
-                {
-                    if(check_i==0)
-                    {
-                        check_i = 1;
-                        device_status.num_updata = 0;
-                    }
-                }
-                else {
-                    check_i = 0;
-                }
-                if(device_status.num_updata!=0)
-                {
-                    device_status.num_updata--;
-                    //屏幕休眠
-                    if(device_status.num_updata==(device_status.dattim * 60-10))
-                    {
-                        HMI_WRITE("sleep=%d",1);
-                    }
-                    LOG_I("掉电检测:%d-%d",atoi(device_status.voltage),device_status.power_status);
-                    //检测到电源掉电
-                    if(atoi(device_status.voltage)<5&&device_status.power_status==1)
-                    {
-                        power_i++;
-                        //确定网络状态
-                        if(power_i==10)
-                        {
-                            device_status.bat_status = 1;
-                            rt_sprintf(device_status.net, "1");
-                            HMI_WRITE("sleep=%d",1);    //屏幕休眠
-                            DTU_Write("%s",makeJson_Warn("power down","power"));
-                            device_status.power_status = 0;
-                            rt_thread_delay(1000);
-                            UpLoad_Data();
-                            rt_thread_delay(5000);
-                            ctr_router(OFF);
-                            RTU_Power_Off_Safe();
-                            power_i = 0;
-                        }
-                    }
-                    if(atoi(device_status.voltage)>=12&&device_status.power_status==0)      //电压正常
-                    {
-                        device_status.power_status = 1;
-                        ctr_router(ON);
-                        RTU_Power_On_Restore();
-                        power_i = 0;
-                    }
-                }
-                else {
-                    char *readinfo =  makeJson_ReadInfo();
-                    DTU_Write("%s",readinfo);
-                    rt_free(readinfo);
-                    rt_thread_delay(1000);
-                    UpLoad_Data();
-                    if(atoi(device_status.fuse_voltage)<1)
-                    {
-                        rt_thread_delay(500);
-                        static char res[30];
-                        sprintf(res, "Fuse is fusing:%s",device_status.fuse_voltage);
-                        char * res_fuse_warn = makeJson_Warn(res,"device");
-                        DTU_Write("%s",res_fuse_warn);
-                        rt_free(res_fuse_warn);
-                    }
-                    device_status.num_updata = device_status.dattim * 60;
-                    if(device_status.dattim==0) device_status.dattim=20;   //数据上传时间间隔设置为0?
-                    if(device_status.bat_status==0) device_status.power_status = 1;     //解除欠压,清除标志位
-                }
-        }
-    else {
-            wait_i ++;
-            LOG_I("wait connect internet......%d",wait_i);
-            //检测到电源掉电
-            if(atoi(device_status.voltage)<5&&device_status.power_status==1&&wait_i>200)
+            /* 数据上传倒计时:距下次周期上报的剩余秒数,每秒递减;
+             * 每 10 秒打印一次,便于真机观察上报节拍 */
+            if(device_status.num_updata > 0)
             {
             {
-                check_i++;
-                LOG_W("断网状态下检测到设备断电!%d",atoi(device_status.voltage));
-                if(check_i==10)
-                {
-                    device_status.bat_status = 1;
-                    device_status.power_status = 0;
-                    rt_thread_delay(5000);
-                    ctr_router(OFF);
-                    RTU_Power_Off_Safe();
-                    check_i = 0;
-                }
+                device_status.num_updata--;
             }
             }
-            if(Read_Real_Voltage()/100>=12&&device_status.power_status==0)
+            if(++print_cnt >= 10)
             {
             {
-                check_i = 0;
-                LOG_W("电源恢复正常,打开路由器和RTU供电!");
-                device_status.power_status = 1;
-                //打开路由器和RTU供电
-                ctr_router(ON);
-                RTU_Power_On_Restore();
+                print_cnt = 0;
+                LOG_I("数据上传周期:%d 分 倒计时:%d S",device_status.dattim,(int)device_status.num_updata);
             }
             }
+            continue;
         }
         }
-        /* 看门狗:检测是否连续2小时未收到JSON数据 */
-        if(s_last_json_rx_tick != 0) {
-            rt_tick_t elapsed = rt_tick_get() - s_last_json_rx_tick;
-            if(elapsed >= JSON_RX_TIMEOUT_TICK) {
-                LOG_W("连续2小时未收到JSON数据,执行RTU断电重启...");
-                RTU_Power_Off_Safe();
-                LOG_I("RTU已断电,等待60秒后重新上电...");
-                rt_thread_mdelay(60000);   /* 保持断电60秒,确保电容放完 */
-                LOG_I("60秒等待结束,重新恢复RTU供电...");
-                RTU_Power_On_Restore();
-                s_last_json_rx_tick = rt_tick_get();  /* 重置计时,防止反复触发 */
-                LOG_I("RTU断电重启完成");
-            }
+        if (evt_ret != RT_EOK)
+        {
+            continue;
+        }
+
+        /* RTU 通信看门狗超时:断电重启 RTU(动作与原实现一致) */
+        if(recved & DTU_EVT_RTU_WDT)
+        {
+            LOG_W("连续2小时未收到JSON数据,执行RTU断电重启...");
+            RTU_Power_Off_Safe();
+            LOG_I("RTU已断电,等待60秒后重新上电...");
+            rt_thread_mdelay(60000);   /* 保持断电60秒,确保电容放完 */
+            LOG_I("60秒等待结束,重新恢复RTU供电...");
+            RTU_Power_On_Restore();
+            s_last_json_rx_tick = rt_tick_get();  /* 重置计时,防止反复触发 */
+            LOG_I("RTU断电重启完成");
+        }
+
+        /* 数据上报(周期到点 或 异常/外部请求触发) */
+        if(recved & DTU_EVT_REPORT)
+        {
+            dtu_periodic_report();
+            dtu_report_timer_reload();
         }
         }
-        rt_thread_mdelay(1000);
     }
     }
 }
 }
 
 
@@ -521,6 +575,14 @@ int dtu_data_play(void)
      * 会重置正在使用的互斥锁;懒初始化可保证只初始化一次。 */
      * 会重置正在使用的互斥锁;懒初始化可保证只初始化一次。 */
     /* 初始化信号量 */
     /* 初始化信号量 */
     rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
     rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
+    /* 初始化发送线程的事件集与两个软定时器(周期上报 / 1s检查),
+     * 对象先于线程创建,保证 dtu_request_report() 等外部调用时序安全 */
+    rt_event_init(&s_dtu_send_evt, "dtu_send", RT_IPC_FLAG_FIFO);
+    rt_timer_init(&s_dtu_report_timer, "du_report", dtu_report_timer_cb, RT_NULL,
+                  RT_TICK_PER_SECOND, RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER);
+    rt_timer_init(&s_dtu_check_timer, "du_check", dtu_check_timer_cb, RT_NULL,
+                  RT_TICK_PER_SECOND, RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER);
+    s_dtu_send_inited = 1;
     /* 设置接收回调函数 */
     /* 设置接收回调函数 */
     rt_device_set_rx_indicate(dtuserial, dtu_input);
     rt_device_set_rx_indicate(dtuserial, dtu_input);
     /*创建线程-指令发送*/
     /*创建线程-指令发送*/
@@ -1283,7 +1345,12 @@ void recover_param_from_rtu(void)
 void upload_sys_monitor_info(void)
 void upload_sys_monitor_info(void)
 {
 {
     char value_str[32];
     char value_str[32];
-    cJSON* proot = cJSON_CreateObject();
+    cJSON* proot;
+
+    /* 现场刷新 CPU温度/利用率/运行时长(原 sys_monitor 后台线程已取消,2026-10-08) */
+    sys_monitor_refresh();
+
+    proot = cJSON_CreateObject();
     if (proot == NULL) {
     if (proot == NULL) {
         LOG_E("Error: Failed to create JSON object\n");
         LOG_E("Error: Failed to create JSON object\n");
         return;
         return;
@@ -1418,10 +1485,6 @@ char * makeJson()
         device_status._lamp = 0;
         device_status._lamp = 0;
     }
     }
 
 
-
-
-
-
     if(atoi(device_status.power)>5000)
     if(atoi(device_status.power)>5000)
     {
     {
         rt_sprintf(device_status.power,"0.01");
         rt_sprintf(device_status.power,"0.01");
@@ -1489,6 +1552,18 @@ char * makeJson()
     cJSON_AddItemToObject(pJsonRoot, "ext", pSubJson);
     cJSON_AddItemToObject(pJsonRoot, "ext", pSubJson);
     cJSON_AddStringToObject(pSubJson, "dver", device_status.driver);        //版本号,字符型
     cJSON_AddStringToObject(pSubJson, "dver", device_status.driver);        //版本号,字符型
     cJSON_AddStringToObject(pSubJson,"proj",device_status.project);         //项目类型
     cJSON_AddStringToObject(pSubJson,"proj",device_status.project);         //项目类型
+    /* bootloader 版本与编译时间上报(blver / bltime):
+     * 由 bootloader 每次启动写入 EF(driver_bl / driver_compile),这里现读 EF。
+     * 注意:device_status.driver_compile 内存值已被 main.c 的 CompileTime 宏覆盖为
+     * app 编译时间(屏幕调试页显示用),不能直接使用,必须从 EF 读取 BL 的。 */
+    {
+        char bl_ver[64]  = {0};
+        char bl_time[64] = {0};
+        ef_get_env_blob("driver_bl", bl_ver, sizeof(bl_ver) - 1, NULL);
+        ef_get_env_blob("driver_compile", bl_time, sizeof(bl_time) - 1, NULL);
+        cJSON_AddStringToObject(pSubJson, "blver", bl_ver);      //bootloader版本
+        cJSON_AddStringToObject(pSubJson, "bltime", bl_time);    //bootloader编译时间
+    }
     //设备类型
     //设备类型
     rt_sprintf(utos, "%d",device_status.dtype);
     rt_sprintf(utos, "%d",device_status.dtype);
     cJSON_AddStringToObject(pSubJson,"dtype",utos);
     cJSON_AddStringToObject(pSubJson,"dtype",utos);
@@ -1764,6 +1839,114 @@ int Parse_Cam_Param(cJSON *param_msg)
     return 0;
     return 0;
 }
 }
 
 
+/* ==================== 运行时 OTA(Ymodem)升级支持 ====================
+ * 需求:收到 {"cmd":"update"} 后不重启,关闭无关线程后直接调用 ymodem_ota(1,0)。
+ * 关键约束:升级时 console/finsh 会被 ymodem_ota 切到 uart2(uart2 被设置成调试口),
+ * 而 uart2 同时是 Ymodem 固件数据通道,因此升级全程"不能打印日志",否则日志
+ * 字节会混入固件数据流导致升级失败。对应措施:
+ *   1) rt_console_mute(1):从进入升级流程起静默全部 rt_kprintf/LOG_x 输出
+ *      (实现见 rt-thread/src/kservice.c);升级结束会复位重启,无需恢复;
+ *   2) 关闭所有会打印日志或写 uart2 的无关线程(工作流程/发送/采集/HMI 等);
+ *   3) 参考 RTU_Power_Off_Safe() 的做法把 uart2 停干净:先复位 USART2 外设停掉
+ *      仍挂着的接收 DMA(避免 close 释放接收缓冲后 DMA 继续写已释放内存),再
+ *      close 并清 ACTIVATED,使 Ymodem 侧重新走完整 open/初始化。
+ *      注意不切断 RTU 供电——升级文件正是经 RTU 转发进入 uart2 的。 */
+extern void rt_console_mute(rt_uint8_t enable);
+extern int  delete_mb_thread(void);              /* 见 sample_mb_master.c */
+
+#define OTA_THREAD_STACK_SIZE       4096
+#define OTA_THREAD_PRIORITY         8
+#define OTA_QUIET_WAIT_MS           2000     /* 静默等待 RTU 最后一帧响应落地 */
+
+static rt_thread_t ota_upgrade_tid = RT_NULL;
+
+/* Ymodem 接收线程入口。
+ * 独立 4KB 栈:避免 ymodem+fal+sfud+SPI 的调用深度叠加在 DTU 接收线程(2560)栈上。 */
+static void ota_upgrade_thread_entry(void *parameter)
+{
+    (void)parameter;
+    rt_thread_mdelay(1000);      /* 等接收线程挂起完成、系统彻底安静 */
+    /* 默认分区(fm_area),与开机升级路径一致;成功/失败内部都会复位重启 */
+    ymodem_ota(1, 0);
+    while (1)                    /* ymodem_ota 正常不返回;兜底挂住等待复位 */
+    {
+        rt_thread_mdelay(1000);
+    }
+}
+
+/* 把 uart2 恢复成"干净未初始化"状态,交给 Ymodem 重新初始化串口 */
+static void uart2_prepare_for_ota(void)
+{
+    if (dtuserial == RT_NULL)
+    {
+        return;
+    }
+    /* 外设复位:停掉接收 DMA 请求,避免 close 释放接收缓冲后 DMA 继续写该内存 */
+    __HAL_RCC_USART2_FORCE_RESET();
+    rt_thread_mdelay(1);
+    __HAL_RCC_USART2_RELEASE_RESET();
+    /* 关闭串口设备(释放接收缓冲并关中断),清 ACTIVATED 让下次 open 重新 init */
+    rt_device_close(dtuserial);
+    dtuserial->flag &= ~RT_DEVICE_FLAG_ACTIVATED;
+}
+
+/* 收到运行时升级指令后的总入口(执行在 DTU 接收线程上下文) */
+static void ota_upgrade_enter(void)
+{
+    rt_device_t wdg;
+    rt_uint32_t wdt_timeout = 25;
+    rt_kprintf("Warning: Ymodem has started! This operator will not recovery.\n");
+    rt_kprintf("Please select the ota firmware file and use Ymodem to send.\n");
+    /* --- 1. 全局静默:从此刻起禁止一切控制台打印(升级期间 uart2 是数据通道)--- */
+    rt_console_mute(1);
+
+    /* --- 2. 置RAM标志让 DTU 发送线程下一轮循环自行退出。
+     *        只改 RAM 不写 Flash:防止升级后再次开机遇 update_flag=1 误入第二次升级 --- */
+    device_status.update_flag = 1;
+
+    /* --- 3. 关闭无关线程(内部均为"判定未挂 IPC 等待再删除+重试"的安全删除)--- */
+    dtu_send_thread_delete_safe();  /* DTU 发送线程:持续向 RTU 发查询并打印 */
+    thread_delete_workloop();       /* 工作流程/工作状态/清扫/加热 4 个线程 */
+    thread_delete_adc();            /* ADC采集/电源检测线程:持续打印采样值 */
+    delete_mb_thread();             /* Modbus 采集线程:打印非常频繁 */
+    delete_hmi_thread();            /* 屏幕收发/电机控制线程:逐帧打印屏幕数据 */
+
+    if (timer_takephoto != RT_NULL) /* 拍照超时定时器回调里有日志 */
+    {
+        rt_timer_stop(timer_takephoto);
+    }
+
+    /* --- 4. 静默等待:确保 RTU 侧在途数据发完、无人再碰 uart2 --- */
+    rt_thread_mdelay(OTA_QUIET_WAIT_MS);
+
+    /* --- 5. 看门狗加长:NorFlash 整片擦除是纯轮询阻塞操作,期间空闲线程无法喂狗,
+     *        10s 超时可能在擦除阶段误复位;放大到 25s(IWDG 硬件上限约 26s)--- */
+    wdg = rt_device_find("wdt");
+    if (wdg != RT_NULL)
+    {
+        rt_device_control(wdg, RT_DEVICE_CTRL_WDT_SET_TIMEOUT, &wdt_timeout);
+    }
+
+    /* --- 6. uart2 停干净,交给 Ymodem --- */
+    uart2_prepare_for_ota();
+
+    /* --- 7. 拉起 Ymodem 接收线程 --- */
+    ota_upgrade_tid = rt_thread_create("ota_upgrade",
+                                       ota_upgrade_thread_entry, RT_NULL,
+                                       OTA_THREAD_STACK_SIZE,
+                                       OTA_THREAD_PRIORITY,
+                                       10);
+    if (ota_upgrade_tid != RT_NULL)
+    {
+        rt_thread_startup(ota_upgrade_tid);
+    }
+    else
+    {
+        /* 理论到不了这里;此时日志已静默,复位回来重新触发即可 */
+        rt_hw_cpu_reset();
+    }
+}
+
 //JSON数据解析
 //JSON数据解析
 int parseDtu(char *json_string)
 int parseDtu(char *json_string)
 {
 {
@@ -1815,6 +1998,7 @@ int parseDtu(char *json_string)
     cJSON* METHOD = NULL;
     cJSON* METHOD = NULL;
     cJSON* PARAMS = NULL;
     cJSON* PARAMS = NULL;
     cJSON* RESULT = NULL;
     cJSON* RESULT = NULL;
+    cJSON* ID = NULL;
     LOG_D("parse:%s\n",json_string);
     LOG_D("parse:%s\n",json_string);
     cJSON *root = cJSON_Parse(json_string);
     cJSON *root = cJSON_Parse(json_string);
     if(!root)
     if(!root)
@@ -1829,6 +2013,7 @@ int parseDtu(char *json_string)
           METHOD = cJSON_GetObjectItem(root,"method");
           METHOD = cJSON_GetObjectItem(root,"method");
           PARAMS = cJSON_GetObjectItem(root,"params");
           PARAMS = cJSON_GetObjectItem(root,"params");
           RESULT = cJSON_GetObjectItem(root,"result");
           RESULT = cJSON_GetObjectItem(root,"result");
+          ID = cJSON_GetObjectItem(root,"id");
           if (JSONRPC != NULL && METHOD != NULL && METHOD->type == cJSON_String) {
           if (JSONRPC != NULL && METHOD != NULL && METHOD->type == cJSON_String) {
               // 使用 strcmp 比较字符串
               // 使用 strcmp 比较字符串
               if (strcmp(METHOD->valuestring, "upgradehmi") == 0) {
               if (strcmp(METHOD->valuestring, "upgradehmi") == 0) {
@@ -1862,6 +2047,27 @@ int parseDtu(char *json_string)
                   }
                   }
               }else if(strcmp(METHOD->valuestring,"systeminfo")==0) {
               }else if(strcmp(METHOD->valuestring,"systeminfo")==0) {
                   upload_sys_monitor_info();
                   upload_sys_monitor_info();
+              }else if(strcmp(METHOD->valuestring,"update")==0) {
+                  /* 先回复 JSONRPC 响应再重启(否则重启后无法应答):
+                   * {"jsonrpc":"2.0","result":{"message":"success"},"id":请求id}
+                   * 该结构与本工程解析 RTU 回复的方式一致(result.message)。 */
+                  char *tmp = makeJson_Warn("system will update","control");
+                  if(tmp!=RT_NULL){
+                      DTU_Write("%s",tmp);
+                      rt_free(tmp);
+                      LOG_W("收到升级指令:已回复success,写BKP_DR2=0x5AA5,重启进入升级!");
+                      /* 修改RTC备份寄存器(DR2=0x5AA5),然后重启MCU:
+                       * bootloader 检测到该标志后进入升级流程。
+                       * 位置与 main.c 中读取/清除的 boot_flag 为同一寄存器
+                       * (BKP_BASE + 4*2 = RTC_BKP_DR2)。写 BKP 前需使能
+                       * PWR/BKP 时钟与备份域写访问(DBP)。 */
+                      __HAL_RCC_PWR_CLK_ENABLE();
+                      __HAL_RCC_BKP_CLK_ENABLE();
+                      HAL_PWR_EnableBkUpAccess();
+                      *(__IO uint16_t *)(BKP_BASE + 4 * 2) = 0x5AA5;
+                      rt_thread_delay(500);     /* 等回复报文发出后再重启 */
+                      rt_hw_cpu_reset();
+                  }
               }
               }
               else{
               else{
                   LOG_W("未知的命令: %s", METHOD->valuestring);
                   LOG_W("未知的命令: %s", METHOD->valuestring);
@@ -2247,13 +2453,24 @@ int parseDtu(char *json_string)
             }
             }
               else if (strstr(item_cmd->valuestring,"update")!=RT_NULL)
               else if (strstr(item_cmd->valuestring,"update")!=RT_NULL)
               {
               {
-                  LOG_W("启动升级!!!");
+                  /* 运行时直接进入 Ymodem 升级(不再先重启):
+                   * 1) 先通知 RTU/平台即将升级,并等其完成最后一次交互;
+                   * 2) ota_upgrade_enter() 关闭无关线程、全局静默日志、把 uart2
+                   *    停干净后拉起 Ymodem 接收线程;
+                   * 3) 本接收线程随即挂起,uart2 完全交给 Ymodem。
+                   * 注意:升级时 uart2 被设置成调试口(console+Ymodem 数据通道),
+                   * 升级全程不能打印任何日志,否则会破坏固件数据流。 */
+                  LOG_W("启动升级(运行时进入Ymodem,不重启)!!!");
                   DTU_Write("%s",makeJson_Warn("system will update","control"));
                   DTU_Write("%s",makeJson_Warn("system will update","control"));
                   rt_thread_delay(2000);
                   rt_thread_delay(2000);
-                  device_status.update_flag = 1;
-                  ef_set_env_blob("update_flag", &device_status.update_flag, sizeof(device_status.update_flag));;
-                  rt_thread_delay(1000);
-                  rt_hw_cpu_reset();
+                  ota_upgrade_enter();
+                  /* 挂起本接收线程:避免其继续 read uart2 抢占 Ymodem 数据 */
+                  rt_thread_suspend(rt_thread_self());
+                  while(1)
+                  {
+                      /* 兜底:若被意外唤醒则空转,等 ymodem 完成后复位 */
+                      rt_thread_mdelay(1000);
+                  }
               }
               }
               else if (strstr(item_cmd->valuestring,"read")!=RT_NULL)
               else if (strstr(item_cmd->valuestring,"read")!=RT_NULL)
               {
               {
@@ -2577,22 +2794,15 @@ int parseDtu(char *json_string)
                       safe_copy_str(device_status.mqttcfg2, sizeof(device_status.mqttcfg2), mqttcfg2->valuestring, "mqttcfg2");
                       safe_copy_str(device_status.mqttcfg2, sizeof(device_status.mqttcfg2), mqttcfg2->valuestring, "mqttcfg2");
                       LOG_I("当前平台2:%s",device_status.mqttcfg2);
                       LOG_I("当前平台2:%s",device_status.mqttcfg2);
                   }
                   }
-                  if( device_status.num_updata==0)
+                  /* s_reporting=1 等效原 num_updata==0 的上报窗口:该窗口内的同步数据只提示,
+                   * 窗口外若屏幕请求过数据刷新(hmi_fresh==2)则补发一次上报 */
+                  if( s_reporting==1 )
                   {
                   {
                       Beep_Tip(100);
                       Beep_Tip(100);
                   }
                   }
-                  else if(device_status.num_updata!=0&&device_status.hmi_fresh==2)
+                  else if(device_status.hmi_fresh==2)
                   {
                   {
                       UpLoad_Data();
                       UpLoad_Data();
-//                      if(strstr(device_status.project,"A7_DTU_V3")!=RT_NULL)
-//                      {
-//
-//                      }
-//                      else
-//                      {
-//                          rt_thread_delay(2000);
-//                          UpLoad_Data();
-//                      }
                   }
                   }
                   device_status.hmi_fresh = 0;
                   device_status.hmi_fresh = 0;
                   }
                   }

+ 2 - 0
Application_CBD/applications/dtu_uart2.h

@@ -31,6 +31,8 @@ typedef struct{
 extern rt_device_t dtuserial;
 extern rt_device_t dtuserial;
 
 
 void dtu_send_data_start(void);
 void dtu_send_data_start(void);
+/* 请求尽快执行一次数据上报(屏幕设置时间后更新 RTU 时间等场景;不阻塞调用者) */
+void dtu_request_report(void);
 
 
 //查询数据---{"cmd": "read"}
 //查询数据---{"cmd": "read"}
 //重启-------{"cmd": "reboot"}
 //重启-------{"cmd": "reboot"}

+ 46 - 47
Application_CBD/applications/hmi.c

@@ -436,6 +436,26 @@ void Stop_timer_Uart2(void)
 }
 }
 
 
 /***************************** 解析从屏幕收到的数据 begin **********************************/
 /***************************** 解析从屏幕收到的数据 begin **********************************/
+/* ==================== 屏幕命令严格匹配(2026-10-08 修复) ====================
+ * 屏幕命令以 \r 结尾(见 Hmi_thread_entry 中说明),但串口按包分段:
+ * 一条 "SwversionV43" 可能被拆成 "SwversionV4" + "3" 两段先后到达。
+ * 原实现用 strstr() 前缀包含匹配,前段 "SwversionV4" 会误命中"水稻"分支,
+ * 把 version_type 错误切换(并误报 RTU、重复写 Flash、随后完整帧又切回,
+ * 配置来回翻转,日志表现为 SwversionV4/save/SwversionV43/save 连环)。
+ * 本函数要求:命令字完整相等,且其后紧跟 \r(完整帧结束符,兼容 \r\n);
+ * 分包残段没有 \r,会被拒绝,等屏幕后续完整帧(心跳重发)正常处理。
+ * 用法:替换存在"短命令是长命令前缀"关系的分支(SwversionV1/V4)。 */
+static rt_bool_t hmi_cmd_match(const char *buf, const char *cmd)
+{
+    size_t n = rt_strlen(cmd);
+
+    if (rt_strncmp(buf, cmd, n) != 0)
+    {
+        return RT_FALSE;
+    }
+    return (buf[n] == '\r') ? RT_TRUE : RT_FALSE;
+}
+
 static void HMI_Decode(void)
 static void HMI_Decode(void)
 {
 {
     time_t now = time(RT_NULL);
     time_t now = time(RT_NULL);
@@ -444,7 +464,7 @@ static void HMI_Decode(void)
     char *json_temp;
     char *json_temp;
     char *var=NULL;
     char *var=NULL;
     if(device_status.refresh_num==0)  device_status.refresh_num = 10;
     if(device_status.refresh_num==0)  device_status.refresh_num = 10;
-    if(strstr(rx_buffer,"getFullData") != NULL){
+    if(strstr(rx_buffer,"SwversionV") != NULL || strstr(rx_buffer,"getFullData") != NULL){
         char *readinfo =  makeJson_ReadInfo();
         char *readinfo =  makeJson_ReadInfo();
         if(device_status.refresh_num==5)
         if(device_status.refresh_num==5)
         {
         {
@@ -679,12 +699,9 @@ static void HMI_Decode(void)
             HMI_WRITE("rtc3=%d",tm.tm_hour);
             HMI_WRITE("rtc3=%d",tm.tm_hour);
             HMI_WRITE("rtc4=%d",tm.tm_min);
             HMI_WRITE("rtc4=%d",tm.tm_min);
             HMI_WRITE("rtc5=%d",tm.tm_sec);
             HMI_WRITE("rtc5=%d",tm.tm_sec);
-
             //更新熄屏时间
             //更新熄屏时间
             HMI_WRITE("thsp=%d",device_status.thsp);
             HMI_WRITE("thsp=%d",device_status.thsp);
         }
         }
-
-
         /**********************************************************************/
         /**********************************************************************/
     }
     }
     else if (strstr(rx_buffer,"getClockData")!=NULL) {
     else if (strstr(rx_buffer,"getClockData")!=NULL) {
@@ -1035,8 +1052,8 @@ static void HMI_Decode(void)
                     set_time(atoi(hour_s),atoi(min_s),atoi(sec_s));
                     set_time(atoi(hour_s),atoi(min_s),atoi(sec_s));
                     MA_save();
                     MA_save();
                 }
                 }
-                //上传最新数据
-                device_status.num_updata = 2;  //2秒后上报数据更新RTU的时间
+                //上传最新数据(立即触发一次上报更新RTU/平台时间;原为 num_updata=2 延时2秒上报)
+                dtu_request_report();
             }
             }
             else {
             else {
                 LOG_E("set_date failed!");
                 LOG_E("set_date failed!");
@@ -1532,7 +1549,9 @@ static void HMI_Decode(void)
         return;
         return;
     }
     }
     //1.0
     //1.0
-    else if (strstr(rx_buffer,"SwversionV1")!=NULL)
+    /* 注意:必须用严格匹配——"SwversionV1" 是 "SwversionV11/12" 的前缀,
+     * 串口分包时残段会误切到本分支(同 V4 的问题,见 hmi_cmd_match 说明) */
+    else if (hmi_cmd_match(rx_buffer,"SwversionV1"))
     {
     {
         if(device_status.version_type != 1)
         if(device_status.version_type != 1)
         {
         {
@@ -1599,7 +1618,12 @@ static void HMI_Decode(void)
         return;
         return;
     }
     }
     //水稻
     //水稻
-    else if (strstr(rx_buffer,"SwversionV4")!=NULL) {
+    /* 注意:必须用严格匹配——"SwversionV4" 是 "SwversionV41/42/43" 的前缀。
+     * 实测(2026-10-08):串口分包时 "SwversionV43" 的前段 "SwversionV4" 会误切到
+     * 本分支(version_type 43→4、误报 RTU、写 Flash),随后完整帧又切回 43,
+     * 造成配置来回翻转。见 hmi_cmd_match 说明。 */
+    else if (hmi_cmd_match(rx_buffer,"SwversionV4"))
+    {
         device_status.dtype = 3;
         device_status.dtype = 3;
         if(device_status.version_type != 4)
         if(device_status.version_type != 4)
         {
         {
@@ -1607,7 +1631,6 @@ static void HMI_Decode(void)
             sprintf(device_status.driver, "%s",VERSION_HK_2000W);
             sprintf(device_status.driver, "%s",VERSION_HK_2000W);
             ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
             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));        //版本类型
             ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
-            DTU_Write("SwversionV4");
             MA_save();
             MA_save();
             param_mirror_sync();
             param_mirror_sync();
         }
         }
@@ -1701,10 +1724,6 @@ static void HMI_Decode(void)
     //屏幕上触发远程升级
     //屏幕上触发远程升级
     else if (strstr(rx_buffer,"hmi_update")!=NULL) {
     else if (strstr(rx_buffer,"hmi_update")!=NULL) {
         DTU_Write("hmi_update");
         DTU_Write("hmi_update");
-        device_status.update_flag = 1;
-        ef_set_env_blob("update_flag", &device_status.update_flag, sizeof(device_status.update_flag));
-        rt_thread_delay(2000);
-        rt_hw_cpu_reset();
     }else if (strstr(rx_buffer,"checkcamera")!=NULL){
     }else if (strstr(rx_buffer,"checkcamera")!=NULL){
         DTU_Write("{\"ctr_cam\":\"checkcamera\"}");
         DTU_Write("{\"ctr_cam\":\"checkcamera\"}");
         //校准屏幕的RTC
         //校准屏幕的RTC
@@ -2022,11 +2041,11 @@ void Check_ParamConfig(void)
     if(easyflash_init()==EF_NO_ERR) //初始化成功
     if(easyflash_init()==EF_NO_ERR) //初始化成功
     {
     {
         ef_get_env_blob("reboot_time", &device_status.rebootcnt, sizeof(device_status.rebootcnt), NULL); //读出reboot_time的值
         ef_get_env_blob("reboot_time", &device_status.rebootcnt, sizeof(device_status.rebootcnt), NULL); //读出reboot_time的值
-        ef_get_env_blob("update_flag", &device_status.update_flag, sizeof(device_status.update_flag), NULL); //读出updateflag的值
         ef_get_env_blob("iSave", &device_status.iSave, sizeof(device_status.iSave), NULL); //判断是否用户配置了程序
         ef_get_env_blob("iSave", &device_status.iSave, sizeof(device_status.iSave), NULL); //判断是否用户配置了程序
         device_status.rebootcnt++;
         device_status.rebootcnt++;
         ef_set_env_blob("reboot_time", &device_status.rebootcnt, sizeof(device_status.rebootcnt));
         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);
+        LOG_I("rebootcnt:%d",device_status.rebootcnt);
+        LOG_I("iSave:%d",device_status.iSave);
     }
     }
     else {
     else {
         LOG_E("easyflash init ERRPR!!!");
         LOG_E("easyflash init ERRPR!!!");
@@ -2074,8 +2093,6 @@ void Check_ParamConfig(void)
         device_status.passWord = 8888;    //屏幕密码
         device_status.passWord = 8888;    //屏幕密码
         device_status.dattim = 10;      //数据上传间隔
         device_status.dattim = 10;      //数据上传间隔
         device_status.ds = 1;           //设备状态
         device_status.ds = 1;           //设备状态
-        device_status.update_flag = 0;
-
         device_status.heat_sw =0;
         device_status.heat_sw =0;
         device_status.cul_time = 1;
         device_status.cul_time = 1;
         device_status.run_sta = 0;
         device_status.run_sta = 0;
@@ -2274,35 +2291,13 @@ void Check_ParamConfig(void)
         LOG_I("handle_bugger:%d",device_status.handle_bugger);
         LOG_I("handle_bugger:%d",device_status.handle_bugger);
         LOG_W("heat_sw加热开关:%d",device_status.heat_sw);
         LOG_W("heat_sw加热开关:%d",device_status.heat_sw);
     }
     }
-    //RTC时间判断,如果当前年份小于2020,提示需要设置时间,切换为光控
-    if(device_status.update_flag==1||device_status.update_flag==2)
-    {
-        if(device_status.update_flag==1){
-            device_status.update_flag = 0;
-            ef_set_env_blob("update_flag", &device_status.update_flag, sizeof(device_status.update_flag));
-            ymodem_ota(1,0);
-        }else{
-            device_status.update_flag = 0;
-            ef_set_env_blob("update_flag", &device_status.update_flag, sizeof(device_status.update_flag));
-            // 准备参数
-            static char *args[] = {
-                "ymodem_ota",
-                "-p",
-                "hmi_area"
-            };
-            // 调用
-            ymodem_ota(3, args);
-        }
 
 
-    }
-    else
     {
     {
         device_status.update_flag = 0;
         device_status.update_flag = 0;
         //初始化联网状态
         //初始化联网状态
         rt_sprintf(device_status.net,"1");
         rt_sprintf(device_status.net,"1");
         rt_sprintf(device_status.csq,"0");
         rt_sprintf(device_status.csq,"0");
         rt_sprintf(device_status.sim,"1");
         rt_sprintf(device_status.sim,"1");
-        Sys_Motor_Task();
         ctr_router(ON);
         ctr_router(ON);
         Hmi_Fresh();
         Hmi_Fresh();
         #if Color_EN == 1
         #if Color_EN == 1
@@ -2358,8 +2353,7 @@ void Check_ParamConfig(void)
             if(connect_num>5) break;
             if(connect_num>5) break;
         }
         }
         if(device_status.version_type==6) device_status.timeSwitch = 1;
         if(device_status.version_type==6) device_status.timeSwitch = 1;
-        if(device_status.update_flag==0)
-            DTU_Write("%s",makeJson_Warn("turnon", "device_stm32"));
+        DTU_Write("%s",makeJson_Warn("turnon", "device_stm32"));
         rt_thread_delay(1000);
         rt_thread_delay(1000);
         dtu_send_data_start();
         dtu_send_data_start();
 #endif
 #endif
@@ -2560,14 +2554,19 @@ void app_partion_backup(void)
 
 
 int delete_hmi_thread(void)
 int delete_hmi_thread(void)
 {
 {
+    int32_t try_cnt;
+
     LOG_W("delete_hmi_thread.");
     LOG_W("delete_hmi_thread.");
-    if(ctr_motor!=RT_NULL)
-    {
-        rt_thread_delete(ctr_motor);
-    }
-    if(hmi1!=RT_NULL)
+    /* 安全删除:两线程平时阻塞在收消息/延时上,若恰好处于 IPC 等待则稍后重试,
+     * 避免 rt_thread_delete 造成 IPC 等待链表野指针(见 control.c 说明)。
+     * 删除成功后 thread_delete_safe 会把句柄置空,便于后续按需重建。 */
+    for (try_cnt = 0; try_cnt < 30; try_cnt++)
     {
     {
-        rt_thread_delete(hmi1);
+        if (thread_delete_safe(&ctr_motor) == 0 && thread_delete_safe(&hmi1) == 0)
+        {
+            break;
+        }
+        rt_thread_mdelay(50);
     }
     }
     return 0;
     return 0;
 }
 }

+ 10 - 6
Application_CBD/applications/sample_mb_master.c

@@ -45,13 +45,17 @@ extern SHORT usMRegHoldBuf[MB_MASTER_TOTAL_SLAVE_NUM][M_REG_HOLDING_NREGS];
 
 
 int delete_mb_thread(void)
 int delete_mb_thread(void)
 {
 {
-    if(tid1!=NULL)
-    {
-        rt_thread_delete(tid1);
-    }
-    if(tid2!=NULL)
+    int32_t try_cnt;
+
+    /* 安全删除:若线程恰好挂在 IPC 等待链表上则稍后重试,
+     * 避免 rt_thread_delete 造成 IPC 等待链表野指针(见 control.c 说明) */
+    for (try_cnt = 0; try_cnt < 30; try_cnt++)
     {
     {
-        rt_thread_delete(tid2);
+        if (thread_delete_safe(&tid1) == 0 && thread_delete_safe(&tid2) == 0)
+        {
+            break;
+        }
+        rt_thread_mdelay(50);
     }
     }
     return 0;
     return 0;
 }
 }

+ 63 - 23
Application_CBD/applications/sht30_collect.c

@@ -16,6 +16,7 @@
 #include "hmi.h"
 #include "hmi.h"
 #include "math.h"
 #include "math.h"
 #include "sys_monitor.h"
 #include "sys_monitor.h"
+#include "dtu_uart2.h"
 #define DBG_ENABLE
 #define DBG_ENABLE
 #define DBG_COLOR
 #define DBG_COLOR
 #define DBG_TAG "control"
 #define DBG_TAG "control"
@@ -29,10 +30,14 @@
 //电压,电流
 //电压,电流
 #define P_THREAD_PRIORITY       13      //线程优先级
 #define P_THREAD_PRIORITY       13      //线程优先级
 /* 栈大小:本线程使用浮点格式化(snprintf %.2f)与 atof,newlib 浮点链
 /* 栈大小:本线程使用浮点格式化(snprintf %.2f)与 atof,newlib 浮点链
- * (_svfprintf_r+_dtoa_r+_Balloc+_calloc_r / _strtod_r) 需要数百字节栈,
- * 1024 字节时最坏链路占用率约 83%,这里增大到 1536 字节留出余量。 */
-#define P_THREAD_STACK_SIZE     1536    //栈大小
+ * (_svfprintf_r+_dtoa_r+_Balloc+_calloc_r / _strtod_r) 需要数百字节栈;
+ * 2026-10-08 掉电上报逻辑移入本线程后,掉电时还需调用 UpLoad_Data()
+ * (cJSON 构造 + 串口发送链路),栈需求与 DTU 发送线程相当,这里增大到
+ * 2560 字节(与 DTU_THREAD_STACK_SIZE 一致)。 */
+#define P_THREAD_STACK_SIZE     2560    //栈大小
 #define P_THREAD_TIMESCLICE     5       //时间片
 #define P_THREAD_TIMESCLICE     5       //时间片
+/* 掉电检测:电压<5V 持续该时长后确认掉电(原 DTU 发送线程为 10 次 1s 计数) */
+#define POWER_DOWN_CONFIRM_TICK (10 * RT_TICK_PER_SECOND)
 //ADC
 //ADC
 #define ADC_DEV_NAME "adc1"     /*ADC设备名称*/
 #define ADC_DEV_NAME "adc1"     /*ADC设备名称*/
 #define ADC_DEV_CHANNLE_0 0     /*ADC通道*///电流
 #define ADC_DEV_CHANNLE_0 0     /*ADC通道*///电流
@@ -141,7 +146,7 @@ static void adc_collect_thread_entry(void *parameter)
     static uint8_t handle_rain = 0;
     static uint8_t handle_rain = 0;
     static uint8_t prework_state = 0;
     static uint8_t prework_state = 0;
     static uint32_t prework_timer = 0;
     static uint32_t prework_timer = 0;
-    static uint8_t clean_count = 0; 
+    static uint8_t clean_count = 0;
     while (1)
     while (1)
     {
     {
         log_cnt ++;
         log_cnt ++;
@@ -273,6 +278,7 @@ static void Power_ReadCheck(void *parameter)
         /* 分配失败时退化为直接采样,不能直接崩溃/退出(否则欠压保护会失效) */
         /* 分配失败时退化为直接采样,不能直接崩溃/退出(否则欠压保护会失效) */
         LOG_E("moving average filter alloc failed, fallback to raw adc value!");
         LOG_E("moving average filter alloc failed, fallback to raw adc value!");
     }
     }
+    uint8_t power_status = 0;
     rt_thread_mdelay(1000);
     rt_thread_mdelay(1000);
     while(1)
     while(1)
     {
     {
@@ -292,17 +298,11 @@ static void Power_ReadCheck(void *parameter)
                     ctr_led(OFF);   //关闭补光灯
                     ctr_led(OFF);   //关闭补光灯
                     ctr_Heat(OFF);  //关闭加热
                     ctr_Heat(OFF);  //关闭加热
                     ctr_Cold(OFF);  //关闭制冷
                     ctr_Cold(OFF);  //关闭制冷
-                    #if Color_EN == 0
                     ctr_cangmen_down(OFF);  //关闭下仓门输出(转盘)
                     ctr_cangmen_down(OFF);  //关闭下仓门输出(转盘)
                     ctr_cangmen_up(OFF);    //关闭上仓门输出(散热)
                     ctr_cangmen_up(OFF);    //关闭上仓门输出(散热)
-                    #endif
                 }
                 }
         if(atof(device_status.voltage)<22.0)    //小于22.0V,并且持续10S,欠压
         if(atof(device_status.voltage)<22.0)    //小于22.0V,并且持续10S,欠压
         {
         {
-            #if ROBOT_EN == 1
-            ctr_led(OFF);
-            HMI_WRITE("sleep=%d",1);
-            #endif
             bat_cnt++;
             bat_cnt++;
         }else if(atof(device_status.voltage)>24.0)    //大于24.0V,解除欠压
         }else if(atof(device_status.voltage)>24.0)    //大于24.0V,解除欠压
         {
         {
@@ -310,12 +310,6 @@ static void Power_ReadCheck(void *parameter)
             device_status.bat_status = 0; //解除欠压
             device_status.bat_status = 0; //解除欠压
             ctr_router(ON);               //打开路由器供电
             ctr_router(ON);               //打开路由器供电
             ctr_photo(ON);                //打开相机供电
             ctr_photo(ON);                //打开相机供电
-        #if ROBOT_EN == 1
-            ctr_led(ON);        //打开补光灯
-            ctr_lamp(ON, 1);    //打开镇流器输出,用于24V转12V给相机供电
-            ctr_router(ON);
-            HMI_WRITE("sleep=%d",0);
-        #endif
         }
         }
         //
         //
         if(device_status.dtype==7)
         if(device_status.dtype==7)
@@ -402,6 +396,48 @@ static void Power_ReadCheck(void *parameter)
                         Read_Fuse_Voltage()/100, Read_Fuse_Voltage()%100);
                         Read_Fuse_Voltage()/100, Read_Fuse_Voltage()%100);
         }
         }
         #endif
         #endif
+        /* ---- 掉电检测与预警上报(2026-10-08 由 DTU 发送线程移入 ADC 模块)----
+         * 系统带备用电池:主电源掉电(电压<5V)持续 10s 确认 → 发 "power down" 预警
+         * 并上报最后一帧数据,5s 后关闭路由器与 RTU 供电(MCU 由备用电池维持);
+         * 电压恢复到 >=12V 时恢复供电。防抖用 tick 比较,不受本线程实际循环
+         * 周期影响(原实现 power_i 计数不清零会跨事件累积,这里恢复即清零)。 */
+        {
+            static rt_tick_t power_down_tick = 0;   /* 首次检测到低电压的时刻(0=未检测到) */
+
+            if(atoi(device_status.voltage)<5&&power_status==0)
+            {
+                if(power_down_tick==0)
+                {
+                    power_down_tick = rt_tick_get();
+                }
+                else if((rt_tick_get() - power_down_tick) >= POWER_DOWN_CONFIRM_TICK)
+                {
+                    power_down_tick = 0;
+                    LOG_W("掉电检测确认:电压:%s,切换备用电池供电!",device_status.voltage);
+                    device_status.bat_status = 1;
+                    rt_sprintf(device_status.net, "1");
+                    HMI_WRITE("sleep=%d",1);    /* 屏幕休眠 */
+                    DTU_Write("%s",makeJson_Warn("power down","power"));    /* 掉电预警上报 */
+                    power_status = 1;
+                    rt_thread_delay(1000);
+                    UpLoad_Data();              /* 上报最后一帧完整数据 */
+                    rt_thread_delay(5000);
+                    ctr_router(OFF);            /* 关闭路由器供电 */
+                    RTU_Power_Off_Safe();       /* 关闭 RTU 供电(MCU 由备用电池维持) */
+                }
+            }
+            else {
+                power_down_tick = 0;
+            }
+
+            if(atoi(device_status.voltage)>=12&&power_status==1)      //电压正常
+            {
+                LOG_W("电源恢复正常,打开路由器和RTU供电!");
+                power_status = 0;
+                ctr_router(ON);
+                RTU_Power_On_Restore();
+            }
+        }
         rt_thread_mdelay(10);
         rt_thread_mdelay(10);
     }
     }
     moving_average_filter_free(filter);
     moving_average_filter_free(filter);
@@ -459,7 +495,7 @@ int Read_Real_Voltage(void)
     adc0_value = adc_read_median(adc_dev, ADC_DEV_CHANNLE_0);
     adc0_value = adc_read_median(adc_dev, ADC_DEV_CHANNLE_0);
     /* 关闭通道 */
     /* 关闭通道 */
     rt_adc_disable(adc_dev, ADC_DEV_CHANNLE_0);
     rt_adc_disable(adc_dev, ADC_DEV_CHANNLE_0);
-    return  (adc0_value * REFER_VOLTAGE/CONVERT_BITS*12+20);
+    return  (adc0_value * REFER_VOLTAGE/CONVERT_BITS*12);
 }
 }
 /*读取保险丝的电压值*/
 /*读取保险丝的电压值*/
 int Read_Fuse_Voltage(void)
 int Read_Fuse_Voltage(void)
@@ -688,14 +724,18 @@ int sht30_collect(void)
 
 
 int thread_delete_adc(void)
 int thread_delete_adc(void)
 {
 {
+    int32_t try_cnt;
+
     LOG_W("退出ADC采集线程...");
     LOG_W("退出ADC采集线程...");
-    if(tid1!=RT_NULL)
+    /* 安全删除:两线程若恰好挂在 IPC 等待链表上则稍后重试,
+     * 避免 rt_thread_delete 造成 IPC 等待链表野指针(见 control.c 说明) */
+    for (try_cnt = 0; try_cnt < 30; try_cnt++)
     {
     {
-        rt_thread_delete(tid1);
-    }
-    if(tid2!=RT_NULL)
-    {
-        rt_thread_delete(tid2);
+        if (thread_delete_safe(&tid1) == 0 && thread_delete_safe(&tid2) == 0)
+        {
+            break;
+        }
+        rt_thread_mdelay(50);
     }
     }
     return 0;
     return 0;
 }
 }

+ 259 - 54
Application_CBD/applications/sys_monitor.c

@@ -6,85 +6,290 @@
  * Change Logs:
  * Change Logs:
  * Date           Author       Notes
  * Date           Author       Notes
  * 2026-02-04     Administrator       the first version
  * 2026-02-04     Administrator       the first version
+ * 2026-10-08     Administrator       取消后台 sys_monitor 线程(避免每 10s 自动刷屏):
+ *                                    统计改为"用到时现场采集";新增控制台命令
+ *                                    Msh_DisplaySysMonitor 手动输出全部统计
+ * 2026-10-08     Administrator       命令升级为类似 linux top 的界面:循环刷新
+ *                                    CPU/RAM/外部Flash/分区/上报进度/工作状态/外设/
+ *                                    线程等;刷新间隔可调(命令参数),按 q 退出
  */
  */
 #include "sys_monitor.h"
 #include "sys_monitor.h"
 #include "cpu_usage.h"
 #include "cpu_usage.h"
 #include "control.h"
 #include "control.h"
 #include "sht30_collect.h"
 #include "sht30_collect.h"
+#include <rtdevice.h>
+#include <fal.h>
+#include <spi_flash_sfud.h>
+#include <stdlib.h>
+#include <time.h>
 #define DBG_ENABLE
 #define DBG_ENABLE
 #define DBG_COLOR
 #define DBG_COLOR
 #define DBG_TAG "sysmonitor"
 #define DBG_TAG "sysmonitor"
 #define DBG_LEVEL         DBG_LOG
 #define DBG_LEVEL         DBG_LOG
 #include <rtdbg.h> //must after of DBG_LVL, DBG_TAG or other options
 #include <rtdbg.h> //must after of DBG_LVL, DBG_TAG or other options
 
 
-rt_thread_t tid_sys_monitor = RT_NULL;
+extern long list_thread(void);   /* rt-thread/components/finsh/cmd.c:内核线程列表 */
 
 
 Device_Status_typedef device_status;
 Device_Status_typedef device_status;
 System_stats_t system_status;
 System_stats_t system_status;
 
 
+/* 刷新实时统计字段(原 sys_monitor 线程的职责,2026-10-08 改为"用到时现场采集")。
+ * 调用点:①控制台命令 top / Msh_DisplaySysMonitor;②upload_sys_monitor_info() 上报前。
+ * CPU 温度 = 读 MCU 内部温度传感器、CPU 利用率 = 读 idle 统计、运行时长 = 系统 tick,
+ * 均为非阻塞快速操作,可在任意线程上下文安全调用。 */
+void sys_monitor_refresh(void)
+{
+    system_status.cpu_tempture = (int)Get_Temprate()/100;
+    system_status.cpu_usage   = (int)cpu_load_average();
+    if(system_status.cpu_usage > system_status.cpu_usage_max)
+    {
+        system_status.cpu_usage_max = system_status.cpu_usage;
+    }
+    system_status.system_uptime = (rt_uint32_t)(rt_tick_get() / RT_TICK_PER_SECOND);
+}
 
 
-static void sys_monitor_thread_entry(void *parameter)
+/* ==================== top 式系统监控命令 ==================== */
+#define SYS_MON_DEF_INTERVAL_SEC    1       /* 默认刷新间隔(秒) */
+#define SYS_MON_MAX_INTERVAL_SEC    60      /* 刷新间隔上限(秒) */
+#define SYS_MON_KEY_SLICE_MS        250     /* 等待刷新点时按键检查粒度 */
+
+/* 绘制一屏监控信息:
+ * CPU(利用率/温度/运行时长)、RAM(堆)、外部Flash参数、FAL分区表、数据上报进度、
+ * 工作状态与进度、外设设备状态、通信/报警状态、线程状态(list_thread)。 */
+static void sys_mon_show_screen(void)
 {
 {
-    uint8_t sec_t;
-    system_status.lamp_start_time = 0;
-    system_status.heat_start_time = 0;
-    while(1)
+    rt_uint32_t total = 0, used = 0, max_used = 0;
+    rt_uint32_t total_sec;
+    time_t now;
+    static struct tm tm_buf;
+    int i;
+    size_t part_num = 0;
+    const struct fal_partition *part_table;
+    const struct fal_flash_dev *onchip;
+    sfud_flash_t nor;
+
+    /* 清屏并回到左上角(VT100 序列,Xshell/MobaXterm/secureCRT 等终端均支持) */
+    rt_kprintf("\033[2J\033[H");
+
+    /* ---- 头部:时间 ---- */
+    now = time(RT_NULL);
+    tm_buf = *localtime(&now);
+    rt_kprintf("================ 系统监控 [q:退出] ================\n");
+    rt_kprintf("时间: %04d-%02d-%02d %02d:%02d:%02d\n",
+               tm_buf.tm_year + 1900, tm_buf.tm_mon + 1, tm_buf.tm_mday,
+               tm_buf.tm_hour, tm_buf.tm_min, tm_buf.tm_sec);
+
+    /* ---- CPU ---- */
+    total_sec = (rt_uint32_t)(rt_tick_get() / RT_TICK_PER_SECOND);
+    system_status.system_uptime = total_sec;
+    system_status.cpu_usage = (int)cpu_load_average();
+    if(system_status.cpu_usage > system_status.cpu_usage_max)
+    {
+        system_status.cpu_usage_max = system_status.cpu_usage;
+    }
+    system_status.cpu_tempture = (int)Get_Temprate()/100;
+    rt_kprintf("[CPU] 利用率:%d%% (峰值:%d%%)  温度:%dC  运行:%d时%d分%d秒\n",
+               system_status.cpu_usage, system_status.cpu_usage_max,
+               system_status.cpu_tempture,
+               total_sec / 3600, (total_sec % 3600) / 60, total_sec % 60);
+
+    /* ---- RAM(堆) ---- */
+    rt_memory_info(&total, &used, &max_used);
+    if (total > 0)
     {
     {
-        sec_t++;
-        system_status.cpu_usage = (int)cpu_load_average();
-        if(system_status.cpu_usage>system_status.cpu_usage_max){
-            system_status.cpu_usage_max = system_status.cpu_usage;
+        rt_kprintf("[RAM] 已用:%u.%uKB / %uKB (%u%%)  峰值:%u.%uKB\n",
+                   (unsigned)(used / 1024), (unsigned)((used % 1024) * 10 / 1024),
+                   (unsigned)(total / 1024), (unsigned)(used * 100 / total),
+                   (unsigned)(max_used / 1024), (unsigned)((max_used % 1024) * 10 / 1024));
+    }
+    else
+    {
+        rt_kprintf("[RAM] 堆信息不可用\n");
+    }
+
+    /* ---- 外部 Flash 参数(SFUD) ---- */
+    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",
+                   nor->name, nor->chip.name,
+                   (unsigned)(nor->chip.capacity / 1024),
+                   (unsigned)(nor->chip.erase_gran),
+                   nor->chip.mf_id, nor->chip.type_id, nor->chip.capacity_id);
+    }
+    else
+    {
+        rt_kprintf("[Flash] 外部:%s 未找到(未初始化?)\n", FAL_USING_NOR_FLASH_DEV_NAME);
+    }
+    onchip = fal_flash_device_find("onchip_flash");
+    if (onchip != RT_NULL)
+    {
+        rt_kprintf("        片内:%s 容量:%uKB 块:%uKB\n",
+                   onchip->name,
+                   (unsigned)(onchip->len / 1024),
+                   (unsigned)(onchip->blk_size / 1024));
+    }
+
+    /* ---- FAL 分区表(外部 Flash 使用分布) ---- */
+    part_table = fal_get_partition_table(&part_num);
+    if (part_table != RT_NULL)
+    {
+        for (i = 0; i < (int)part_num; i++)
+        {
+            rt_kprintf("%s %-9s @%-13s 起址:%6uK  大小:%5uK\n",
+                       (i == 0) ? "[分区]" : "      ",
+                       part_table[i].name, part_table[i].flash_name,
+                       (unsigned)(part_table[i].offset / 1024),
+                       (unsigned)(part_table[i].len / 1024));
         }
         }
-        rt_tick_t tick = rt_tick_get();
-        rt_uint32_t total_sec = (rt_uint32_t)(tick / RT_TICK_PER_SECOND);
-        system_status.system_uptime = total_sec;
-        system_status.cpu_tempture = (int)Get_Temprate()/100;
-        rt_uint32_t hours   = total_sec / 3600;
-        rt_uint32_t minutes = (total_sec % 3600) / 60;
-        rt_uint32_t seconds = total_sec % 60;
-        rt_thread_delay(1000);
-        if(sec_t%10==0){
-            LOG_D("CPU温度:%d℃",system_status.cpu_tempture);
-            LOG_D("CPU利用率 :%d% Max:%d%",system_status.cpu_usage,system_status.cpu_usage_max);
-            LOG_D("系统运行时长:%d时%d分%d秒",hours,minutes,seconds);
-            LOG_D("重启次数:%d",device_status.rebootcnt);
-
-            LOG_D("串口2累计发送字节:%d",system_status.uart2_tx_bytes);
-            LOG_D("串口2累计接收字节:%d",system_status.uart2_rx_bytes);
-
-            LOG_D("串口4累计发送字节:%d",system_status.uart4_tx_bytes);
-            LOG_D("串口4累计接收字节:%d",system_status.uart4_rx_bytes);
-
-            LOG_D("累计上传数据:%d 条",system_status.json_upload_count);
-            LOG_D("累计拍照次数:%d ",system_status.photo_taken_count);
-            LOG_D("累计清扫次数:%d ",system_status.cleaning_count);
-            LOG_D("累计震动次数:%d ",system_status.vibration_count);
-
-            LOG_D("上仓门累计打开:%d ",system_status.upper_door_open_count);
-            LOG_D("上仓门累计关闭:%d ",system_status.upper_door_close_count);
-            LOG_D("下仓门累计打开:%d ",system_status.lower_door_open_count);
-            LOG_D("下仓门累计关闭:%d ",system_status.lower_door_close_count);
-
-            LOG_D("灯管累计运行:%d S",system_status.lamp_running_time/RT_TICK_PER_SECOND);
-            LOG_D("加热累计运行:%d S",system_status.heater_running_time/RT_TICK_PER_SECOND);
-            LOG_D("雨控触发值:%d",system_status.rain_value);
-            LOG_D("雨控触发次数:%d",system_status.rain_control_triggers);
+    }
+
+    /* ---- 数据上报进度 ---- */
+    rt_kprintf("[上报] 距下次上传:%us (间隔:%umin)  累计上传:%u 次  RTU: rx:%u tx:%u B\n",
+               (unsigned)device_status.num_updata, (unsigned)device_status.dattim,
+               (unsigned)system_status.json_upload_count,
+               (unsigned)system_status.uart2_rx_bytes,
+               (unsigned)system_status.uart2_tx_bytes);
+
+    /* ---- 工作状态与进度 ---- */
+    rt_kprintf("[工作] 状态:%s [开关机]:%s workdone:%d | 收集[%s]:%umin 加热[%s]:%dmin | 光:%d 雨:%d 温:%d 欠压:%d\n",
+               (device_status.work_status == 1) ? "工作中" : "待机",
+               (device_status.ds == 1) ? "开机" : "关机",
+               device_status.work_done,
+               (device_status.collt_status == 1) ? "开" : "关",
+               device_status.clt_time,
+               (device_status.heat_status == 1) ? "开" : "关",
+               device_status.heattime,
+               device_status.sun_status, device_status.rain_status,
+               device_status.temp_status, device_status.bat_status);
+
+    /* ---- 外设(关键设备的打开状态) ---- */
+    {
+        static const char *dev_names[] = {"uart1", "uart2", "uart4", "uart5",
+                                          "adc1", "wdt", "rtc", "spi10"};
+        rt_kprintf("[外设] ");
+        for (i = 0; i < (int)(sizeof(dev_names) / sizeof(dev_names[0])); i++)
+        {
+            rt_device_t dev = rt_device_find(dev_names[i]);
+            if (dev == RT_NULL)
+            {
+                rt_kprintf("%s:NA ", dev_names[i]);
+            }
+            else
+            {
+                rt_kprintf("%s:%s ", dev_names[i], (dev->ref_count > 0) ? "开" : "关");
+            }
         }
         }
+        rt_kprintf("\n");
     }
     }
+
+    /* ---- 通信与报警状态 ---- */
+    rt_kprintf("[状态] net:%s csq:%s sim:%s | 485:%d RTU启动:%d |[报警] 相机:%d 加热:%d 补光:%d\n",
+               device_status.net, device_status.csq, device_status.sim,
+               device_status.sensor_485_sta, device_status.rtu_isboot,
+               device_status.camsta, device_status.heat_sta, device_status.led_sta);
+
+    /* ---- 动作统计 ---- */
+    rt_kprintf("[统计] 拍照:%u 清扫:%u 震动:%u | 仓门 上开:%u |上关:%u |下开:%u | 下关:%u\n",
+               (unsigned)system_status.photo_taken_count,
+               (unsigned)system_status.cleaning_count,
+               (unsigned)system_status.vibration_count,
+               (unsigned)system_status.upper_door_open_count,
+               (unsigned)system_status.upper_door_close_count,
+               (unsigned)system_status.lower_door_open_count,
+               (unsigned)system_status.lower_door_close_count);
+
+    /* ---- 线程状态(复用内核 list_thread 输出) ---- */
+    rt_kprintf("[线程]\n");
+    list_thread();
+
+    rt_kprintf("========== top [间隔秒] [次数] 刷新, 按 q 或 Ctrl+C 退出 ==========\n");
 }
 }
 
 
-int Sys_Motor_Task(void)
+/* 检查控制台是否收到退出按键(q/Q/Ctrl+C)。
+ * 串口 INT_RX 模式下 rt_device_read 为非阻塞:无数据时返回 0,可直接轮询。
+ * 返回 1 表示请求退出;顺带丢弃其它按键,避免残留字符干扰后续 shell 输入。 */
+static int sys_mon_exit_key(void)
 {
 {
-    /* 创建线程*/
-    tid_sys_monitor = rt_thread_create("sys_monitor",
-                                sys_monitor_thread_entry, RT_NULL,
-                                1024,       //2048
-                                28,         //12
-                                5);       //5
-
-    if(tid_sys_monitor!=RT_NULL)
+    rt_device_t console = rt_console_get_device();
+    char ch;
+
+    if (console == RT_NULL)
     {
     {
-        rt_thread_startup(tid_sys_monitor);
+        return 0;
+    }
+    while (rt_device_read(console, 0, &ch, 1) == 1)
+    {
+        if (ch == 'q' || ch == 'Q' || ch == 0x03)   /* 0x03 = Ctrl+C */
+        {
+            return 1;
+        }
     }
     }
     return 0;
     return 0;
 }
 }
+
+/* 控制台命令:top 式系统监控,持续刷新显示。
+ * 用法:Msh_DisplaySysMonitor [刷新间隔秒 1-60,默认1] [刷新次数,省略/0=持续刷新]
+ *       持续刷新模式下按 q(或 Ctrl+C)退出。别名:top
+ * 示例:top          —— 每 1 秒刷新,q 退出
+ *       top 5        —— 每 5 秒刷新,q 退出
+ *       top 2 30     —— 每 2 秒刷新,共 30 次后自动退出 */
+void Msh_DisplaySysMonitor(int argc, char **argv)
+{
+    int interval = SYS_MON_DEF_INTERVAL_SEC;
+    int times = 0;      /* 0=持续刷新 */
+    int count = 0;
+    int exited = 0;
+
+    if (argc >= 2)
+    {
+        interval = atoi(argv[1]);
+        if (interval < 1) interval = 1;
+        if (interval > SYS_MON_MAX_INTERVAL_SEC) interval = SYS_MON_MAX_INTERVAL_SEC;
+    }
+    if (argc >= 3)
+    {
+        times = atoi(argv[2]);
+        if (times < 0) times = 0;
+    }
+
+    while (1)
+    {
+        sys_mon_show_screen();
+        count++;
+        if (times > 0 && count >= times)
+        {
+            break;
+        }
+
+        /* 等待下一个刷新点:分片等待,期间检查退出按键 */
+        {
+            int waited = 0;
+            int total_ms = interval * 1000;
+
+            while (waited < total_ms)
+            {
+                int step = SYS_MON_KEY_SLICE_MS;
+                if ((total_ms - waited) < step)
+                {
+                    step = total_ms - waited;
+                }
+                rt_thread_mdelay(step);
+                waited += step;
+                if (sys_mon_exit_key())
+                {
+                    exited = 1;
+                    break;
+                }
+            }
+        }
+        if (exited)
+        {
+            break;
+        }
+    }
+
+    rt_kprintf("系统监控已退出.\n");
+}
+MSH_CMD_EXPORT(Msh_DisplaySysMonitor, system monitor (top style): [interval_s] [count]);
+MSH_CMD_EXPORT_ALIAS(Msh_DisplaySysMonitor, top, system monitor (top style));

+ 4 - 1
Application_CBD/applications/sys_monitor.h

@@ -69,6 +69,9 @@ typedef struct
 } System_stats_t;
 } System_stats_t;
 
 
 
 
-int Sys_Motor_Task(void);
+/* 刷新实时统计字段(CPU温度/利用率/运行时长)。
+ * 原 sys_monitor 后台线程已取消,现由控制台命令 Msh_DisplaySysMonitor 与
+ * upload_sys_monitor_info() 上报前调用(非阻塞,可任意线程上下文调用)。 */
+void sys_monitor_refresh(void);
 
 
 #endif /* APPLICATIONS_SYS_MONITOR_H_ */
 #endif /* APPLICATIONS_SYS_MONITOR_H_ */

+ 193 - 0
Application_CBD/doc/readme.md

@@ -1,3 +1,196 @@
+# 2026-10-08 更新说明(六:JSONRPC 升级指令增加回复)
+
+		版本:保持 1.73.41;
+		编译:text 245636B / data 2468B / bss 40004B(arm-none-eabi-gcc 6.3.1);
+		可烧录镜像 bin/Application_CBD-1.73.41-20261008.bin(已覆盖更新为含本改动的
+		最终版),带符号 elf 见 Debug/Application_CBD-1.73.41-20261008.elf;链接零警告。
+	1、applications/dtu_uart2.c —— JSONRPC 分支(method=="update")增加回复:
+		设备在写 BKP 标志并重启之前,先回复一条 JSONRPC 响应:
+		{"jsonrpc":"2.0","result":{"message":"success"},"id":<请求id>}
+		① 回复结构与本工程解析 RTU 回复的方式一致(result.message=="success"),
+		   便于 RTU/平台确认设备已接收升级指令;
+		② 请求 id 原样回填(缺失或非数字时用 1);
+		③ 回复发出后延时 500ms 再写 RTC_BKP_DR2=0x5AA5 并重启,确保报文送出。
+# 2026-10-08 更新说明(五:数据上报增加 bootloader 版本与编译时间)
+
+		版本:保持 1.73.41;
+		编译:text 245452B / data 2468B / bss 40004B(arm-none-eabi-gcc 6.3.1);
+		可烧录镜像 bin/Application_CBD-1.73.41-20261008.bin(已覆盖更新为含本改动的
+		最终版),带符号 elf 见 Debug/Application_CBD-1.73.41-20261008.elf;链接零警告。
+	1、applications/dtu_uart2.c —— makeJson()(UpLoad_Data 上报的 data 报文)ext 中
+		新增两个字段:
+		① "blver":bootloader 版本;
+		② "bltime":bootloader 编译时间。
+		数据来源:bootloader 每次启动写入 EF 的 driver_bl / driver_compile
+		(见 CBD_FOTA_BootLoader/main.c),上报时现读 EF 获取。
+	2、说明:device_status.driver_compile 内存值会被 app 的 main.c 中 CompileTime 宏
+		覆盖为 app 编译时间(屏幕调试页显示用),因此上报必须从 EF 读取 BL 的编译时间,
+		不能直接复用该内存变量。
+# 2026-10-08 更新说明(四:JSONRPC 升级指令改为写 RTC_BKP_DR2=0x5AA5 后重启)
+
+		版本:保持 1.73.41;
+		编译:text 245356B / data 2468B / bss 40004B(arm-none-eabi-gcc 6.3.1);
+		可烧录镜像 bin/Application_CBD-1.73.41-20261008.bin(已覆盖更新为含本改动的
+		最终版),带符号 elf 见 Debug/Application_CBD-1.73.41-20261008.elf;链接零警告。
+	1、applications/dtu_uart2.c —— JSONRPC 分支(method=="update")实现(原为空分支):
+		收到升级指令后:
+		① 使能 PWR/BKP 时钟与备份域写访问(HAL_PWR_EnableBkUpAccess,DBP);
+		② 写 RTC_BKP_DR2 = 0x5AA5(BKP_BASE + 4*2,与 main.c 读取/清除的
+		   boot_flag 为同一寄存器);
+		③ rt_hw_cpu_reset() 重启 MCU——由 bootloader 检测该标志后进入升级流程。
+	2、说明:旧协议 {"cmd":"update"}(parseDtu 的 cmd 分支,运行时直接 Ymodem 方式)
+		本次未改动。
+# 2026-10-08 更新说明(三:修复屏幕 Swversion 命令分包误切版本类型)
+
+		版本:保持 1.73.41;
+		编译:text 245180B / data 2468B / bss 40004B(arm-none-eabi-gcc 6.3.1);
+		可烧录镜像 bin/Application_CBD-1.73.41-20261008.bin(已覆盖更新为含本修复的
+		最终版),带符号 elf 见 Debug/Application_CBD-1.73.41-20261008.elf;链接零警告。
+	1、现象(真机日志):"getFullData/SwversionV43" 心跳之间夹杂一条 "SwversionV4"
+		(伴随 DTU_Write:SwversionV4、DTU_Write:save),隔一秒又出现孤立的 "3" 与
+		完整 "SwversionV43"(再次 save)——设备版本类型在"中端款(43)"与"水稻(4)"
+		之间来回翻转,并产生重复 Flash 写入。
+	2、根因:串口按包分段,"SwversionV43" 被拆成 "SwversionV4"(前段)+"3"(后段)
+		先后到达;hmi.c 中版本切换分支用 strstr() 前缀包含匹配,而 "SwversionV4"
+		是 "SwversionV41/42/43" 的真前缀,残段被误判为完整命令 → 误切到水稻分支
+		(version_type 43→4、误报 RTU、写 EF/镜像、MA_save);随后完整帧到达又切回
+		43,再次写 EF。
+	3、修复(applications/hmi.c):
+		① 新增 hmi_cmd_match():要求命令字完整相等且其后紧跟 \r(完整帧结束符,
+		   兼容 \r\n)。分包残段没有 \r,会被拒绝,等屏幕心跳的完整帧正常处理;
+		② 将存在"短命令是长命令前缀"关系的两个分支改为严格匹配:
+		   SwversionV1(是 V11/V12 的前缀)与 SwversionV4(是 V41/42/43 的前缀);
+		③ 其余 Swversion 分支(V43/V42/V41/V12/V11/V6/V30/V7)无前缀冲突,保持原样。
+	4、说明:修复后偶发的分包残段被直接丢弃(不产生任何配置动作),屏幕心跳重发
+		保证最终正常同步;完整帧正常路径不受影响。
+# 2026-10-08 更新说明(二:DTU 周期上报定时器化,掉电检测移入 ADC 模块)
+
+		版本:保持 1.73.41(同一版本内的发布前改动);
+		编译:text 245076B / data 2468B / bss 40004B(arm-none-eabi-gcc 6.3.1);
+		可烧录镜像 bin/Application_CBD-1.73.41-20261008.bin(已覆盖更新为含本改动的
+		最终版),带符号 elf 见 Debug/Application_CBD-1.73.41-20261008.elf;链接零警告。
+	1、applications/dtu_uart2.c —— dtu_thread_entry_send 发送线程重构:
+		① 不再区分联网状态:删除原 if(net==0||gps==1||年份>=2026) 双分支
+		   ("正常上报"与"等待联网"各带一套掉电逻辑的重复实现),统一为一条流程,
+		   线程启动后 10s 即执行首次上报,网侧状态不影响上报节拍;
+		② 周期上报改由软件定时器驱动:新增 rt_timer "du_report"(周期 = dattim 分钟)
+		   与发送线程事件集(rt_event);定时器到点只发事件,线程执行完整上报
+		   (readinfo → 1s → UpLoad_Data → 保险丝熔断检测);每次上报后按最新
+		   dattim 重排定时器(等效原"上报后重置 num_updata 倒计时"语义);
+		③ 新增 1 秒检查软定时器 "du_check",承载原每秒轮询中的两个轻量检查——
+		   雨控/温控异常提前触发上报(原 check_i 逻辑)、RTU 通信看门狗
+		   (连续 2 小时无 JSON → 断电重启 RTU,动作仍由发送线程执行);
+		④ 新增对外接口 dtu_request_report():请求尽快执行一次上报;hmi.c 中屏幕
+		   设置时间后的"num_updata=2 延时 2 秒上报"改为直接调用该接口;
+		⑤ 保留:保险丝熔断预警、开机首次上报延时 10s;上报完成后延时 1s 返回循环
+		   (现场调试已移除原"上报后 10 秒屏幕休眠");
+		⑥ OTA 升级删除发送线程时同步停止两个定时器(dtu_send_thread_delete_safe)。
+	2、applications/sht30_collect.c —— 掉电检测与预警上报移入 ADC 模块
+		(Power_ReadCheck,原本就以 100ms 周期采集电压/电流并做欠压判断),
+		原 DTU 线程内逻辑整体迁入:
+		① 主电源掉电(电压<5V)持续 10s 确认 → bat_status=1、发 "power down" 预警、
+		   屏幕休眠、1s 后上报最后一帧数据、5s 后关闭路由器与 RTU 供电(MCU 由
+		   备用电池维持);电压恢复 >=12V → 恢复供电(ctr_router / RTU_Power_On_Restore);
+		② 防抖改用 tick 比较,不受循环周期影响;恢复即清零(原 power_i 计数不
+		   清零会跨事件累积,属修正);
+		③ 电源检测线程栈 1536→2560(掉电时需调用 UpLoad_Data(),cJSON 构造 +
+		   串口发送链路栈需求与 DTU 线程相当)。
+	3、说明:
+		① 语义微调:屏幕设置时间后的上报由"延时 2 秒"改为"立即触发";
+		② 字段 device_status.num_updata 重新用作数据上传倒计时(重排定时器时重置为
+		   dattim*60 秒、发送线程每秒递减);原"上报窗口"判断由内部标志 s_reporting 承担;
+		③ 掉电检测状态机使用模块内局部变量(开机初值=正常,避免电压正常时误触发
+		   恢复流程);device_status.power_status 字段不再被引用。
+	4、(同日增量)数据上传倒计时与周期打印:发送线程的事件等待由"永久阻塞"改为
+		1 秒超时——每秒递减 device_status.num_updata(距下次周期上报剩余秒数),
+		并每 10 秒打印一行日志 "数据上传倒计时:%d S",便于真机观察上报节拍。
+	5、(同日增量)sys_monitor 命令升级为类似 linux top 的刷新界面(applications/sys_monitor.c):
+		控制台输入 top(或 Msh_DisplaySysMonitor)后循环刷新显示:
+		CPU(利用率/峰值/温度/运行时长)、RAM(堆已用/峰值)、外部 Flash 参数(SFUD 查
+		芯片名/容量/擦除粒度/JEDEC ID)、片内 Flash 参数、FAL 分区表(使用分布)、
+		数据上报进度(倒计时/间隔/累计次数)、工作状态与进度(转盘位/收集/培养)、
+		外设设备打开状态、通信与报警状态、动作统计、线程状态(复用 list_thread)。
+		用法:top [间隔秒 1-60,默认1] [刷新次数,省略/0=持续刷新];
+		持续刷新按下 q(或 Ctrl+C)退出(串口 INT_RX 非阻塞轮询按键,不影响 shell);
+		屏幕以 ANSI 序列清屏后原地刷新(Xshell/MobaXterm 等均支持)。
+		说明:原"一次性输出全部统计"的 Msh_DisplaySysMonitor 已由本界面替代;
+		sys_monitor_refresh() 保留(平台 systeminfo 上报前仍调用它刷新字段)。
+# 2026-10-08 更新说明(sys_monitor 取消后台线程,改为控制台命令输出)
+
+		版本:保持 1.73.41(与 2026-10-07 条目同一版本,本项为同版本内的补充改动);
+		编译:text 243752B / data 2468B / bss 39884B(arm-none-eabi-gcc 6.3.1);
+		可烧录镜像 bin/Application_CBD-1.73.41-20261008.bin(已覆盖更新为含本改动的
+		最终版),带符号 elf 见 Debug/Application_CBD-1.73.41-20261008.elf;链接零警告,
+		较 2026-10-07 构建 text -1332B(去掉后台线程与周期性打印字符串)。
+	1、applications/sys_monitor.c —— 系统监控不再后台线程运行:
+		原实现为 sys_monitor 线程每秒刷新统计、每 10s 自动打印一整段日志(CPU温度/
+		利用率/串口字节数/各类动作计数);现整体取消该线程,改为:
+		① 新增 sys_monitor_refresh():用到时现场采集实时字段(CPU 温度读 MCU 内部温度
+		   传感器、CPU 利用率读 idle 统计、运行时长取系统 tick),均为非阻塞快速操作;
+		② 新增控制台命令 Msh_DisplaySysMonitor:手动执行时刷新并输出一次全部统计;
+		③ 删除 Sys_Motor_Task()(线程创建)与 thread_delete_sysmonitor()(配套的安全
+		   删除函数,线程已不存在)。
+	2、联动修改:
+		① hmi.c 启动流程移除 Sys_Motor_Task() 调用;
+		② dtu_uart2.c upload_sys_monitor_info()(RTU 下发 {"method":"systeminfo"} 或
+		   工作任务完成时上报平台)改为上报前调用 sys_monitor_refresh() 现场刷新,
+		   保证 cpu_tempture / cpu_usage / system_uptime 字段仍为当前值;
+		③ 运行时 OTA(ota_upgrade_enter)的关闭线程列表同步移除"系统监控"一项(线程
+		   已不存在)——2026-10-07 条目中该列表含"系统监控",以本条说明为准。
+	3、说明(语义微调):cpu_usage_max(历史最大利用率)原为线程逐秒比较更新,现仅
+		在上报/手动输出时更新,即"每次采样时的最大值"。
+# 2026-10-07 更新说明(运行时 Ymodem 升级:指令触发不重启 + 升级期全程禁日志)
+
+	#define VERSION_HK          "1.73.41(HK)"            //4.0海康-1200W
+	#define VERSION_HK_2000W    "1.73.40(2000W)"         //4.0水稻
+	#define VERSION_ZP          "1.73.1(ZP)"             //1.0转盘
+	#define VERSION_GK          "1.73.1(GK)"             //1.0高空
+	#define VERSION_BZY         "2.61"                   //孢子仪(dtype=7)
+		版本变更(control.h):测报灯系列中间版本号 72→73,即 1.72.41(HK) → 1.73.41(HK)、
+		1.72.40(2000W) → 1.73.40(2000W)、1.72.1(ZP) → 1.73.1(ZP)、1.72.1(GK) → 1.73.1(GK);
+		孢子仪 2.60 → 2.61。三色光源(LAMP_EN=1)与 DZ 定制分支属独立序列,本次未改动。
+		编译:text 245084B / data 2476B / bss 39884B(arm-none-eabi-gcc 6.3.1,2026-10-08 构建);
+		可烧录镜像 bin/Application_CBD-1.73.41-20261008.bin(基址 0x08032000,与旧版一致),
+		带符号 elf 见 Debug/Application_CBD-1.73.41-20261008.elf;链接零警告,
+		较上一版 1.72.41 的 text +728B,即新增运行时升级逻辑的开销。
+	说明:收到 {"cmd":"update"} 后不再"置标志→重启→开机进 Ymodem",改为运行时直接
+		关闭无关线程后调用 ymodem_ota(1,0)。升级时 uart2 会被设置成调试口
+		(console/finsh 切到 uart2),而 uart2 同时是 Ymodem 固件数据通道,
+		所以升级全程不能打印日志——任何日志字节混入数据流都会导致升级失败。
+	1、applications/dtu_uart2.c —— update 指令处理重写:
+		① 不再置 update_flag 并写 Flash、不再 rt_hw_cpu_reset();改为:
+		   通告 RTU("system will update") → ota_upgrade_enter() →
+		   接收线程 rt_thread_suspend() 挂起(避免继续读 uart2 抢 Ymodem 数据);
+		② 新增 ota_upgrade_enter(),依次执行:
+		   - rt_console_mute(1):全局静默所有打印(见下);
+		   - 置 RAM 内 update_flag=1 让 DTU 发送线程自行退出循环(不写 Flash,
+		     防止下次开机遇 update_flag=1 误入第二次升级);
+		   - 关闭无关线程(均已改为安全删除):DTU 发送 / 工作流程4线程 /
+		     系统监控 / ADC采集 / Modbus采集 / HMI屏幕收发,并停拍照超时定时器;
+		   - 静默等待 2s,让 RTU 在途数据落地;
+		   - 看门狗超时 10s→25s:NorFlash 整片擦除期间空闲线程无法喂狗,
+		     避免擦除阶段被看门狗中途复位(IWDG 硬件上限约 26s);
+		   - uart2 停干净(参考 RTU_Power_Off_Safe 的思路):先 USART2 外设复位
+		     停掉仍挂着的接收 DMA(否则 close 释放接收缓冲后 DMA 会继续写已释放
+		     内存),再 close 并清 ACTIVATED,让 Ymodem 重新走完整 open/初始化;
+		     不切断 RTU 供电(升级文件正是经 RTU 转发进入 uart2 的);
+		③ 新增 ota_upgrade 传输线程(独立 4KB 栈)执行 ymodem_ota(1,0):
+		   避免 ymodem+fal+sfud+SPI 的调用深度叠加在 DTU 接收线程(2560)栈上。
+	2、rt-thread/src/kservice.c —— 新增全局静默开关:
+		rt_console_mute(enable) + rt_kprintf/rt_kputs 输出前判断;
+		升级结束由 ymodem 内部复位重启,无需恢复(残留的线程/回调随复位消失)。
+	3、安全删除线程改造(统一复用 control.c 的 thread_delete_safe:
+		仅在"线程未挂在 IPC 等待链表上"时删除,否则重试,避免 rt_thread_delete
+		把同一 tlist 节点同时挂进 IPC 等待链表与 defunct 链表造成内核链表损坏):
+		- hmi.c delete_hmi_thread():原 rt_thread_delete 直删改为安全删除+句柄置空;
+		- sht30_collect.c thread_delete_adc():同上;
+		- sample_mb_master.c delete_mb_thread():同上;
+		- sys_monitor.c/.h 新增 thread_delete_sysmonitor():同上。
+	4、注意:
+		① 升级成功/失败最终都会复位重启;失败路径下设备正常启动(update_flag
+		   未写 Flash),需云端重新下发升级指令;
+		② 屏幕菜单触发的 hmi_update 升级路径本次未改(仍是"置标志+重启"进入);
+		③ 进入升级前最后的交互动作是向 RTU 发 "system will update",与旧流程一致。
 # 2026-10-02 更新说明(自动化测试接口 + 控制台命令缺陷修复)
 # 2026-10-02 更新说明(自动化测试接口 + 控制台命令缺陷修复)
 
 
 	#define VERSION_HK          "1.72.41(HK)"            //4.0海康-1200W
 	#define VERSION_HK          "1.72.41(HK)"            //4.0海康-1200W

+ 6 - 3
Application_CBD/packages/ota_downloader-latest/src/ymodem_ota.c

@@ -110,14 +110,17 @@ void ymodem_ota(uint8_t argc, char **argv)
             return;
             return;
         }
         }
     }
     }
+//    rt_kprintf("Warning: Ymodem has started! This operator will not recovery.\n");
+//    rt_kprintf("Please select the ota firmware file and use Ymodem to send.\n");
     rt_console_set_device("uart2");
     rt_console_set_device("uart2");
     finsh_set_device("uart2");
     finsh_set_device("uart2");
-    //rt_kprintf("Warning: Ymodem has started! This operator will not recovery.\n");
-    //rt_kprintf("Please select the ota firmware file and use Ymodem to send.\n");
-
     if (!rym_recv_on_device(&rctx, rt_console_get_device(), RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
     if (!rym_recv_on_device(&rctx, rt_console_get_device(), RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
                             ymodem_on_begin, ymodem_on_data, NULL, RT_TICK_PER_SECOND))
                             ymodem_on_begin, ymodem_on_data, NULL, RT_TICK_PER_SECOND))
     {
     {
+
+        rt_console_set_device("uart1");
+        finsh_set_device("uart1");
+        rt_thread_delay(rt_tick_from_millisecond(200));
         rt_kprintf("Download firmware to flash success.\n");
         rt_kprintf("Download firmware to flash success.\n");
         rt_kprintf("System now will restart...\r\n");
         rt_kprintf("System now will restart...\r\n");
 
 

+ 20 - 0
Application_CBD/rt-thread/src/kservice.c

@@ -1142,6 +1142,18 @@ rt_device_t rt_console_set_device(const char *name)
 RTM_EXPORT(rt_console_set_device);
 RTM_EXPORT(rt_console_set_device);
 #endif
 #endif
 
 
+/* [BZY-OTA-PATCH] 控制台全局静默开关
+ * 运行时固件升级(Ymodem)期间,console/finsh 会被切换到 uart2 —— uart2 同时是
+ * Ymodem 固件数据通道,任何 rt_kprintf/LOG_x 输出都会混入协议流导致升级失败,
+ * 因此升级流程里先调用 rt_console_mute(1) 把整机打印全部静掉(升级结束会复位
+ * 重启,无需恢复)。调用点见 applications/dtu_uart2.c 的 ota_upgrade_enter()。*/
+static volatile rt_uint8_t _console_mute_enable = 0;
+
+void rt_console_mute(rt_uint8_t enable)
+{
+    _console_mute_enable = enable;
+}
+
 RT_WEAK void rt_hw_console_output(const char *str)
 RT_WEAK void rt_hw_console_output(const char *str)
 {
 {
     /* empty console output */
     /* empty console output */
@@ -1157,6 +1169,9 @@ void rt_kputs(const char *str)
 {
 {
     if (!str) return;
     if (!str) return;
 
 
+    /* [BZY-OTA-PATCH] 升级静默期间禁止一切控制台输出(见 _console_mute_enable 注释)*/
+    if (_console_mute_enable) return;
+
 #ifdef RT_USING_DEVICE
 #ifdef RT_USING_DEVICE
     if (_console_device == RT_NULL)
     if (_console_device == RT_NULL)
     {
     {
@@ -1185,6 +1200,11 @@ void rt_kprintf(const char *fmt, ...)
     va_list args;
     va_list args;
     rt_size_t length;
     rt_size_t length;
     static char rt_log_buf[RT_CONSOLEBUF_SIZE];
     static char rt_log_buf[RT_CONSOLEBUF_SIZE];
+
+    /* [BZY-OTA-PATCH] 升级静默期间禁止一切控制台输出
+     * (升级时 console 切到 uart2 作为 Ymodem 数据通道,打印会破坏固件数据流)*/
+    if (_console_mute_enable) return;
+
     rt_memset(rt_log_buf,'\0',sizeof(rt_log_buf));
     rt_memset(rt_log_buf,'\0',sizeof(rt_log_buf));
     va_start(args, fmt);
     va_start(args, fmt);
     /* the return value of vsnprintf is the number of bytes that would be
     /* the return value of vsnprintf is the number of bytes that would be

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

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

+ 61 - 0
CBD_FOTA_BootLoader/.workbuddy/memory/2026-10-08.md

@@ -0,0 +1,61 @@
+# 2026-10-08 工作日志
+
+## BootLoader 代码审计(只读静态分析,未改动任何源码)
+- 对 CBD_FOTA_BootLoader(APM32F103 / RT-Thread 4.0.2 / BL_VERSION 1.2.5)完成漏洞与代码质量审计。
+- 产出报告:工程根目录 `代码审计报告_CBD_FOTA_BootLoader_2026-10-08.md`(P0×3 / P1×4 / P2×4 / P3×16)。
+- 核心结论:
+  1. main.c:328-329 HMI 串口 rx_buffer[256] 溢出(msg.size 可达 ~1023,为环形缓冲累计未读长度)→ BSS 破坏,P0。
+  2. rt_fota.c:641/671/702 升级包 block_size 未校验 → 堆越界读写,P0。
+  3. quicklz qlz_decompress 输出长度由流头自报(dsiz)无上限 → 堆溢出,P0(fastlz 有 FASTLZ_SAFE,反例)。
+  4. 升级包无签名 + AES 密钥硬编码(sys_config.h:30 / rt_fota.c:62)+ ymodem/HMI 命令无鉴权 → 完整攻击链。
+  5. 跳转 APP 未 __enable_irq、NVIC 清理被注释、未设 VTOR(依赖 APP 侧 board.c:464 兜底)。
+  6. drv_flash_f1.c 擦除路径(:153)缺 APM32 要求的"解锁前关中断"(写路径 :95 有)。
+  7. stop_in_bootloader 默认值字符串 "0"(0x30) 与二进制读写语义不一致 → 出厂设备被强制留引导模式。
+  8. main.c erasedf_area 仍是 16MB 时代旧偏移 15729152 + fal_erase.len 未初始化。
+- 需上机验证:IWDG(10s±LSI漂移) 与 312KB 擦除(6~12.5s) 余量、擦除路径关中断缺失的实际影响。
+- 审计时基线:源文件 mtime 2026-10-07 23:35(用户可能仍在编辑,行号以该版本为准)。
+- 备注:用户要求"不改代码",因此未动任何源码,也未动 readme.md。
+
+## 第一批修复执行完成(P0-1 / P0-2 / P0-3),版本 1.2.6
+- 用户指示:"执行第一批修复,每次修改代码要变更版本号(和)readme"。
+- 代码改动(git diff:+56 行,纯新增,无删除):
+  - main.c Hmi_thread_entry:读取前将 msg.size 钳位到 sizeof(rx_buffer)-1=255,读取后对 rx_length 再钳位,LOG_W 记录截断(P0-1)。
+  - rt_fota.c 升级循环 6 处新增校验(P0-2/P0-3):
+    ① Site A(block_hdr_pos>=2048 主分支)② 跨缓冲分支容量校验 ③ 跨缓冲第二段读取量校验
+    ④ hdr_tmp 补齐分支校验 ⑤⑥ 两处 qlz_decompress 前 qlz_size_decompressed()<=4096 预校验。
+  - 校验失败统一 fota_err=RT_FOTA_GENERAL_ERR; goto __exit_upgrade(升级失败但保留原 APP,不破坏设备)。
+- 版本:sys_config.h RT_FOTA_SW_VERSION "1.2.5"→"1.2.6";main.c COMPILE "20260713"→"20261008";readme.md 顶部新增 2026-10-08 版本说明。
+- 备份:.workbuddy/memory/backup_20261008_135412/{rt_fota.c.bak,main.c.bak}。
+- 编译验证:CLI 全量重建 143 条命令全部成功(GCC 6.3.1,21.7s);产物 Debug/rtthread.bin = 165568 B(text 163436/data 2132/bss 8568),<200KB bl 分区。
+- 构建告警(均为预存在,非本次引入):fastlz.c 的 rt_malloc/rt_free implicit declaration;fal_def.h assert `return 1` 的指针转换告警(对应审计 P3-7);rt_fota.c:951 HMI_WRITE implicit declaration(rt_fota.c 未声明 extern,建议下次补一行)。
+- 构建方法沉淀:见 rtthread-studio-cli-build 技能新增的"Python 直编法"(make -n 出命令清单 → Python subprocess 逐条用 6.3.1 执行,规避 PATH/工具链错配坑)。
+- 未动:审计报告(保持时点文档原貌);代码改动未提交 git。
+
+## 第二批修复:RTC_BKP_DR2 升级请求 → ymodem_ota(v1.2.7)
+- 需求(用户):读取 RTC_BKP_DR2,若为 0x5AA5 则停留 bootloader,然后执行 ymodem_ota。
+- 跨工程背景:APP 侧(Application_CBD)已实现 JSONRPC "update" 指令 → 写 BKP_DR2=0x5AA5 + 复位(dtu_uart2.c:2036-2048,__HAL_RCC_PWR/BKP_CLK_ENABLE + HAL_PWR_EnableBkUpAccess + *(__IO uint16_t*)(BKP_BASE+4*2));APP main.c:43-52 启动时读并清除该 boot_flag。bootloader 侧检测为本次补齐的一环。
+- 实现(rt_fota.c,本次 +43 行):
+  - 新增 rt_fota_check_ymodem_request()(放在 rt_fota_thread_entry 之前):使能 PWR/BKP 时钟 + DBP 解锁 → 读 *(__IO uint16_t *)(BKP_BASE + 4*2);==RT_FOTA_YMODEM_REQ_BKP_MAGIC(0x5AA5) 时**读取即清**(防 ymodem 复位后循环进入)并返回 RT_EOK。
+  - rt_fota_thread_entry 中(boot_verify 之后、Shell 初始化之前):命中 → led_upgrade_mode + ymodem_ota(1, RT_NULL)(默认下载分区 fm_area;内部完成后复位、正常不返回)。
+  - 另补 extern void HMI_WRITE(char *fmt,...); 消除 rt_fota.c 隐式声明编译告警(第二批候选之一)。
+- 版本:sys_config.h 1.2.6→**1.2.7**;readme 顶部新增"版本说明 2026-10-08(第二次)"。
+- 编译(增量,.d 依赖跟踪生效):6 条命令(ymodem_ota.o/main.o/rt_fota.o + 链接 + objcopy + size)全部成功、重编零告警;rtthread.bin **165940B**(+372B),text 163808/data 2132/bss 8568;固件内含 "RTC_BKP_DR2 = 0x5AA5" 与 "1.2.7" 字符串(grep -a 验证)。
+- 备份:backup_20261008_144903_batch2/{rt_fota.c,sys_config.h,readme.md}.bak。
+- 完整链路:APP(JSONRPC update) 写 DR2→复位 → bootloader 检测→清标志→ ymodem(uart2,115200) 收 RBL 包写 fm_area → 复位 → bootloader 校验 fm_area 并搬运到 app → 启动新固件。ymodem 失败时复位回正常启动(标志已清、自愈);平台可重发 update 指令重试。
+## 第二批(剩余四项)完成:v1.2.8
+- P1-2 rt_fota.c 跳转序列规范化:禁/清全部 NVIC(用寄存器遍历替代原注释循环——F1 无 FPU_IRQn)、清 PendSV/SysTick 挂起、停 SysTick、HAL_DeInit×2+RCC_DeInit、SCB->VTOR=app_addr+DSB/ISB、__set_MSP → __set_CONTROL(0) → __enable_irq → 跳转。反汇编逐条核对通过:CONTROL 切换后仅剩全局/绝对访问(此前实现依赖 r7 帧指针寻址"侥幸可用",现已与优化等级无关)。
+- P1-4 drv_flash_f1.c:stm32_flash_erase_bank 重写为分块擦除(每块 ≤ FLASH_ERASE_CHUNK_PAGES=16 页),每块内 __disable_irq + HAL_FLASH_Unlock → Erase → Lock + __enable_irq;同时满足 APM32"解锁前关中断"与 IWDG 喂狗(避免 312KB 整片关中断 6~12s 触发复位)。
+- P2-1 rt_fota.c:stop_in_bootloader 读取改为先取 4 字节再归一化,兼容字符串 "0"/"1"(0x30/0x31,EasyFlash 默认值)与二进制 0/1;修复新设备默认值 "0" 按二进制读为 0x30(非零)被误判为停留引导模式的缺陷。
+- P2-2 main.c:eraseapp / erasedf_area 改用 fal_partition_find 获取真实分区对象(修正 erasedf_area 旧 16MB 偏移 15729152 与 fal_erase.len 未初始化),并增加执行结果打印。
+- 版本 1.2.8(sys_config.h)+ readme「版本说明 2026-10-08(第三次)」。
+- 编译:增量 7 条命令(rt_fota.o/main.o/drv_flash_f1.o/ymodem_ota.o + 链接 + objcopy + size)全成功、零告警;bin 166468B(+528B);grep -a 确认 "eraseapp done"/"erasedf_area done"/"1.2.8"/"RTC_BKP_DR2 = 0x5AA5" 均在固件中。
+- 备份:backup_20261008_163326_batch2b/{rt_fota.c,main.c,drv_flash_f1.c,sys_config.h,readme.md}.bak。
+- 至此第二批全部完成(含早前的 RTC 升级入口与 HMI_WRITE extern)。
+
+## 第三批(部分):P2-4 Ymodem 完整性加固(v1.2.9)
+- 背景:发现 ymodem_ota.c 有用户 14:53 的未提交改动(成功后先切回 uart1 再打印成功信息)——已保留并在本版一并编译(readme 第四次条目第 2 点注明"既有改动,一并纳入")。
+- 改动 1(ymodem_on_begin):文件名结束符查找 + 大小解析全部限定在首包 len 内(用**手写循环**替代 rt_strlen/atol——minilibc 无 memchr/strnlen,链接表已核实均无);无效首包 RYM_CODE_CAN;"大小 > 分区"检查扩展为拒绝 0。
+- 改动 2(ymodem_on_data):收满首包声明长度后拒收后续数据包(RYM_CODE_CAN),防超发写入未擦除区。关键语义:rym 回调 len=**整块**(128/1024,含 0x1A 填充),故用"cur >= total 才拦"而非"cur+len > total",避免误伤末包填充(正常流程末包写完后不再有数据包)。
+- 版本 1.2.9 + readme「版本说明 2026-10-08(第四次)」;编译增量 6 条命令全成功、0 告警;bin 166788B(+320B),固件内含 "Data overrun"/"Invalid file name in handshake"/"1.2.9"。
+- 备份:backup_20261008_163838_batch3/。
+- 第三批剩余:P1-1(升级包签名/鉴权——需方案决策:HMAC-SHA256 / ECDSA / 暂缓;且需固件打包工具配合,已向用户列出选项);P1-3(IWDG 余量上机实测——需硬件,无法在 CLI 完成)。

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


+ 39 - 11
CBD_FOTA_BootLoader/applications/main.c

@@ -34,7 +34,7 @@
 #include <easyflash.h>
 #include <easyflash.h>
 
 
 #define BL_VERSION RT_FOTA_SW_VERSION
 #define BL_VERSION RT_FOTA_SW_VERSION
-#define COMPILE "20260713"
+#define COMPILE "20261008"
 
 
 #define RTU_DTU GET_PIN(B,13)
 #define RTU_DTU GET_PIN(B,13)
 #define Beep    GET_PIN(B, 4)
 #define Beep    GET_PIN(B, 4)
@@ -253,11 +253,20 @@ static void HMI_Decode(char *cmd,uint8_t cmd_len)
     }
     }
     //擦除app分区
     //擦除app分区
     else if (strstr(rx_buffer, "eraseapp")!=NULL) {
     else if (strstr(rx_buffer, "eraseapp")!=NULL) {
-        struct fal_partition fal_erase;
-        fal_erase.offset=204800;
-        rt_sprintf(fal_erase.name, "%s","app");
-        rt_sprintf(fal_erase.flash_name, "%s","onchip_flash");
-        fal_partition_erase(&fal_erase,0,319488);
+        const struct fal_partition *fal_erase;
+        fal_erase = fal_partition_find("app");
+        if (fal_erase != RT_NULL)
+        {
+            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)
+                rt_kprintf("eraseapp failed!\n");
+            else
+                rt_kprintf("eraseapp done.\n");
+        }
+        else
+        {
+            rt_kprintf("eraseapp: 'app' partition is not exist!\n");
+        }
     }
     }
     //擦除easyflash
     //擦除easyflash
     else if(strstr(rx_buffer, "eraseeasyflash")!=NULL){
     else if(strstr(rx_buffer, "eraseeasyflash")!=NULL){
@@ -268,11 +277,20 @@ static void HMI_Decode(char *cmd,uint8_t cmd_len)
         HMI_WRITE("easyflash擦除成功!");
         HMI_WRITE("easyflash擦除成功!");
     }
     }
     else if(strstr(rx_buffer, "erasedf_area")!=NULL){
     else if(strstr(rx_buffer, "erasedf_area")!=NULL){
-        struct fal_partition fal_erase;
-        fal_erase.offset=15729152;
-        rt_sprintf(fal_erase.name, "%s","df_area");
-        rt_sprintf(fal_erase.flash_name, "%s","w25q16m");
-        fal_partition_erase(&fal_erase,0,524288);
+        const struct fal_partition *fal_erase;
+        fal_erase = fal_partition_find("df_area");
+        if (fal_erase != RT_NULL)
+        {
+            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)
+                rt_kprintf("erasedf_area failed!\n");
+            else
+                rt_kprintf("erasedf_area done.\n");
+        }
+        else
+        {
+            rt_kprintf("erasedf_area: 'df_area' partition is not exist!\n");
+        }
     }
     }
 }
 }
 /*HMI*/
 /*HMI*/
@@ -325,7 +343,17 @@ static void Hmi_thread_entry(void *parameter)
         result = rt_mq_recv(&rx_mq, &msg, sizeof(msg), 1000);
         result = rt_mq_recv(&rx_mq, &msg, sizeof(msg), 1000);
         if (result == RT_EOK)
         if (result == RT_EOK)
         {
         {
+                /* 防止越界:msg.size 为环形缓冲区累计未读长度,可能超过 rx_buffer 容量 */
+                if (msg.size > sizeof(rx_buffer) - 1)
+                {
+                    LOG_W("HMI rx data truncated: %d > %d", (int)msg.size, (int)(sizeof(rx_buffer) - 1));
+                    msg.size = sizeof(rx_buffer) - 1;
+                }
                 rx_length = rt_device_read(msg.dev, 0, rx_buffer, msg.size);
                 rx_length = rt_device_read(msg.dev, 0, rx_buffer, msg.size);
+                if (rx_length > sizeof(rx_buffer) - 1)
+                {
+                    rx_length = sizeof(rx_buffer) - 1;
+                }
                 rx_buffer[rx_length] = '\0';
                 rx_buffer[rx_length] = '\0';
                 LOG_I("%s\n",rx_buffer);
                 LOG_I("%s\n",rx_buffer);
                 HMI_Decode(rx_buffer,rx_length);
                 HMI_Decode(rx_buffer,rx_length);

+ 136 - 22
CBD_FOTA_BootLoader/applications/rt_fota.c

@@ -27,6 +27,9 @@
 #include <shell.h>
 #include <shell.h>
 #endif
 #endif
 #include <rt_fota.h>
 #include <rt_fota.h>
+
+extern void HMI_WRITE(char *fmt,...);
+
 #define DBG_ENABLE
 #define DBG_ENABLE
 #define DBG_SECTION_NAME                    "fota"
 #define DBG_SECTION_NAME                    "fota"
 
 
@@ -637,6 +640,15 @@ int rt_fota_upgrade(const char *part_name)
 
 
 				rt_memcpy(block_hdr_buf, crypt_buf, RT_FOTA_BLOCK_HEADER_SIZE);
 				rt_memcpy(block_hdr_buf, crypt_buf, RT_FOTA_BLOCK_HEADER_SIZE);
 				block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
 				block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
+				/* 校验块长:防止损坏/伪造的升级包造成缓冲区越界 */
+				if ((fw_raw_len < RT_FOTA_BLOCK_HEADER_SIZE) ||
+					(block_size > (rt_uint32_t)(fw_raw_len - RT_FOTA_BLOCK_HEADER_SIZE)) ||
+					(block_size > (RT_FOTA_CMPRS_BUFFER_SIZE + padding_size)))
+				{
+					LOG_D("Invalid compressed block size(%d).", block_size);
+					fota_err = RT_FOTA_GENERAL_ERR;
+					goto __exit_upgrade;
+				}
 				rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
 				rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
 				rt_memcpy(cmprs_buff, &crypt_buf[RT_FOTA_BLOCK_HEADER_SIZE], block_size);
 				rt_memcpy(cmprs_buff, &crypt_buf[RT_FOTA_BLOCK_HEADER_SIZE], block_size);
 
 
@@ -654,6 +666,13 @@ int rt_fota_upgrade(const char *part_name)
 					else
 					else
 					{
 					{
 						block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
 						block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
+						/* 校验块长:防止损坏/伪造的升级包造成缓冲区越界 */
+						if (block_size > (RT_FOTA_CMPRS_BUFFER_SIZE + padding_size))
+						{
+							LOG_D("Invalid compressed block size(%d).", block_size);
+							fota_err = RT_FOTA_GENERAL_ERR;
+							goto __exit_upgrade;
+						}
 						
 						
 						rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
 						rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
 						if (block_size > (RT_FOTA_ALGO_BUFF_SIZE - block_hdr_pos))
 						if (block_size > (RT_FOTA_ALGO_BUFF_SIZE - block_hdr_pos))
@@ -667,6 +686,13 @@ int rt_fota_upgrade(const char *part_name)
 								goto __exit_upgrade;
 								goto __exit_upgrade;
 							}
 							}
 							fw_raw_pos += fw_raw_len;
 							fw_raw_pos += fw_raw_len;
+							/* 校验跨缓冲块的剩余长度不超过本次读取的字节数 */
+							if (((block_size + block_hdr_pos) - RT_FOTA_ALGO_BUFF_SIZE) > (rt_uint32_t)fw_raw_len)
+							{
+								LOG_D("Invalid compressed block size(%d).", block_size);
+								fota_err = RT_FOTA_GENERAL_ERR;
+								goto __exit_upgrade;
+							}
 
 
 							rt_memcpy(&cmprs_buff[RT_FOTA_ALGO_BUFF_SIZE - block_hdr_pos], &crypt_buf[0], (block_size +  block_hdr_pos) - RT_FOTA_ALGO_BUFF_SIZE);
 							rt_memcpy(&cmprs_buff[RT_FOTA_ALGO_BUFF_SIZE - block_hdr_pos], &crypt_buf[0], (block_size +  block_hdr_pos) - RT_FOTA_ALGO_BUFF_SIZE);
 							block_hdr_pos = (block_size +  block_hdr_pos) - RT_FOTA_ALGO_BUFF_SIZE;
 							block_hdr_pos = (block_size +  block_hdr_pos) - RT_FOTA_ALGO_BUFF_SIZE;
@@ -697,6 +723,15 @@ int rt_fota_upgrade(const char *part_name)
 						block_hdr_buf[hdr_tmp_pos++] = crypt_buf[block_hdr_pos++];
 						block_hdr_buf[hdr_tmp_pos++] = crypt_buf[block_hdr_pos++];
 					}
 					}
 					block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
 					block_size = block_hdr_buf[0] * (1 << 24) + block_hdr_buf[1] * (1 << 16) + block_hdr_buf[2] * (1 << 8) + block_hdr_buf[3];
+					/* 校验块长:防止损坏/伪造的升级包造成缓冲区越界 */
+					if ((fw_raw_len < (int)block_hdr_pos) ||
+						(block_size > (rt_uint32_t)(fw_raw_len - block_hdr_pos)) ||
+						(block_size > (RT_FOTA_CMPRS_BUFFER_SIZE + padding_size)))
+					{
+						LOG_D("Invalid compressed block size(%d).", block_size);
+						fota_err = RT_FOTA_GENERAL_ERR;
+						goto __exit_upgrade;
+					}
 
 
 					rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
 					rt_memset(cmprs_buff, 0x0, RT_FOTA_CMPRS_BUFFER_SIZE + padding_size);
 					rt_memcpy(cmprs_buff, &crypt_buf[block_hdr_pos], block_size);
 					rt_memcpy(cmprs_buff, &crypt_buf[block_hdr_pos], block_size);
@@ -712,6 +747,13 @@ int rt_fota_upgrade(const char *part_name)
 			}
 			}
 			else if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_QUICKLZ) 
 			else if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_QUICKLZ) 
 			{
 			{
+				/* 校验解压长度:qlz 解压长度由流头自报,必须在目标缓冲区容量内 */
+				if (qlz_size_decompressed((const char *)&cmprs_buff[0]) > RT_FOTA_CMPRS_BUFFER_SIZE)
+				{
+					LOG_D("Invalid quicklz decompressed size in upgrade package.");
+					fota_err = RT_FOTA_GENERAL_ERR;
+					goto __exit_upgrade;
+				}
 				dcprs_size = qlz_decompress((const char *)&cmprs_buff[0], &dcprs_buff[0], dcprs_state);
 				dcprs_size = qlz_decompress((const char *)&cmprs_buff[0], &dcprs_buff[0], dcprs_state);
 			}
 			}
 			
 			
@@ -777,6 +819,13 @@ int rt_fota_upgrade(const char *part_name)
                     }
                     }
                     else if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_QUICKLZ) 
                     else if ((part_head->fota_algo & RT_FOTA_CMPRS_STAT_MASK) == RT_FOTA_CMPRS_ALGO_QUICKLZ) 
                     {
                     {
+                        /* 校验解压长度:qlz 解压长度由流头自报,必须在目标缓冲区容量内 */
+                        if (qlz_size_decompressed((const char *)&cmprs_buff[0]) > RT_FOTA_CMPRS_BUFFER_SIZE)
+                        {
+                            LOG_D("Invalid quicklz decompressed size in upgrade package.");
+                            fota_err = RT_FOTA_GENERAL_ERR;
+                            goto __exit_upgrade;
+                        }
                         dcprs_size = qlz_decompress((const char *)&cmprs_buff[0], &dcprs_buff[0], dcprs_state);
                         dcprs_size = qlz_decompress((const char *)&cmprs_buff[0], &dcprs_buff[0], dcprs_state);
                     }
                     }
                 
                 
@@ -874,29 +923,45 @@ int rt_fota_start_application(void)
 	}
 	}
 
 
 	LOG_I("Implement application now.");
 	LOG_I("Implement application now.");
-        
-    __disable_irq();
-    HAL_DeInit();
-    __set_CONTROL(0);
-    //LOG_I("Implement application now.");
-//    for (IRQn_Type irq = WWDG_IRQn; irq <= FPU_IRQn; irq++)
-//    {
-//        HAL_NVIC_DisableIRQ(irq);
-//        HAL_NVIC_ClearPendingIRQ(irq);
-//    }
-    //Resets the RCC clock configuration to the default reset state.
-    HAL_RCC_DeInit();
-    
-    SysTick->CTRL = 0;
-    SysTick->LOAD = 0;
-    SysTick->VAL = 0;
-    HAL_DeInit();
+
+	__disable_irq();
+	/* 禁用并清除全部 NVIC 中断(原循环因 F1 无 FPU_IRQn 被注释,改用寄存器遍历),
+	 * 防止 APP 启动初期残留/挂起中断使用旧向量表或未初始化外设 */
+	for (int nvic_idx = 0; nvic_idx < 8; nvic_idx++)
+	{
+		NVIC->ICER[nvic_idx] = 0xFFFFFFFF;
+		NVIC->ICPR[nvic_idx] = 0xFFFFFFFF;
+	}
+	/* 清除可能挂起的系统异常(PendSV/SysTick) */
+	SCB->ICSR |= SCB_ICSR_PENDSVCLR_Msk;
+	SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk;
+
+	/* 停止 SysTick */
+	SysTick->CTRL = 0;
+	SysTick->LOAD = 0;
+	SysTick->VAL = 0;
+
+	/* 外设与时钟恢复到默认状态 */
+	HAL_DeInit();
+	HAL_RCC_DeInit();
+	HAL_DeInit();
+
+	/* 向量表预先指向 APP(其 SystemInit 会先写回 0x08000000,此步保证交接窗口安全) */
+	SCB->VTOR = app_addr;
+	__DSB();
+	__ISB();
 
 
 	//用户代码区第二个字为程序开始地址(复位地址)
 	//用户代码区第二个字为程序开始地址(复位地址)
 	app_func = (rt_fota_app_func)*(__IO uint32_t *)(app_addr + 4);
 	app_func = (rt_fota_app_func)*(__IO uint32_t *)(app_addr + 4);
-	/* Configure main stack */ 
-	__set_MSP(*(__IO uint32_t *)app_addr);       
-           
+	/* Configure main stack */
+	__set_MSP(*(__IO uint32_t *)app_addr);
+
+	/* 由线程(PSP)切回 MSP:APP 以复位状态(CONTROL=0)运行 */
+	__set_CONTROL(0);
+
+	/* 恢复中断屏蔽(PRIMASK=0),以接近复位后的状态进入 APP */
+	__enable_irq();
+
 	/* jump to application */
 	/* jump to application */
 	app_func();
 	app_func();
 	
 	
@@ -1030,6 +1095,35 @@ static rt_err_t rt_fota_check_defalut_key(void)
 }
 }
 #endif
 #endif
 
 
+/* 应用侧(JSONRPC "update" 指令)将 RTC 备份寄存器 DR2 写入 0x5AA5 并重启,
+ * bootloader 检测到该值后停留在 bootloader 并进入 ymodem 升级模式 */
+#define RT_FOTA_YMODEM_REQ_BKP_MAGIC		0x5AA5
+
+/* 检测应用侧写入的 RTC_BKP_DR2 升级请求:
+ * BKP_BASE + 4*2 即 RTC_BKP_DR2(16 位),访问方式与 Application_CBD 的
+ * main.c / dtu_uart2.c 配对;命中约定值时清除标志并返回 RT_EOK(请求 ymodem 升级) */
+static rt_err_t rt_fota_check_ymodem_request(void)
+{
+	rt_uint16_t boot_flag;
+
+	/* 使能 PWR/BKP 时钟并解除备份域写访问保护(DBP) */
+	__HAL_RCC_PWR_CLK_ENABLE();
+	__HAL_RCC_BKP_CLK_ENABLE();
+	HAL_PWR_EnableBkUpAccess();
+
+	boot_flag = *(__IO uint16_t *)(BKP_BASE + 4 * 2);
+
+	if (boot_flag != RT_FOTA_YMODEM_REQ_BKP_MAGIC)
+	{
+		return RT_ERROR;
+	}
+
+	/* 先清除标志:避免 ymodem 完成复位后再次进入升级模式(app 启动时也会清除) */
+	*(__IO uint16_t *)(BKP_BASE + 4 * 2) = 0x0000;
+
+	return RT_EOK;
+}
+
 void rt_fota_thread_entry(void *arg)
 void rt_fota_thread_entry(void *arg)
 {
 {
 	int fota_err = RT_FOTA_NO_ERR;
 	int fota_err = RT_FOTA_NO_ERR;
@@ -1055,14 +1149,34 @@ void rt_fota_thread_entry(void *arg)
 	}
 	}
 #endif
 #endif
 
 
+	/* RTC 备份寄存器 DR2 升级请求检测:命中 0x5AA5 → 停留 bootloader 执行 ymodem 升级 */
+	if (rt_fota_check_ymodem_request() == RT_EOK)
+	{
+		extern void ymodem_ota(uint8_t argc, char **argv);
+
+		LOG_I("RTC_BKP_DR2 = 0x5AA5, stay in bootloader, start ymodem ota.");
+		rt_fota_signal_led_mode(led_upgrade_mode);
+		/* 下载分区默认 fm_area;ymodem 完成后内部复位,正常不返回 */
+		ymodem_ota(1, RT_NULL);
+	}
+
 	/* Shell initialized */
 	/* Shell initialized */
 	if (rt_fota_set_device(RT_CONSOLE_DEVICE_NAME) == RT_EOK)
 	if (rt_fota_set_device(RT_CONSOLE_DEVICE_NAME) == RT_EOK)
 	{
 	{
 
 
 	    if(easyflash_init()==EF_NO_ERR) //初始化成功
 	    if(easyflash_init()==EF_NO_ERR) //初始化成功
 	    {
 	    {
-	        ef_get_env_blob("stop_in_bootloader", &stop_in_bootloader, sizeof(stop_in_bootloader), NULL); //读出reboot_time的值
-	        rt_kprintf("stop_in_bootloader:%d\n",stop_in_bootloader);
+	        rt_uint8_t boot_flag_buf[4] = {0, 0, 0, 0};
+	        ef_get_env_blob("stop_in_bootloader", boot_flag_buf, sizeof(boot_flag_buf), NULL);
+	        /* 兼容三种历史存储格式:字符串 "0"/"1"(EasyFlash 默认值)与二进制 0/1。
+	         * 历史缺陷:默认值 "0" 按二进制读为 0x30(非零),会误判为停留引导模式 */
+	        if (boot_flag_buf[0] == '0')
+	            stop_in_bootloader = 0;
+	        else if (boot_flag_buf[0] == '1')
+	            stop_in_bootloader = 1;
+	        else
+	            stop_in_bootloader = (boot_flag_buf[0] != 0) ? 1 : 0;
+	        rt_kprintf("stop_in_bootloader:%d\n", stop_in_bootloader);
 	    }
 	    }
 		rt_kprintf("Please press [Enter] key into shell mode in %d secs:\r\n", RT_FOTA_GET_CHAR_WAITTIGN / RT_TICK_PER_SECOND);
 		rt_kprintf("Please press [Enter] key into shell mode in %d secs:\r\n", RT_FOTA_GET_CHAR_WAITTIGN / RT_TICK_PER_SECOND);
 		if (rt_fota_get_shell_key() == RT_EOK)
 		if (rt_fota_get_shell_key() == RT_EOK)

+ 1 - 1
CBD_FOTA_BootLoader/applications/sys_config.h

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

+ 41 - 13
CBD_FOTA_BootLoader/drivers/drv_flash_f1.c

@@ -136,13 +136,19 @@ int stm32_flash_write(rt_uint32_t addr, const rt_uint8_t *buf, size_t size)
  *
  *
  * @return result
  * @return result
  */
  */
+/* 擦除分块(页数):APM32 要求在 flash 操作期间关闭中断,但大分区整片擦除
+ * 若全程关中断会使 IWDG 无法喂狗(312KB 最坏 >10s)——按此粒度分块,
+ * 每块内关中断完成"解锁→擦除→上锁",块间开中断让喂狗/调度正常工作 */
+#define FLASH_ERASE_CHUNK_PAGES      16
+
 int stm32_flash_erase_bank(uint32_t bank, rt_uint32_t addr, size_t size)
 int stm32_flash_erase_bank(uint32_t bank, rt_uint32_t addr, size_t size)
 {
 {
     rt_err_t result = RT_EOK;
     rt_err_t result = RT_EOK;
-    uint32_t PAGEError = 0;
+    uint32_t page_addr;
 
 
     /*Variable used for Erase procedure*/
     /*Variable used for Erase procedure*/
     FLASH_EraseInitTypeDef EraseInitStruct;
     FLASH_EraseInitTypeDef EraseInitStruct;
+    uint32_t PAGEError = 0;
 
 
     if ((addr + size) > STM32_FLASH_END_ADDRESS)
     if ((addr + size) > STM32_FLASH_END_ADDRESS)
     {
     {
@@ -150,23 +156,45 @@ int stm32_flash_erase_bank(uint32_t bank, rt_uint32_t addr, size_t size)
         return -RT_EINVAL;
         return -RT_EINVAL;
     }
     }
 
 
-    HAL_FLASH_Unlock();
+    page_addr = GetPage(addr);
 
 
-    /* Fill EraseInit structure*/
-    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
-    EraseInitStruct.PageAddress = GetPage(addr);
-    EraseInitStruct.NbPages     = (size + FLASH_PAGE_SIZE - 1) / FLASH_PAGE_SIZE;
-    EraseInitStruct.Banks       = bank;
-    
-    if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
+    while (page_addr < (addr + size))
     {
     {
-        result = -RT_ERROR;
-        goto __exit;
+        rt_uint32_t chunk_pages;
+
+        chunk_pages = (addr + size - page_addr + FLASH_PAGE_SIZE - 1) / FLASH_PAGE_SIZE;
+        if (chunk_pages > FLASH_ERASE_CHUNK_PAGES)
+        {
+            chunk_pages = FLASH_ERASE_CHUNK_PAGES;
+        }
+
+        /* Fill EraseInit structure*/
+        EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
+        EraseInitStruct.PageAddress = page_addr;
+        EraseInitStruct.NbPages     = chunk_pages;
+        EraseInitStruct.Banks       = bank;
+
+        /* APM32: 解锁前关闭中断,上锁后打开(与写路径一致) */
+        __disable_irq();
+        HAL_FLASH_Unlock();
+
+        if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
+        {
+            result = -RT_ERROR;
+        }
+
+        HAL_FLASH_Lock();
+        __enable_irq();
+
+        if (result != RT_EOK)
+        {
+            goto __exit;
+        }
+
+        page_addr += chunk_pages * FLASH_PAGE_SIZE;
     }
     }
 
 
 __exit:
 __exit:
-    HAL_FLASH_Lock();
-
     if (result != RT_EOK)
     if (result != RT_EOK)
     {
     {
         return result;
         return result;

+ 34 - 8
CBD_FOTA_BootLoader/packages/ota_downloader-latest/src/ymodem_ota.c

@@ -36,13 +36,29 @@ static const struct fal_partition * dl_part = RT_NULL;
 
 
 static enum rym_code ymodem_on_begin(struct rym_ctx *ctx, rt_uint8_t *buf, rt_size_t len)
 static enum rym_code ymodem_on_begin(struct rym_ctx *ctx, rt_uint8_t *buf, rt_size_t len)
 {
 {
-    char *file_name, *file_size;
+    char *file_size;
+    rt_size_t name_len;
+    char *p, *end;
 
 
-    /* calculate and store file size */
-    file_name = (char *)&buf[0];
-    file_size = (char *)&buf[rt_strlen(file_name) + 1];
-    update_file_total_size = atol(file_size);
-    //rt_kprintf("Ymodem file_size:%d\n", update_file_total_size);
+    /* 在首包数据范围内定位文件名结束符并解析文件大小(限定 len,防非 NUL 结尾包越界读) */
+    name_len = 0;
+    while (name_len < len && buf[name_len] != 0)
+    {
+        name_len++;
+    }
+    if (name_len == 0 || name_len >= len)
+    {
+        LOG_E("Firmware download failed! Invalid file name in handshake packet!");
+        return RYM_CODE_CAN;
+    }
+    file_size = (char *)&buf[name_len + 1];
+
+    update_file_total_size = 0;
+    end = (char *)&buf[len];
+    for (p = file_size; p < end && *p >= '0' && *p <= '9'; p++)
+    {
+        update_file_total_size = update_file_total_size * 10 + (rt_size_t)(*p - '0');
+    }
 
 
     update_file_cur_size = 0;
     update_file_cur_size = 0;
 
 
@@ -53,9 +69,9 @@ static enum rym_code ymodem_on_begin(struct rym_ctx *ctx, rt_uint8_t *buf, rt_si
         return RYM_CODE_CAN;
         return RYM_CODE_CAN;
     }
     }
 
 
-    if (update_file_total_size > dl_part->len)
+    if (update_file_total_size == 0 || update_file_total_size > dl_part->len)
     {
     {
-        LOG_E("Firmware is too large! File size (%d), '%s' partition size (%d)", update_file_total_size, recv_partition, dl_part->len);
+        LOG_E("Firmware size invalid or too large! File size (%d), '%s' partition size (%d)", update_file_total_size, recv_partition, dl_part->len);
         return RYM_CODE_CAN;
         return RYM_CODE_CAN;
     }
     }
 
 
@@ -72,6 +88,14 @@ static enum rym_code ymodem_on_begin(struct rym_ctx *ctx, rt_uint8_t *buf, rt_si
 
 
 static enum rym_code ymodem_on_data(struct rym_ctx *ctx, rt_uint8_t *buf, rt_size_t len)
 static enum rym_code ymodem_on_data(struct rym_ctx *ctx, rt_uint8_t *buf, rt_size_t len)
 {
 {
+    /* 已收满首包声明的文件长度后拒绝继续写入,防止超发数据写入未擦除区域;
+     * 末包含 0x1A 填充属正常,故只在“已满后”拦截 */
+    if (update_file_cur_size >= update_file_total_size)
+    {
+        LOG_E("Firmware download failed! Data overrun: %d >= %d", update_file_cur_size, update_file_total_size);
+        return RYM_CODE_CAN;
+    }
+
     /* write data of application to DL partition  */
     /* write data of application to DL partition  */
     if (fal_partition_write(dl_part, update_file_cur_size, buf, len) < 0)
     if (fal_partition_write(dl_part, update_file_cur_size, buf, len) < 0)
     {
     {
@@ -116,6 +140,8 @@ void ymodem_ota(uint8_t argc, char **argv)
     if (!rym_recv_on_device(&rctx, rt_console_get_device(), RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
     if (!rym_recv_on_device(&rctx, rt_console_get_device(), RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
                             ymodem_on_begin, ymodem_on_data, NULL, RT_TICK_PER_SECOND))
                             ymodem_on_begin, ymodem_on_data, NULL, RT_TICK_PER_SECOND))
     {
     {
+        rt_console_set_device("uart1");
+        rt_thread_delay(rt_tick_from_millisecond(200));
         rt_kprintf("Download firmware to flash success.\n");
         rt_kprintf("Download firmware to flash success.\n");
         rt_kprintf("System now will restart...\r\n");
         rt_kprintf("System now will restart...\r\n");
 
 

+ 28 - 0
CBD_FOTA_BootLoader/readme.md

@@ -1,3 +1,31 @@
+# 版本说明 2026-10-08(第四次)
+	#define BL_VERSION "1.2.9"
+	#define COMPILE "20261008"
+	1、ymodem_ota.c:Ymodem 下载完整性加固——首包文件名/大小解析限定在包长范围内(防非 NUL 结尾包与 atol 越界读),并拒绝 size=0;
+	   收满首包声明长度后拒绝继续写入数据(防超发数据写入未擦除区域造成静默损坏)
+	2、ymodem_ota.c:下载成功后先切回 uart1 再打印成功信息(既有改动,一并纳入本次发版)
+
+# 版本说明 2026-10-08(第三次)
+	#define BL_VERSION "1.2.8"
+	#define COMPILE "20261008"
+	1、rt_fota.c:跳转 APP 交接序列规范化——跳转前禁用并清除全部 NVIC 中断、清除 PendSV/SysTick 挂起、SCB->VTOR 指向 APP、恢复 PRIMASK 后再跳转(消除 APP 带屏蔽启动与残留中断隐患)
+	2、drv_flash_f1.c:擦除路径补齐“解锁前关中断”(APM32 要求,与写路径一致);大分区擦除按 16 页分块、块间开中断,保证 IWDG 喂狗不受影响
+	3、rt_fota.c:stop_in_bootloader 读取兼容字符串 "0"/"1" 与二进制 0/1(修复新设备因默认值 "0"(0x30) 被误判为停留引导模式的缺陷)
+	4、main.c:eraseapp / erasedf_area 改用 fal_partition_find 获取真实分区对象(修正 erasedf_area 旧 16MB 偏移和未初始化 len),并增加执行结果打印
+
+# 版本说明 2026-10-08(第二次)
+	#define BL_VERSION "1.2.7"
+	#define COMPILE "20261008"
+	1、rt_fota.c:新增 RTC 备份寄存器 DR2 升级请求检测——读取 RTC_BKP_DR2==0x5AA5(应用侧 JSONRPC "update" 指令写入)时,停留 bootloader 并执行 ymodem_ota 升级;读取后立即清标志防重复进入
+	2、rt_fota.c:补 HMI_WRITE extern 声明,消除隐式声明编译告警
+
+# 版本说明 2026-10-08
+	#define BL_VERSION "1.2.6"
+	#define COMPILE "20261008"
+	1、main.c:修复HMI串口接收缓冲区溢出(rx_buffer读取长度钳位至255)
+	2、rt_fota.c:升级包压缩块长度block_size越界校验(防止堆越界)
+	3、rt_fota.c:quicklz解压长度预校验(防止解压输出越界)
+
 # 版本说明 2026-07-13
 # 版本说明 2026-07-13
 	#define BL_VERSION "1.2.5"
 	#define BL_VERSION "1.2.5"
 	#define COMPILE "20260713"
 	#define COMPILE "20260713"

File diff suppressed because it is too large
+ 240 - 0
CBD_FOTA_BootLoader/代码审计报告_CBD_FOTA_BootLoader_2026-10-08.md