zhunk 1 месяц назад
Родитель
Сommit
17b2fa46a9

BIN
Application_cbd_apm32f1/.sconsign.dblite


+ 5 - 5
Application_cbd_apm32f1/applications/control.c

@@ -2428,11 +2428,11 @@ static void Control_Clear_thread_entry(void *parameter)
         if(device_status.update_flag==1) break;
         if(device_status.clear_status==1)
         {
-        if(device_status.version_type==41){
-            ctr_TG_Clear(300);
-        }else {
-            ctr_TG_Clear(400);  //20260924-350修改为400
-        }
+            if(device_status.version_type==41){
+                ctr_TG_Clear(300);
+            }else {
+                ctr_TG_Clear(400);  //20260924-350修改为400
+            }
             system_status.cleaning_count +=1;   //清扫次数
         }
         if(device_status.clear_status==2)

+ 9 - 10
Application_cbd_apm32f1/applications/control.h

@@ -15,11 +15,11 @@
 #include <rtdevice.h>
 //定制相关//////////////////////////////////////////////////////
 
-#define PCB_V1           1             //1-旧PCB,0-新PCB(模块化)
+#define PCB_V1           0             //1-旧PCB,0-新PCB(模块化)
 #define MATCH_DEVICE     0             //比赛设备1-开启 0-关闭
 #define SENSOR_EN        0             //温湿度:0关闭,1打开
 #define UART_TEST_EN     0             ///串口测试0-关闭,1-启用
-#define TG_MODULE        0             //推杆电机结构模块化控制
+#define TG_MODULE        1             //推杆电机结构模块化控制
 #define DINGZHI_0722     0             //控制一个电机每天12点20工作12秒
 #define QINGSAO_IO       1             //调整清扫顺序20250801
 #define WENKONG          1             //温控功能1-开启 0-关闭
@@ -34,10 +34,10 @@
 #endif
 ////////////////////////////////////////////////////////////////
 
-#define VERSION_HK          "2.52.41(HK)"            //4.0海康-1200W
+#define VERSION_HK          "2.56.41(HK)"            //4.0海康-1200W
 #if TG_MODULE == 0
     #if JINGJIKUAN == 0
-        #define VERSION_HK_2000W    "2.52.4(2000W)"         //4.0水稻
+        #define VERSION_HK_2000W    "2.56.4(2000W)"         //4.0水稻
     #else
         #define VERSION_HK_2000W    "2.49.4(jjk-5)"           //经济款
     #endif
@@ -45,13 +45,13 @@
     #if MATCH_DEVICE == 1
         #define VERSION_HK_2000W    "3.3.4(TG)"             //推杆结构比赛设备
     #else
-        #define VERSION_HK_2000W    "2.13.4(TG111)"         //推杆结构
+        #define VERSION_HK_2000W    "2.56.4(TG)"            //推杆结构
     #endif
 #endif
 
 
-#define VERSION_ZP          "2.52.1(ZP)"            //1.0转盘
-#define VERSION_GK          "2.52.1(GK)"            //1.0高空
+#define VERSION_ZP          "2.56.1(ZP)"            //1.0转盘
+#define VERSION_GK          "2.56.1(GK)"            //1.0高空
 
 extern rt_event_t event_485_play;
 
@@ -185,9 +185,8 @@ typedef struct  _packed
     char imei[32];             //IMEI,唯一ID
     char link_ip[32];
     char cam_model[64];        //相机型号
-    char json_w_clock[128];    //修改时间
-    char json_w_reset[128];    //
-    char json_w_platform[128]; //
+    /* json_w_clock/json_w_reset/json_w_platform 三个操作记录串已改为
+       上报处的局部缓冲(仅用于即时组包上报),不再占用全局结构体 384 字节。 */
     /* ★ P2-7 这三个字段原来分别是 power[8] / heat_power[8] / voltage[6],
        而写入用的是无长度检查的 sprintf:
          voltage    <- "%d.%02d"  如 "39.80" = 5 字符 + '\0' = 6 字节  → 零余量

+ 317 - 49
Application_cbd_apm32f1/applications/dtu_uart2.c

@@ -86,6 +86,41 @@ static rt_tick_t s_last_json_rx_tick = 0;   /* 上次收到完整JSON数据的
 
 #define JSON_RX_TIMEOUT_TICK    (2ULL * 3600 * RT_TICK_PER_SECOND)  /* 2小时超时(tick数) */
 
+/* ================= 开机参数同步(备份/恢复)一次性任务 =================
+ * 原实现在发送线程入口无条件调用一次:
+ *   iFlag==0 -> backup_param_to_rtu()   把 MCU 参数写给 RTU
+ *   iFlag==1 -> recover_param_from_rtu() 参数异常, 向 RTU 要备份参数
+ * 但线程启动那一刻 RTU 往往还没起来(MCU 先起、RTU 后起; 或 RTU 正在被断电重启),
+ * 发出去的帧没有接收方: 备份丢包、恢复请求无人应答, 参数就永久停在默认值,
+ * 而"只执行一次"又导致永不重试。
+ * 现改为三态状态机(见 dtu_param_sync_poll):
+ *   IDLE -> 先等 RTU 首个完整 JSON(链路真的通了)再发(最多等 PARAM_SYNC_WAIT_MS);
+ *           超时说明 RTU 一直沉默, 先盲发一帧, 转 WAIT
+ *   WAIT -> RTU 已就绪但未确认: 按 PARAM_SYNC_RETRY_MS 重发, 超 PARAM_SYNC_RETRY_MAX 次放弃;
+ *           RTU 仍未就绪: 按 PARAM_SYNC_PROBE_MS 盲发(不提前放弃, 等它后面起来)
+ *   DONE -> 本次上电不再执行(保证"只执行一次")
+ */
+#define PARAM_SYNC_IDLE         0u
+#define PARAM_SYNC_WAIT         1u
+#define PARAM_SYNC_DONE         2u
+#define PARAM_SYNC_WAIT_MS      120000u   /* 等 RTU 就绪的最长时间(ms) */
+#define PARAM_SYNC_RETRY_MS     15000u    /* RTU 已就绪但未确认时的重发间隔(ms) */
+#define PARAM_SYNC_RETRY_MAX    4u        /* RTU 已就绪时的重发次数上限 */
+#define PARAM_SYNC_PROBE_MS     60000u    /* RTU 沉默(未就绪)时的盲发间隔(ms) */
+
+/* 上报线程等联网成功(net=="0")的最长时间: 未联网就上报, 平台根本收不到,
+   首包丢了还得等一个完整 dattim 周期才会重发 —— 所以先等网, 最多 3 分钟。 */
+#define DTU_NET_WAIT_MS         180000u
+
+static volatile uint8_t s_rtu_rx_ok = 0;      /* 本次上电是否已收到过 RTU 的完整 JSON */
+static uint8_t  s_param_sync_state = PARAM_SYNC_IDLE;
+static uint8_t  s_param_sync_retry = 0;
+static rt_tick_t s_param_sync_start = 0;      /* 线程启动时刻(等待超时基准) */
+static rt_tick_t s_param_sync_last  = 0;      /* 上次发出请求的时刻(重发基准) */
+
+static void dtu_param_sync_poll(void);
+static void dtu_param_sync_on_rtu_params(void);
+
 /* ★ 接收批量读的块大小。
    原来接收线程是 rt_device_read(dev, -1, &ch, 1) —— 一次系统调用只取 1 字节。
    uart2 跑 115200bps 8N1 = 11520 字节/秒,也就是**每秒一万多次 rt_device_read**,
@@ -349,6 +384,14 @@ void DTU_Write(char *fmt, ...)
     static char dtu_str[1024];
     rt_size_t str_length;
 
+    /* ★ OTA 前 uart_stop_for_ota() / 串口重连过程中 dtuserial 可能为 NULL,
+       原来直接 rt_device_write(NULL,...) 会解引用空设备指针 -> HardFault。
+       与 Uart5_Write()/Uart5_Write_Bin() 的判空保持一致。 */
+    if (dtuserial == RT_NULL)
+    {
+        return;
+    }
+
     /* dtu_write_mutex 可能在 dtu_data_play() 之前被使用(如开机参数丢失时
        ResetParamDefault_DC() 提前调用 DTU_Write),首次使用时确保已初始化。
        ★ 惰性初始化必须放在临界区里: 否则两个线程同时第一次进来会各自 init 一次
@@ -457,8 +500,13 @@ static rt_err_t dtu_input(rt_device_t dev, rt_size_t size)
  */
 void dtu_uart2_reinit_rx(void)
 {
-    rt_device_set_rx_indicate(dtuserial, dtu_input);
-    LOG_I("dtu_uart2 rx_indicate re-registered");
+    /* ★ 设备未找到/已关闭时 dtuserial 为 NULL, rt_device_set_rx_indicate(NULL,..)
+       会解引用空句柄 */
+    if (dtuserial != RT_NULL)
+    {
+        rt_device_set_rx_indicate(dtuserial, dtu_input);
+        LOG_I("dtu_uart2 rx_indicate re-registered");
+    }
 }
 
 /* ===================== 平台/RTU 下发的 JSON 安全取用辅助 =====================
@@ -568,13 +616,23 @@ static void dtu_feed_block(lwjson_stream_parser_t *parser,
                   case lwjsonSTREAMINPROG:      /* 3, 正在解析中 */
                     break;
                   case lwjsonSTREAMDONE:        /* 4, 解析已完成 */
+                     /* ★ accum_buf 是逐字节追加的, 从来没有补 '\0':
+                        后一帧比前一帧短时, 尾部还残留上一帧的字节,
+                        cJSON_Parse() 按字符串解析会读到垃圾甚至越界。
+                        *accum_len 最大 MAX_DTU_SIZE-1, 补终止符不会越界。 */
+                     if (*accum_len < MAX_DTU_SIZE)
+                     {
+                         accum_buf[*accum_len] = '\0';
+                     }
                      parseDtu(accum_buf);
                      if (uart2_tick)
                      {
                          s_last_json_rx_tick = rt_tick_get();   /* 记录收到完整JSON的时间 */
+                         s_rtu_rx_ok = 1;                       /* RTU 已起来且链路正常 */
                      }
                      *accum_len = 0;
-                     memset(accum_buf, 0, sizeof(accum_buf));
+                     /* ★ 原来写 sizeof(accum_buf): accum_buf 是形参指针, 只清了 4 字节 */
+                     memset(accum_buf, 0, MAX_DTU_SIZE);
                      //rt_thread_kill(dtu_send_data, SIGUSR2);
                      lwjson_stream_reset(parser);
                      break;
@@ -601,6 +659,13 @@ static void dtu_thread_entry_recv(void *parameter)
         /* ★ 一次读一整块, 而不是 rt_device_read(dev,-1,&ch,1) 一个字节一次。
            pending 只是"有多少字节可读"的参考值, 不参与正确性判断:
            read 返回 0 就说明暂时没数据了, 直接退回等信号量。 */
+        /* ★ dtuserial 在 OTA/串口重连期间会被置 NULL, 原来直接传进
+           rt_device_read() 会解引用空指针。 */
+        if (dtuserial == RT_NULL)
+        {
+            rt_thread_delay(100);
+            continue;
+        }
         n = rt_device_read(dtuserial, 0, rx_blk, sizeof(rx_blk));
         if (n == 0)
         {
@@ -638,6 +703,12 @@ static void uart5_thread_entry_recv(void *parameter)
 
     lwjson_stream_init(&lwparser_485, NULL);
     while (1) {
+        /* ★ 同 uart2: 设备句柄判空, 避免热插拔/重连窗口内解引用 NULL */
+        if (serial_485 == RT_NULL)
+        {
+            rt_thread_delay(100);
+            continue;
+        }
         n = rt_device_read(serial_485, 0, rx_blk, sizeof(rx_blk));
         if (n == 0)
         {
@@ -664,22 +735,36 @@ struct tm* parseTimestamp(const char *timestamp) {
         return NULL;
     }
     LOG_I("parseTimestamp:%s",timestamp);
-    int year, month, day, hour, minute, second;
-    sscanf(timestamp, "%4d%2d%2d%2d%2d%2d", &year, &month, &day, &hour, &minute, &second);
-    //校验时间日期
-    if(year<2024||month>12||day>31||hour>23||minute>59||second>59) return NULL;
+    int year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0;
+    /* ★ 必须检查 sscanf 返回值: 时间戳里混入非数字时 6 个变量保持未初始化,
+       后面的校验和 mktime() 全在拿栈上的随机值运算。 */
+    if (sscanf(timestamp, "%4d%2d%2d%2d%2d%2d", &year, &month, &day, &hour, &minute, &second) != 6)
+    {
+        LOG_E("Invalid timestamp content: %s", timestamp);
+        return NULL;
+    }
+    //校验时间日期(★ 原来没判 month<1 / day<1, 0 月 0 日会算成上月月末)
+    if(year<2024||month<1||month>12||day<1||day>31||hour>23||minute>59||second>59) return NULL;
 
-    struct tm* tm_time = (struct tm*)malloc(sizeof(struct tm));
+    struct tm* tm_time = (struct tm*)rt_malloc(sizeof(struct tm));
+    /* ★ malloc 未判空: 内存不足时直接写空指针; 且 tm_isdst/tm_wday 未初始化,
+       mktime() 会读未定义值(夏令时判断)。 */
+    if (tm_time == NULL) {
+        LOG_E("No memory for tm");
+        return NULL;
+    }
+    memset(tm_time, 0, sizeof(struct tm));
     tm_time->tm_year = year - 1900; // tm_year is years since 1900
     tm_time->tm_mon = month - 1;   // tm_mon is 0-11
     tm_time->tm_mday = day;
     tm_time->tm_hour = hour;
     tm_time->tm_min = minute;
     tm_time->tm_sec = second;
+    tm_time->tm_isdst = 0;
 
     // Check if the time is valid
     if (mktime(tm_time) == -1) {
-        free(tm_time);
+        rt_free(tm_time);   /* ★ 与 rt_malloc 配对, 不能用 newlib 的 free() */
         LOG_E("Failed to parse time: %s", timestamp);
         return NULL;
     }
@@ -842,18 +927,20 @@ static void dtu_thread_entry_send(void *parameter)
     static uint8_t record_current = 0;
     static uint8_t lamp_sta_cnt = 0;
 
-    if(device_status.iFlag==0){
-        backup_param_to_rtu();
-    }else{
-        recover_param_from_rtu();
-    }
+    /* ★ 原来在这里直接 backup/recover:
+         此刻 RTU 可能还没启动(或正在被断电重启), 发出去没人接 —— 备份丢包、
+         恢复请求无应答, 参数永久停在默认值且不再重试。
+       改成登记起始时刻, 由 dtu_param_sync_poll() 在 RTU 链路通了之后执行,
+       且整个上电周期只执行一次(状态机 DONE)。 */
+    s_param_sync_start = rt_tick_get();
+    s_param_sync_state = PARAM_SYNC_IDLE;
+    s_param_sync_retry = 0;
     device_status.num_updata = 0;
-    rt_thread_delay(10000);
+    rt_thread_delay(5000);
     /* RTU 通信看门狗从线程启动时开始计时:
      * 原实现只在"曾经收到过 JSON"后才计时,RTU 完全无输出(波特率错、模块故障)时保护失效 */
     s_last_json_rx_tick = rt_tick_get();
-
-    /* 开机首次上报(不等联网、不区分联网状态),随后启动周期定时器 */
+    /* 开机首次上报,随后启动周期定时器 */
     dtu_periodic_report();
     dtu_report_timer_reload();
     rt_timer_start(&s_dtu_check_timer);
@@ -862,6 +949,9 @@ static void dtu_thread_entry_send(void *parameter)
     {
         rt_err_t evt_ret;
 
+        /* 开机参数备份/恢复(一次性):等 RTU 就绪后执行一次, 未确认则按间隔重发 */
+        dtu_param_sync_poll();
+
         /* 1 秒超时用于维护数据上传倒计时与周期打印;有事件时立即唤醒处理 */
         evt_ret = rt_event_recv(&s_dtu_send_evt,
                                 DTU_EVT_REPORT | DTU_EVT_RTU_WDT,
@@ -944,7 +1034,10 @@ int dtu_data_play(void)
 #if 1
     DTU_uart5_init();
     rt_sem_init(&rx5_sem, "rx5_sem", 0, RT_IPC_FLAG_FIFO);
-    rt_device_set_rx_indicate(serial_485, uart5_input);
+    if (serial_485 != RT_NULL)
+    {
+        rt_device_set_rx_indicate(serial_485, uart5_input);
+    }
 #endif
     //初始化消息队列
     rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
@@ -957,8 +1050,11 @@ int dtu_data_play(void)
                   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);
+    /* 设置接收回调函数(设备打开失败时 dtuserial 为 NULL, 不能直接传进去) */
+    if (dtuserial != RT_NULL)
+    {
+        rt_device_set_rx_indicate(dtuserial, dtu_input);
+    }
     /*创建线程-指令发送*/
     dtu_send_data = rt_thread_create("DTU_Uart_thread_send",
                                     dtu_thread_entry_send,RT_NULL,
@@ -1192,10 +1288,15 @@ char *makeJson_selfCheck_(uint8_t sta)  //sta==0 应答,sta==1结果
         cJSON_AddItemToObject(pRoot2, "C708", cJSON_CreateNumber(device_status.temp_status));       //低温保护状态
         cJSON_AddItemToObject(pRoot2, "C709", cJSON_CreateNumber(device_status.timeSwitch));       //工作模式
         char time_stet[10];
-        sprintf(time_stet,"%d-%d",device_status.startBar,device_status.stopBar);
+        rt_snprintf(time_stet,sizeof(time_stet),"%d-%d",device_status.startBar,device_status.stopBar);
         cJSON_AddItemToObject(pRoot2, "C710", cJSON_CreateString(time_stet));    //时控时长
         char voltage_s[10];     /* 原 [6] 在电压>=100.00V 时结果达 7 字节即越界,放大并改用带界格式化 */
-        rt_snprintf(voltage_s,sizeof(voltage_s),"%d.%02d",Read_Real_Voltage()/100,Read_Real_Voltage()%100);
+        /* ★ 原来 Read_Real_Voltage() 连调两次: 两次 ADC 采样值可能不同,
+           组出来的电压可能自相矛盾(如 12.99 -> "12.00")。读一次再用。 */
+        {
+            int mv = Read_Real_Voltage();
+            rt_snprintf(voltage_s,sizeof(voltage_s),"%d.%02d",mv/100,mv%100);
+        }
         //f_voltage = (int)(f_voltage * 100 + 0.5) / 100.0f;
         cJSON_AddItemToObject(pRoot2, "C711", cJSON_CreateNumber(atof(voltage_s)));    //电池电压
         cJSON_AddItemToObject(pRoot2, "C712", cJSON_CreateNumber(0.00));    //太阳能板电压
@@ -1421,21 +1522,32 @@ char* makeJsonRpc2_0(const char* method, cJSON* params, int id)
         return NULL;
     }
 
+    /* ★ 约定: params 一旦传进来, 无论成功失败都由本函数接管(成功时随 root 一起释放)。
+       原来前面这几条失败路径直接 return, params 对象无人释放 -> 每次失败泄漏一块堆。 */
     cJSON* root = cJSON_CreateObject();
     if (root == NULL) {
         fprintf(stderr, "Error: Failed to create JSON object\n");
+        if (params != NULL) {
+            cJSON_Delete(params);
+        }
         return NULL;
     }
 
     // 添加 jsonrpc 版本
     if (!cJSON_AddStringToObject(root, "jsonrpc", "2.0")) {
         cJSON_Delete(root);
+        if (params != NULL) {
+            cJSON_Delete(params);
+        }
         return NULL;
     }
 
     // 添加 method
     if (!cJSON_AddStringToObject(root, "method", method)) {
         cJSON_Delete(root);
+        if (params != NULL) {
+            cJSON_Delete(params);
+        }
         return NULL;
     }
 
@@ -1680,6 +1792,127 @@ void recover_param_from_rtu(void)
     dtu_write_json(makeJsonRpc2_0("recover_param", NULL, 1));
 }
 
+/* RTU 回传了一批参数(sync_param): 若本次上电的参数恢复还在等应答,
+   说明 RTU 已收到请求并把备份参数发回来了 —— 恢复完成, 清 iFlag 并终结一次性任务。
+
+   (平台正常下发参数时状态机多半处于 DONE/IDLE, 这里直接返回, 不干扰。) */
+static void dtu_param_sync_on_rtu_params(void)
+{
+    if (s_param_sync_state != PARAM_SYNC_WAIT)
+    {
+        return;
+    }
+
+    s_param_sync_state = PARAM_SYNC_DONE;
+
+    if (device_status.iFlag != 0)
+    {
+        device_status.iFlag = 0;    /* 参数已从 RTU 恢复, 本上电不再请求 */
+        LOG_I("[param] 已从RTU恢复备份参数, 开机一次性恢复完成");
+    }
+    else
+    {
+        LOG_I("[param] 开机参数备份已得到RTU响应");
+    }
+}
+
+/* 开机参数备份/恢复的一次性任务: 由发送线程每轮循环调用(约 1s), 非阻塞。
+   规则: RTU 就绪(收到过完整 JSON)后才正式发送; RTU 一直不就绪时按 60s 盲发等待它起来;
+         恢复请求未收到 sync_param 应答则重发, 超限放弃;
+         无论成功、放弃还是已完成, 都置 DONE, 保证一个上电周期只执行一次。 */
+static void dtu_param_sync_poll(void)
+{
+    rt_tick_t now = rt_tick_get();
+    rt_tick_t interval;
+
+    if (s_param_sync_state == PARAM_SYNC_DONE)
+    {
+        return;         /* 本上电的一次性任务已结束, 不再执行 */
+    }
+
+    if (s_param_sync_state == PARAM_SYNC_IDLE)
+    {
+        /* RTU 尚未启动时发送的帧没有接收方: 先等链路通;
+           最多等 PARAM_SYNC_WAIT_MS, 之后按盲发处理(RTU 可能一直沉默) */
+        if (s_rtu_rx_ok == 0 &&
+            (now - s_param_sync_start) < rt_tick_from_millisecond(PARAM_SYNC_WAIT_MS))
+        {
+            return;
+        }
+
+        if (device_status.iFlag == 0)
+        {
+            backup_param_to_rtu();
+            LOG_I("[param] 开机参数备份到RTU(RTU %s)",
+                  s_rtu_rx_ok ? "已就绪" : "未就绪, 先盲发");
+            if (s_rtu_rx_ok)
+            {
+                s_param_sync_state = PARAM_SYNC_DONE;   /* 链路已通, 备份发出即完成 */
+                return;
+            }
+        }
+        else
+        {
+            recover_param_from_rtu();
+            LOG_I("[param] 参数异常, 请求RTU下发备份参数(RTU %s)",
+                  s_rtu_rx_ok ? "已就绪" : "未就绪, 先盲发");
+        }
+
+        s_param_sync_state = PARAM_SYNC_WAIT;
+        s_param_sync_retry = 0;
+        s_param_sync_last  = now;
+        return;
+    }
+
+    /* ---------------- PARAM_SYNC_WAIT ---------------- */
+
+    /* 备份请求曾在"RTU 未就绪"时盲发过: 链路一通就补发一帧最新参数, 然后完成 */
+    if (s_rtu_rx_ok && device_status.iFlag == 0)
+    {
+        backup_param_to_rtu();
+        LOG_I("[param] RTU 就绪, 补发一次开机参数备份, 完成");
+        s_param_sync_state = PARAM_SYNC_DONE;
+        return;
+    }
+
+    /* RTU 已就绪但没等到应答: 15s 一次, 最多 4 次;
+       RTU 一直未就绪: 60s 盲发一次 —— 它后面(耗电模式结束/断电重启完成)起来就能收到 */
+    interval = rt_tick_from_millisecond(s_rtu_rx_ok ? PARAM_SYNC_RETRY_MS
+                                                    : PARAM_SYNC_PROBE_MS);
+    if ((now - s_param_sync_last) < interval)
+    {
+        return;
+    }
+
+    if (s_rtu_rx_ok)
+    {
+        if (s_param_sync_retry >= PARAM_SYNC_RETRY_MAX)
+        {
+            LOG_E("[param] RTU 未确认%s请求, 放弃本次(保持当前参数, 下次上电再试)",
+                  device_status.iFlag ? "恢复" : "备份");
+            s_param_sync_state = PARAM_SYNC_DONE;
+            return;
+        }
+        s_param_sync_retry++;
+        LOG_W("[param] 重发%s请求 %d/%d", device_status.iFlag ? "恢复" : "备份",
+              s_param_sync_retry, PARAM_SYNC_RETRY_MAX);
+    }
+    else
+    {
+        LOG_W("[param] RTU 仍未就绪, 重新盲发%s请求", device_status.iFlag ? "恢复" : "备份");
+    }
+
+    if (device_status.iFlag == 0)
+    {
+        backup_param_to_rtu();
+    }
+    else
+    {
+        recover_param_from_rtu();
+    }
+    s_param_sync_last = now;
+}
+
 void upload_sys_monitor_info(void)
 {
     char value_str[32];
@@ -1795,8 +2028,12 @@ char * makeJson()
     /* ★ 原来只有 5 字节: dattim / shake_sec 是 uint16_t, 十进制最长 "65535" = 5 字符 + '\0' = 6,
        parse_param_to_mcu() 从 RTU 同步时若没做范围校验(见本文件 sync_* 的校验), 这里就会栈溢出。 */
     char utos[12];
-    if(device_status.gps==NULL)
-    rt_sprintf(device_status.gps, "0");
+    /* ★ 原来写的是 if(device_status.gps==NULL): gps 是数组成员不是指针,
+       该条件恒为假(gcc 会警告), 空 GPS 从来没被填 "0"。 */
+    if(device_status.gps[0]=='\0')
+    {
+        rt_snprintf(device_status.gps, sizeof(device_status.gps), "0");
+    }
 
     if(device_status.work_status==0) {
         device_status.lamp = 0;
@@ -1841,6 +2078,7 @@ char * makeJson()
     if(NULL==pSubJson)
     {
         rt_kprintf("cJSON pSubJson NULL!!!\n");
+        cJSON_Delete(pJsonRoot);   /* ★ 原来直接 return: pJsonRoot 及已挂的子对象全部泄漏 */
         return NULL;
     }
 
@@ -2251,6 +2489,8 @@ int parseDtu(char *json_string)
                   if(strcmp(method_s,"sync_param")==0){
                       if(PARAMS!=NULL&&PARAMS->type==cJSON_Object){
                           parse_param_to_mcu(PARAMS);
+                          /* 开机"参数恢复"的一次性任务: 收到 RTU 回传的参数即视为恢复完成 */
+                          dtu_param_sync_on_rtu_params();
                       }
                   }else if (strcmp(method_s, "upgradehmi") == 0) {
                       if(PARAMS !=NULL&&PARAMS->type==cJSON_Object){
@@ -2317,8 +2557,10 @@ int parseDtu(char *json_string)
                               /* ★ alarm_tg 只有 12 字节, 原来是无长度限制的 rt_sprintf */
                               SET_STATUS_STR(device_status.alarm_tg, s_time->valuestring);
                               ef_set_env_blob("alarm_tg", &device_status.alarm_tg, sizeof(device_status.alarm_tg));
-                              static char temp[10];
-                              rt_sprintf(temp, "time:%s",device_status.alarm_tg);
+                              /* ★ 原来是 char temp[10] + "time:%s": alarm_tg 最长 11 字节,
+                                 "time:" + 11 = 16 字节, 直接踩栈溢出。 */
+                              char temp[24];
+                              rt_snprintf(temp, sizeof(temp), "time:%s",device_status.alarm_tg);
                               dtu_write_json(makeJson_Warn(temp, "set alarmtime"));
                           }
                       }
@@ -2329,23 +2571,21 @@ int parseDtu(char *json_string)
 
               }
               //json rpc服务端响应
-              if(RESULT!=NULL&&RESULT->type==cJSON_String)
+              /* ★ 原来外层条件是 type==cJSON_String, 内层却判 type==cJSON_Object:
+                 Object 分支永远进不去(死代码), 而且 RESULT 是 Object 时
+                 HMI_WRITE(...RESULT->valuestring) 会拿 NULL 当字符串。 */
+              if(RESULT!=NULL)
               {
-                  if(RESULT!=NULL && RESULT->type==cJSON_Object){
+                  if(RESULT->type==cJSON_Object){
                       cJSON* message = cJSON_GetObjectItem(RESULT, "message");
-                      if(message!=NULL && message->type==cJSON_String){
-                          if(strcmp(message->valuestring,"success")==0){
-                              LOG_W("重启RTU指令响应成功!");
-                          }
-                      }else{
-                          HMI_WRITE("menu.result.txt=\"%s\"",RESULT->valuestring);
+                      if(message!=NULL && message->type==cJSON_String
+                         && strcmp(message->valuestring,"success")==0){
+                          LOG_W("重启RTU指令响应成功!");
                       }
                   }
-                  if(RESULT!=NULL && RESULT->type==cJSON_String){
+                  else if(RESULT->type==cJSON_String){
                       HMI_WRITE("menu.result.txt=\"%s\"",RESULT->valuestring);
                   }
-
-
               }
           }
           if(mqtt_data_record_TF_Max!=NULL)
@@ -2423,8 +2663,13 @@ int parseDtu(char *json_string)
               //上报自检结果
               if(strlen(device_status.qianming)>=2){
                   char *json_temp = makeJson_selfCheck_(1);
-                  DTU_Write("%s",json_temp);
-                  free(json_temp);
+                  if(json_temp!=NULL){
+                      DTU_Write("%s",json_temp);
+                      /* ★ cJSON 在 __RTTHREAD__ 下用 rt_malloc, 原来配 newlib 的 free():
+                         两个堆不同, free 到错误堆上 -> 堆链表被破坏, 运行一段时间后
+                         malloc 崩溃/死机。改为 rt_free 并判空。 */
+                      rt_free(json_temp);
+                  }
               }
 
           }
@@ -2436,8 +2681,10 @@ int parseDtu(char *json_string)
               SET_STATUS_STR(device_status.qianming, cj_str(item_checkself, ""));
               //生成自检应答json
               char *json_temp = makeJson_selfCheck_(0);
-              DTU_Write("%s",json_temp);
-              free(json_temp);
+              if(json_temp!=NULL){
+                  DTU_Write("%s",json_temp);
+                  rt_free(json_temp);   // ★ 同上: cJSON 内存必须用 rt_free
+              }
               ctr_lamp(ON, 1);
               ctr_Heat(OFF);
               //执行自检
@@ -2803,7 +3050,7 @@ int parseDtu(char *json_string)
 //                             setSystemTime(tm_time);
 //                          }
                       }
-                      free(tm_time); // Free the allocated memory
+                      rt_free(tm_time); // ★ 与 parseTimestamp() 里的 rt_malloc 配对
                   }
                   {
                       //先判断是否是空字符再判断数值是否合理
@@ -2848,7 +3095,9 @@ int parseDtu(char *json_string)
                     LOG_W("Unknow cmd value!");
                   }
               }
-              else if (strstr(item_cmd->valuestring,"synchronization")!=RT_NULL)
+              /* ★ item_cmd 是 Object/Number 时 valuestring 为 NULL, strstr(NULL,..) 直接崩;
+                 统一走 cmd_s(cj_str 已做类型与空值兜底) */
+              else if (strstr(cmd_s,"synchronization")!=RT_NULL)
                 {
                     HMI_WRITE("menu.warn.txt=\"%s\"","");
                     /* 类型校验:同步数据全部位于 ext 对象内,ext 缺失/类型错误时直接忽略,
@@ -2944,15 +3193,22 @@ int parseDtu(char *json_string)
                         else if(set_date(year,month,day)==RT_EOK)
                         {
                               LOG_I("设置日期:%d年%d月%d日",year,month,day);
-                              if(hour<24&&minute>=0&&minute<60&&second>=0&&second<60)
+                              if(hour>=0&&hour<24&&minute>=0&&minute<60&&second>=0&&second<60)
                               {
                                   LOG_I("设置时间:%d时%d分%d秒",hour,minute,second);
                                   set_time(hour,minute,second);
                               }else{
-                                  LOG_E("set_date failed!");
-                                  rt_hw_rtc_init();
+                                  /* ★ 日期已经写成功了, 这里只是时分秒非法: 原来错报
+                                     "set_date failed" 并 rt_hw_rtc_init(), 把刚设好的
+                                     日期整块冲掉。 */
+                                  LOG_E("invalid time field:%02d:%02d:%02d, date kept",hour,minute,second);
                               }
                         }
+                        else
+                        {
+                              LOG_E("set_date failed!");
+                              rt_hw_rtc_init();
+                        }
                     }
 
                     if(lat!=RT_NULL||lng!=RT_NULL)
@@ -3097,15 +3353,27 @@ int parseDtu(char *json_string)
                     }
                     /* s_reporting=1 等效原 num_updata==0 的上报窗口:该窗口内的同步数据只提示,
                      * 窗口外若屏幕请求过数据刷新(hmi_fresh==2)则补发一次上报 */
-                    if( s_reporting==1 )
+                    if( s_reporting==1 || device_status.num_updata==0)
                     {
                         Beep_Tip(100);
+                        /* 2026-10-15 修复:上报窗口内的同步数据不得吞掉待补发的上报请求。
+                         * 原实现无条件清零 hmi_fresh,云端 read 的补发请求(==2)一旦落在
+                         * 周期上报窗口内即被清除 → read 应答丢失、RTU 侧等待超时(设备实测)。
+                         * 现窗口内仅当 hmi_fresh!=2 时清零;在途请求由后续同步触发补发。 */
+                        if(device_status.hmi_fresh!=2)
+                        {
+                            device_status.hmi_fresh = 0;
+                        }
                     }
-                    else if(device_status.hmi_fresh==2)
+                    if(device_status.hmi_fresh==2)
                     {
                         UpLoad_Data();
+                        device_status.hmi_fresh = 0;
+                    }
+                    else
+                    {
+                        device_status.hmi_fresh = 0;
                     }
-                    device_status.hmi_fresh = 0;
                     }
                 }
               if(item_ext!=RT_NULL&&strstr(cmd_s,"paramconf")!=RT_NULL)

+ 332 - 217
Application_cbd_apm32f1/applications/hmi.c

@@ -95,8 +95,13 @@ static rt_err_t uart_input(rt_device_t dev, rt_size_t size);
 /* P2-14 把开机等联网搬进独立线程时新增的两个函数, 定义在文件后段
    (Check_ParamConfig 之后), 但 net_wait_start() 在前面的 Check_ParamConfig 里
    就被调用 -> 必须先有前向声明, 否则报 implicit declaration。 */
-static void net_wait_thread_entry(void *parameter);
-static void net_wait_start(void);
+static void net_wait_thread_entry(void);
+
+/* 开机"联网检测线程"(net_wait)是否仍在运行。
+   net_wait 在等网期间自己每秒发一帧 read 去刷新网络状态;
+   refresh_hmi_Component() 每 5 个节拍也会发一帧 read —— 两者同时发就是重复上报,
+   RTU 会连续收到两倍 read 帧。用本标志让 HMI 侧在 net_wait 退出前让路。 */
+static volatile uint8_t net_wait_running = 0;
 
 #ifdef RT_USING_SERIAL_V2
 static int HMI_uart4_init(void)
@@ -134,7 +139,6 @@ static int HMI_uart4_init(void)
 }
 #endif
 
-
 /* ==================== UART4(屏幕)发送:互斥 / 升级闸门 / 批量 / 去重 ====================
  * 来源: master 分支 2026-10-10 发送优化(HMI_WRITE 签名不变, 调用方无感):
  *   ① 批量发送:HMI_BATCH_BEGIN()/END() 之间累积成整块再一次写入(缓冲满自动 flush);
@@ -546,6 +550,10 @@ void process_hex_payload(const char* hex_str, int req_id) {
     {
         /* 新一轮屏幕升级开始: 复位重复过滤表, 升级结束后屏幕控件恢复全量刷新 */
         hmi_dedupe_reset();
+        /* ★ 原来只复位去重表: 第二轮升级时 bytes_received 仍是上一轮的值,
+           首包就满足 >= total_file_size -> 立刻判"升级完成"并退出 HMI 线程。 */
+        bytes_received = 0;
+        recv_write_pos = 0;
     }
     /* 升级传输期间屏蔽普通刷新指令(见 HMI_WRITE 升级闸门) */
     Hmi_Upgrade_Begin();
@@ -572,14 +580,22 @@ void process_hex_payload(const char* hex_str, int req_id) {
     if (recv_write_pos >= 4096) {
         LOG_I("发送 4096 字节到HMI...");
 
-        if (send_raw_to_hmi(recv_buffer, 4096) == 0) {
-            LOG_I("发送成功");
-            // ✅ 直接清空缓冲区
-            recv_write_pos = 0;
-        } else {
+        if (send_raw_to_hmi(recv_buffer, 4096) != 0) {
             LOG_E("发送失败");
+            return;
         }
-        return;
+        LOG_I("发送成功");
+        /* ★ 原来发送后直接 recv_write_pos = 0: 本块解码长度不是 512 整数倍时,
+           超出的尾部(最多 511 字节)被整块丢掉 -> 屏幕收到的固件流缺字节。
+           发完 4096 字节后把剩余字节前移保留。 */
+        if (recv_write_pos > 4096) {
+            memmove(recv_buffer, recv_buffer + 4096, recv_write_pos - 4096);
+            recv_write_pos -= 4096;
+        } else {
+            recv_write_pos = 0;
+        }
+        /* 不再 return: 文件长度正好是 4096 整数倍时, 最后一包之后不会再有新数据,
+           原来在这里返回会让升级永远停在 RECEIVING。继续走下面的完成判断。 */
     }
 
     // 检查完成
@@ -754,9 +770,18 @@ static void refresh_hmi_Component(struct tm tm)
     if(device_status.refresh_num>=5)
     {
         device_status.refresh_num = 0;
-        char *readinfo =  makeJson_ReadInfo();
-        DTU_Write("%s",readinfo);
-        rt_free(readinfo);
+        /* ★ 开机联网检测线程(net_wait)还没退出时, 它自己每秒都在发 read 刷状态:
+           这里再发就是重复上报。等它退出(联网成功/超时)后由本函数接管刷新。
+           顺带补上 makeJson_ReadInfo() 的空指针判断(原实现会把 NULL 送进 DTU_Write)。 */
+        if (net_wait_running == 1)
+        {
+            char *readinfo = makeJson_ReadInfo();
+            if (readinfo != RT_NULL)
+            {
+                DTU_Write("%s", readinfo);
+                rt_free(readinfo);
+            }
+        }
         device_status.hmi_fresh = 1;
         rt_thread_delay(100);
     }
@@ -1759,6 +1784,188 @@ static void hmi_refresh_debug1(void)
     }
 }
 
+/* 屏幕版本握手串变化检测。
+ * 说明:屏幕心跳里 SwversionV** 可能与 getFullData 一样每秒都发,
+ * 若每次都复位重复过滤表会让去重完全失效;因此只在"版本串发生变化"时复位
+ * (换型号/换页面工程才会变)。屏幕重启但版本不变的情况由 HMI_DEDUPE_RESYNC_SEC
+ * 周期复位兜底(最坏 10s 后恢复全量刷新)。
+ * 2026-10-15:版本串变化还用于触发版本类型切换(hmi_switch_version),
+ * 见 HMI_Decode 的 SwversionV 分支。 */
+static char s_last_hmi_ver[16] = {0};
+
+static rt_bool_t hmi_ver_changed(const char *frame)
+{
+    char cur[16];
+    int  i = 0;
+
+    while (frame[i] != '\0' && frame[i] != '\r' && frame[i] != '\n' && i < (int)sizeof(cur) - 1)
+    {
+        cur[i] = frame[i];
+        i++;
+    }
+    cur[i] = '\0';
+
+    if (rt_strcmp(cur, s_last_hmi_ver) != 0)
+    {
+        rt_strncpy(s_last_hmi_ver, cur, sizeof(s_last_hmi_ver) - 1);
+        s_last_hmi_ver[sizeof(s_last_hmi_ver) - 1] = '\0';
+        LOG_I("hmi version frame changed: %s", s_last_hmi_ver);
+        return RT_TRUE;
+    }
+    return RT_FALSE;
+}
+
+/* ==================== 屏幕版本串 → 版本类型切换(2026-10-15) ====================
+ * 触发:HMI_Decode 的 SwversionV 分支中,hmi_ver_changed() 检测到屏幕版本握手串
+ *   发生变化时调用一次——即连接/更换不同版本的屏幕工程时,按串切换
+ *   dtype/version_type/driver 并写 EF(MA_save/param_mirror_sync)。
+ * 历史:本逻辑原为 HMI_Decode 内一段 else-if 链(V12/V11/V1/V43/V42/V41/V4/V6/
+ *   V30/V7),自 SwversionV 整页刷新分支加入后所有版本帧都被其先命中,
+ *   原链永远不可达(死代码);现迁移为本函数并改由版本串变化事件触发,
+ *   逐分支语义与原链一致(分包防误切仍用 hmi_cmd_match 严格匹配)。 */
+static void hmi_switch_version(const char *frame)
+{
+    //高空-带拍照
+    if (strstr(frame,"SwversionV12")!=NULL)
+    {
+        device_status.dtype = 3;
+        if(device_status.version_type != 12)
+        {
+            device_status.version_type = 12;
+            sprintf(device_status.driver, "%s",VERSION_GK);
+            ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
+            ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
+            MA_save();
+            param_mark_dirty();
+        }
+        else {
+
+        }
+    }
+    //高空
+    else if (strstr(frame,"SwversionV11")!=NULL)
+    {
+        device_status.dtype = 3;
+        if(device_status.version_type != 11)
+        {
+            device_status.version_type = 11;
+            sprintf(device_status.driver, "%s",VERSION_GK);
+            ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
+            ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
+            MA_save();
+            param_mark_dirty();
+        }
+        else {
+
+        }
+        return;
+    }
+    //1.0
+    /* 注意:必须用严格匹配——"SwversionV1" 是 "SwversionV11/12" 的前缀,
+     * 串口分包时残段会误切到本分支(同 V4 的问题,见 hmi_cmd_match 说明) */
+    else if (hmi_cmd_match(frame,"SwversionV1"))
+    {
+        if(device_status.version_type != 1)
+        {
+            device_status.dtype = 3;
+            device_status.version_type = 1;
+            sprintf(device_status.driver, "%s",VERSION_ZP);
+            ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
+            ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
+            MA_save();
+            param_mark_dirty();
+        }
+        else {
+
+        }
+        return;
+    }
+    //中端款
+    else if (strstr(frame,"SwversionV43")!=NULL) {
+        device_status.dtype = 3;
+        if(device_status.version_type != 43)
+        {
+            device_status.dtype = 3;
+            device_status.version_type = 43;
+            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("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型+
+            MA_save();
+            param_mark_dirty();
+        }
+        return;
+    }
+    //低端款
+    else if (strstr(frame,"SwversionV42")!=NULL) {
+        device_status.dtype = 3;
+        if(device_status.version_type != 42)
+        {
+            device_status.dtype = 3;
+            device_status.version_type = 42;
+            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("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型+
+            MA_save();
+            param_mark_dirty();
+        }
+        return;
+    }
+    //4.0
+    else if (strstr(frame,"SwversionV41")!=NULL) {
+        device_status.dtype = 3;
+        if(device_status.version_type != 41)
+        {
+            device_status.dtype = 3;
+            device_status.version_type = 41;
+            sprintf(device_status.driver, "%s",VERSION_HK);
+            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));        //版本类型+
+            DTU_Write("SwversionV41");
+            MA_save();
+            param_mark_dirty();
+        }
+        else {
+
+        }
+        return;
+    }
+    //水稻
+    /* 注意:必须用严格匹配——"SwversionV4" 是 "SwversionV41/42/43" 的前缀。
+     * 实测(2026-10-08):串口分包时 "SwversionV43" 的前段 "SwversionV4" 会误切到
+     * 本分支(version_type 43→4、误报 RTU、写 Flash),随后完整帧又切回 43,
+     * 造成配置来回翻转。见 hmi_cmd_match 说明。 */
+    else if (hmi_cmd_match(frame,"SwversionV4"))
+    {
+        device_status.dtype = 3;
+        if(device_status.version_type != 4)
+        {
+            device_status.version_type = 4;
+            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("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
+            MA_save();
+            param_mark_dirty();
+        }
+        else {
+
+        }
+        return;
+    }
+    else if((strstr(frame,"SwversionV7")!=NULL)) {
+        if(device_status.dtype!=7)
+        {
+            LOG_D("设置版本类型:7");
+            device_status.dtype = 7;
+            device_status.version_type = 7;
+            ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //设备类型
+            ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
+            DTU_Write("SwversionV7");
+            MA_save();
+            param_mark_dirty();
+        }
+    }
+}
+
 static void HMI_Decode(void)
 {
     time_t now = time(RT_NULL);
@@ -1776,109 +1983,16 @@ static void HMI_Decode(void)
      * 注意:显式排除 "dbg:" 控制台发送帧——b4[发送]会回传整框文本,其中可能内嵌
      * 历史日志里的版本串(如本机口镜像的 hmi rx 行),若不排除会抢在 hmi_debug1_handle
      * 之前吞掉命令帧,导致命令不再执行。 */
-    if (rt_strncmp(rx_buffer, "dbg:", 4) != 0 &&
-        (strstr(rx_buffer,"SwversionV") != NULL || strstr(rx_buffer,"getFullData") != NULL))
+    if(strstr(rx_buffer,"SwversionV") != NULL || strstr(rx_buffer,"getFullData") != NULL)
     {
-        if (strstr(rx_buffer,"SwversionV") != NULL)
+        /* 屏幕版本握手串变化(换型号/换页面工程) → 复位重复过滤表 + 按串切换版本类型,
+                 * 并立即整页全量刷新 */
+        if (strstr(rx_buffer,"SwversionV") != NULL && hmi_ver_changed(rx_buffer))
         {
-            /* 版本串变化检测:只跟踪版本帧本身,getFullData 心跳不参与比较,
-             * 否则两类帧交替到达会反复冲掉跟踪值,去重表被持续清空(去重失效) */
-            static char hmi_ver_last[16];
-            char hmi_ver_cur[16];
-            int  i = 0;
-
-            while (i < (int)sizeof(hmi_ver_cur) - 1 &&
-                   rx_buffer[i] != '\0' && rx_buffer[i] != '\r' && rx_buffer[i] != '\n')
-            {
-                hmi_ver_cur[i] = rx_buffer[i];
-                i++;
-            }
-            hmi_ver_cur[i] = '\0';
-            if (rt_strcmp(hmi_ver_cur, hmi_ver_last) != 0)
-            {
-                rt_strncpy(hmi_ver_last, hmi_ver_cur, sizeof(hmi_ver_last) - 1);
-                hmi_ver_last[sizeof(hmi_ver_last) - 1] = '\0';
-                LOG_I("hmi ver frame changed: %s", hmi_ver_cur);
-                hmi_dedupe_reset();
-            }
-
-            /* ---- 版本类型检测与持久化(原 SwversionV11/V1/V43/V42/V41/V4 分支链并入) ---- */
-            //高空
-            if (strstr(rx_buffer,"SwversionV11")!=NULL)
-            {
-                device_status.dtype = 3;
-                if(device_status.version_type != 11)
-                {
-                    device_status.version_type = 11;
-                    sprintf(device_status.driver, "%s",VERSION_GK);
-                    ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
-                    ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
-                    MA_save();
-                }
-            }
-            //1.0
-            else if (hmi_cmd_match(rx_buffer,"SwversionV1"))
-            {
-                if(device_status.version_type != 1)
-                {
-                    device_status.dtype = 3;
-                    device_status.version_type = 1;
-                    sprintf(device_status.driver, "%s",VERSION_ZP);
-                    ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
-                    ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
-                    MA_save();
-                }
-            }
-            //中端款
-            else if (strstr(rx_buffer,"SwversionV43")!=NULL) {
-                device_status.dtype = 3;
-                if(device_status.version_type != 43)
-                {
-                    device_status.version_type = 43;
-                    sprintf(device_status.driver, "%s",VERSION_HK);
-                    ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
-                    ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型+
-                    MA_save();
-                }
-            }
-            //低端款
-            else if (strstr(rx_buffer,"SwversionV42")!=NULL) {
-                device_status.dtype = 3;
-                if(device_status.version_type != 42)
-                {
-                    device_status.version_type = 42;
-                    sprintf(device_status.driver, "%s",VERSION_HK);
-                    ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
-                    ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型+
-                    MA_save();
-                }
-            }
-            //4.0
-            else if (strstr(rx_buffer,"SwversionV41")!=NULL) {
-                device_status.dtype = 3;
-                if(device_status.version_type != 41)
-                {
-                    device_status.version_type = 41;
-                    sprintf(device_status.driver, "%s",VERSION_HK);
-                    ef_set_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type));        //版本类型
-                    ef_set_env_blob("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型+
-                    MA_save();
-                }
-            }
-            //水稻
-            else if (hmi_cmd_match(rx_buffer,"SwversionV4")) {
-                device_status.dtype = 3;
-                if(device_status.version_type != 4)
-                {
-                    device_status.version_type = 4;
-                    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("dtype",&device_status.dtype,sizeof(device_status.dtype));        //版本类型
-                    MA_save();
-                }
-            }
+            hmi_dedupe_reset();
+            /* 2026-10-15:版本串变化后按字符设置版本类型(见 hmi_switch_version 说明) */
+            hmi_switch_version(rx_buffer);
         }
-
         /* 整页刷新 60+ 条属性合并为 1~3 次串口写(见 HMI_WRITE 发送优化) */
         HMI_BATCH_BEGIN();
         refresh_hmi_Component(tm);
@@ -2124,7 +2238,8 @@ static void HMI_Decode(void)
             if(set_date(atoi(year_s),atoi(month_s),atoi(day_s))==RT_EOK)
             {
                 LOG_I("设置日期:%d年%d月%d日",atoi(year_s),atoi(month_s),atoi(day_s));
-                if(atoi(hour_s)>0&&atoi(hour_s)<=24&&atoi(min_s)>=0&&atoi(min_s)<=59&&atoi(sec_s)>=0&&atoi(sec_s)<=59)
+                /* ★ 原来是 >0: 合法的 00:xx:xx 永远设不进去(只改了日期)。且 24 点非法。 */
+                if(atoi(hour_s)>=0&&atoi(hour_s)<24&&atoi(min_s)>=0&&atoi(min_s)<=59&&atoi(sec_s)>=0&&atoi(sec_s)<=59)
                 {
                     LOG_I("设置时间:%d时%d分%d秒",atoi(hour_s),atoi(min_s),atoi(sec_s));
                     set_time(atoi(hour_s),atoi(min_s),atoi(sec_s));
@@ -2155,7 +2270,9 @@ static void HMI_Decode(void)
                 break;
             }
         }
-        if(var[6] != '\r') {
+        /* ★ 原来无条件写 var[6]: 载荷短于 6 位时读写越过字符串结尾,
+           帧被截断时 var+6 甚至越过 rx_buffer 末尾。先判长度再截断。 */
+        if(strlen(var) > 6) {
             var[6] = '\0';
         }
         // 现在 var 只剩下干净的 6 位数字了
@@ -2354,13 +2471,16 @@ static void HMI_Decode(void)
                 LOG_E("参数设置异常(模式):%d!!!",atoi(value_str));
             }
         }
-        //2022/06/23,add:
-        rt_sprintf(device_status.json_w_clock,"屏幕操作:修改工作时间:开始-%d,结束-%d,模式-%d(0-光控,1-时控)操作时间:%s",device_status.startBar,device_status.stopBar,device_status.timeSwitch,device_status.stamp);
-        json_temp = makeJson_Warn(device_status.json_w_clock, "修改工作时间");
-        ef_set_env_blob("json_w_clock", &device_status.json_w_clock, sizeof(device_status.json_w_clock));   //将修改屏幕参数操作记录保存到Flash中
-        if(atoi(device_status.net)==0)
-            DTU_Write("%s",json_temp);
-        rt_free(json_temp);
+        //2022/06/23,add: 操作记录改为局部缓冲(原 device_status.json_w_clock)
+        {
+            char json_warn[192];
+            rt_snprintf(json_warn, sizeof(json_warn),"屏幕操作:修改工作时间:开始-%d,结束-%d,模式-%d(0-光控,1-时控)操作时间:%s",device_status.startBar,device_status.stopBar,device_status.timeSwitch,device_status.stamp);
+            json_temp = makeJson_Warn(json_warn, "修改工作时间");
+            ef_set_env_blob("json_w_clock", json_warn, strlen(json_warn) + 1);   //将修改屏幕参数操作记录保存到Flash中
+            if(atoi(device_status.net)==0)
+                DTU_Write("%s",json_temp);
+            rt_free(json_temp);
+        }
         rt_thread_delay(2000);
         MA_save();
         rt_kprintf("工作时间参数已保存:模式-%d,光控时间-%d,时控开始时间-%d,时控结束时间-%d\n",device_status.timeSwitch,device_status.sunBar,device_status.startBar,device_status.stopBar);
@@ -2471,33 +2591,35 @@ static void HMI_Decode(void)
         //rt_kprintf("系统设置已保存:收集时间-%d,加热时间-%d,加热温度-%d,音量-%d,自动关屏-%d\n",device_status.clt_time,device_status.heattime,device_status.heatvalue,device_status.vol,device_status.thsp);
     }
     else if (strstr(rx_buffer,"rtc_h=")!=NULL) {
-        char rtc_h[2];
+        /* ★ 原来是 char rtc_h[2] + strncpy(rtc_h,var,2): 拷贝满 2 字节不补 '\0',
+           atoi() 会越界读栈; 而且小时上限写成 24(非法)。直接解析并做范围校验。 */
+        int v;
         var = strstr(rx_buffer,"=");
         var++;
-        strncpy(rtc_h,var,2);
-        if(atoi(rtc_h)>=0 && atoi(rtc_h) <= 24)
+        v = atoi(var);
+        if(v>=0 && v<=23)
         {
-            set_time(atoi(rtc_h), 99, 99);
+            set_time(v, 99, 99);
         }
     }
     else if (strstr(rx_buffer,"rtc_m=")!=NULL) {
-        char rtc_m[2];
+        int v;
         var = strstr(rx_buffer,"=");
         var++;
-        strncpy(rtc_m,var,2);
-        if(atoi(rtc_m)>=0 && atoi(rtc_m) <= 24)
+        v = atoi(var);
+        if(v>=0 && v<=59)
         {
-            set_time(99, atoi(rtc_m), 99);
+            set_time(99, v, 99);
         }
     }
     else if (strstr(rx_buffer,"rtc_s=")!=NULL) {
-        char rtc_s[2];
+        int v;
         var = strstr(rx_buffer,"=");
         var++;
-        strncpy(rtc_s,var,2);
-        if(atoi(rtc_s)>=0 && atoi(rtc_s) <= 24)
+        v = atoi(var);
+        if(v>=0 && v<=59)
         {
-            set_time(99, 99, atoi(rtc_s));
+            set_time(99, 99, v);
         }
     }
     else if(strstr(rx_buffer,"saveUploadSet=")!=NULL)
@@ -2548,13 +2670,16 @@ static void HMI_Decode(void)
     {
         ResetParamDefault_DC();
         rt_thread_delay(1000);
-        //2022/06/23,add:
-        rt_sprintf(device_status.json_w_reset,"屏幕操作:系统重置:电池供电,操作时间:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
-        json_temp = makeJson_Warn(device_status.json_w_reset, "系统重置");
-        ef_set_env_blob("json_w_reset", &device_status.json_w_reset, sizeof(device_status.json_w_reset));   //将修改屏幕参数操作记录保存到Flash中
-        if(atoi(device_status.net)==0)
-            DTU_Write("%s",json_temp);
-        rt_free(json_temp);
+        //2022/06/23,add: 操作记录改为局部缓冲(原 device_status.json_w_reset)
+        {
+            char json_warn[192];
+            rt_snprintf(json_warn, sizeof(json_warn),"屏幕操作:系统重置:电池供电,操作时间:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
+            json_temp = makeJson_Warn(json_warn, "系统重置");
+            ef_set_env_blob("json_w_reset", json_warn, strlen(json_warn) + 1);   //将修改屏幕参数操作记录保存到Flash中
+            if(atoi(device_status.net)==0)
+                DTU_Write("%s",json_temp);
+            rt_free(json_temp);
+        }
 
     }
     //恢复出厂设置-交流
@@ -2562,13 +2687,16 @@ static void HMI_Decode(void)
     {
         ResetParamDefault();
         rt_thread_delay(1000);
-        //2022/06/23,add:
-        rt_sprintf(device_status.json_w_reset,"屏幕操作:系统重置:交流供电,操作时间:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
-        json_temp = makeJson_Warn(device_status.json_w_reset, "系统重置");
-        ef_set_env_blob("json_w_reset", &device_status.json_w_reset, sizeof(device_status.json_w_reset));   //将修改屏幕参数操作记录保存到Flash中
-        if(atoi(device_status.net)==0)
-            DTU_Write("%s",json_temp);
-        rt_free(json_temp);
+        //2022/06/23,add: 操作记录改为局部缓冲(原 device_status.json_w_reset)
+        {
+            char json_warn[192];
+            rt_snprintf(json_warn, sizeof(json_warn),"屏幕操作:系统重置:交流供电,操作时间:%04d-%02d-%02d %02d:%02d:%02d",tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec);
+            json_temp = makeJson_Warn(json_warn, "系统重置");
+            ef_set_env_blob("json_w_reset", json_warn, strlen(json_warn) + 1);   //将修改屏幕参数操作记录保存到Flash中
+            if(atoi(device_status.net)==0)
+                DTU_Write("%s",json_temp);
+            rt_free(json_temp);
+        }
 
     }
     //获取SIM卡信息
@@ -2620,13 +2748,15 @@ static void HMI_Decode(void)
         ef_set_env_blob("stop_in_bootloader", &device_status.stop_in_bootloader, sizeof(device_status.stop_in_bootloader));
         rt_hw_cpu_reset();
     }
+    /* ★ "dtu_reboot" 里包含 "reboot", 原来 reboot 分支在前 -> 屏幕下发 dtu_reboot
+       会走整机复位, RTU 重启指令永远发不出去。dtu_reboot 必须先判。 */
+    else if (strstr(rx_buffer,"dtu_reboot")!=NULL) {
+        DTU_Write("{\"cmd\": \"dtu_reboot\"}");
+    }
     //软件重启
     else if (strstr(rx_buffer,"reboot")!=NULL) {
         rt_hw_cpu_reset();
     }
-    else if (strstr(rx_buffer,"dtu_reboot")!=NULL) {
-        DTU_Write("{\"cmd\": \"dtu_reboot\"}");
-    }
     else if (strstr(rx_buffer,"saveLog_usb")!=NULL) {
         DTU_Write("{\"cmd\": \"saveLog_usb\"}");
     }
@@ -2638,11 +2768,15 @@ static void HMI_Decode(void)
         int param1, param2;
         // 从冒号后开始扫描
         if (sscanf(rx_buffer + strlen("SaveRecordParam:"), "%d-%d", &param1, &param2) == 2) {
-            printf("Param1: %d\n", param1);
-            printf("Param2: %d\n", param2);
-            char temp_val_mqtt[10],temp_val_pic[10];
-            itoa(param1, temp_val_pic, 10);
-            itoa(param2, temp_val_mqtt, 10);
+            /* ★ 原 itoa(param1, temp_val_pic, 10) 写 char[10]: 10 位十进制(或负值 11 字节)
+               直接踩栈, itoa 不做容量检查。负数是非法参数, 直接丢弃。 */
+            char temp_val_mqtt[12],temp_val_pic[12];
+            if (param1 < 0 || param2 < 0) {
+                LOG_E("Invalid record param:%d-%d", param1, param2);
+                return;
+            }
+            rt_snprintf(temp_val_pic, sizeof(temp_val_pic), "%d", param1);
+            rt_snprintf(temp_val_mqtt, sizeof(temp_val_mqtt), "%d", param2);
             /* ★ 原来 DTU_Write(write_record_param) 把 JSON 当格式串(内容含 '-' 等无所谓,
                但一旦含 '%' 就会被 vsnprintf 当格式说明符) -> 统一走 dtu_write_json */
             dtu_write_json(makeJson_record_write(temp_val_mqtt,temp_val_pic));
@@ -2724,9 +2858,13 @@ static void HMI_Decode(void)
         dtu_write_json(makeJsonRpc2_0("MOVE_IMAGE", NULL, 1));
     }else if(strstr(rx_buffer,"COPY_IMAGE")!=NULL){
         cJSON *params = cJSON_CreateObject();        // params 子对象
-        cJSON_AddNumberToObject(params, "st", device_status.startBar);     // st:20
-        cJSON_AddNumberToObject(params, "et", device_status.stopBar);      // et:7
-        dtu_write_json(makeJsonRpc2_0("COPY_IMAGE", params, 1));
+        if (params == RT_NULL) {
+            LOG_E("COPY_IMAGE: create params failed (no memory)");
+        } else {
+            cJSON_AddNumberToObject(params, "st", device_status.startBar);     // st:20
+            cJSON_AddNumberToObject(params, "et", device_status.stopBar);      // et:7
+            dtu_write_json(makeJsonRpc2_0("COPY_IMAGE", params, 1));
+        }
     }else if(strstr(rx_buffer,"UMOUNT_UPAN")!=NULL){
             dtu_write_json(makeJsonRpc2_0("UMOUNT_UPAN", NULL, 1));
     }
@@ -2962,8 +3100,12 @@ int Hmi_Fresh(void)
                    sizeof(struct rx_msg),    /* 一条消息的最大长度 */
                    sizeof(msg_pool),         /* 存放消息的缓冲区大小 */
                    RT_IPC_FLAG_FIFO);        /* 如果有多个线程等待,按照先来先得到的方法分配消息 */
-    /* 设置接收回调函数 */
-    rt_device_set_rx_indicate(serial, uart_input);
+    /* 设置接收回调函数(★ 原来未判空: 屏幕串口设备名配错/未注册时
+       rt_device_find() 返回 NULL, 这里直接解引用空设备句柄) */
+    if (serial != RT_NULL)
+    {
+        rt_device_set_rx_indicate(serial, uart_input);
+    }
     /* 创建线程*/
     hmi1 = rt_thread_create("Hmi_Fresh_thread",
                             Hmi_thread_entry,
@@ -3211,9 +3353,7 @@ void Check_ParamConfig(void)
         ef_get_env_blob("ds",&device_status.ds,sizeof(device_status.ds),NULL);                                      //开关机状态
         ef_get_env_blob("env_t",&device_status.tempture,sizeof(device_status.tempture),NULL);                       //环境温度
         ef_get_env_blob("env_h",&device_status.humidity,sizeof(device_status.humidity),NULL);                       //环境湿度
-        ef_get_env_blob("json_w_clock",&device_status.json_w_clock,sizeof(device_status.json_w_clock),NULL);        //时间
-        ef_get_env_blob("json_w_reset",&device_status.json_w_reset,sizeof(device_status.json_w_reset),NULL);        //重置
-        ef_get_env_blob("json_w_platform",&device_status.json_w_platform,sizeof(device_status.json_w_platform),NULL);//平台
+        /* json_w_clock/json_w_reset/json_w_platform 已无对应全局字段,开机不再回读 */
         ef_get_env_blob("version_type",&device_status.version_type,sizeof(device_status.version_type),NULL);        //版本类型
         ef_get_env_blob("driver_bl",&device_status.driver_bl,sizeof(device_status.driver_bl),NULL);                 //BL版本号 进BL的时候存储到FLASH
         ef_get_env_blob("platform",&device_status.mqttcfg1,sizeof(device_status.mqttcfg1),NULL);                    //平台地址
@@ -3378,10 +3518,7 @@ void Check_ParamConfig(void)
 #if SENSOR_EN==1
         mb_master_samlpe();
 #endif
-        /* ★ P2-14: 原来这里在 main 线程里做最长 180s + 12s 的阻塞等联网,
-           期间后面的 dtu_send_data_start / Workstatus_check / Work_Loop_Task
-           全部延后。现在搬到独立线程, main 立刻往下走。 */
-        net_wait_start();
+        net_wait_thread_entry();
         dtu_send_data_start();
         Workstatus_check();
         Work_Loop_Task();
@@ -3396,7 +3533,7 @@ void Check_ParamConfig(void)
    现在把等待搬到本线程, main 立刻往下走。
    ⚠️ 本线程里所有用到 tm 的地方都用本函数自己的时间快照, 不再借用
       Check_ParamConfig() 的 static struct tm(那里开机后还会被别处改写)。 */
-static void net_wait_thread_entry(void *parameter)
+static void net_wait_thread_entry(void)
 {
     uint16_t connect_num = 0;
     time_t nnow = time(RT_NULL);
@@ -3412,14 +3549,14 @@ static void net_wait_thread_entry(void *parameter)
             DTU_Write("%s", readinfo);
             rt_free(readinfo);
         }
-        rt_thread_delay(1000);
+        rt_thread_delay(2000);
         connect_num++;
         LOG_I("联网中......%d", connect_num);
         /* 超时时间为 3 分钟 */
 #if MATCH_DEVICE == 1
         if (connect_num == 60)   /* 180 */
 #else
-        if (connect_num == 180)  /* 180 */
+        if (connect_num == 90)  /* 180 */
 #endif
         {
             device_status.timeSwitch = 0;
@@ -3433,49 +3570,19 @@ static void net_wait_thread_entry(void *parameter)
             break;
         }
     }
-
     connect_num = 0;
-    while (atoi(device_status.net) == 0)
-    {
-        char *readinfo = makeJson_ReadInfo();
-        if (readinfo != RT_NULL)
-        {
-            DTU_Write("%s", readinfo);
-            rt_free(readinfo);
-        }
-        rt_thread_delay(2000);
-        connect_num++;
-        if (connect_num > 5) break;
-    }
+    rt_thread_delay(2000);
 #if MATCH_DEVICE == 1
     device_status.timeSwitch = 1;
 #endif
     /* ★ 原来 makeJson_Warn() 的返回值从未释放 -> 每次开机都漏一块堆 */
     dtu_write_json(makeJson_Warn("turnon", "device_stm32"));
     rt_thread_delay(1000);
+    /* 本线程退出(联网成功或 3 分钟超时): 交还 read 刷新职责给 refresh_hmi_Component() */
+    net_wait_running = 1;
     LOG_I("net wait thread exit");
 }
 
-/* 启动"等待联网"线程, 立即返回, 不阻塞调用者 */
-static void net_wait_start(void)
-{
-    static rt_thread_t tid = RT_NULL;
-
-    if (tid != RT_NULL)
-    {
-        return;
-    }
-    tid = rt_thread_create("net_wait", net_wait_thread_entry, RT_NULL,
-                           2048,   /* 栈: 里面有 cJSON/DTU_Write 的 vsnprintf */
-                           12, 20);
-    if (tid == RT_NULL)
-    {
-        LOG_E("create net_wait thread failed, run net wait inline");
-        return;
-    }
-    rt_thread_startup(tid);
-}
-
 void ResetParamDefault(void)
 {
     #if MATCH_DEVICE == 1
@@ -3687,21 +3794,29 @@ void Debug_log_OFF(void)
 {
     rt_console_set_device("uart1");
     finsh_set_device("uart1");
-    rt_mq_init(&rx_mq, "rx_mq",
-                   msg_pool,                 /* 存放消息的缓冲区 */
-                   sizeof(struct rx_msg),    /* 一条消息的最大长度 */
-                   sizeof(msg_pool),         /* 存放消息的缓冲区大小 */
-                   RT_IPC_FLAG_FIFO);        /* 如果有多个线程等待,按照先来先得到的方法分配消息 */
-    rt_device_set_rx_indicate(serial, uart_input);
-    hmi1 = rt_thread_create("Hmi_Fresh_thread",
-                            Hmi_thread_entry,
-                            RT_NULL,
-                            HMI_THREAD_STACK_SIZE,
-                            HMI_THREAD_PRIORITY,
-                            HMI_THREAD_TIMESLICE);
-    if (hmi1 != RT_NULL)
+    /* ★ 原来这里无条件再 rt_mq_init() 一次 + 再建一个 "Hmi_Fresh_thread":
+       ① 对已初始化的消息队列重复 init 会重置其等待链表/读写指针(返回 -RT_ERROR),
+          正在排队的屏幕指令直接丢;
+       ② 线程重复创建后同一消息队列有两个消费者, 每条屏幕指令会被处理两遍
+          (reboot / 写 Flash 等动作执行两次), 且每次泄漏一份线程栈。
+       消息队列与接收回调在 INIT_BOARD 阶段已建立, 这里只需在升级结束线程退出后
+       重建(rt_thread_find 为空), 否则保持现状。 */
+    if (serial != RT_NULL)
     {
-       rt_thread_startup(hmi1);
+        rt_device_set_rx_indicate(serial, uart_input);
+    }
+    if (rt_thread_find("Hmi_Fresh_thread") == RT_NULL)
+    {
+        hmi1 = rt_thread_create("Hmi_Fresh_thread",
+                                Hmi_thread_entry,
+                                RT_NULL,
+                                HMI_THREAD_STACK_SIZE,
+                                HMI_THREAD_PRIORITY,
+                                HMI_THREAD_TIMESLICE);
+        if (hmi1 != RT_NULL)
+        {
+           rt_thread_startup(hmi1);
+        }
     }
 
 }

+ 4 - 1
Application_cbd_apm32f1/applications/hmi.h

@@ -39,7 +39,10 @@ extern rt_timer_t timer_uart2;
 #define HMI_TERMINATOR          "\xFF\xFF\xFF"
 #define HMI_RESPONSE_TIMEOUT    1000    // 响应超时(ms)
 #define HMI_TRANSFER_TIMEOUT    30000   // 传输超时(ms)
-uint32_t total_file_size;
+/* ★ 原来这里是定义(uint32_t total_file_size;): 9 个 .c 都包含 hmi.h,
+   全靠 -fcommon 合并 tentative definition; 一旦换成 -fno-common 立刻
+   multiple definition。真实定义在 hmi.c, 这里只做 extern 声明。 */
+extern uint32_t total_file_size;
 // 升级状态
 typedef enum {
     STATE_IDLE = 0,

+ 0 - 6
Application_cbd_apm32f1/applications/param_backup.c

@@ -499,9 +499,6 @@ void param_pack(param_persist_t *dst)
     strncpy(dst->lat,            device_status.lat,            sizeof(dst->lat) - 1);
     strncpy(dst->lng,            device_status.lng,            sizeof(dst->lng) - 1);
     strncpy(dst->alarm_tg,       device_status.alarm_tg,       sizeof(dst->alarm_tg) - 1);
-    strncpy(dst->json_w_clock,   device_status.json_w_clock,   sizeof(dst->json_w_clock) - 1);
-    strncpy(dst->json_w_reset,   device_status.json_w_reset,   sizeof(dst->json_w_reset) - 1);
-    strncpy(dst->json_w_platform,device_status.json_w_platform,sizeof(dst->json_w_platform) - 1);
     strncpy(dst->driver_bl,      device_status.driver_bl,      sizeof(dst->driver_bl) - 1);
     strncpy(dst->driver_compile, device_status.driver_compile, sizeof(dst->driver_compile) - 1);
 }
@@ -567,9 +564,6 @@ void param_unpack(const param_persist_t *src)
     strncpy(device_status.lat,            src->lat,            sizeof(device_status.lat) - 1);
     strncpy(device_status.lng,            src->lng,            sizeof(device_status.lng) - 1);
     strncpy(device_status.alarm_tg,       src->alarm_tg,       sizeof(device_status.alarm_tg) - 1);
-    strncpy(device_status.json_w_clock,   src->json_w_clock,   sizeof(device_status.json_w_clock) - 1);
-    strncpy(device_status.json_w_reset,   src->json_w_reset,   sizeof(device_status.json_w_reset) - 1);
-    strncpy(device_status.json_w_platform,src->json_w_platform,sizeof(device_status.json_w_platform) - 1);
     strncpy(device_status.driver_bl,      src->driver_bl,      sizeof(device_status.driver_bl) - 1);
     strncpy(device_status.driver_compile, src->driver_compile, sizeof(device_status.driver_compile) - 1);
 }

+ 2 - 4
Application_cbd_apm32f1/applications/param_backup.h

@@ -24,7 +24,8 @@
 #define PARAM_PART_B_NAME          "param_b"
 
 #define PARAM_MAGIC                0x5041524Du   /* "PARM" */
-#define PARAM_VERSION              1u            /* 结构版本,变更 param_persist_t 时必须 +1 */
+#define PARAM_VERSION              2u            /* 结构版本,变更 param_persist_t 时必须 +1
+                                                    v2: 删除 json_w_clock/reset/platform 三个 128B 字段 */
 
 /* 参数变更后的静默期(tick),期间无新变更才真正落盘。RT_TICK_PER_SECOND=1000 */
 #ifndef PARAM_QUIET_TICKS
@@ -115,9 +116,6 @@ typedef struct
     char     lat[32];            /* lat */
     char     lng[32];            /* lng */
     char     alarm_tg[12];       /* alarm_tg   闹钟 */
-    char     json_w_clock[128];  /* json_w_clock */
-    char     json_w_reset[128];  /* json_w_reset */
-    char     json_w_platform[128];/* json_w_platform */
     char     driver_bl[64];      /* driver_bl  BL版本 */
     char     driver_compile[64]; /* driver_compile */
 } param_persist_t;

+ 7 - 2
Application_cbd_apm32f1/applications/selfcheck.c

@@ -324,8 +324,13 @@ int selfcheck(uint8_t type)
     /*******************************************************/
     HMI_WRITE("sysSet.va0.txt=\"故障码:%d\"",device_status.C01);
     char *js = makeJson_C01_Warn(device_status.C01,1.0);
-    DTU_Write("%s",js);
-    free(js);
+    if(js != NULL)
+    {
+        DTU_Write("%s",js);
+        /* ★ makeJson_* 返回 cJSON_Print 的缓冲, __RTTHREAD__ 下由 rt_malloc 分配,
+           原来用 newlib 的 free() 释放: 两套堆不一致, 会把 heap 链表写坏。 */
+        rt_free(js);
+    }
     LOG_I("重启线程workloop:%d",thread_restart_workloop());
     device_status.selfcheck_ws = 0;
     device_status.process = 0.0;

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


BIN
Application_cbd_apm32f1/rt-thread/tools/building.pyc


BIN
Application_cbd_apm32f1/rt-thread/tools/gcc.pyc


BIN
Application_cbd_apm32f1/rt-thread/tools/mkdist.pyc


BIN
Application_cbd_apm32f1/rt-thread/tools/options.pyc


BIN
Application_cbd_apm32f1/rt-thread/tools/utils.pyc


BIN
Application_cbd_apm32f1/rtconfig.pyc


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

@@ -5,7 +5,7 @@
 			<provider copy-of="extension" id="org.eclipse.cdt.ui.UserLanguageSettingsProvider"/>
 			<provider-reference id="org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider" ref="shared-provider"/>
 			<provider-reference id="org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider" ref="shared-provider"/>
-			<provider class="org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector" console="false" env-hash="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.g++"/>
 			</provider>