zhangsheng/WLG
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add x,y,z switch

Browse Source
This commit is contained in:
zhangsheng 2025-01-04 15:10:54 +08:00
parent b820734282
commit 59864c8461
18 changed files with 1742 additions and 1102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common/global.hpp
View File

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

14
common/parameter_defination.hpp
View File

@ -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_

2
jsonparse/communication_cmd.hpp
View File

@ -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:

93
jsonparse/web_cmd_parse3.cpp
View File

@ -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);
}

4
localserver/local_server.hpp
View File

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

72
localserver/web_cmd.cpp
View File

@ -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();

56
scheduler/schedule.cpp
View File

@ -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 {
// 执行上送特征值任务
zlog_warn(zct, "[%d:%x] send eigen value in eigen slice", id, short_addr);
current_request_ = kScheduleEigenValue;
return kScheduleEigenValue;
wave_feature_set_inst::instance().GetFeatureCfg(short_addr, g_x, g_y, g_z);
if (g_x || g_y || g_z) {
// 执行上送特征值任务
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);
current_request_ = kScheduleWaveForm;
return kScheduleWaveForm;
wave_feature_set_inst::instance().GetWaveCfg(short_addr, g_x, g_y, g_z);
if (g_x || g_y || g_z) {
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_slice <= forward_wave_slice_num + wave_slice_num_per_eigen_interval_) {
// 发送波的时间窗也在本次特征值发送间隔中
for (int i = forward_wave_slice_num; i <= forward_wave_slice_num + wave_slice_num_per_eigen_interval_; ++i) {
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_;
zlog_warn(zct, "[Nxt] [%d:%x] send wave time:[%s]", id, short_addr, GetUTCTime(send_wave_ts).c_str());
break;
wave_feature_set_inst::instance().GetWaveCfg(short_addr, g_x, g_y, g_z);
if (g_x || g_y || g_z) {
if (wave_slice > forward_wave_slice_num &&
wave_slice <= forward_wave_slice_num + wave_slice_num_per_eigen_interval_) {
// 发送波的时间窗也在本次特征值发送间隔中
for (int i = forward_wave_slice_num; i <= forward_wave_slice_num + wave_slice_num_per_eigen_interval_; ++i) {
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_;
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);
}
}

12
scheduler/upgrade_cfg.cpp
View File

@ -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;

370
scheduler/wave_feature_set.cpp Normal file
View File

@ -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());
}

56
scheduler/wave_feature_set.hpp Normal file
View File

@ -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_

24
uart/uart_feature_parse.cpp
View File

@ -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);
}
if (bSendTimeStamp) //波形处理中
return;
uint8_t Feature_x,Feature_y,Feature_z;
char *end_ptr;
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());

13
uart/uart_parameter_config.cpp
View File

@ -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);
}
if (scheduleTask.cmd == MEAS_EVAL)
}else 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++) {