add x,y,z switch

common/global.hpp

@@ -18,7 +18,7 @@ enum enumZigBeeTransmitStatus {
 
 
 //#define NR5G_MODULE
-//#define Q4G_MODULE
+#define Q4G_MODULE
 //#define WIFI_MODULE
 //#define NR5G_MEIGE
 

common/parameter_defination.hpp

@@ -2,6 +2,7 @@
 #define PARAMETER_DEFINATION_HPP_
 
 #include <string>
+#include "scheduler/wave_feature_set.hpp"
 
 struct Param_01 {
     int mMode; // 0:登陆  1:更改密码
@@ -343,5 +344,18 @@ struct Param_62 {
     int mPackageFlag;
     Param_62() : MeasurementID(""),timeStart(""),timeEnd(""),mPackageFlag(0){};
 };
+struct Param_63 {
     
+    int mMode;
+    bool partial;
+    std::vector<FeatureEntryUploadCfg> cfg;
+    Param_63() : mMode(0),partial(false){};
+};
+struct Param_64 {
+    
+    int mMode;
+    bool partial;
+    std::vector<FeatureEntryUploadCfg> cfg;
+    Param_64() : mMode(0),partial(false){};
+};
 #endif // PARAMETER_DEFINATION_HPP_

jsonparse/communication_cmd.hpp

@@ -71,6 +71,8 @@ public:
     std::string JsonCmd_Cgi_60(Param_60 &param);
     std::string JsonCmd_Cgi_61(Param_61 &param);
     std::string JsonCmd_Cgi_62(Param_62 &param);
+    std::string JsonCmd_Cgi_63(Param_63 &param);
+    std::string JsonCmd_Cgi_64(Param_64 &param);
     std::string JsonCmd_Cgi_default();
 
 private:

jsonparse/web_cmd_parse3.cpp

@@ -955,3 +955,96 @@ std::string JsonData::JsonCmd_Cgi_62(Param_62 &param){
     }
     return show_value_.write(jsonVal);
 }
+std::string JsonData::JsonCmd_Cgi_63(Param_63 &param)
+{
+    Json::Value jsonVal;
+    jsonVal.clear();
+    Json::Value jsBody;
+    jsonVal[JSON_FIELD_CMD] = "63";
+    jsonVal["success"] = true;
+    jsonVal["message"] = "";
+    if (param.mMode == 0)
+    {
+        std::vector<FeatureEntryUploadCfg> cfg;
+        wave_feature_set_inst::instance().GetAllFeatureCfg(cfg);
+        if (cfg.size() > 0)
+        {
+            for (size_t i = 0; i < cfg.size(); i++)
+            {
+                Json::Value xyz_status;
+                xyz_status.append(cfg[i].x);
+                xyz_status.append(cfg[i].y);
+                xyz_status.append(cfg[i].z);
+                if (cfg[i].short_addr == 0)
+                {
+                    jsBody["global"] = xyz_status;
+                }else{
+                    char buf[8] = {0};
+                    snprintf(buf, 8, "%02x%02x", UINT16_HIGH(cfg[i].short_addr), UINT16_LOW(cfg[i].short_addr));
+                    jsBody[buf] = xyz_status;
+                }
+            }
+        }else{
+            jsonVal["success"] = false;
+            jsonVal["message"] = "";
+        } 
+    }else if(param.mMode == 1){
+        if (param.partial)
+        {
+            zlog_info(zct, "63 short_addr = %d,x = %d,y = %d,z = %d", param.cfg[0].short_addr, param.cfg[0].x, param.cfg[0].y, param.cfg[0].z);
+            wave_feature_set_inst::instance().SetFeatureCfg(param.cfg[0].short_addr, param.cfg[0].x, param.cfg[0].y, param.cfg[0].z);
+        }else{
+            wave_feature_set_inst::instance().SetAllFeatureCfg(param.cfg);
+        }
+        
+    }
+    jsonVal["cmdBody"] = jsBody;
+    return show_value_.write(jsonVal);
+}
+std::string JsonData::JsonCmd_Cgi_64(Param_64 &param)
+{
+    Json::Value jsonVal;
+    jsonVal.clear();
+    Json::Value jsBody;
+    jsonVal[JSON_FIELD_CMD] = "64";
+    jsonVal["success"] = true;
+    jsonVal["message"] = "";
+    if (param.mMode == 0)
+    {
+        std::vector<FeatureEntryUploadCfg> cfg;
+        wave_feature_set_inst::instance().GetAllWaveCfg(cfg);
+        zlog_info(zct,"cfg size = %d",cfg.size());
+        if (cfg.size() > 0)
+        {
+            for (size_t i = 0; i < cfg.size(); i++)
+            {
+                Json::Value xyz_status;
+                xyz_status.append(cfg[i].x);
+                xyz_status.append(cfg[i].y);
+                xyz_status.append(cfg[i].z);
+                if (cfg[i].short_addr == 0)
+                {
+                    jsBody["global"] = xyz_status;
+                }else{
+                    char buf[8] = {0};
+                    snprintf(buf, 8, "%02x%02x", UINT16_HIGH(cfg[i].short_addr), UINT16_LOW(cfg[i].short_addr));
+                    jsBody[buf] = xyz_status;
+                }
+            }
+        }else{
+            jsonVal["success"] = false;
+            jsonVal["message"] = "";
+        } 
+    }else if(param.mMode == 1){
+        if (param.partial)
+        {
+            zlog_info(zct, "64 short_addr = %d,x = %d,y = %d,z = %d", param.cfg[0].short_addr, param.cfg[0].x, param.cfg[0].y, param.cfg[0].z);
+            wave_feature_set_inst::instance().SetWaveCfg(param.cfg[0].short_addr, param.cfg[0].x, param.cfg[0].y, param.cfg[0].z);
+        }else{
+            wave_feature_set_inst::instance().SetAllWaveCfg(param.cfg);
+        }
+        
+    }
+    jsonVal["cmdBody"] = jsBody;
+    return show_value_.write(jsonVal);
+}

localserver/local_server.hpp

@@ -51,7 +51,9 @@ enum WebCommand {
     kLostRecords = 59,
     kTransducerUpgrade = 60,
     kWaveRecords = 61,
-    kWaveReceive = 62
+    kWaveReceive = 62,
+    kWaveSend = 63,
+    kFeatureSend = 64
 };
 
 class LocalServer {

localserver/web_cmd.cpp

@@ -438,6 +438,78 @@ std::string LocalServer::HandleCgi_cmd(std::string &pData) {
                     std::string data = jd.JsonCmd_Cgi_62(param);
                     return data;
                 }break;
+                case kWaveSend:{
+                    JsonData jd;
+                    Param_63 param;
+                    param.mMode = recvBody["sub_cmd"].asInt();
+                    param.partial = recvBody["partial"].asBool();
+                    if (param.mMode == 1)
+                    {
+                        for (const auto &key : recvBody.getMemberNames()) 
+                        {
+                            if (key != "sub_cmd" && key != "partial")
+                            {
+                                FeatureEntryUploadCfg tmpCfg;
+                                char *end_ptr;
+                                if (key == "global")
+                                {
+                                    tmpCfg.short_addr = 0;
+                                }else{
+                                    tmpCfg.short_addr = strtol(key.c_str(), &end_ptr, 16);
+                                }
+                                Json::Value xyz_status =  recvBody[key];
+                                for (size_t i = 0; i < xyz_status.size(); ++i) {
+                                    if (i == 0) {
+                                        tmpCfg.x = xyz_status[i].asInt();
+                                    } else if (i == 1) {
+                                        tmpCfg.y = xyz_status[i].asInt();
+                                    } else if (i == 2) {
+                                        tmpCfg.z = xyz_status[i].asInt();
+                                    }                         
+                                }  
+                                param.cfg.push_back(tmpCfg);
+                            }
+                        }
+                    }
+                    std::string data = jd.JsonCmd_Cgi_63(param);
+                    return data;
+                }break;
+                case kFeatureSend:{
+                    JsonData jd;
+                    Param_64 param;
+                    param.mMode = recvBody["sub_cmd"].asInt();
+                    param.partial = recvBody["partial"].asBool();
+                    if (param.mMode == 1)
+                    {
+                        for (const auto &key : recvBody.getMemberNames()) 
+                        {
+                            if (key != "sub_cmd" && key != "partial")
+                            {
+                                FeatureEntryUploadCfg tmpCfg;
+                                char *end_ptr;
+                                if (key == "global")
+                                {
+                                    tmpCfg.short_addr = 0;
+                                }else{
+                                    tmpCfg.short_addr = strtol(key.c_str(), &end_ptr, 16);
+                                }
+                                Json::Value xyz_status =  recvBody[key];
+                                for (size_t i = 0; i < xyz_status.size(); ++i) {
+                                    if (i == 0) {
+                                        tmpCfg.x = xyz_status[i].asInt();
+                                    } else if (i == 1) {
+                                        tmpCfg.y = xyz_status[i].asInt();
+                                    } else if (i == 2) {
+                                        tmpCfg.z = xyz_status[i].asInt();
+                                    }                         
+                                }  
+                                param.cfg.push_back(tmpCfg);
+                            }
+                        }
+                    }
+                    std::string data = jd.JsonCmd_Cgi_64(param);
+                    return data;
+                }break;
                 default:
                     JsonData jd;
                     std::string data = jd.JsonCmd_Cgi_default();

scheduler/schedule.cpp

@@ -10,10 +10,13 @@
 #include <zlog.h>
 #include "short_addr_cfg.hpp"
 #include "update_cfg.hpp"
+#include "wave_feature_set.hpp"
 
 extern zlog_category_t *zct;
 extern zlog_category_t *zbt;
 
+uint8_t g_x, g_y, g_z;
+
 int SensorScheduler::StartSchedule(int short_addr, int &next_duration) {    
     int id = 0;
     auto iter = short_addr_map_.find(short_addr);
@@ -52,10 +55,17 @@ int SensorScheduler::StartSchedule(int short_addr, int &next_duration) {
                 current_request_ = kScheduleConfigSensor;
                 return kScheduleConfigSensor;
             } else {
-                // 执行上送特征值任务
+                wave_feature_set_inst::instance().GetFeatureCfg(short_addr, g_x, g_y, g_z);
-                zlog_warn(zct, "[%d:%x] send eigen value in eigen slice", id, short_addr);
+                if (g_x || g_y || g_z) { 
-                current_request_ = kScheduleEigenValue;
+                    // 执行上送特征值任务
-                return kScheduleEigenValue;
+                    zlog_warn(zct, "[%d:%x] send eigen value in eigen slice", id, short_addr);
+                    current_request_ = kScheduleEigenValue;
+                    return kScheduleEigenValue;
+                } else {                    
+                    next_duration = GetNextDuration(short_addr);
+                    zlog_warn(zct, "[%d:%x] no need for eigen", id, short_addr);
+                    return kScheduleWrongTime;
+                }
             }           
         } else {
             zlog_warn(zct, "[%d:%x] Invalid request, revive in %d eigen slice", id, short_addr, nth_eigen_slice_ + 1);
@@ -99,9 +109,16 @@ int SensorScheduler::StartSchedule(int short_addr, int &next_duration) {
                 current_request_ = kScheduleConfigSensor;
                 return kScheduleConfigSensor;
             }
-            zlog_warn(zct, "[%d:%x] it is wave time", id, short_addr);
+            wave_feature_set_inst::instance().GetWaveCfg(short_addr, g_x, g_y, g_z);
-            current_request_ = kScheduleWaveForm;
+            if (g_x || g_y || g_z) {
-            return kScheduleWaveForm;
+                zlog_warn(zct, "[%d:%x] it is wave time", id, short_addr);
+                current_request_ = kScheduleWaveForm;
+                return kScheduleWaveForm;
+            } else {
+                next_duration = GetNextDuration(short_addr);
+                zlog_warn(zct, "[%d:%x] no need for wave", id, short_addr);
+                return kScheduleWrongTime;
+            }
         } else {                
             if (slice_sensor_id_[nth_wave_slice-1] == 0) {
                 zlog_warn(zct, "[%d:%x] in idle time", id, short_addr);
@@ -147,14 +164,17 @@ long SensorScheduler::CalcNextTimestamp(int id, uint16_t short_addr) {
         }
         int wave_slice = wave_slice_iter->second; // 从1开始
         long send_wave_ts = 0;
-        if (wave_slice > forward_wave_slice_num && 
+        wave_feature_set_inst::instance().GetWaveCfg(short_addr, g_x, g_y, g_z);
-            wave_slice <= forward_wave_slice_num + wave_slice_num_per_eigen_interval_) {
+        if (g_x || g_y || g_z) {
-            // 发送波的时间窗也在本次特征值发送间隔中
+            if (wave_slice > forward_wave_slice_num && 
-            for (int i = forward_wave_slice_num; i <= forward_wave_slice_num + wave_slice_num_per_eigen_interval_; ++i) {
+                wave_slice <= forward_wave_slice_num + wave_slice_num_per_eigen_interval_) {
-                if (wave_slice - 1 == i) {
+                // 发送波的时间窗也在本次特征值发送间隔中
-                    send_wave_ts = current_wave_start_ts_ + nth_eigen_value_slice_ * eigen_value_send_interval_ + eigen_value_slice_total_seconds_ + (i - forward_wave_slice_num) * seconds_per_wave_slice_;
+                for (int i = forward_wave_slice_num; i <= forward_wave_slice_num + wave_slice_num_per_eigen_interval_; ++i) {
-                    zlog_warn(zct, "[Nxt] [%d:%x] send wave time:[%s]", id, short_addr, GetUTCTime(send_wave_ts).c_str());
+                    if (wave_slice - 1 == i) {
-                    break;
+                        send_wave_ts = current_wave_start_ts_ + nth_eigen_value_slice_ * eigen_value_send_interval_ + eigen_value_slice_total_seconds_ + (i - forward_wave_slice_num) * seconds_per_wave_slice_;
+                        zlog_warn(zct, "[Nxt] [%d:%x] send wave time:[%s]", id, short_addr, GetUTCTime(send_wave_ts).c_str());
+                        break;
+                    }
                 }
             }
         } 
@@ -207,7 +227,7 @@ int SensorScheduler::GetNextDuration(int short_addr) {
     long current_ts = GetLocalTs(); 
     long next_ts = CalcNextTimestamp(id, short_addr);
     int duration = next_ts - current_ts;
-    if (duration <= 10 || duration > eigen_value_send_interval_) {
+    if (duration < 0 || duration > eigen_value_send_interval_) {
         zlog_warn(zct, "[Nxt] exception duration: %d", duration);
         duration = eigen_value_send_interval_;
     }
@@ -650,11 +670,15 @@ void SensorScheduler::ClearScheduleCfg(int short_addr) {
         ShortAddrCfg::ClearCfg();
         UpdateCfg::ClearCfg();
         UpgradeCfg::ClearCfg();
+        wave_feature_set_inst::instance().RemoveAllFeatureCfg();
+        wave_feature_set_inst::instance().RemoveAllWaveCfg();
     } else {
         UpdateConfigResult(short_addr, 0);
         UpgradeResult(short_addr, kUpgradeSuccess);
         short_addr_map_.erase(short_addr);
         ShortAddrCfg::WriteCfg(short_addr_map_);
+        wave_feature_set_inst::instance().RemoveFeatureCfg(short_addr);
+        wave_feature_set_inst::instance().RemoveWaveCfg(short_addr);
     }
     
 }

scheduler/upgrade_cfg.cpp

@@ -13,14 +13,6 @@ int UpgradeCfg::ReadCfg(std::map<int, UpgradeInfo> &upgrade) {
         return 0;
     }
 
-    upgrade_file.seekg(0, std::ios::end);
-    std::streampos file_size = upgrade_file.tellg();
-    if (file_size > 256000) {
-        zlog_error(zct, "upgrade file exception, will remove it");
-        ClearCfg();
-        return 1;
-    }
-    upgrade_file.seekg(0, std::ios::beg);
     Json::Reader reader;
     Json::Value root;
     if (!reader.parse(upgrade_file, root, false)) {
@@ -59,10 +51,6 @@ int UpgradeCfg::ReadCfg(std::map<int, UpgradeInfo> &upgrade) {
 }
 
 int UpgradeCfg::WriteCfg(std::map<int, UpgradeInfo> &upgrade) {
-    if (upgrade.size() == 0) {
-        ClearCfg();
-        return 0;
-    }
     Json::Value root;        
     for (auto item : upgrade) {
         Json::Value upgrade_item;

scheduler/wave_feature_set.cpp

@@ -0,0 +1,370 @@
+#include "wave_feature_set.hpp"
+#include <fstream>
+#include "common/common_func.hpp"
+#include <zlog.h>
+
+extern zlog_category_t *zct;
+extern zlog_category_t *zbt;
+
+WaveFeatureSetting::WaveFeatureSetting() {
+    std::ifstream feature_filter_file(FEATURE_FILTER_CFG);
+    if (!feature_filter_file.good()) {
+        zlog_info(zbt, "[WaveFeatureSetting] no file %s", FEATURE_FILTER_CFG);
+        global_feature_.short_addr = 0;
+        global_feature_.x = 1;
+        global_feature_.y = 1;
+        global_feature_.z = 1;   
+    } else {
+        Json::Reader reader;
+        Json::Value root;
+        if (!reader.parse(feature_filter_file, root, false)) {
+            zlog_error(zbt, "[WaveFeatureSetting] invalid format, fail to parse %s", FEATURE_FILTER_CFG);
+            feature_filter_file.close();  
+            global_feature_.short_addr = 0;
+            global_feature_.x = 1;
+            global_feature_.y = 1;
+            global_feature_.z = 1;          
+        } else {
+            uint16_t short_addr;
+            char *end_ptr;
+            for (const auto &key : root.getMemberNames()) {
+                if (key == "global") {
+                    Json::Value v = root[key];
+                    global_feature_.short_addr = 0;
+                    for (size_t i = 0; i < v.size(); ++i) {
+                        if (i == 0) {
+                            global_feature_.x = v[i].asInt();
+                        } else if (i == 1) {
+                            global_feature_.y = v[i].asInt();
+                        } else if (i == 2) {
+                            global_feature_.z = v[i].asInt();
+                        }                         
+                    }
+                } else {
+                    short_addr = strtol(key.c_str(), &end_ptr, 16);
+                    Json::Value v = root[key];
+                    FeatureEntryPrivateCfg item;
+                    for (size_t i = 0; i < v.size(); ++i) {
+                        if (i == 0) {
+                            item.x = v[i].asInt();
+                        } else if (i == 1) {
+                            item.y = v[i].asInt();
+                        } else if (i == 2) {
+                            item.z = v[i].asInt();
+                        }                         
+                    }                   
+                    eigen_map_[short_addr] = item;
+                }
+            }
+        }
+    }
+
+    std::ifstream wave_filter_file(WAVE_FILTER_CFG);
+    if (!wave_filter_file.good()) {
+        zlog_info(zbt, "[WaveFeatureSetting] no file %s", WAVE_FILTER_CFG);
+        global_wave_.short_addr = 0;
+        global_wave_.x = 1;
+        global_wave_.y = 1;
+        global_wave_.z = 1;   
+    } else {
+        Json::Reader reader;
+        Json::Value root;
+        if (!reader.parse(wave_filter_file, root, false)) {
+            zlog_error(zbt, "[WaveFeatureSetting] invalid format, fail to parse %s", WAVE_FILTER_CFG);
+            wave_filter_file.close();  
+            global_wave_.short_addr = 0;
+            global_wave_.x = 1;
+            global_wave_.y = 1;
+            global_wave_.z = 1;          
+        } else {
+            uint16_t short_addr;
+            char *end_ptr;
+            for (const auto &key : root.getMemberNames()) {
+                if (key == "global") {
+                    Json::Value v = root[key];
+                    global_wave_.short_addr = 0;
+                    for (size_t i = 0; i < v.size(); ++i) {
+                        if (i == 0) {
+                            global_wave_.x = v[i].asInt();
+                        } else if (i == 1) {
+                            global_wave_.y = v[i].asInt();
+                        } else if (i == 2) {
+                            global_wave_.z = v[i].asInt();
+                        }                         
+                    }                    
+                } else {
+                    short_addr = strtol(key.c_str(), &end_ptr, 16);
+                    Json::Value v = root[key];
+                    FeatureEntryPrivateCfg item;
+                    for (size_t i = 0; i < v.size(); ++i) {
+                        if (i == 0) {
+                            item.x = v[i].asInt();
+                        } else if (i == 1) {
+                            item.y = v[i].asInt();
+                        } else if (i == 2) {
+                            item.z = v[i].asInt();
+                        }                         
+                    }  
+                    
+                    wave_map_[short_addr] = item;
+                }
+            }
+        }
+    }
+}
+
+int WaveFeatureSetting::GetFeatureCfg(uint16_t short_addr, uint8_t &x, uint8_t &y, uint8_t &z) {
+    if (short_addr == 0) {
+        x = global_feature_.x;
+        y = global_feature_.y;
+        z = global_feature_.z;
+        return 0;
+    }
+    auto iter = eigen_map_.find(short_addr);
+    if (iter == eigen_map_.end()) {
+        x = global_feature_.x;
+        y = global_feature_.y;
+        z = global_feature_.z;
+        return 0;
+    }
+
+    x = iter->second.x;
+    y = iter->second.y;
+    z = iter->second.z;
+    return 0; 
+}
+
+void WaveFeatureSetting::SetFeatureCfg(uint16_t short_addr, uint8_t x, uint8_t y, uint8_t z) {
+    bool need_submit = false;
+    if (short_addr == 0) {
+        if (global_feature_.x == x && global_feature_.y == y && global_feature_.z == z) {
+            return;
+        }
+        need_submit = true;
+        global_feature_.x = x;
+        global_feature_.y = y;
+        global_feature_.z = z;        
+    } else {
+        auto iter = eigen_map_.find(short_addr);
+        if (iter == eigen_map_.end()) {
+            FeatureEntryPrivateCfg cfg;
+            cfg.x = x;
+            cfg.y = y;
+            cfg.z = z;
+            eigen_map_[short_addr] = cfg;
+            need_submit = true;
+        } else {
+            if (iter->second.x == x && iter->second.y == y && iter->second.z == z) {
+                return;
+            }
+            
+            iter->second.x = x;
+            iter->second.y = y;
+            iter->second.z = z;            
+            need_submit = true;
+        }
+    }
+
+    if (need_submit) {
+        WriteFeatureCfgFile();
+    }
+}
+
+void WaveFeatureSetting::SetAllFeatureCfg(std::vector<FeatureEntryUploadCfg> cfg) {
+    eigen_map_.clear();
+    for (auto item : cfg) {
+        if (item.short_addr == 0) {
+            global_feature_.short_addr = 0;
+            global_feature_.x = item.x;
+            global_feature_.y = item.y;
+            global_feature_.z = item.z;
+        } else {
+            FeatureEntryPrivateCfg entry;
+            entry.x = item.x;
+            entry.y = item.y;
+            entry.z = item.z;
+            eigen_map_[item.short_addr] = entry;
+        }
+    }
+    WriteFeatureCfgFile();
+}
+
+int WaveFeatureSetting::GetAllFeatureCfg(std::vector<FeatureEntryUploadCfg> &cfg) {
+    cfg.clear();
+    cfg.push_back(global_feature_); 
+    for (auto item : eigen_map_) {
+        FeatureEntryUploadCfg current;
+        current.short_addr = item.first;
+        current.x = item.second.x;
+        current.y = item.second.y;
+        current.z = item.second.z;
+        cfg.push_back(current);
+    }
+    return 0; 
+}
+
+void WaveFeatureSetting::RemoveFeatureCfg(uint16_t short_addr) {
+    auto iter = eigen_map_.find(short_addr);
+    if (iter == eigen_map_.end()) {
+        return;
+    }
+    eigen_map_.erase(short_addr);
+    WriteFeatureCfgFile();
+}
+
+void WaveFeatureSetting::RemoveAllFeatureCfg() {
+    std::string clear_cmd = "rm -rf ";
+    clear_cmd.append(FEATURE_FILTER_CFG);
+    system(clear_cmd.c_str());
+}
+
+void WaveFeatureSetting::WriteFeatureCfgFile() {
+    Json::Value root;
+    Json::Value global_arr;
+    global_arr.append(global_feature_.x);
+    global_arr.append(global_feature_.y);
+    global_arr.append(global_feature_.z);
+    root["global"] = global_arr;
+
+    char buf[8] = {0};
+    for (auto item : eigen_map_) {
+        memset(buf, 0, 8);
+        snprintf(buf, 8, "%02x%02x", UINT16_HIGH(item.first), UINT16_LOW(item.first));
+        Json::Value arr;
+        arr.append(item.second.x);
+        arr.append(item.second.y);
+        arr.append(item.second.z);
+        root[buf] = arr;
+    }
+    Json::StyledStreamWriter streamWriter;
+    std::ofstream out_file(FEATURE_FILTER_CFG);
+    streamWriter.write(out_file, root);
+}
+
+void WaveFeatureSetting::WriteWaveCfgFile() {
+    Json::Value root;
+    Json::Value global_arr;
+    global_arr.append(global_wave_.x);
+    global_arr.append(global_wave_.y);
+    global_arr.append(global_wave_.z);
+    root["global"] = global_arr;
+
+    char buf[8] = {0};
+    for (auto item : wave_map_) {
+        memset(buf, 0, 8);
+        snprintf(buf, 8, "%02x%02x", UINT16_HIGH(item.first), UINT16_LOW(item.first));
+        Json::Value arr;
+        arr.append(item.second.x);
+        arr.append(item.second.y);
+        arr.append(item.second.z);
+        root[buf] = arr;
+    }
+    Json::StyledStreamWriter streamWriter;
+    std::ofstream out_file(WAVE_FILTER_CFG);
+    streamWriter.write(out_file, root);
+}
+
+int WaveFeatureSetting::GetWaveCfg(uint16_t short_addr, uint8_t &x, uint8_t &y, uint8_t &z) { 
+    if (short_addr == 0) {
+        x = global_wave_.x;
+        y = global_wave_.y;
+        z = global_wave_.z;
+        return 0;
+    }
+    auto iter = wave_map_.find(short_addr);
+    if (iter == wave_map_.end()) {
+        x = global_wave_.x;
+        y = global_wave_.y;
+        z = global_wave_.z;
+        return 0;
+    }
+
+    x = iter->second.x;
+    y = iter->second.y;
+    z = iter->second.z;
+    return 0;
+}
+
+void WaveFeatureSetting::SetWaveCfg(uint16_t short_addr, uint8_t x, uint8_t y, uint8_t z) {
+    bool need_submit = false;
+    if (short_addr == 0) {
+        if (global_wave_.x == x && global_wave_.y == y && global_wave_.z == z) {
+            return;
+        }
+        need_submit = true;
+        global_wave_.x = x;
+        global_wave_.y = y;
+        global_wave_.z = z;        
+    } else {
+        auto iter = wave_map_.find(short_addr);
+        if (iter == wave_map_.end()) {
+            FeatureEntryPrivateCfg cfg;
+            cfg.x = x;
+            cfg.y = y;
+            cfg.z = z;
+            wave_map_[short_addr] = cfg;
+            need_submit = true;
+        } else {
+            if (iter->second.x == x && iter->second.y == y && iter->second.z == z) {
+                return;
+            }
+            
+            iter->second.x = x;
+            iter->second.y = y;
+            iter->second.z = z;            
+            need_submit = true;
+        }
+    }
+
+    if (need_submit) {
+        WriteWaveCfgFile();
+    }
+}
+
+void WaveFeatureSetting::SetAllWaveCfg(std::vector<FeatureEntryUploadCfg> cfg) {
+    eigen_map_.clear();
+    for (auto item : cfg) {
+        if (item.short_addr == 0) {
+            global_wave_.short_addr = 0;
+            global_wave_.x = item.x;
+            global_wave_.y = item.y;
+            global_wave_.z = item.z;
+        } else {
+            FeatureEntryPrivateCfg entry;
+            entry.x = item.x;
+            entry.y = item.y;
+            entry.z = item.z;
+            wave_map_[item.short_addr] = entry;
+        }
+    }
+    WriteWaveCfgFile();
+}
+
+int WaveFeatureSetting::GetAllWaveCfg(std::vector<FeatureEntryUploadCfg> &cfg) { 
+    cfg.clear();
+    cfg.push_back(global_wave_); 
+    for (auto item : wave_map_) {
+        FeatureEntryUploadCfg current;
+        current.short_addr = item.first;
+        current.x = item.second.x;
+        current.y = item.second.y;
+        current.z = item.second.z;
+        cfg.push_back(current);
+    }
+    return 0; 
+}
+
+void WaveFeatureSetting::RemoveWaveCfg(uint16_t short_addr) {
+    auto iter = wave_map_.find(short_addr);
+    if (iter == wave_map_.end()) {
+        return;
+    }
+    wave_map_.erase(short_addr);
+    WriteWaveCfgFile();
+}
+
+void WaveFeatureSetting::RemoveAllWaveCfg() {
+    std::string clear_cmd = "rm -rf ";
+    clear_cmd.append(WAVE_FILTER_CFG);
+    system(clear_cmd.c_str());
+}

scheduler/wave_feature_set.hpp

@@ -0,0 +1,56 @@
+#ifndef WAVE_FEATURE_SET_HPP_
+#define WAVE_FEATURE_SET_HPP_
+
+#include <iostream>
+#include <map>
+#include <unordered_set>
+#include <vector>
+#include <stdint.h>
+#include <boost/container/detail/singleton.hpp>
+#include <json/json.h>
+
+#define FEATURE_FILTER_CFG   "/opt/configenv/feature_filter.json"
+#define WAVE_FILTER_CFG   "/opt/configenv/wave_filter.json"
+
+typedef struct {
+    uint16_t short_addr; // 全局配置的短地址写0
+    uint8_t x, y, z;
+} FeatureEntryUploadCfg;
+
+typedef struct {
+    uint8_t x, y, z;
+} FeatureEntryPrivateCfg;
+
+class WaveFeatureSetting {
+public:
+    WaveFeatureSetting();
+
+    // Feature set
+    int GetFeatureCfg(uint16_t short_addr, uint8_t &x, uint8_t &y, uint8_t &z); // 获取单个    
+    void SetFeatureCfg(uint16_t short_addr, uint8_t x, uint8_t y, uint8_t z); // 设置单个传感器
+    void SetAllFeatureCfg(std::vector<FeatureEntryUploadCfg> cfg); // 设置所有的
+    int GetAllFeatureCfg(std::vector<FeatureEntryUploadCfg> &cfg); // 获取所有的
+    void RemoveFeatureCfg(uint16_t short_addr);
+    void RemoveAllFeatureCfg();
+
+    // Wave set
+    int GetWaveCfg(uint16_t short_addr, uint8_t &x, uint8_t &y, uint8_t &z); // 获取单个
+    void SetWaveCfg(uint16_t short_addr, uint8_t x, uint8_t y, uint8_t z); // 设置单个传感器
+    void SetAllWaveCfg(std::vector<FeatureEntryUploadCfg> cfg); // 设置所有的
+    int GetAllWaveCfg(std::vector<FeatureEntryUploadCfg> &cfg); // 获取所有的
+    void RemoveWaveCfg(uint16_t short_addr);
+    void RemoveAllWaveCfg();
+
+private:
+    void WriteFeatureCfgFile();
+    FeatureEntryUploadCfg global_feature_;
+    std::map<uint16_t, FeatureEntryPrivateCfg> eigen_map_;
+
+    void WriteWaveCfgFile();
+    FeatureEntryUploadCfg global_wave_;
+    std::map<uint16_t, FeatureEntryPrivateCfg> wave_map_;
+};
+
+typedef boost::container::dtl::singleton_default<WaveFeatureSetting> wave_feature_set_inst;
+
+#endif // WAVE_FEATURE_SET_HPP_

uart/uart_feature_parse.cpp

@@ -52,11 +52,12 @@ void Uart::DealDataNodeFeature(const char *pData, int flag) {
     if (flag == 1) {
         zlog_info(zct, "DealDataNodeFeature %02x%02x, %d", pRecvData->ShortAddr[0], pRecvData->ShortAddr[1], flag);
     }
-
+    uint8_t Feature_x,Feature_y,Feature_z;
-    if (bSendTimeStamp) //波形处理中
+    char *end_ptr;
-        return;
+    uint16_t u_short_addr = strtol(buf, &end_ptr, 16);
+    wave_feature_set_inst::instance().GetFeatureCfg(u_short_addr,Feature_x,Feature_y,Feature_z);
     std::string strShortAddr = std::string(buf);
-    zlog_info(zct, "zigbeeShortAddr='%s'", strShortAddr.c_str());
+    zlog_info(zct, "zigbeeShortAddr='%s',Feature_x = %d,Feature_y = %d,Feature_z = %d", strShortAddr.c_str(),Feature_x,Feature_y,Feature_z);
     char getLongAddr_sql[32] = {0};
     //根据数据包中的传感器的短地址获取数据库中长地址（MAC），在下面判断该传感器是否存在，如果不存在则把数据包丢弃
     sprintf(getLongAddr_sql, "zigbeeShortAddr='%s'", strShortAddr.c_str());
@@ -343,7 +344,10 @@ void Uart::DealDataNodeFeature(const char *pData, int flag) {
     valNodeFeature["Phase3"] = dataDymX.Phase3;
     valNodeFeature["Phase4"] = dataDymX.Phase4;
     valNodeFeature["timeStamp"] = nowTimetamp;
-    valNodeData.append(valNodeFeature);
+     if (Feature_x)
+    {
+        valNodeData.append(valNodeFeature);
+    }
     DataRecvDym dataDymY;
     
     DataExtract(pRecvData, 34, lowbit, n);
@@ -430,7 +434,10 @@ void Uart::DealDataNodeFeature(const char *pData, int flag) {
     valNodeFeature["Phase3"] = dataDymY.Phase3;
     valNodeFeature["Phase4"] = dataDymY.Phase4;
     valNodeFeature["timeStamp"] = nowTimetamp;
-    valNodeData.append(valNodeFeature);
+    if (Feature_y)
+    {
+        valNodeData.append(valNodeFeature);
+    }
 
     DataRecvDym dataDymZ;
     DataExtract(pRecvData, 52, lowbit, n);
@@ -527,7 +534,10 @@ void Uart::DealDataNodeFeature(const char *pData, int flag) {
     valNodeFeature["Phase3"] = dataDymZ.Phase3;
     valNodeFeature["Phase4"] = dataDymZ.Phase4;
     valNodeFeature["timeStamp"] = nowTimetamp;
-    valNodeData.append(valNodeFeature);
+    if (Feature_z)
+    {
+        valNodeData.append(valNodeFeature);
+    }
 
     memset(whereCon, 0, 1024);
     sprintf(whereCon, "MeasurementID='%s'", strMeasurementID.c_str());

uart/uart_parameter_config.cpp

@@ -9,6 +9,8 @@
 #include <zlog.h>
 #include "common/common_func.hpp"
 #include "minilzo/minilzo.h"
+#include "scheduler/wave_feature_set.hpp"
+
 
 extern zlog_category_t* zct;
 extern zlog_category_t* zbt;
@@ -560,13 +562,20 @@ int Uart::TaskResp(ScheduleTask scheduleTask){
     {
         UpdateData[7] = UINT16_LOW(scheduleTask.duration);
         UpdateData[8] = UINT16_HIGH(scheduleTask.duration);
-    }
+    }else if (scheduleTask.cmd == MEAS_EVAL)
-    if (scheduleTask.cmd == MEAS_EVAL)
     {
         UpdateData[9]  = UINT32_LOW_2(scheduleTask.timeStamp);
         UpdateData[10] = UINT32_LOW_1(scheduleTask.timeStamp);
         UpdateData[11] = UINT32_HIGH_2(scheduleTask.timeStamp);
         UpdateData[12] = UINT32_HIGH_1(scheduleTask.timeStamp);
+    }else if (scheduleTask.cmd == WAVE_CMD)
+    {
+        uint8_t x,y,z;
+        wave_feature_set_inst::instance().GetWaveCfg(scheduleTask.shortAddr,x,y,z);
+        zlog_info(zct,"wave x = %d,y = %d,z = %d\n",x,y,z);
+        UpdateData[17] = (x^1) & 0xFF;
+        UpdateData[18] = (y^1) & 0xFF;
+        UpdateData[19] = (z^1) & 0xFF;
     }
     unsigned char tmp = 0x00;
     for (int k = 0; k < 99; k++) {