add event fun

LFtid1056/client2.h

@@ -62,7 +62,6 @@ enum class DeviceState {
     READING_DEVVERSION,          // <20><>ȡװ<C8A1>ð汾<C3B0><E6B1BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ
     SET_RIGHTTIME,               // <20><><EFBFBD><EFBFBD>װ<EFBFBD>ö<EFBFBD>ʱ
     READING_EVENTLOG,            // <20><><EFBFBD><EFBFBD><EFBFBD>¼<EFBFBD><C2BC><EFBFBD>־
-    READING_EVENTFILE,           // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̬<EFBFBD><CCAC><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
     READING_STATSFILE,           // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̬<EFBFBD><CCAC><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD>
     // <20>ɸ<EFBFBD><C9B8><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD>Ӹ<EFBFBD><D3B8><EFBFBD>״̬
     CUSTOM_ACTION       // <20>Զ<EFBFBD><D4B6>嶯<EFBFBD><E5B6AF>

LFtid1056/cloudfront/code/cfg_parser.cpp

@@ -26,7 +26,7 @@
 
 #include "nlohmann/json.hpp"
 #include "curl/curl.h" 
-#include "log4cplus/log4.h"	//关键上送日志
+#include "log4.h"	//关键上送日志
 #include "interface.h"		//台账结构
 #include "tinyxml2.h"
 #include "rocketmq.h"
@@ -560,6 +560,17 @@ double sGetMsTime() {
     return static_cast<double>(ms);
 }
 
+//秒时间转为标准时间字符串
+// ★新增：将 epoch 秒级时间转成 "YYYY-MM-DD HH:MM:SS"
+static std::string epoch_to_datetime_str(long long epoch_sec) {
+    char buf[20];
+    std::tm tm{};
+    time_t t = static_cast<time_t>(epoch_sec);
+    localtime_r(&t, &tm);
+    std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
+    return std::string(buf);
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////实时触发部分
 
 //获取实时触发文件
@@ -781,7 +792,7 @@ void check_3s_config() {
     }
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////补招部分
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////补招文件部分
 
 //将文件内容读取到结构中
 void parse_recall(recall_xml_t* recall_xml, const std::string& parentTag, const std::map<std::string, std::string>& attributes, const std::string& id) {
@@ -1030,7 +1041,7 @@ void create_recall_xml()
 	CreateRecallXml();
 	//}
 }
-
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////补招部分
 // 工具函数：将时间字符串转为 time_t（秒级）
 static long long parse_time_to_epoch(const std::string& time_str) {
     std::tm tm = {};
@@ -1084,7 +1095,6 @@ int recall_json_handle(const std::string& jstr) {
     int stat = 0;
     int voltage = 0;
     try {
-        std::vector<JournalRecall> recallParams;
 
         // 1. 解析 JSON 数组
         auto json_root = nlohmann::json::parse(jstr);
@@ -1096,7 +1106,9 @@ int recall_json_handle(const std::string& jstr) {
         // 2. 遍历每个补招项
         for (auto& item : json_root) {
             // 获取必需字段
-            if (!item.contains("monitorId") ||
+            // ★修改：强制要求 terminalId；
+            if (!item.contains("terminalId") ||
+                !item.contains("monitor") || 
                 !item.contains("timeInterval") ||
                 !item.contains("dataType"))
             {
@@ -1104,131 +1116,115 @@ int recall_json_handle(const std::string& jstr) {
                 return 10000;
             }
 
+            // ★新增：读取 terminalId（必填）
+            std::string terminalId = item["terminalId"].get<std::string>();
+            if (terminalId.empty()) {
+                std::cout << "terminalId为空" << std::endl;
+                continue;
+            }
+
             // 2.1 解析 dataType
             std::string datatype = item["dataType"].get<std::string>();
             if (!datatype.empty()) {
-                stat    = (datatype == "0") ? 1 : 0;  // 稳态
+                // ★修改：仅保留稳态/暂态
-                voltage = (datatype == "1") ? 1 : 0;  // 暂态
+                if (datatype == "0" || datatype == "稳态" || datatype == "steady" || datatype == "STEADY") {
+                    stat = 1;  voltage = 0;   // 稳态
+                } else if (datatype == "1" || datatype == "暂态" || datatype == "voltage" || datatype == "VOLTAGE") {
+                    stat = 0;  voltage = 1;   // 暂态
+                } else {
+                    stat = voltage = 1;       // 其他情况按全补
+                }
             } else {
-                stat = voltage = 1;  // 全补
+                stat = voltage = 1;           // 全补
             }
 
-            // 2.2 处理 monitorId 数组
+            // ★新增：定位并校验该 terminal 是否归属当前进程
-            auto& midArr = item["monitorId"];
+            std::lock_guard<std::mutex> lock(ledgermtx);
-            auto& tiArr  = item["timeInterval"];
-            if (midArr.is_array() && tiArr.is_array() && !midArr.empty()) {
-                for (auto& idItem : midArr) {
-                    std::string monitorId = idItem.get<std::string>();
 
-                    // 判断此监测点是否归属当前进程
+            const terminal_dev* targetDev = nullptr;
-                    bool mppair = false;
+            for (const auto& dev : terminal_devlist) {
-                    for (const auto& dev : terminal_devlist) {
+                // 只处理本进程对应的终端
-                        // 只处理本进程对应的终端
+                if (dev.terminal_id == terminalId) {
-                        if (std::stoi(dev.processNo) != g_front_seg_index &&
+                    targetDev = &dev;
-                            g_front_seg_index != 0) {
+                    break;
-                            continue;
-                        }
-                        for (const auto& mon : dev.line) {
-                            if (mon.monitor_id.empty()) continue;
-                            if (mon.monitor_id == monitorId) {
-                                mppair = true;
-                                std::cout << "Matched monitorId " << monitorId
-                                          << " in terminal " << dev.terminal_id
-                                          << std::endl;
-                                break;
-                            }
-                        }
-                        if (mppair) break;
-                    }
-                    if (!mppair) continue;
-
-                    // 遍历 timeInterval 数组
-                    for (auto& timeItem : tiArr) {
-                        std::string ti = timeItem.get<std::string>();
-                        auto pos = ti.find('~');
-                        std::string start = ti.substr(0, pos);
-                        std::string end   = ti.substr(pos + 1);
-
-                        JournalRecall param;
-                        param.MonitorID  = monitorId;
-                        param.StartTime   = start;
-                        param.EndTime     = end;
-                        param.STEADY    = std::to_string(stat);
-                        param.VOLTAGE = std::to_string(voltage);
-                        recallParams.push_back(param);
-                    }
                 }
             }
-            // 2.3 monitorId 数组存在但为空 -> 补招所有监测点
+            if (!targetDev) {
-            else if (midArr.is_array() && midArr.empty()) {
+                std::cout << "terminalId未匹配当前进程内装置: " << terminalId << std::endl;
-                std::cout << "monitorIdArray is null,补招所有监测点" << std::endl;
+                continue;
-                for (const auto& dev : terminal_devlist) {
+            }
-                    if (std::stoi(dev.processNo) != g_front_seg_index &&
+
-                        g_front_seg_index != 0) {
+            // ★新增：按新结构解析 monitor 层级
+            auto& monitors = item["monitor"];
+            if (!monitors.is_array() || monitors.empty()) {
+                std::cout << "monitor数组为空或非数组类型" << std::endl;
+                continue;
+            }
+
+            for (auto& mobj : monitors) {
+                if (!mobj.contains("monitorId") || !mobj.contains("timeInterval")) {
+                    std::cout << "monitor项缺少 monitorId 或 timeInterval" << std::endl;
+                    continue;
+                }
+            
+                std::string monitorId = mobj["monitorId"].get<std::string>();
+                if (monitorId.empty()) continue;
+            
+                // 不只是判断存在，还要拿到指针 lm 以便后续 push_back
+                ledger_monitor* lm = nullptr;
+                for (auto& mon : const_cast<terminal_dev*>(targetDev)->line) {
+                    if (!mon.monitor_id.empty() && mon.monitor_id == monitorId) {
+                        lm = &mon;
+                        break;
+                    }
+                }
+                if (!lm) {
+                    std::cout << "monitorId未在terminal内找到: " << monitorId
+                              << " @ " << terminalId << std::endl;
+                    continue;
+                }
+            
+                auto& tiArr = mobj["timeInterval"];
+                if (!tiArr.is_array() || tiArr.empty()) {
+                    std::cout << "timeInterval为空或非数组类型: monitorId=" << monitorId << std::endl;
+                    continue;
+                }
+            
+                // 这里拆分时间段并 push 到 lm->recall_list
+                for (auto& timeItem : tiArr) {
+                    std::string ti = timeItem.get<std::string>();
+                    auto pos = ti.find('~');
+                    if (pos == std::string::npos) {
+                        std::cout << "timeInterval格式错误: " << ti << std::endl;
                         continue;
                     }
-                    for (const auto& mon : dev.line) {
+                    std::string start = ti.substr(0, pos);
-                        if (mon.monitor_id.empty()) continue;
+                    std::string end   = ti.substr(pos + 1);
-                        for (auto& timeItem : tiArr) {
-                            std::string ti = timeItem.get<std::string>();
-                            auto pos = ti.find('~');
-                            std::string start = ti.substr(0, pos);
-                            std::string end   = ti.substr(pos + 1);
                 
-                            JournalRecall param;
+                    // 拆分时间段为 1 小时一段，并存入 recall_list
-                            param.MonitorID   = mon.monitor_id;
+                    std::vector<RecallInfo> recallinfo_list_hour;
-                            param.StartTime   = start;
+                    Get_Recall_Time_Char(start, end, recallinfo_list_hour);
-                            param.EndTime     = end;
+                
-                            param.STEADY    = std::to_string(stat);
+                    for (auto& info : recallinfo_list_hour) {
-                            param.VOLTAGE = std::to_string(voltage);
+                        RecallMonitor rm;
-                            recallParams.push_back(param);
+                        rm.recall_status = 0; // 初始状态：未补招
-                        }
+                        rm.StartTime = epoch_to_datetime_str(info.starttime); // 需要你已有的工具函数
+                        rm.EndTime   = epoch_to_datetime_str(info.endtime);
+                        rm.STEADY    = std::to_string(stat);
+                        rm.VOLTAGE   = std::to_string(voltage);
+                    
+                        lm->recall_list.push_back(std::move(rm)); // ★逐一压入
+                    
+                        // 可选：调试打印
+                        std::cout << "[recall_json_handle] terminal=" << terminalId
+                                  << " monitor=" << monitorId
+                                  << " start=" << lm->recall_list.back().StartTime
+                                  << " end="   << lm->recall_list.back().EndTime
+                                  << " steady="<< lm->recall_list.back().STEADY
+                                  << " voltage="<< lm->recall_list.back().VOLTAGE
+                                  << std::endl;
                     }
                 }
-            } else {
-                std::cout << "monitorIdArray 不存在或类型不正确" << std::endl;
-            }
-        }
-
-        // 3. 生成具体补招记录
-        for (auto& rp : recallParams) {
-            std::string start_time = rp.StartTime;
-            std::string end_time   = rp.EndTime;
-
-            std::cout << "mp_id "       << rp.MonitorID
-                      << " start_time " << start_time
-                      << " end_time "   << end_time
-                      << " stat "       << rp.STEADY
-                      << " voltage "    << rp.VOLTAGE
-                      << std::endl;
-
-            std::vector<RecallInfo> recallinfo_list_hour;
-            Get_Recall_Time_Char(start_time, end_time, recallinfo_list_hour);
-
-            for (auto& info : recallinfo_list_hour) {
-                JournalRecall jr;
-                jr.MonitorID = rp.MonitorID;
-
-                // 转换 starttime
-                char buf[20];
-                std::tm tm{};
-                time_t st = static_cast<time_t>(info.starttime);
-                localtime_r(&st, &tm);
-                std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
-                jr.StartTime = buf;
-
-                // 转换 endtime
-                std::tm tm2{};
-                time_t et = static_cast<time_t>(info.endtime);
-                localtime_r(&et, &tm2);
-                std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm2);
-                jr.EndTime = buf;
-
-                jr.STEADY  = rp.STEADY;
-                jr.VOLTAGE = rp.VOLTAGE;
-
-                std::lock_guard<std::mutex> lock(g_StatisticLackList_list_mutex);
-                g_StatisticLackList.push_back(jr);
             }
         }
     }
@@ -3765,3 +3761,399 @@ bool send_internal_value_reply(const std::string &dev_id, const std::vector<DZ_k
 
     return true;
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////清空运行状态
+// 清理指定 terminal_id 的运行时状态
+void clear_terminal_runtime_state(const std::string& id) {
+    std::lock_guard<std::mutex> lock(ledgermtx);  // 加锁保证线程安全
+
+    for (auto& dev : terminal_devlist) {
+        if (dev.terminal_id == id) {
+            dev.guid.clear();       // 清空 guid
+            dev.busytype = 0;       // 业务类型归零
+            dev.isbusy = 0;         // 清空业务标志
+            dev.busytimecount = 0;  // 计时归零
+            std::cout << "[clear_terminal_runtime_state] Cleared runtime state for terminal_id="
+                      << id << std::endl;
+            break; // 找到后跳出
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////处理补招逻辑
+// ===== 一次遍历可下发“多个终端的一条” =====
+void check_recall_event() {
+
+    std::vector<RecallTask> tasks;     // 本轮要发送的“每终端一条”
+    std::vector<std::string> empty_devs_to_clear; // 本轮发现已无任务的终端，解锁后统一清理
+
+    {   //锁作用域
+        std::lock_guard<std::mutex> lock(ledgermtx);
+
+        // 遍历所有 terminal —— 每个 terminal 只挑一条
+        for (auto& dev : terminal_devlist) {
+            // 1) 先弹掉首条为 DONE/FAILED 的记录（所有 monitor 都要处理首条）
+            bool any_non_empty = false;
+            for (auto& lm : dev.line) {
+                while (!lm.recall_list.empty()) {
+                    const RecallMonitor& front = lm.recall_list.front();
+                    if (front.recall_status == static_cast<int>(RecallStatus::DONE)) {
+                        std::cout << "[check_recall_work] DONE dev=" << dev.terminal_id
+                                  << " monitor=" << lm.monitor_id
+                                  << " " << front.StartTime << " ~ " << front.EndTime << std::endl;
+
+                        //调用reply接口通知web端补招完成
+                        
+
+                        lm.recall_list.pop_front(); // 弹掉首条
+                    } else if (front.recall_status == static_cast<int>(RecallStatus::FAILED)) {
+                        std::cout << "[check_recall_work] FAILED dev=" << dev.terminal_id
+                                  << " monitor=" << lm.monitor_id
+                                  << " " << front.StartTime << " ~ " << front.EndTime << std::endl;
+
+                        //调用reply接口通知web端补招失败
+
+
+                        lm.recall_list.pop_front(); // 弹掉首条
+                    } else {
+                        break; // 首条不是 2/3，停
+                    }
+                }
+                if (!lm.recall_list.empty()) any_non_empty = true;  // 处理了成功和失败的以后只要有一条非空就标记，可能是待处理或者正在处理的补招
+            }
+
+            if (!any_non_empty) {
+                // 该终端本轮已无任何补招条目，等解锁后清空运行态
+                empty_devs_to_clear.push_back(dev.terminal_id);
+                continue;
+            }
+
+            // 2) 若任一 monitor 的首条为 RUNNING，则该终端正在补招中 -> 跳过该终端
+            bool has_running = false;
+            for (auto& lm : dev.line) {
+                if (!lm.recall_list.empty() &&
+                    lm.recall_list.front().recall_status == static_cast<int>(RecallStatus::RUNNING)) {
+                    has_running = true;
+                    break;
+                }
+            }
+            if (has_running) continue;
+
+            // 3) 选择该终端的“第一条 NOT_STARTED(0)”作为本终端本轮任务
+            bool picked = false;
+            for (auto& lm : dev.line) {
+                if (lm.recall_list.empty()) continue;
+
+                RecallMonitor& front = lm.recall_list.front();
+                if (front.recall_status == static_cast<int>(RecallStatus::NOT_STARTED)) {
+                    // 标记为 RUNNING，并设置终端忙状态
+                    front.recall_status = static_cast<int>(RecallStatus::RUNNING);
+
+                    dev.isbusy        = 1;
+                    dev.busytype      = static_cast<int>(DeviceState::READING_EVENTLOG);
+                    dev.busytimecount = 0;
+                    // 如需 guid，可在此生成 dev.guid = new_guid();
+
+                    // 记录任务（每终端只取这一条）
+                    tasks.push_back(RecallTask{
+                        dev.terminal_id,
+                        front.StartTime,
+                        front.EndTime,
+                        lm.monitor_id
+                    });
+                    picked = true;
+                    break;
+                }
+            }
+            // 若该终端没有 NOT_STARTED 的首条（可能剩下的都是 RUNNING 或内部已经被清空），
+            // 就留待下一轮；不要清空运行态，直到所有条目被处理为止。
+        }
+    } // 解锁
+
+    // 先处理“已空终端”的运行态清理，如果在上面循环中直接清理，可能会与正在处理的补招冲突。而且就算上面解锁后写了新的补招，也会在下一轮被执行。
+    for (const auto& id : empty_devs_to_clear) {
+        clear_terminal_runtime_state(id);
+    }
+
+    // 对于本轮挑选到的任务，逐终端下发一条，这些终端的状态都已设为补招
+    for (const auto& t : tasks) {
+        std::tm tm1{}, tm2{};
+        if (!parse_datetime_tm(t.start_time, tm1) || !parse_datetime_tm(t.end_time, tm2)) {
+            std::cout << "[check_recall_event] parse time fail: "
+                      << t.start_time << " ~ " << t.end_time << std::endl;
+            // 视情况：标记失败/弹出/继续下一个
+            continue;
+        }
+
+        uint8_t mp = 1; // 默认
+        try {
+            mp = static_cast<uint8_t>(std::stoi(t.monitor_index));
+        } catch (...) { /* 保持默认1或根据需要处理 */ }
+
+        ClientManager::instance().read_eventlog_action_to_device(
+            t.dev_id, tm1, tm2, 2, mp);//2是暂态事件
+
+        std::cout << "[check_recall_event] SEND dev=" << t.dev_id
+                  << " monitor=" << mp
+                  << " start=" << t.start_time
+                  << " end="   << t.end_time
+                  << " action(2)" << std::endl;
+    }
+
+    // 重要：本函数不把 RUNNING 改成 DONE/FAILED；
+    //       应由设备回调/结果处理逻辑在完成后调用通知函数，把对应 monitor.front().recall_status 从1置为 2/3，
+    //       下一轮本函数会弹掉 2/3，并在该终端所有 recall_list 全部清空后调用 clear_terminal_runtime_state()。
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////通讯响应处理
+void on_device_response_minimal(int response_code,
+                                const std::string& id,
+                                unsigned char cid,
+                                int device_state_int)
+{
+    const bool ok = is_ok(response_code);
+    DeviceState state = static_cast<DeviceState>(device_state_int);
+
+    switch (state) {
+    // ================= 特殊：补招事件日志 =================
+    case DeviceState::READING_EVENTLOG: {
+        std::lock_guard<std::mutex> lk(ledgermtx);
+
+        terminal_dev* dev = nullptr;
+        for (auto& d : terminal_devlist) {
+            if (d.terminal_id == id) { dev = &d; break; }
+        }
+        if (!dev) {
+            std::cout << "[RESP][EVENTLOG] dev not found, id=" << id
+                      << " rc=" << response_code << std::endl;
+            return;
+        }
+
+        // 找到“首条 RUNNING”的补招条目，按 rc==200 成功/失败标记
+        bool updated = false;
+
+        // 1) 找到 logical_device_seq 与 cid 匹配的 monitor
+        ledger_monitor* matched_monitor = nullptr;
+
+        // 将 cid 转成十进制字符串用于直接比较
+        const std::string cid_str = std::to_string(static_cast<int>(cid));
+
+        for (auto& lm : dev->line) {
+            // 直接字符串相等
+            if (lm.logical_device_seq == cid_str) {
+                matched_monitor = &lm;
+                break;
+            }
+        }
+
+        if (!matched_monitor) { //没有匹配的监测点
+            std::cout << "[RESP][EVENTLOG][WARN] dev=" << id
+                      << " cannot find monitor by cid=" << static_cast<int>(cid)
+                      << " (no logical_device_seq match)" << std::endl;
+        } 
+        else {
+
+            // 准备日志用的 key
+            std::ostringstream mon_key_c, mon_key_d;
+            mon_key_c << "monitor." << matched_monitor->terminal_id << "." << matched_monitor->logical_device_seq << ".COM";
+            mon_key_d << "monitor." << matched_monitor->terminal_id << "." << matched_monitor->logical_device_seq << ".DATA";
+
+            // 2) 仅更新该监测点 recall_list 的首条，且要求处于 RUNNING
+            if (!matched_monitor->recall_list.empty()) {
+                RecallMonitor& front = matched_monitor->recall_list.front();    //取出首条
+                if (front.recall_status == static_cast<int>(RecallStatus::RUNNING)) {   //正在补招
+                    if (ok) {   //补招成功
+                        front.recall_status = static_cast<int>(RecallStatus::DONE);  //标记为完成，补招任务会执行下一条
+                        std::cout << "[RESP][EVENTLOG][OK] dev=" << id
+                                  << " mon=" << matched_monitor->monitor_id
+                                  << " " << front.StartTime << "~" << front.EndTime
+                                  << std::endl;
+                    } else {    //补招失败
+                        front.recall_status = static_cast<int>(RecallStatus::FAILED);
+                        std::cout << "[RESP][EVENTLOG][FAIL] dev=" << id
+                                  << " mon=" << matched_monitor->monitor_id
+                                  << " " << front.StartTime << "~" << front.EndTime
+                                  << " rc=" << response_code << std::endl;  //错误响应码
+
+                        //记录日志
+                        DIY_ERRORLOG_CODE(mon_key_d.str().c_str(),static_cast<int>(LogCode::LOG_CODE_RECALL),"【ERROR】监测点:%s 补招数据失败 - 失败时间点:%lld 至 %lld",mon_key_d.str().c_str(),front.StartTime,front.EndTime);
+                    }
+                    updated = true;
+                } else {    //首条不是 RUNNING 状态，不应该收到这条响应
+                    std::cout << "[RESP][EVENTLOG][WARN] dev=" << id
+                              << " mon=" << matched_monitor->monitor_id
+                              << " first item not RUNNING (status="
+                              << front.recall_status << ")" << std::endl;   //打印调试
+                }
+            } else {    //补招列表为空，不应该收到这条响应
+                std::cout << "[RESP][EVENTLOG][WARN] dev=" << id
+                          << " mon=" << matched_monitor->monitor_id
+                          << " recall_list empty" << std::endl;
+            }
+        }
+
+        if (!updated) {//不更新补招列表
+            std::cout << "[RESP][EVENTLOG][WARN] no RUNNING item, dev=" << id
+                      << " rc=" << response_code << std::endl;
+        }
+
+        break;
+    }
+
+    // ================= 特殊：读取文件目录 =================
+    case DeviceState::READING_FILEMENU: {
+        std::lock_guard<std::mutex> lk(ledgermtx);
+
+        // 1) 找到对应终端
+        terminal_dev* dev = nullptr;
+        for (auto& d : terminal_devlist) {
+            if (d.terminal_id == id) { dev = &d; break; }
+        }
+        if (!dev) {
+            std::cout << "[RESP][FILEMENU] dev not found, id=" << id
+                      << " rc=" << response_code << std::endl;
+            break;
+        }
+
+        // 2) 按该终端当前 busytype 分支处理
+        const int bt = dev->busytype;
+        if (bt == static_cast<int>(DeviceState::READING_FILEMENU)) {
+            // ====== 分支 A：当前业务就是“读取文件目录” ======
+            if (ok) {
+                // 成功：复位
+                dev->guid.clear();
+                dev->isbusy        = 0;
+                dev->busytype      = 0;
+                dev->busytimecount = 0;
+                std::cout << "[RESP][FILEMENU->FILEMENU][OK] dev=" << id << std::endl;
+            } else {
+                // 失败：响应web并复位为空闲
+                send_reply_to_cloud(response_code, id, static_cast<int>(DeviceState::READING_FILEMENU));
+
+                dev->guid.clear();
+                dev->isbusy        = 0;
+                dev->busytype      = 0;
+                dev->busytimecount = 0;
+                std::cout << "[RESP][FILEMENU->FILEMENU][FAIL] dev=" << id
+                          << " rc=" << response_code << std::endl;
+            }
+        }
+        else if (
+            bt == static_cast<int>(DeviceState::READING_EVENTFILE)
+            || bt == static_cast<int>(DeviceState::READING_STATSFILE)
+        ) {
+            // ====== 分支 B：当前业务为“下载事件文件/统计文件”（两者处理相同） ======
+            if (ok) {
+                // 成功：通常紧接着进入读取文件数据阶段
+
+                std::cout << "[RESP][FILEMENU->FILEDATA][OK] dev=" << id << std::endl;
+            } else {
+                // 失败：尝试下一个目录
+
+                std::cout << "[RESP][FILEMENU->(EVENT/STATS)FILE][FAIL] dev=" << id
+                          << " rc=" << response_code << std::endl;
+            }
+        }
+        else {
+            // ====== 分支 C：其他业务场景下收到 FILEMENU 响应，统一处理 打印提示======
+            if (ok) {
+                // 成功：
+
+                std::cout << "[unknown][RESP][FILEMENU->OTHER][OK] dev=" << id
+                          << " keep busytype=" << bt << std::endl;
+            } else {
+                // 失败：
+
+                std::cout << "[unknown][RESP][FILEMENU->OTHER][FAIL] dev=" << id
+                          << " rc=" << response_code << " prev busytype=" << bt << std::endl;
+            }
+        }
+        break;
+    }
+
+    // ================= 特殊：下载文件 =================
+    case DeviceState::READING_FILEDATA: {
+        std::lock_guard<std::mutex> lk(ledgermtx);
+
+        // 1) 找到对应终端
+        terminal_dev* dev = nullptr;
+        for (auto& d : terminal_devlist) {
+            if (d.terminal_id == id) { dev = &d; break; }
+        }
+        if (!dev) {
+            std::cout << "[RESP][FILEDATA] dev not found, id=" << id
+                      << " rc=" << response_code << std::endl;
+            break;
+        }
+
+        // 2) 按该终端当前 busytype 分支处理
+        const int bt = dev->busytype;
+        if (bt == static_cast<int>(DeviceState::READING_FILEDATA)) {
+            // ====== 分支 A：当前业务就是“读取文件数据” ======
+            if (ok) {
+                // 成功：复位
+                send_reply_to_cloud(static_cast<int>(ResponseCode::OK), id, static_cast<int>(DeviceState::READING_FILEDATA));
+
+                dev->guid.clear();
+                dev->isbusy        = 0;
+                dev->busytype      = 0;
+                dev->busytimecount = 0;
+                std::cout << "[RESP][FILEDATA->FILEDATA][OK] dev=" << id << std::endl;
+            } else {
+                // 失败：响应web并复位
+                send_reply_to_cloud(response_code, id, static_cast<int>(DeviceState::READING_FILEDATA));
+
+                dev->guid.clear();
+                dev->isbusy        = 0;
+                dev->busytype      = 0;
+                dev->busytimecount = 0;
+                std::cout << "[RESP][FILEDATA->FILEDATA][FAIL] dev=" << id
+                          << " rc=" << response_code << std::endl;
+            }
+        }
+        else if (
+            bt == static_cast<int>(DeviceState::READING_EVENTFILE)
+            || bt == static_cast<int>(DeviceState::READING_STATSFILE)
+        ) {
+            // ====== 分支 B：当前业务为“下载事件文件/统计文件”（两者处理相同） ======
+            if (ok) {
+                // 成功：通常紧接着进入读取文件数据阶段
+
+                std::cout << "[RESP][FILEDATA->(EVENT/STATS)FILE][OK] dev=" << id << std::endl;
+            } else {
+                // 失败：尝试下一个目录
+
+                std::cout << "[RESP][FILEDATA->(EVENT/STATS)FILE][FAIL] dev=" << id
+                          << " rc=" << response_code << std::endl;
+            }
+        }
+        else {
+            // ====== 分支 C：其他业务场景下收到 FILEDATA 响应，统一处理 打印提示======
+            if (ok) {
+                // 成功：
+
+                std::cout << "[unknown][RESP][FILEDATA->OTHER][OK] dev=" << id
+                          << " keep busytype=" << bt << std::endl;
+            } else {
+                // 失败：
+
+                std::cout << "[unknown][RESP][FILEDATA->OTHER][FAIL] dev=" << id
+                          << " rc=" << response_code << " prev busytype=" << bt << std::endl;
+            }
+        }
+        break;
+    }
+
+    // ================= 其它状态统一处理 =================
+    default: {
+
+        //直接根据输入响应mq
+        send_reply_to_cloud(response_code, id, device_state_int);
+
+        //其他的错误和成功都会结束业务
+        clear_terminal_runtime_state(id);
+        
+        break;
+    }
+    }
+}

LFtid1056/cloudfront/code/interface.h

@@ -30,7 +30,7 @@ class Front;
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-//单条补招结构
+//单条补招时间结构
 class RecallInfo
 {
 public:
@@ -38,10 +38,37 @@ public:
 	long long endtime;	//结束时间
 };
 
-//日志补招结构类
+//测点记录的补招结构
+class RecallMonitor
+{
+public:
+    int recall_status;      //补招状态 0-未补招 1-补招中 2-补招完成 3-补招失败
+    std::string StartTime; //数据补招起始时间
+	std::string EndTime;   //数据补招结束时间
+	std::string STEADY;    //补招历史统计数据标识 0-不补招；1-补招     
+	std::string VOLTAGE;   //补招暂态事件标识     0-不补招；1-补招
+};
+
+enum class RecallStatus {
+    NOT_STARTED = 0, // 未补招
+    RUNNING     = 1, // 补招中
+    DONE        = 2, // 补招完成
+    FAILED      = 3  // 补招失败
+};
+
+// 本轮要下发的一条任务（每个终端最多一条）
+struct RecallTask {
+    std::string dev_id;
+    std::string start_time;
+    std::string end_time;
+    std::string monitor_index;
+};
+
+//日志补招结构类,当前不使用
 class JournalRecall 
 {
 public:
+    std::string DevID;     //装置号
 	std::string MonitorID; //线路监测点号
 	std::string StartTime; //数据补招起始时间
 	std::string EndTime;   //数据补招结束时间
@@ -84,7 +111,7 @@ class ledger_monitor
 {
 public:
 	std::string monitor_id;			//监测点id
-    std::string terminal_id;		//监测点
+    std::string terminal_id;		//监测点的终端id
     std::string monitor_name;		//监测点名
     std::string logical_device_seq;	//监测点序号
     std::string voltage_level;		//监测点电压等级
@@ -99,6 +126,9 @@ public:
     //暂态事件
     qvvr_event qvvrevent;   
 
+    //补招列表
+    std::list<RecallMonitor> recall_list;
+
     //定值list
     std::list<float> set_values;
     std::vector<DZ_TAB_STRUCT> dz_info_list; //定值信息列表
@@ -511,7 +541,7 @@ void check_and_backup_qvvr_files();
 //业务超时检查
 void check_device_busy_timeout();
 
-//业务响应
+//业务上报
 void send_reply_to_cloud(int reply_code, const std::string& dev_id, int type);
 
 //查guid
@@ -538,6 +568,18 @@ void SendFileWeb(const std::string& strUrl, const std::string& localpath, const
 //状态翻转
 void connect_status_update(const std::string& id, int status);
 
+//业务停止
+void clear_terminal_runtime_state(const std::string& id);
+
+//业务响应
+void on_device_response_minimal(int response_code,
+                                const std::string& id,
+                                unsigned char cid,
+                                int device_state_int);
+
+//处理补招的任务
+void check_recall_event();
+
 //小工具
 inline std::string trim_cstr(const char* s, size_t n) {
     if (!s) return {};
@@ -570,7 +612,12 @@ enum class ResponseCode : int {
     TIMEOUT           = 406, // 请求超出了等待时间
     INTERNAL_ERROR    = 500  // 其他错误
 };
+static inline bool is_ok(int rc) { return rc == static_cast<int>(ResponseCode::OK); }
 
+static bool parse_datetime_tm(const std::string& s, std::tm& out) {
+    std::memset(&out, 0, sizeof(out));
+    return strptime(s.c_str(), "%Y-%m-%d %H:%M:%S", &out) != nullptr;
+}
 #endif
 
 

LFtid1056/cloudfront/code/log4.h

@@ -73,8 +73,7 @@ void process_log_command(const std::string& id, const std::string& level, const
 
 void update_log_entries_countdown();
 
-extern "C" {
+
-#endif
 void remove_loggers_by_terminal_id(const std::string& terminal_id_cstr);
 void init_logger_process();
 void init_loggers();
@@ -152,10 +151,7 @@ typedef enum LogCode {
     LOG_CODE_SPACE_ALARM       = 700   /* 空间告警 */
 } LogCode;
 
-
+#endif // __cplusplus
-#ifdef __cplusplus
-}
-#endif
 
 
 

LFtid1056/cloudfront/code/main.cpp

@@ -317,8 +317,8 @@ void Front::FrontThread() {
 
     try {
         while (!m_bIsFrontThreadCancle) {
-            //check_3s_config();      // 实时数据触发
+
-            //create_recall_xml();    // 生成待补招xml文件
+            check_recall_event();    // 处理补招事件，从list中读取然后直接调用接口,每一条可能都不同测点，每个测点自己做好记录
             check_ledger_update();  // 触发台账更新
 
             std::this_thread::sleep_for(std::chrono::milliseconds(100));

LFtid1056/cloudfront/code/rocketmq.cpp

@@ -1007,7 +1007,6 @@ rocketmq::ConsumeStatus myMessageCallbackrecall(const rocketmq::MQMessageExt& ms
 
     if (!result.empty()) {
 
-        std::lock_guard<std::mutex> lock(ledgermtx);
         recall_json_handle(result);//不再使用文件补招方式
 
     } else {
@@ -1824,7 +1823,7 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
 
                     ClientManager::instance().get_fixedvalue_action_to_device(
                         devid, static_cast<uint16_t>(parsed.cldid));        // 获取装置测点定值数据
-                    ClientManager::instance().get_fixedvaluedes_action_to_device(devid); // 获取装置定值描述
+                    ClientManager::instance().get_fixedvaluedes_action_to_device(devid); // 获取装置定值描述 只有这一步可以响应成功和关闭
                     break;
                 }
                 case 2: { // 写
@@ -1871,7 +1870,7 @@ bool parsemsg(const std::string& devid, const std::string& guid, const nlohmann:
 
                     ClientManager::instance().get_interfixedvalue_action_to_device(devid);   // 获取内部定值
                     ClientManager::instance().get_fixedvalucontrolword_action_to_device(devid, 1); // 1-内部定值描述
-                    ClientManager::instance().get_fixedvalucontrolword_action_to_device(devid, 2); // 2-控制字描述
+                    ClientManager::instance().get_fixedvalucontrolword_action_to_device(devid, 2); // 2-控制字描述  只有这一步可以响应成功和关闭
                     break;
                 }
                 case 2: { // 写

LFtid1056/dealMsg.cpp

@@ -617,7 +617,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 }
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, static_cast<int>(DeviceState::READING_REALSTAT));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id,0, static_cast<int>(DeviceState::READING_REALSTAT));
                     // <20><><EFBFBD><EFBFBD>ʵʱ<CAB5><CAB1><EFBFBD>ݴ<EFBFBD><DDB4>󣬵<EFBFBD><F3A3ACB5><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }
@@ -706,8 +706,8 @@ void process_received_message(string mac, string id,const char* data, size_t len
                                 << ", Error: " << strerror(errno) << std::endl;
 
                             // <20>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD>ܣ<EFBFBD>֪ͨ<CDA8>ƶ<EFBFBD>
-                            send_reply_to_cloud(static_cast<int>(ResponseCode::BAD_REQUEST),
+                            on_device_response_minimal(static_cast<int>(ResponseCode::BAD_REQUEST),
-                                id, static_cast<int>(DeviceState::READING_EVENTFILE));
+                                id, 0, static_cast<int>(DeviceState::READING_EVENTFILE));
                         }
 
                         //<2F><>ǰ<EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD><CFA3><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD>أ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD>еȺ<D0B5><C8BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ˣ<EFBFBD><CBA3><EFBFBD><EFBFBD>ɿ<EFBFBD><C9BF><EFBFBD>״̬<D7B4><CCAC>ֱ<EFBFBD>ӾͻῪʼ<E1BFAA><CABC><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ع<EFBFBD><D8B9><EFBFBD><EFBFBD><EFBFBD>
@@ -716,7 +716,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 }
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, static_cast<int>(DeviceState::READING_EVENTFILE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, 0, static_cast<int>(DeviceState::READING_EVENTFILE));
                     // <20><><EFBFBD>ղ<EFBFBD><D5B2><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݴ<EFBFBD><DDB4>󣬵<EFBFBD><F3A3ACB5><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }
@@ -761,7 +761,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 else {
                     std::cout << "reason code: " << static_cast<int>(udata[8]) << "-" << static_cast<int>(udata[9]) << "-" << static_cast<int>(udata[10]) << "-" << static_cast<int>(udata[11]) << std::endl;
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, static_cast<int>(DeviceState::READING_FILEMENU));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, 0, static_cast<int>(DeviceState::READING_FILEMENU));
                     // <20><><EFBFBD><EFBFBD>Ŀ¼<C4BF><C2BC><EFBFBD>ݴ<EFBFBD><DDB4>󣬵<EFBFBD><F3A3ACB5><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }
@@ -859,7 +859,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 }
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, static_cast<int>(DeviceState::READING_FILEDATA));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, 0, static_cast<int>(DeviceState::READING_FILEDATA));
                     // <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD>ݴ<EFBFBD><DDB4>󣬵<EFBFBD><F3A3ACB5><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }
@@ -932,7 +932,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 }
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR),id,static_cast<int>(DeviceState::READING_FIXEDVALUE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, 0, static_cast<int>(DeviceState::READING_FIXEDVALUE));
 
                     // <20><>ȡ<EFBFBD><C8A1>ֵ<EFBFBD><D6B5><EFBFBD>󣬵<EFBFBD><F3A3ACB5><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
@@ -1018,7 +1018,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 }
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR),id,static_cast<int>(DeviceState::READING_FIXEDVALUEDES));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR),id,0,static_cast<int>(DeviceState::READING_FIXEDVALUEDES));
 
                     // <20><>ȡ<EFBFBD><C8A1>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
@@ -1031,7 +1031,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                     std::cout << "set success" << mac << std::endl;
 
                     //<2F><>Ӧlnk20250828                    
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::OK),id,static_cast<int>(DeviceState::SET_FIXEDVALUE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::OK),id,0,static_cast<int>(DeviceState::SET_FIXEDVALUE));
 
                     //<2F><>ֵ<EFBFBD><D6B5><EFBFBD>óɹ<C3B3><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
@@ -1041,7 +1041,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                     // װ<>÷<EFBFBD><C3B7><EFBFBD>Ӧ<EFBFBD>𣬶<EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>
 
                     //<2F><>Ӧlnk20250828                    
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::BAD_REQUEST),id,static_cast<int>(DeviceState::SET_FIXEDVALUE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::BAD_REQUEST),id,0,static_cast<int>(DeviceState::SET_FIXEDVALUE));
 
                     // <20><><EFBFBD><EFBFBD>װ<EFBFBD>ö<EFBFBD>ֵʧ<D6B5>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
@@ -1051,7 +1051,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                     // <20><><EFBFBD><EFBFBD>װ<EFBFBD>ö<EFBFBD>ֵʧ<D6B5>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
 
                     //<2F><>Ӧlnk20250828                    
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR),id,static_cast<int>(DeviceState::SET_FIXEDVALUE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR),id,0,static_cast<int>(DeviceState::SET_FIXEDVALUE));
 
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }
@@ -1103,7 +1103,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
 
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, static_cast<int>(DeviceState::READING_INTERFIXEDVALUE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, 0, static_cast<int>(DeviceState::READING_INTERFIXEDVALUE));
 
                     // <20><>ȡװ<C8A1><D7B0><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>ֵʧ<D6B5>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
@@ -1182,7 +1182,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
 
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, static_cast<int>(DeviceState::READING_INTERFIXEDVALUEDES));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, 0, static_cast<int>(DeviceState::READING_INTERFIXEDVALUEDES));
 
                     // <20><>ȡװ<C8A1><D7B0><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>ʧ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
@@ -1246,7 +1246,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 }
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, static_cast<int>(DeviceState::READING_CONTROLWORD));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, 0, static_cast<int>(DeviceState::READING_CONTROLWORD));
                     // <20><>ȡװ<C8A1>ÿ<EFBFBD><C3BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }
@@ -1257,7 +1257,7 @@ void process_received_message(string mac, string id,const char* data, size_t len
                 if (udata[8] == static_cast<unsigned char>(MsgResponseType::Response_NewACK)) {
                     std::cout << "set success" << mac << std::endl;
                     //<2F>ڲ<EFBFBD><DAB2><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD>óɹ<C3B3><C9B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::OK), id, static_cast<int>(DeviceState::SET_INTERFIXEDVALUE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::OK), id, 0, static_cast<int>(DeviceState::SET_INTERFIXEDVALUE));
 
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }
@@ -1267,14 +1267,14 @@ void process_received_message(string mac, string id,const char* data, size_t len
                     std::cout << "reason code: " << static_cast<int>(udata[8]) << "-" << static_cast<int>(udata[9]) << "-" << static_cast<int>(udata[10]) << "-" << static_cast<int>(udata[11]) << std::endl;
 
                     // װ<>÷<EFBFBD><C3B7><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD><EFBFBD><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::BAD_REQUEST), id, static_cast<int>(DeviceState::SET_INTERFIXEDVALUE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::BAD_REQUEST), id, 0, static_cast<int>(DeviceState::SET_INTERFIXEDVALUE));
 
                     // <20><><EFBFBD><EFBFBD>װ<EFBFBD><D7B0><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>ֵʧ<D6B5>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }
                 else {
                     // װ<>ô<EFBFBD><C3B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>쳣
-                    send_reply_to_cloud(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, static_cast<int>(DeviceState::SET_INTERFIXEDVALUE));
+                    on_device_response_minimal(static_cast<int>(ResponseCode::INTERNAL_ERROR), id, 0, static_cast<int>(DeviceState::SET_INTERFIXEDVALUE));
                     // <20><><EFBFBD><EFBFBD>װ<EFBFBD><D7B0><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>ֵʧ<D6B5>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>״̬<D7B4><CCAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EEB9A4><EFBFBD><EFBFBD>
                     ClientManager::instance().change_device_state(id, DeviceState::IDLE);
                 }