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

add interface to clear cfg file.

Browse Source
This commit is contained in:
pandx 2024-11-08 14:23:09 +08:00
parent 972c23424f
commit f0ade9888d
8 changed files with 286 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

491
scheduler/schedule.cpp
View File

@ -14,238 +14,6 @@
extern zlog_category_t *zct;
extern zlog_category_t *zbt;
// 当一个传感器来进行通信时
int SensorScheduler::WriteScheduleCfg(long &ts, std::string &world_time) {
Json::Value root;
root["schedule_start_timestamp"] = std::to_string(ts);
root["schedule_start_time"] = world_time;
root["eigen_value_send_interval"] = eigen_value_send_interval_;
root["eigen_value_send_duration"] = eigen_value_send_duration_;
root["wave_form_send_interval"] = wave_form_send_interval_;
root["wave_form_send_duration"] = wave_form_send_duration_;
root["max_sensor_num"] = max_sensor_num_;
root["available_slice"] = available_slice_;
root["free_slice"] = free_slice_;
root["support_modification"] = true;
int *slice_allocation = new int[available_slice_];
int slice_index = 0; // 有时间片的索引
int no_slice_index = 0; // 没有时间片的索引
int k = 1;
slice_sensor_id_.clear();
for (int i = 0; i < available_slice_; ++i) {
if (slice_index < max_sensor_num_ && (i % 2 == 0 || no_slice_index >= free_slice_)) {
slice_allocation[i] = k;
sensor_id_nth_slice_[k] = i + 1;
slice_sensor_id_.push_back(k);
k = k + 1;
slice_index++;
} else if (no_slice_index < free_slice_) {
slice_sensor_id_.push_back(0);
slice_allocation[i] = 0;
no_slice_index++;
}
}
Json::Value ids;
for (int i = 0; i < available_slice_; ++i) {
ids.append(slice_allocation[i]);
}
delete []slice_allocation;
root["id"] = ids;
Json::StyledStreamWriter streamWriter;
std::ofstream out_file(SCHEDULE_CONFIG);
streamWriter.write(out_file, root);
out_file.close();
return 0;
}
SensorScheduler::SensorScheduler() {
support_modification_ = true;
std::ifstream schedule_file(SCHEDULE_CONFIG);
if (schedule_file.good()) {
zlog_info(zbt, "exist configuration file");
Json::Reader reader;
Json::Value root;
if (!reader.parse(schedule_file, root, false)) {
zlog_error(zbt, "invalid format, fail to parse %s", SCHEDULE_CONFIG);
schedule_file.close();
return;
}
schedule_file.close();
if (!root.isObject()) {
zlog_error(zbt, "invalid format, not an object: %s", SCHEDULE_CONFIG);
return;
}
start_timestamp_ = std::stol(root["schedule_start_timestamp"].asString());
start_ts_str_ = root["schedule_start_timestamp"].asString();
eigen_value_send_interval_ = root["eigen_value_send_interval"].asInt();
eigen_value_send_duration_ = root["eigen_value_send_duration"].asInt();
wave_form_send_interval_ = root["wave_form_send_interval"].asInt();
wave_form_send_duration_ = root["wave_form_send_duration"].asInt();
max_sensor_num_ = root["max_sensor_num"].asInt();
available_slice_ = root["available_slice"].asInt();
free_slice_ = root["free_slice"].asInt();
support_modification_ = root["support_modification"].asBool();
const Json::Value ids = root["id"];
int sensor_id = 0;
int i = 0;
for (const auto& id : ids) {
sensor_id = id.asInt();
slice_sensor_id_.push_back(sensor_id);
if (sensor_id != 0) {
sensor_id_nth_slice_[sensor_id] = i+1;
}
++i;
}
eigen_value_slice_total_seconds_ = eigen_value_send_duration_ * max_sensor_num_;
int rest_duration = eigen_value_send_interval_ - eigen_value_slice_total_seconds_;
wave_slice_num_per_eigen_interval_ = rest_duration / wave_form_send_duration_;
seconds_per_wave_slice_ = rest_duration / wave_slice_num_per_eigen_interval_;
} else {
zlog_info(zbt, "use default configuration");
// int eigen_value_send_interval = 300;
// int wave_form_send_interval = 7200;
// int eigen_value_send_duration = 6;
// int wave_form_send_duration = 50;
// int max_sensor_num = 32;
int eigen_value_send_interval = 120;
int wave_form_send_interval = 240;
int eigen_value_send_duration = 6;
int wave_form_send_duration = 40;
int max_sensor_num = 4;
std::string error_msg;
Config(eigen_value_send_interval,
wave_form_send_interval,
eigen_value_send_duration,
wave_form_send_duration,
max_sensor_num,
error_msg);
}
short_addr_map_.clear();
ShortAddrCfg::ReadCfg(short_addr_map_);
// read upgrade config file: UPGRADE_CONFIG
UpgradeCfg::ReadCfg(upgrade_);
// read config update file: CONFIG_UPDATE
UpdateCfg::ReadCfg(update_);
}
int SensorScheduler::GetNextDuration(int short_addr) {
int id = 0;
auto iter = short_addr_map_.find(short_addr);
if (iter == short_addr_map_.end()) {
zlog_error(zct, "cannot find id for short_addr %x", short_addr);
return 0;
} else {
id = iter->second;
}
long current_ts = GetLocalTs();
long next_ts = CalcNextTimestamp(id);
int duration = next_ts - current_ts;
zlog_warn(zct, "[%d] next duration is %d", id, duration);
return duration;
}
long SensorScheduler::GetBaseTimestamp(int short_addr) {
int id = 0;
auto iter = short_addr_map_.find(short_addr);
if (iter == short_addr_map_.end()) {
zlog_error(zct, "cannot find id for short_addr %x", short_addr);
return 0;
} else {
id = iter->second;
}
return start_timestamp_ + (id - 1) * eigen_value_send_duration_;
}
long SensorScheduler::CalcNextTimestamp(int id) {
// current_ts_ = GetLocalTs();
if (ts_in_eigen_slice_) {
int forward_wave_slice_num = nth_eigen_value_slice_ * wave_slice_num_per_eigen_interval_;
auto wave_slice_iter = sensor_id_nth_slice_.find(id);
if (wave_slice_iter == sensor_id_nth_slice_.end()) {
zlog_error(zct, "invaild id:%d, not find wave slice id", id);
long available_ts = current_wave_start_ts_ + eigen_value_send_interval_ + nth_eigen_slice_ * eigen_value_send_duration_;
zlog_error(zct, "[%d] next feature send utc time:[%s]", id, GetUTCTime(available_ts).c_str());
return available_ts;
}
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_debug(zct, "[%d] send wave time:[%s]\n", id, GetUTCTime(send_wave_ts).c_str());
break;
}
}
}
long available_ts = 0;
auto upgrade_iter = upgrade_.find(id);
if (upgrade_iter != upgrade_.end()) {
if (upgrade_iter->second.try_times < 10) {
for (int i = 0; i < wave_slice_num_per_eigen_interval_; ++i) {
if (slice_sensor_id_[i+forward_wave_slice_num] == 0) {
// 判断此空闲位置是否被占用
long current_wave_slice_ts = current_wave_start_ts_ + nth_eigen_value_slice_ * eigen_value_send_interval_ + eigen_value_slice_total_seconds_ + i * seconds_per_wave_slice_;
if (free_slice_ocuppied_.count(current_wave_slice_ts) == 0) {
available_ts = current_wave_slice_ts;
free_slice_ocuppied_.insert(available_ts);
zlog_debug(zct, "[%d] %d nth free wave slice will be used to upgrade, utc time:[%s]", id, i+forward_wave_slice_num, GetUTCTime(available_ts).c_str());
break;
}
}
}
}
}
if (send_wave_ts > 0 && available_ts > 0) {
long min_ts = std::min(send_wave_ts, available_ts);
zlog_warn(zct, "[%d] next feature send utc time1:%s", id, GetUTCTime(min_ts).c_str());
return min_ts;
}
if (send_wave_ts + available_ts > 0) {
long max_ts = std::max(send_wave_ts, available_ts);
zlog_warn(zct, "[%d] next feature send utc time2:%s", id, GetUTCTime(max_ts).c_str());
return max_ts;
}
}
// 如果是在当前波形时间窗中，不管是空闲时间窗，还是发送波形的时间窗，下一个时间窗是特征值
long available_ts = current_wave_start_ts_ + (nth_eigen_value_slice_ + 1)* eigen_value_send_interval_ + (id - 1) * eigen_value_send_duration_;
zlog_warn(zct, "[%d] next feature send utc time3:[%s]", id, GetUTCTime(available_ts).c_str());
return available_ts;
}
int SensorScheduler::GetAvailableId(int short_addr) {
int max_support_sensor[128] = {0};
for (auto it = short_addr_map_.begin(); it != short_addr_map_.end(); ++it) {
max_support_sensor[it->second] = 1;
}
int available_id = 0;
for (int i = 1; i < 128; ++i) {
if (max_support_sensor[i] == 0) {
available_id = i;
break;
}
}
zlog_warn(zct, "[GetAvailableId][%d] short addr : %x", available_id, short_addr);
short_addr_map_[short_addr] = available_id;
ShortAddrCfg::WriteCfg(short_addr_map_);
return available_id;
}
int SensorScheduler::StartSchedule(int short_addr, int &next_duration) {
int id = 0;
auto iter = short_addr_map_.find(short_addr);
@ -363,6 +131,236 @@ int SensorScheduler::StartSchedule(int short_addr, int &next_duration) {
}
}
long SensorScheduler::CalcNextTimestamp(int id) {
// current_ts_ = GetLocalTs();
if (ts_in_eigen_slice_) {
int forward_wave_slice_num = nth_eigen_value_slice_ * wave_slice_num_per_eigen_interval_;
auto wave_slice_iter = sensor_id_nth_slice_.find(id);
if (wave_slice_iter == sensor_id_nth_slice_.end()) {
zlog_error(zct, "invaild id:%d, not find wave slice id", id);
long available_ts = current_wave_start_ts_ + eigen_value_send_interval_ + nth_eigen_slice_ * eigen_value_send_duration_;
zlog_error(zct, "[%d] next feature send utc time:[%s]", id, GetUTCTime(available_ts).c_str());
return available_ts;
}
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_debug(zct, "[%d] send wave time:[%s]\n", id, GetUTCTime(send_wave_ts).c_str());
break;
}
}
}
long available_ts = 0;
auto upgrade_iter = upgrade_.find(id);
if (upgrade_iter != upgrade_.end()) {
if (upgrade_iter->second.try_times < 10) {
for (int i = 0; i < wave_slice_num_per_eigen_interval_; ++i) {
if (slice_sensor_id_[i+forward_wave_slice_num] == 0) {
// 判断此空闲位置是否被占用
long current_wave_slice_ts = current_wave_start_ts_ + nth_eigen_value_slice_ * eigen_value_send_interval_ + eigen_value_slice_total_seconds_ + i * seconds_per_wave_slice_;
if (free_slice_ocuppied_.count(current_wave_slice_ts) == 0) {
available_ts = current_wave_slice_ts;
free_slice_ocuppied_.insert(available_ts);
zlog_debug(zct, "[%d] %d nth free wave slice will be used to upgrade, utc time:[%s]", id, i+forward_wave_slice_num, GetUTCTime(available_ts).c_str());
break;
}
}
}
}
}
if (send_wave_ts > 0 && available_ts > 0) {
long min_ts = std::min(send_wave_ts, available_ts);
zlog_warn(zct, "[%d] next feature send utc time1:%s", id, GetUTCTime(min_ts).c_str());
return min_ts;
}
if (send_wave_ts + available_ts > 0) {
long max_ts = std::max(send_wave_ts, available_ts);
zlog_warn(zct, "[%d] next feature send utc time2:%s", id, GetUTCTime(max_ts).c_str());
return max_ts;
}
}
// 如果是在当前波形时间窗中，不管是空闲时间窗，还是发送波形的时间窗，下一个时间窗是特征值
long available_ts = current_wave_start_ts_ + (nth_eigen_value_slice_ + 1)* eigen_value_send_interval_ + (id - 1) * eigen_value_send_duration_;
zlog_warn(zct, "[%d] next feature send utc time3:[%s]", id, GetUTCTime(available_ts).c_str());
return available_ts;
}
int SensorScheduler::GetNextDuration(int short_addr) {
int id = 0;
auto iter = short_addr_map_.find(short_addr);
if (iter == short_addr_map_.end()) {
zlog_error(zct, "cannot find id for short_addr %x", short_addr);
return 0;
} else {
id = iter->second;
}
long current_ts = GetLocalTs();
long next_ts = CalcNextTimestamp(id);
int duration = next_ts - current_ts;
zlog_warn(zct, "[%d] next duration is %d", id, duration);
return duration;
}
SensorScheduler::SensorScheduler() {
support_modification_ = true;
std::ifstream schedule_file(SCHEDULE_CONFIG);
if (schedule_file.good()) {
zlog_info(zbt, "exist configuration file");
Json::Reader reader;
Json::Value root;
if (!reader.parse(schedule_file, root, false)) {
zlog_error(zbt, "invalid format, fail to parse %s", SCHEDULE_CONFIG);
schedule_file.close();
return;
}
schedule_file.close();
if (!root.isObject()) {
zlog_error(zbt, "invalid format, not an object: %s", SCHEDULE_CONFIG);
return;
}
start_timestamp_ = std::stol(root["schedule_start_timestamp"].asString());
start_ts_str_ = root["schedule_start_time"].asString();
eigen_value_send_interval_ = root["eigen_value_send_interval"].asInt();
eigen_value_send_duration_ = root["eigen_value_send_duration"].asInt();
wave_form_send_interval_ = root["wave_form_send_interval"].asInt();
wave_form_send_duration_ = root["wave_form_send_duration"].asInt();
max_sensor_num_ = root["max_sensor_num"].asInt();
available_slice_ = root["available_slice"].asInt();
free_slice_ = root["free_slice"].asInt();
support_modification_ = root["support_modification"].asBool();
const Json::Value ids = root["id"];
int sensor_id = 0;
int i = 0;
for (const auto& id : ids) {
sensor_id = id.asInt();
slice_sensor_id_.push_back(sensor_id);
if (sensor_id != 0) {
sensor_id_nth_slice_[sensor_id] = i+1;
}
++i;
}
eigen_value_slice_total_seconds_ = eigen_value_send_duration_ * max_sensor_num_;
int rest_duration = eigen_value_send_interval_ - eigen_value_slice_total_seconds_;
wave_slice_num_per_eigen_interval_ = rest_duration / wave_form_send_duration_;
seconds_per_wave_slice_ = rest_duration / wave_slice_num_per_eigen_interval_;
} else {
zlog_info(zbt, "use default configuration");
// int eigen_value_send_interval = 300;
// int wave_form_send_interval = 7200;
// int eigen_value_send_duration = 6;
// int wave_form_send_duration = 50;
// int max_sensor_num = 32;
int eigen_value_send_interval = 120;
int wave_form_send_interval = 240;
int eigen_value_send_duration = 6;
int wave_form_send_duration = 40;
int max_sensor_num = 4;
std::string error_msg;
Config(eigen_value_send_interval,
wave_form_send_interval,
eigen_value_send_duration,
wave_form_send_duration,
max_sensor_num,
error_msg);
}
short_addr_map_.clear();
ShortAddrCfg::ReadCfg(short_addr_map_);
// read upgrade config file: UPGRADE_CONFIG
UpgradeCfg::ReadCfg(upgrade_);
// read config update file: CONFIG_UPDATE
UpdateCfg::ReadCfg(update_);
}
long SensorScheduler::GetBaseTimestamp(int short_addr) {
int id = 0;
auto iter = short_addr_map_.find(short_addr);
if (iter == short_addr_map_.end()) {
zlog_error(zct, "cannot find id for short_addr %x", short_addr);
return 0;
} else {
id = iter->second;
}
return start_timestamp_ + (id - 1) * eigen_value_send_duration_;
}
int SensorScheduler::GetAvailableId(int short_addr) {
int max_support_sensor[128] = {0};
for (auto it = short_addr_map_.begin(); it != short_addr_map_.end(); ++it) {
max_support_sensor[it->second] = 1;
}
int available_id = 0;
for (int i = 1; i < 128; ++i) {
if (max_support_sensor[i] == 0) {
available_id = i;
break;
}
}
zlog_warn(zct, "[GetAvailableId][%d] short addr : %x", available_id, short_addr);
short_addr_map_[short_addr] = available_id;
ShortAddrCfg::WriteCfg(short_addr_map_);
return available_id;
}
int SensorScheduler::WriteScheduleCfg(long &ts, std::string &world_time) {
Json::Value root;
root["schedule_start_timestamp"] = std::to_string(ts);
root["schedule_start_time"] = world_time;
root["eigen_value_send_interval"] = eigen_value_send_interval_;
root["eigen_value_send_duration"] = eigen_value_send_duration_;
root["wave_form_send_interval"] = wave_form_send_interval_;
root["wave_form_send_duration"] = wave_form_send_duration_;
root["max_sensor_num"] = max_sensor_num_;
root["available_slice"] = available_slice_;
root["free_slice"] = free_slice_;
root["support_modification"] = true;
int *slice_allocation = new int[available_slice_];
int slice_index = 0; // 有时间片的索引
int no_slice_index = 0; // 没有时间片的索引
int k = 1;
slice_sensor_id_.clear();
for (int i = 0; i < available_slice_; ++i) {
if (slice_index < max_sensor_num_ && (i % 2 == 0 || no_slice_index >= free_slice_)) {
slice_allocation[i] = k;
sensor_id_nth_slice_[k] = i + 1;
slice_sensor_id_.push_back(k);
k = k + 1;
slice_index++;
} else if (no_slice_index < free_slice_) {
slice_sensor_id_.push_back(0);
slice_allocation[i] = 0;
no_slice_index++;
}
}
Json::Value ids;
for (int i = 0; i < available_slice_; ++i) {
ids.append(slice_allocation[i]);
}
delete []slice_allocation;
root["id"] = ids;
Json::StyledStreamWriter streamWriter;
std::ofstream out_file(SCHEDULE_CONFIG);
streamWriter.write(out_file, root);
out_file.close();
return 0;
}
int SensorScheduler::Config(int eigen_value_send_interval, int wave_form_send_interval, int eigen_value_send_duration,
int wave_form_send_duration, int max_sensor_num, std::string &error_msg) {
if (!support_modification_) {
@ -594,3 +592,32 @@ void SensorScheduler::UpdateUpgradeInfo(int id) {
upgrade_iter->second.try_world_time1.push_back(GetUTCTime(ts));
UpgradeCfg::WriteCfg(upgrade_);
}
void SensorScheduler::ModifyScheduleTs(int diff_ts) {
zlog_warn(zbt, "[ModifyScheduleTs] adjust ts:%d, from:%ld to:%ld", diff_ts, start_timestamp_, start_timestamp_ + diff_ts);
start_timestamp_ += diff_ts;
start_ts_str_ = GetUTCTime(start_timestamp_);
std::ifstream schedule_file(SCHEDULE_CONFIG);
Json::Reader reader;
Json::Value root;
if (!reader.parse(schedule_file, root, false)) {
zlog_error(zbt, "[ModifyScheduleTs] invalid format, fail to parse %s", SCHEDULE_CONFIG);
schedule_file.close();
return;
}
schedule_file.close();
root["schedule_start_timestamp"] = std::to_string(start_timestamp_);
root["schedule_start_time"] = start_ts_str_;
Json::StyledStreamWriter streamWriter;
std::ofstream out_file(SCHEDULE_CONFIG);
streamWriter.write(out_file, root);
out_file.close();
}
void SensorScheduler::ClearScheduleCfg() {
zlog_warn(zbt, "[ClearScheduleCfg] clear all schedule config");
ShortAddrCfg::ClearCfg();
UpdateCfg::ClearCfg();
UpgradeCfg::ClearCfg();
}

8
scheduler/schedule.hpp
View File

@ -84,12 +84,16 @@ public:
// void ReadScheduleCfg();
// 配置完成后
int WriteScheduleCfg(long &ts, std::string &world_time);
// 当系统进行校时时，修改时间戳信息, "slices"字段
void ModifyScheduleTs(long start_ts);
// 当系统进行校时时，输入参数为新的时间戳与以前时间戳的差值
void ModifyScheduleTs(int diff_ts);
// 当接入传感器时，设置为不可修改; 当停用所有传感器后，修改为可修改
void AdjustSupportModification(bool support_modification);
// ======schedule.json操作结束======
void ClearScheduleCfg();
long GetLocalTs();
long GetLocalWorldTime(std::string &world_time);
std::string GetUTCTime(long ts);

6
scheduler/short_addr_cfg.cpp
View File

@ -54,3 +54,9 @@ int ShortAddrCfg::WriteCfg(std::map<uint16_t, int> &short_addr_map) {
streamWriter.write(out_file, root);
return 0;
}
void ShortAddrCfg::ClearCfg() {
std::string clear_cmd = "rm -rf ";
clear_cmd.append(BASE_RELATION);
system(clear_cmd.c_str());
}

1
scheduler/short_addr_cfg.hpp
View File

@ -9,6 +9,7 @@ class ShortAddrCfg {
public:
static int ReadCfg(std::map<uint16_t, int> &short_addr_map);
static int WriteCfg(std::map<uint16_t, int> &short_addr_map);
static void ClearCfg();
};
#endif // SHORT_ADDR_CFG_HPP_

6
scheduler/update_cfg.cpp
View File

@ -46,3 +46,9 @@ int UpdateCfg::WriteCfg(std::unordered_set<int> &update) {
out_file.close();
return 0;
}
void UpdateCfg::ClearCfg() {
std::string clear_cmd = "rm -rf ";
clear_cmd.append(CONFIG_UPDATE);
system(clear_cmd.c_str());
}

1
scheduler/update_cfg.hpp
View File

@ -8,6 +8,7 @@ class UpdateCfg {
public:
static int ReadCfg(std::unordered_set<int> &update);
static int WriteCfg(std::unordered_set<int> &update);
static void ClearCfg();
};

6
scheduler/upgrade_cfg.cpp
View File

@ -74,3 +74,9 @@ int UpgradeCfg::WriteCfg(std::map<int, UpgradeInfo> &upgrade) {
out_file.close();
return 0;
}
void UpgradeCfg::ClearCfg() {
std::string clear_cmd = "rm -rf ";
clear_cmd.append(UPGRADE_CONFIG);
system(clear_cmd.c_str());
}

1
scheduler/upgrade_cfg.hpp
View File

@ -20,6 +20,7 @@ class UpgradeCfg {
public:
static int ReadCfg(std::map<int, UpgradeInfo> &upgrade);
static int WriteCfg(std::map<int, UpgradeInfo> &upgrade);
static void ClearCfg();
};
#endif // UPGRADE_CFG_HPP_