1133 lines
75 KiB
C++
1133 lines
75 KiB
C++
#include "config_mgr.h"
|
|
#include <QDebug>
|
|
#include <QJsonDocument>
|
|
#include <QJsonArray>
|
|
#include <QJsonObject>
|
|
|
|
#include "data_config.h"
|
|
#include "vibrationdata.h"
|
|
#include "tachometer_data.h"
|
|
#include "keyphase_data.h"
|
|
#include "singlerelay_data.h"
|
|
#include "tmrrelayassociation_data.h"
|
|
#include <QCoreApplication>
|
|
|
|
|
|
ConfigMgr *ConfigMgr::instance = nullptr;
|
|
|
|
ConfigMgr::~ConfigMgr() {
|
|
}
|
|
|
|
void ConfigMgr::Save(QString & file_path) {
|
|
QJsonObject doc_obj;
|
|
int slot = 0;
|
|
QJsonArray card_type;
|
|
for (int i = 0; i < SLOT_NUM; ++i) {
|
|
if (card_type_[i] == kCardNone) {
|
|
continue;
|
|
}
|
|
QJsonObject card_item;
|
|
slot = i + 1;
|
|
card_item["type"] = card_type_[i];
|
|
card_item["slot"] = slot;
|
|
card_type.append(card_item);
|
|
if (card_type_[i] != kCardVibSingle &&
|
|
card_type_[i] != kCardVibTMRPrimary &&
|
|
card_type_[i] != kCardSpeedSingle &&
|
|
card_type_[i] != kCardSpeedTMRPrimary &&
|
|
card_type_[i] != kCardKeyphaseSingle &&
|
|
card_type_[i] != kCardRelaySingle &&
|
|
card_type_[i] != kCardRelayTMRPrimary &&
|
|
card_type_[i] != kCardRelaySingleNOK) {
|
|
continue;
|
|
}
|
|
// process slot
|
|
QJsonObject slot_item;
|
|
if (card_type_[i] != kCardRelaySingle &&
|
|
card_type_[i] != kCardRelayTMRPrimary &&
|
|
card_type_[i] != kCardRelaySingleNOK &&
|
|
card_type_[i] != kCardRelayTMRBackup) {
|
|
QJsonObject dc_output;
|
|
for (int cid = 0; cid < CHANNEL_COUNT; ++cid) {
|
|
QJsonObject channel_item;
|
|
if (card_type_[i] == kCardVibSingle ||
|
|
card_type_[i] == kCardVibTMRPrimary) {
|
|
std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
|
|
if (base_ptr == nullptr) {
|
|
continue;
|
|
}
|
|
std::shared_ptr<VibrationData> ptr = std::dynamic_pointer_cast<VibrationData>(base_ptr);
|
|
if( ptr->base_config_[cid].channel_type == -1){
|
|
continue;
|
|
}
|
|
channel_item["standby"] = ptr->base_config_[cid].standby;
|
|
channel_item["active"] = ptr->base_config_[cid].active;
|
|
// channel_item["rack_type"] = 0; // TODO:
|
|
channel_item["channel_type"] = ptr->base_config_[cid].channel_type;
|
|
// channel_item["transducer_id"] = ptr->base_config_[cid].transducer_id;
|
|
// channel_item["scale_factor"] = ptr->base_config_[cid].scale_factor;
|
|
// channel_item["sampling_rate"] = ptr->base_config_[cid].sampling_rate;
|
|
channel_item["power"] = ptr->base_config_[cid].power;
|
|
channel_item["point_name"] = ptr->base_config_[cid].point_name;
|
|
channel_item["chan_id"] = ptr->base_config_[cid].chan_id;
|
|
channel_item["sensitivity_unit"] = ptr->base_config_[cid].sensitivity_unit;
|
|
channel_item["signal_sensitivity"] = ptr->base_config_[cid].signal_sensitivity;
|
|
|
|
|
|
QJsonArray voltage_range;
|
|
voltage_range.append(ptr->base_config_[cid].normal_voltage_low);
|
|
voltage_range.append(ptr->base_config_[cid].normal_voltage_high);
|
|
channel_item["normal_voltage_range"] = voltage_range;
|
|
// output channel
|
|
QJsonObject dc_output_item;
|
|
if(ptr->dc_output[cid].output_channel != -1){
|
|
dc_output_item["output_channel"] = ptr->dc_output[cid].output_channel;
|
|
dc_output_item["minmum"] = ptr->dc_output[cid].minmum;
|
|
dc_output_item["maxmum"] = ptr->dc_output[cid].maxmum;
|
|
dc_output[QString::number(cid + 1)] = dc_output_item;
|
|
}
|
|
if(ptr->base_config_[cid].channel_type == kVibRadial || ptr->base_config_[cid].channel_type == kVibThrust ||
|
|
ptr->base_config_[cid].channel_type == kVibAcc || ptr->base_config_[cid].channel_type == kVibVelocity ){
|
|
if(ptr->base_config_[cid].channel_type != kVibThrust){
|
|
channel_item["keyphase"] = ptr->base_config_[cid].keyphase;
|
|
channel_item["keyphase_slot"] = ptr->base_config_[cid].keyphase_slot;
|
|
channel_item["keyphase_ch"] = ptr->base_config_[cid].keyphase_ch;
|
|
}
|
|
}
|
|
// if(ptr->base_config_[cid].channel_type == kVibPressurePulsation){
|
|
// setpoint_data["low_upper"] = qRound(ptr->alert_danger_press[cid].low_upper * 10)/10.0;
|
|
// setpoint_data["low_enable"] = ptr->alert_danger_press[cid].low_enable;
|
|
// setpoint_data["mid1_upper"] = qRound(ptr->alert_danger_press[cid].mid1_upper * 10)/10.0;
|
|
// setpoint_data["mid1_enable"] = ptr->alert_danger_press[cid].mid1_enable;
|
|
// setpoint_data["mid2_upper"] = qRound(ptr->alert_danger_press[cid].mid2_upper * 10)/10.0;
|
|
// setpoint_data["mid2_enable"] = ptr->alert_danger_press[cid].mid2_enable;
|
|
// setpoint_data["danger_param"] = ptr->alert_danger_press[cid].danger_param;
|
|
// setpoint_data["danger_upper"] = qRound(ptr->alert_danger_press[cid].danger_upper * 10)/10.0;
|
|
// setpoint_data["danger_enable"] = ptr->alert_danger_press[cid].danger_enable;
|
|
// }
|
|
// channel_item["setpoint"] = setpoint_data;
|
|
// variables
|
|
QJsonObject variables;
|
|
std::shared_ptr<VariableBase> base_channel_ptr = ptr->GetChannelPtr(cid + 1);
|
|
if (base_channel_ptr == nullptr) {
|
|
continue;
|
|
}
|
|
if (ptr->base_config_[cid].channel_type == kVibRadial) {
|
|
std::shared_ptr<RadialVariable> radial_ptr = std::dynamic_pointer_cast<RadialVariable>(base_channel_ptr);
|
|
if(radial_ptr == nullptr){
|
|
continue;
|
|
}
|
|
// filter
|
|
QJsonArray filter;
|
|
QJsonObject low_pass;
|
|
low_pass["low"] = radial_ptr->filter_[0].low;
|
|
low_pass["high"] = radial_ptr->filter_[0].high;
|
|
low_pass["checked"] = radial_ptr->filter_[0].checked;
|
|
filter.append(low_pass);
|
|
QJsonObject high_pass;
|
|
high_pass["low"] = radial_ptr->filter_[1].low;
|
|
high_pass["high"] = radial_ptr->filter_[1].high;
|
|
high_pass["checked"] = radial_ptr->filter_[1].checked;
|
|
filter.append(high_pass);
|
|
QJsonObject band_pass;
|
|
band_pass["low"] = radial_ptr->filter_[2].low;
|
|
band_pass["high"] = radial_ptr->filter_[2].high;
|
|
band_pass["checked"] = radial_ptr->filter_[2].checked;
|
|
filter.append(band_pass);
|
|
variables["filter"] = filter;
|
|
// measurement
|
|
QJsonObject measurement,general,alarm;
|
|
general["output_used"] = radial_ptr->general.output_used;
|
|
general["engieneering_unit"] = radial_ptr->general.engineering_unit;
|
|
general["rectifier_function"] = radial_ptr->general.rectifier_function;
|
|
|
|
alarm["danger_high_level"] = radial_ptr->danger_high.level;
|
|
alarm["danger_high_hysteresis"] = radial_ptr->danger_high.hysteresis;
|
|
alarm["danger_high_delay"] = radial_ptr->danger_high.delay;
|
|
alarm["danger_high_enable"] = radial_ptr->danger_high.enable;
|
|
alarm["danger_high_latch"] = radial_ptr->danger_high.latch;
|
|
alarm["alert_high_level"] = radial_ptr->alert_high.level;
|
|
alarm["alert_high_hysteresis"] = radial_ptr->alert_high.hysteresis;
|
|
alarm["alert_high_delay"] = radial_ptr->alert_high.delay;
|
|
alarm["alert_high_enable"] = radial_ptr->alert_high.enable;
|
|
alarm["alert_high_latch"] = radial_ptr->alert_high.latch;
|
|
// alarm["danger_low_level"] = radial_ptr->danger_low.level;
|
|
// alarm["danger_low_hysteresis"] = radial_ptr->danger_low.hysteresis;
|
|
// alarm["danger_low_delay"] = radial_ptr->danger_low.delay;
|
|
// alarm["danger_low_enable"] = radial_ptr->danger_low.enable;
|
|
// alarm["danger_low_latch"] = radial_ptr->danger_low.latch;
|
|
// alarm["alert_low_level"] = radial_ptr->alert_low.level;
|
|
// alarm["alert_low_hysteresis"] = radial_ptr->alert_low.hysteresis;
|
|
// alarm["alert_low_delay"] = radial_ptr->alert_low.delay;
|
|
// alarm["alert_low_enable"] = radial_ptr->alert_low.enable;
|
|
// alarm["alert_low_latch"] = radial_ptr->alert_low.latch;
|
|
measurement["general"] = general;
|
|
measurement["alarm"] = alarm;
|
|
variables["measurement"] = measurement;
|
|
// gap
|
|
QJsonObject gap,gap_general,gap_alarm;
|
|
gap_general["output_used"] = radial_ptr->gap_general.output_used;
|
|
gap_general["engieneering_unit"] = radial_ptr->gap_general.engineering_unit;
|
|
gap_general["rectifier_function"] = radial_ptr->gap_general.rectifier_function;
|
|
|
|
gap_alarm["danger_high_level"] = radial_ptr->gap_danger_high.level;
|
|
gap_alarm["danger_high_hysteresis"] = radial_ptr->gap_danger_high.hysteresis;
|
|
gap_alarm["danger_high_delay"] = radial_ptr->gap_danger_high.delay;
|
|
gap_alarm["danger_high_enable"] = radial_ptr->gap_danger_high.enable;
|
|
gap_alarm["danger_high_latch"] = radial_ptr->gap_danger_high.latch;
|
|
gap_alarm["alert_high_level"] = radial_ptr->gap_alert_high.level;
|
|
gap_alarm["alert_high_hysteresis"] = radial_ptr->gap_alert_high.hysteresis;
|
|
gap_alarm["alert_high_delay"] = radial_ptr->gap_alert_high.delay;
|
|
gap_alarm["alert_high_enable"] = radial_ptr->gap_alert_high.enable;
|
|
gap_alarm["alert_high_latch"] = radial_ptr->gap_alert_high.latch;
|
|
// gap_alarm["danger_low_level"] = radial_ptr->gap_danger_low.level;
|
|
// gap_alarm["danger_low_hysteresis"] = radial_ptr->gap_danger_low.hysteresis;
|
|
// gap_alarm["danger_low_delay"] = radial_ptr->gap_danger_low.delay;
|
|
// gap_alarm["danger_low_enable"] = radial_ptr->gap_danger_low.enable;
|
|
// gap_alarm["danger_low_latch"] = radial_ptr->gap_danger_low.latch;
|
|
// gap_alarm["alert_low_level"] = radial_ptr->gap_alert_low.level;
|
|
// gap_alarm["alert_low_hysteresis"] = radial_ptr->gap_alert_low.hysteresis;
|
|
// gap_alarm["alert_low_delay"] = radial_ptr->gap_alert_low.delay;
|
|
// gap_alarm["alert_low_enable"] = radial_ptr->gap_alert_low.enable;
|
|
// gap_alarm["alert_low_latch"] = radial_ptr->gap_alert_low.latch;
|
|
gap["general"] = gap_general;
|
|
gap["alarm"] = gap_alarm;
|
|
variables["gap"] = gap;
|
|
|
|
|
|
}else if(ptr->base_config_[cid].channel_type == kVibThrust){
|
|
std::shared_ptr<ThrustVariable> thrust_ptr = std::dynamic_pointer_cast<ThrustVariable>(base_channel_ptr);
|
|
if(thrust_ptr == nullptr){
|
|
continue;
|
|
}
|
|
// filter
|
|
QJsonArray filter;
|
|
QJsonObject low_pass;
|
|
low_pass["low"] = thrust_ptr->filter_[0].low;
|
|
low_pass["high"] = thrust_ptr->filter_[0].high;
|
|
low_pass["checked"] = thrust_ptr->filter_[0].checked;
|
|
filter.append(low_pass);
|
|
QJsonObject high_pass;
|
|
high_pass["low"] = thrust_ptr->filter_[1].low;
|
|
high_pass["high"] = thrust_ptr->filter_[1].high;
|
|
high_pass["checked"] = thrust_ptr->filter_[1].checked;
|
|
filter.append(high_pass);
|
|
QJsonObject band_pass;
|
|
band_pass["low"] = thrust_ptr->filter_[2].low;
|
|
band_pass["high"] = thrust_ptr->filter_[2].high;
|
|
band_pass["checked"] = thrust_ptr->filter_[2].checked;
|
|
filter.append(band_pass);
|
|
variables["filter"] = filter;
|
|
// gap
|
|
QJsonObject gap,gap_general,gap_alarm;
|
|
gap_general["output_used"] = thrust_ptr->gap_general.output_used;
|
|
gap_general["engieneering_unit"] = thrust_ptr->gap_general.engineering_unit;
|
|
|
|
gap_alarm["danger_high_level"] = thrust_ptr->gap_danger_high.level;
|
|
gap_alarm["danger_high_hysteresis"] = thrust_ptr->gap_danger_high.hysteresis;
|
|
gap_alarm["danger_high_delay"] = thrust_ptr->gap_danger_high.delay;
|
|
gap_alarm["danger_high_enable"] = thrust_ptr->gap_danger_high.enable;
|
|
gap_alarm["danger_high_latch"] = thrust_ptr->gap_danger_high.latch;
|
|
gap_alarm["alert_high_level"] = thrust_ptr->gap_alert_high.level;
|
|
gap_alarm["alert_high_hysteresis"] = thrust_ptr->gap_alert_high.hysteresis;
|
|
gap_alarm["alert_high_delay"] = thrust_ptr->gap_alert_high.delay;
|
|
gap_alarm["alert_high_enable"] = thrust_ptr->gap_alert_high.enable;
|
|
gap_alarm["alert_high_latch"] = thrust_ptr->gap_alert_high.latch;
|
|
gap_alarm["danger_low_level"] = thrust_ptr->gap_danger_low.level;
|
|
gap_alarm["danger_low_hysteresis"] = thrust_ptr->gap_danger_low.hysteresis;
|
|
gap_alarm["danger_low_delay"] = thrust_ptr->gap_danger_low.delay;
|
|
gap_alarm["danger_low_enable"] = thrust_ptr->gap_danger_low.enable;
|
|
gap_alarm["danger_low_latch"] = thrust_ptr->gap_danger_low.latch;
|
|
gap_alarm["alert_low_level"] = thrust_ptr->gap_alert_low.level;
|
|
gap_alarm["alert_low_hysteresis"] = thrust_ptr->gap_alert_low.hysteresis;
|
|
gap_alarm["alert_low_delay"] = thrust_ptr->gap_alert_low.delay;
|
|
gap_alarm["alert_low_enable"] = thrust_ptr->gap_alert_low.enable;
|
|
gap_alarm["alert_low_latch"] = thrust_ptr->gap_alert_low.latch;
|
|
gap["general"] = gap_general;
|
|
gap["alarm"] = gap_alarm;
|
|
variables["gap"] = gap;
|
|
variables["negation"] = thrust_ptr->zero_position.negation;
|
|
variables["zero_position"] = thrust_ptr->zero_position.value;
|
|
|
|
}else if(ptr->base_config_[cid].channel_type == kVibPressurePulsation){
|
|
std::shared_ptr<PressurePulsationVariable> pressure_ptr = std::dynamic_pointer_cast<PressurePulsationVariable>(base_channel_ptr);
|
|
if(pressure_ptr == nullptr){
|
|
continue;
|
|
}
|
|
// filter
|
|
QJsonArray filter;
|
|
QJsonObject low_pass;
|
|
low_pass["low"] = pressure_ptr->filter_[0].low;
|
|
low_pass["high"] = pressure_ptr->filter_[0].high;
|
|
low_pass["checked"] = pressure_ptr->filter_[0].checked;
|
|
filter.append(low_pass);
|
|
QJsonObject high_pass;
|
|
high_pass["low"] = pressure_ptr->filter_[1].low;
|
|
high_pass["high"] = pressure_ptr->filter_[1].high;
|
|
high_pass["checked"] = pressure_ptr->filter_[1].checked;
|
|
filter.append(high_pass);
|
|
QJsonObject band_pass;
|
|
band_pass["low"] = pressure_ptr->filter_[2].low;
|
|
band_pass["high"] = pressure_ptr->filter_[2].high;
|
|
band_pass["checked"] = pressure_ptr->filter_[2].checked;
|
|
filter.append(band_pass);
|
|
variables["filter"] = filter;
|
|
QJsonObject sampling;
|
|
QJsonObject scaling;
|
|
sampling["fixed"] = pressure_ptr->fixed;
|
|
sampling["sample_rate"] = pressure_ptr->sample_rate;
|
|
sampling["band_width"] = pressure_ptr->bandwidth;
|
|
sampling["fft_points"] = pressure_ptr->fft_points;
|
|
scaling["measuring_min"] = pressure_ptr->measuring_min;
|
|
scaling["measuring_max"] = pressure_ptr->measuring_max;
|
|
scaling["scale_min"] = pressure_ptr->scale_min;
|
|
scaling["scale_max"] = pressure_ptr->scale_max;
|
|
variables["sampling"] = sampling;
|
|
variables["scaling"] = scaling;
|
|
QJsonObject general;
|
|
general["engieneering_unit"] = pressure_ptr->general.engineering_unit;
|
|
variables["general"] = general;
|
|
QJsonObject freband_output,number;
|
|
for (int var = 0; var < 10; ++var) {
|
|
if(pressure_ptr->freband_output[var].start != 0 || pressure_ptr->freband_output[var].end != 0){
|
|
freband_output["enable"] = pressure_ptr->freband_output[var].enable;
|
|
freband_output["start"] = pressure_ptr->freband_output[var].start;
|
|
freband_output["end"] = pressure_ptr->freband_output[var].end;
|
|
number[QString::number(var + 1)] = freband_output;
|
|
}
|
|
}
|
|
variables["freband_output"] = number;
|
|
|
|
} else if(ptr->base_config_[cid].channel_type == kVibAcc){
|
|
std::shared_ptr<AccVelVariable> av_ptr = std::dynamic_pointer_cast<AccVelVariable>(base_channel_ptr);
|
|
if(av_ptr == nullptr){
|
|
continue;
|
|
}
|
|
// filter
|
|
QJsonArray filter;
|
|
QJsonObject low_pass;
|
|
low_pass["low"] = av_ptr->filter_[0].low;
|
|
low_pass["high"] = av_ptr->filter_[0].high;
|
|
low_pass["checked"] = av_ptr->filter_[0].checked;
|
|
filter.append(low_pass);
|
|
QJsonObject high_pass;
|
|
high_pass["low"] = av_ptr->filter_[1].low;
|
|
high_pass["high"] = av_ptr->filter_[1].high;
|
|
high_pass["checked"] = av_ptr->filter_[1].checked;
|
|
filter.append(high_pass);
|
|
QJsonObject band_pass;
|
|
band_pass["low"] = av_ptr->filter_[2].low;
|
|
band_pass["high"] = av_ptr->filter_[2].high;
|
|
band_pass["checked"] = av_ptr->filter_[2].checked;
|
|
filter.append(band_pass);
|
|
variables["filter"] = filter;
|
|
// processed output
|
|
QJsonObject processed_output,general,alarm;
|
|
general["output_used"] = av_ptr->general.output_used;
|
|
general["engieneering_unit"] = av_ptr->general.engineering_unit;
|
|
general["rectifier_function"] = av_ptr->general.rectifier_function;
|
|
|
|
alarm["danger_high_level"] = av_ptr->danger_high.level;
|
|
alarm["danger_high_hysteresis"] = av_ptr->danger_high.hysteresis;
|
|
alarm["danger_high_delay"] = av_ptr->danger_high.delay;
|
|
alarm["danger_high_enable"] = av_ptr->danger_high.enable;
|
|
alarm["danger_high_latch"] = av_ptr->danger_high.latch;
|
|
alarm["alert_high_level"] = av_ptr->alert_high.level;
|
|
alarm["alert_high_hysteresis"] = av_ptr->alert_high.hysteresis;
|
|
alarm["alert_high_delay"] = av_ptr->alert_high.delay;
|
|
alarm["alert_high_enable"] = av_ptr->alert_high.enable;
|
|
alarm["alert_high_latch"] = av_ptr->alert_high.latch;
|
|
// alarm["danger_low_level"] = av_ptr->danger_low.level;
|
|
// alarm["danger_low_hysteresis"] = av_ptr->danger_low.hysteresis;
|
|
// alarm["danger_low_delay"] = av_ptr->danger_low.delay;
|
|
// alarm["danger_low_enable"] = av_ptr->danger_low.enable;
|
|
// alarm["danger_low_latch"] = av_ptr->danger_low.latch;
|
|
// alarm["alert_low_level"] = av_ptr->alert_low.level;
|
|
// alarm["alert_low_hysteresis"] = av_ptr->alert_low.hysteresis;
|
|
// alarm["alert_low_delay"] = av_ptr->alert_low.delay;
|
|
// alarm["alert_low_enable"] = av_ptr->alert_low.enable;
|
|
// alarm["alert_low_latch"] = av_ptr->alert_low.latch;
|
|
processed_output["general"] = general;
|
|
processed_output["alarm"] = alarm;
|
|
variables["processed_output"] = processed_output;
|
|
QJsonObject freband_output,number;
|
|
for (int var = 0; var < 10; ++var) {
|
|
if(av_ptr->freband_output[var].start != 0 || av_ptr->freband_output[var].end != 0){
|
|
freband_output["enable"] = av_ptr->freband_output[var].enable;
|
|
freband_output["start"] = av_ptr->freband_output[var].start;
|
|
freband_output["end"] = av_ptr->freband_output[var].end;
|
|
number[QString::number(var + 1)] = freband_output;
|
|
}
|
|
}
|
|
variables["freband_output"] = number;
|
|
|
|
}else if(ptr->base_config_[cid].channel_type == kVibVelocity){
|
|
std::shared_ptr<AccVelVariable> vel_ptr = std::dynamic_pointer_cast<AccVelVariable>(base_channel_ptr);
|
|
if(vel_ptr == nullptr){
|
|
continue;
|
|
}
|
|
// filter
|
|
QJsonArray filter;
|
|
QJsonObject low_pass;
|
|
low_pass["low"] = vel_ptr->filter_[0].low;
|
|
low_pass["high"] = vel_ptr->filter_[0].high;
|
|
low_pass["checked"] = vel_ptr->filter_[0].checked;
|
|
filter.append(low_pass);
|
|
QJsonObject high_pass;
|
|
high_pass["low"] = vel_ptr->filter_[1].low;
|
|
high_pass["high"] = vel_ptr->filter_[1].high;
|
|
high_pass["checked"] = vel_ptr->filter_[1].checked;
|
|
filter.append(high_pass);
|
|
QJsonObject band_pass;
|
|
band_pass["low"] = vel_ptr->filter_[2].low;
|
|
band_pass["high"] = vel_ptr->filter_[2].high;
|
|
band_pass["checked"] = vel_ptr->filter_[2].checked;
|
|
filter.append(band_pass);
|
|
variables["filter"] = filter;
|
|
// processed output
|
|
QJsonObject processed_output,general,alarm;
|
|
general["output_used"] = vel_ptr->general.output_used;
|
|
general["engieneering_unit"] = vel_ptr->general.engineering_unit;
|
|
general["rectifier_function"] = vel_ptr->general.rectifier_function;
|
|
|
|
alarm["danger_high_level"] = vel_ptr->danger_high.level;
|
|
alarm["danger_high_hysteresis"] = vel_ptr->danger_high.hysteresis;
|
|
alarm["danger_high_delay"] = vel_ptr->danger_high.delay;
|
|
alarm["danger_high_enable"] = vel_ptr->danger_high.enable;
|
|
alarm["danger_high_latch"] = vel_ptr->danger_high.latch;
|
|
alarm["alert_high_level"] = vel_ptr->alert_high.level;
|
|
alarm["alert_high_hysteresis"] = vel_ptr->alert_high.hysteresis;
|
|
alarm["alert_high_delay"] = vel_ptr->alert_high.delay;
|
|
alarm["alert_high_enable"] = vel_ptr->alert_high.enable;
|
|
alarm["alert_high_latch"] = vel_ptr->alert_high.latch;
|
|
// alarm["danger_low_level"] = vel_ptr->danger_low.level;
|
|
// alarm["danger_low_hysteresis"] = vel_ptr->danger_low.hysteresis;
|
|
// alarm["danger_low_delay"] = vel_ptr->danger_low.delay;
|
|
// alarm["danger_low_enable"] = vel_ptr->danger_low.enable;
|
|
// alarm["danger_low_latch"] = vel_ptr->danger_low.latch;
|
|
// alarm["alert_low_level"] = vel_ptr->alert_low.level;
|
|
// alarm["alert_low_hysteresis"] = vel_ptr->alert_low.hysteresis;
|
|
// alarm["alert_low_delay"] = vel_ptr->alert_low.delay;
|
|
// alarm["alert_low_enable"] = vel_ptr->alert_low.enable;
|
|
// alarm["alert_low_latch"] = vel_ptr->alert_low.latch;
|
|
processed_output["general"] = general;
|
|
processed_output["alarm"] = alarm;
|
|
variables["processed_output"] = processed_output;
|
|
}else if(ptr->base_config_[cid].channel_type == kVib12){
|
|
std::shared_ptr<DefaultVariable> av_ptr = std::dynamic_pointer_cast<DefaultVariable>(base_channel_ptr);
|
|
if(av_ptr == nullptr){
|
|
continue;
|
|
}
|
|
// filter
|
|
QJsonArray filter;
|
|
QJsonObject low_pass;
|
|
low_pass["low"] = av_ptr->filter_[0].low;
|
|
low_pass["high"] = av_ptr->filter_[0].high;
|
|
low_pass["checked"] = av_ptr->filter_[0].checked;
|
|
filter.append(low_pass);
|
|
QJsonObject high_pass;
|
|
high_pass["low"] = av_ptr->filter_[1].low;
|
|
high_pass["high"] = av_ptr->filter_[1].high;
|
|
high_pass["checked"] = av_ptr->filter_[1].checked;
|
|
filter.append(high_pass);
|
|
QJsonObject band_pass;
|
|
band_pass["low"] = av_ptr->filter_[2].low;
|
|
band_pass["high"] = av_ptr->filter_[2].high;
|
|
band_pass["checked"] = av_ptr->filter_[2].checked;
|
|
filter.append(band_pass);
|
|
variables["filter"] = filter;
|
|
// processed output
|
|
QJsonObject processed_output,general,alarm;
|
|
general["output_used"] = av_ptr->general.output_used;
|
|
general["engieneering_unit"] = av_ptr->general.engineering_unit;
|
|
general["rectifier_function"] = av_ptr->general.rectifier_function;
|
|
|
|
alarm["danger_high_level"] = av_ptr->danger_high.level;
|
|
alarm["danger_high_hysteresis"] = av_ptr->danger_high.hysteresis;
|
|
alarm["danger_high_delay"] = av_ptr->danger_high.delay;
|
|
alarm["danger_high_enable"] = av_ptr->danger_high.enable;
|
|
alarm["danger_high_latch"] = av_ptr->danger_high.latch;
|
|
alarm["alert_high_level"] = av_ptr->alert_high.level;
|
|
alarm["alert_high_hysteresis"] = av_ptr->alert_high.hysteresis;
|
|
alarm["alert_high_delay"] = av_ptr->alert_high.delay;
|
|
alarm["alert_high_enable"] = av_ptr->alert_high.enable;
|
|
alarm["alert_high_latch"] = av_ptr->alert_high.latch;
|
|
processed_output["general"] = general;
|
|
processed_output["alarm"] = alarm;
|
|
variables["processed_output"] = processed_output;
|
|
|
|
}else if(ptr->base_config_[cid].channel_type == kVib34){
|
|
std::shared_ptr<DefaultVariable> av_ptr = std::dynamic_pointer_cast<DefaultVariable>(base_channel_ptr);
|
|
if(av_ptr == nullptr){
|
|
continue;
|
|
}
|
|
// filter
|
|
QJsonArray filter;
|
|
QJsonObject low_pass;
|
|
low_pass["low"] = av_ptr->filter_[0].low;
|
|
low_pass["high"] = av_ptr->filter_[0].high;
|
|
low_pass["checked"] = av_ptr->filter_[0].checked;
|
|
filter.append(low_pass);
|
|
QJsonObject high_pass;
|
|
high_pass["low"] = av_ptr->filter_[1].low;
|
|
high_pass["high"] = av_ptr->filter_[1].high;
|
|
high_pass["checked"] = av_ptr->filter_[1].checked;
|
|
filter.append(high_pass);
|
|
QJsonObject band_pass;
|
|
band_pass["low"] = av_ptr->filter_[2].low;
|
|
band_pass["high"] = av_ptr->filter_[2].high;
|
|
band_pass["checked"] = av_ptr->filter_[2].checked;
|
|
filter.append(band_pass);
|
|
variables["filter"] = filter;
|
|
// processed output
|
|
QJsonObject processed_output,general,alarm;
|
|
general["output_used"] = av_ptr->general.output_used;
|
|
general["engieneering_unit"] = av_ptr->general.engineering_unit;
|
|
general["rectifier_function"] = av_ptr->general.rectifier_function;
|
|
|
|
alarm["danger_high_level"] = av_ptr->danger_high.level;
|
|
alarm["danger_high_hysteresis"] = av_ptr->danger_high.hysteresis;
|
|
alarm["danger_high_delay"] = av_ptr->danger_high.delay;
|
|
alarm["danger_high_enable"] = av_ptr->danger_high.enable;
|
|
alarm["danger_high_latch"] = av_ptr->danger_high.latch;
|
|
alarm["alert_high_level"] = av_ptr->alert_high.level;
|
|
alarm["alert_high_hysteresis"] = av_ptr->alert_high.hysteresis;
|
|
alarm["alert_high_delay"] = av_ptr->alert_high.delay;
|
|
alarm["alert_high_enable"] = av_ptr->alert_high.enable;
|
|
alarm["alert_high_latch"] = av_ptr->alert_high.latch;
|
|
processed_output["general"] = general;
|
|
processed_output["alarm"] = alarm;
|
|
variables["processed_output"] = processed_output;
|
|
|
|
}
|
|
channel_item["variable"] = variables;
|
|
} else if (card_type_[i] == kCardSpeedSingle || card_type_[i] == kCardSpeedTMRPrimary) {
|
|
std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
|
|
if (base_ptr == nullptr || cid > 3) {
|
|
continue;
|
|
}
|
|
std::shared_ptr<TachometerData> ptr = std::dynamic_pointer_cast<TachometerData>(base_ptr);
|
|
QJsonArray voltage_range_array;
|
|
voltage_range_array.append(ptr->variables_[cid].normal_voltage_low);
|
|
voltage_range_array.append(ptr->variables_[cid].normal_voltage_high);
|
|
QJsonObject setpoint_data;
|
|
setpoint_data["speed_upper"] = ptr->alert_danger[cid].speed_upper;
|
|
setpoint_data["speed_lower"] = ptr->alert_danger[cid].speed_lower;
|
|
setpoint_data["speed_upper_enable"] = ptr->alert_danger[cid].speed_upper_enable;
|
|
setpoint_data["speed_lower_enable"] = ptr->alert_danger[cid].speed_lower_enable;
|
|
setpoint_data["danger_speed_upper"] = ptr->alert_danger[cid].danger_speed_upper;
|
|
channel_item["setpoint"] = setpoint_data;
|
|
channel_item.insert("active", ptr->variables_[cid].active);
|
|
channel_item.insert("normal_voltage_range", voltage_range_array);
|
|
channel_item.insert("threshold", ptr->variables_[cid].threshold);
|
|
channel_item.insert("hysteresis", ptr->variables_[cid].hysteresis);
|
|
channel_item.insert("events_per_revolution", ptr->variables_[cid].events_per_revolution);
|
|
channel_item.insert("record_output", ptr->variables_[cid].record_output);
|
|
channel_item.insert("two_ma_clamp", ptr->variables_[cid].two_ma_clamp);
|
|
channel_item.insert("alert_latching", ptr->variables_[cid].alert_latching);
|
|
channel_item.insert("overspeed_latching", ptr->variables_[cid].overspeed_latching);
|
|
channel_item.insert("normal_latching", ptr->variables_[cid].normal_latching);
|
|
channel_item.insert("speed_peak", ptr->variables_[cid].speed_peek);
|
|
channel_item.insert("default_speed", ptr->variables_[cid].default_speed);
|
|
channel_item.insert("automatic_threshold",ptr->variables_[cid].automatic_threshold);
|
|
channel_item.insert("point_name",ptr->variables_[cid].point_name);
|
|
QJsonObject alarm;
|
|
alarm["danger_high_level"] = ptr->danger_high[cid].level;
|
|
alarm["danger_high_hysteresis"] = ptr->danger_high[cid].hysteresis;
|
|
alarm["danger_high_delay"] = ptr->danger_high[cid].delay;
|
|
alarm["danger_high_enable"] = ptr->danger_high[cid].enable;
|
|
alarm["danger_high_latch"] = ptr->danger_high[cid].latch;
|
|
alarm["alert_high_level"] = ptr->alert_high[cid].level;
|
|
alarm["alert_high_hysteresis"] = ptr->alert_high[cid].hysteresis;
|
|
alarm["alert_high_delay"] = ptr->alert_high[cid].delay;
|
|
alarm["alert_high_enable"] = ptr->alert_high[cid].enable;
|
|
alarm["alert_high_latch"] = ptr->alert_high[cid].latch;
|
|
channel_item.insert("alarm" , alarm);
|
|
|
|
} else if (card_type_[i] == kCardKeyphaseSingle) {
|
|
std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
|
|
if (base_ptr == nullptr || cid > 3) {
|
|
continue;
|
|
}
|
|
std::shared_ptr<KeyphaseData> ptr = std::dynamic_pointer_cast<KeyphaseData>(base_ptr);
|
|
QJsonArray voltage_range_array;
|
|
voltage_range_array.append(ptr->variables_[cid].normal_voltage_low);
|
|
voltage_range_array.append(ptr->variables_[cid].normal_voltage_high);
|
|
channel_item.insert("active", ptr->variables_[cid].active);
|
|
channel_item.insert("normal_voltage_range", voltage_range_array);
|
|
channel_item.insert("threshold", ptr->variables_[cid].threshold);
|
|
channel_item.insert("hysteresis", ptr->variables_[cid].hysteresis);
|
|
channel_item.insert("events_per_revolution", ptr->variables_[cid].events_per_revolution);
|
|
channel_item.insert("automatic_threshold",ptr->variables_[cid].automatic_threshold);
|
|
channel_item.insert("point_name",ptr->variables_[cid].point_name);
|
|
|
|
}
|
|
slot_item[QString::number(cid + 1)] = channel_item;
|
|
slot_item["dc_output"] = dc_output;
|
|
}
|
|
slot_item["version"] = 1;
|
|
}else{
|
|
for(int ch = 0;ch < RELAY_COUNT;++ch){
|
|
QJsonObject channel_item;
|
|
if(card_type_[i] == kCardRelaySingle){
|
|
std::shared_ptr<CardBase> base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot);
|
|
if (base_ptr == nullptr) {
|
|
continue;
|
|
}
|
|
std::shared_ptr<SingleRelayData> ptr = std::dynamic_pointer_cast<SingleRelayData>(base_ptr);
|
|
if(ptr->single_relay[ch].vote){
|
|
channel_item.insert("count_vote",ptr->single_relay[ch].count_vote);
|
|
QJsonArray array_logic;
|
|
for(int var = 0 ; var < 10;++var){
|
|
if(ptr->single_relay[ch].logic[var] != ""){
|
|
array_logic.append(ptr->single_relay[ch].logic[var]);
|
|
}
|
|
}
|
|
channel_item.insert("logic_vote", array_logic);
|
|
}else{
|
|
if(ptr->single_relay[ch].logic_expression != ""){
|
|
qDebug() << "ch" << ch << ptr->single_relay[ch].logic_expression;
|
|
channel_item.insert("logic_expression", ptr->single_relay[ch].logic_expression);
|
|
|
|
}
|
|
}
|
|
channel_item.insert("vote",ptr->single_relay[ch].vote);
|
|
channel_item.insert("active", ptr->single_relay[ch].active);
|
|
channel_item.insert("group",ptr->single_relay[ch].group);
|
|
}
|
|
if(!channel_item.isEmpty() ){
|
|
slot_item[QString::number(ch + 1)] = channel_item;
|
|
}
|
|
}
|
|
slot_item["version"] = 1;
|
|
}
|
|
doc_obj[QString::number(slot)] = slot_item;
|
|
}
|
|
doc_obj["card_type"] = card_type;
|
|
// TODO: show success message box
|
|
QJsonDocument jsonDoc;
|
|
jsonDoc.setObject(doc_obj);
|
|
QFile file(file_path);
|
|
file.open(QIODevice::WriteOnly);
|
|
file.write(jsonDoc.toJson());
|
|
file.close();
|
|
}
|
|
|
|
void ConfigMgr::Load(QString filename) {
|
|
QFile file(filename);
|
|
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
// TODO: show message box
|
|
qDebug() << "Cannot open file for reading:" << filename;
|
|
return;
|
|
}
|
|
QString content = file.readAll();
|
|
file.close();
|
|
QByteArray jsonData = content.toUtf8();
|
|
QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData);
|
|
if (jsonDoc.isNull()) {
|
|
// TODO: show message box
|
|
qDebug() << "Cannot parse JSON document";
|
|
return;
|
|
}
|
|
if (!jsonDoc.isObject() && !jsonDoc.isArray()) {
|
|
// TODO: show message box
|
|
qDebug() << "JSON document is not an object or an array";
|
|
return;
|
|
}
|
|
filename_ = filename;
|
|
QJsonObject json_obj = jsonDoc.object();
|
|
// parse card_type
|
|
QJsonArray card_type = json_obj["card_type"].toArray();
|
|
int slot = 0;
|
|
QJsonObject temp_obj;
|
|
for (int i = 0; i < card_type.size(); ++i) {
|
|
temp_obj = card_type[i].toObject();
|
|
slot = temp_obj["slot"].toInt();
|
|
card_type_[slot - 1] = static_cast<CardType>(temp_obj["type"].toInt());
|
|
}
|
|
// parse each slot
|
|
QJsonObject channel;
|
|
for (int i = 0; i < SLOT_NUM; ++i) {
|
|
if (card_type_[i] == kCardNone) {
|
|
continue;
|
|
}
|
|
slot = i + 1;
|
|
if (json_obj[QString::number(slot)].isNull() && card_type_[i] != kCardRelayTMRBackup) {
|
|
continue;
|
|
}
|
|
temp_obj = json_obj[QString::number(slot)].toObject();
|
|
if (card_type_[i] == kCardVibSingle) {
|
|
std::shared_ptr<VibrationData> vib_data = std::make_shared<VibrationData>();
|
|
vib_data->version_ = temp_obj["version"].toInt();
|
|
vib_data->card_type_ = static_cast<CardType>(card_type_[i]);
|
|
vib_data->slot_ = slot;
|
|
// dc_output
|
|
QJsonObject dc_output_obj = temp_obj["dc_output"].toObject();
|
|
if(!dc_output_obj.isEmpty()){
|
|
QJsonObject output_obj;
|
|
for (int var = 0; var < CHANNEL_COUNT; ++var) {
|
|
output_obj = dc_output_obj[QString::number(var + 1)].toObject();
|
|
if(output_obj.isEmpty())
|
|
continue;
|
|
vib_data->dc_output[var].output_channel = output_obj["output_channel"].toInt();
|
|
vib_data->dc_output[var].minmum = output_obj["minmum"].toDouble();
|
|
vib_data->dc_output[var].maxmum = output_obj["maxmum"].toDouble();
|
|
}
|
|
|
|
}
|
|
for (int j = 0; j < CHANNEL_COUNT; ++j) {
|
|
std::shared_ptr<VariableBase> base_channel_ptr = vib_data->GetChannelPtr(j + 1);
|
|
channel = temp_obj[QString::number(j + 1)].toObject();
|
|
if(channel.isEmpty())
|
|
continue;
|
|
// base info
|
|
vib_data->base_config_[j].standby = channel["standby"].toBool();
|
|
vib_data->base_config_[j].active = channel["active"].toBool();
|
|
// vib_data->base_config_[j].rack_type = channel["rack_type"].toInt();
|
|
// vib_data->base_config_[j].tmr_group = channel["tmr_group"].toString();
|
|
vib_data->base_config_[j].channel_type = channel["channel_type"].toInt();
|
|
vib_data->base_config_[j].transducer_id = channel["transducer_id"].toInt();
|
|
// vib_data->base_config_[j].scale_factor = channel["scale_factor"].toDouble();
|
|
// vib_data->base_config_[j].sampling_rate = channel["sampling_rate"].toInt();
|
|
QJsonArray voltage_range_array = channel["normal_voltage_range"].toArray();
|
|
vib_data->base_config_[j].normal_voltage_low = voltage_range_array[0].toDouble();
|
|
vib_data->base_config_[j].normal_voltage_high = voltage_range_array[1].toDouble();
|
|
vib_data->base_config_[j].power = channel["power"].toBool();
|
|
vib_data->base_config_[j].point_name = channel["point_name"].toString();
|
|
vib_data->base_config_[j].chan_id = channel["chan_id"].toString();
|
|
vib_data->base_config_[j].sensitivity_unit = channel["sensitivity_unit"].toInt();
|
|
vib_data->base_config_[j].signal_sensitivity = channel["signal_sensitivity"].toDouble();
|
|
vib_data->base_config_[j].keyphase = channel["keyphase"].toBool();
|
|
vib_data->base_config_[j].keyphase_slot = channel["keyphase_slot"].toInt();
|
|
vib_data->base_config_[j].keyphase_ch = channel["keyphase_ch"].toInt();
|
|
//setpoint
|
|
QJsonObject setpoint_data = channel["setpoint"].toObject();
|
|
if(vib_data->base_config_[j].channel_type == kVibRadial || vib_data->base_config_[j].channel_type == kVibThrust ||
|
|
vib_data->base_config_[j].channel_type == kVibAcc ||vib_data->base_config_[j].channel_type == kVibVelocity ){
|
|
vib_data->base_config_[j].keyphase = channel["keyphase"].toBool();
|
|
vib_data->base_config_[j].keyphase_slot = channel["keyphase_slot"].toInt();
|
|
vib_data->base_config_[j].keyphase_ch = channel["keyphase_ch"].toInt();
|
|
}
|
|
|
|
// if(vib_data->base_config_[j].channel_type == kVibPressurePulsation){
|
|
// vib_data->alert_danger_press[j].low_upper = setpoint_data["low_upper"].toDouble();
|
|
// vib_data->alert_danger_press[j].low_enable = setpoint_data["low_enable"].toBool();
|
|
// vib_data->alert_danger_press[j].mid1_upper = setpoint_data["mid1_upper"].toDouble();
|
|
// vib_data->alert_danger_press[j].mid1_enable = setpoint_data["mid1_enable"].toBool();
|
|
// vib_data->alert_danger_press[j].mid2_upper = setpoint_data["mid2_upper"].toDouble();
|
|
// vib_data->alert_danger_press[j].mid2_enable = setpoint_data["mid2_enable"].toBool();
|
|
// vib_data->alert_danger_press[j].danger_param = setpoint_data["danger_param"].toInt();
|
|
// vib_data->alert_danger_press[j].danger_upper = setpoint_data["danger_upper"].toDouble();
|
|
// vib_data->alert_danger_press[j].danger_enable = setpoint_data["danger_enable"].toBool();
|
|
// }
|
|
// variables
|
|
QJsonObject tmp_variable = channel["variable"].toObject();
|
|
switch (vib_data->base_config_[j].channel_type) {
|
|
case kVibRadial: {
|
|
std::shared_ptr<RadialVariable> variable = std::make_shared<RadialVariable>();
|
|
// filter
|
|
QJsonArray filter_array = tmp_variable["filter"].toArray();
|
|
for (int k = 0; k < filter_array.size(); k++) {
|
|
QJsonObject filter_ele = filter_array[k].toObject();
|
|
variable->filter_[k].low = filter_ele["low"].toInt();
|
|
variable->filter_[k].high = filter_ele["high"].toInt();
|
|
variable->filter_[k].checked = filter_ele["checked"].toBool();
|
|
}
|
|
variable->id_ = j + 1;
|
|
QJsonObject measurement, gap,m_general,m_alarm,g_general,g_alarm;
|
|
measurement = tmp_variable["measurement"].toObject();
|
|
gap = tmp_variable["gap"].toObject();
|
|
m_general = measurement["general"].toObject();
|
|
m_alarm = measurement["alarm"].toObject();
|
|
g_general = gap["general"].toObject();
|
|
g_alarm = gap["alarm"].toObject();
|
|
variable->general.output_used = m_general["output_used"].toBool();
|
|
variable->general.engineering_unit = m_general["engieneering_unit"].toInt();
|
|
variable->general.rectifier_function = m_general["rectifier_function"].toInt();
|
|
variable->danger_high.level = m_alarm["danger_high_level"].toDouble();
|
|
variable->danger_high.hysteresis = m_alarm["danger_high_hysteresis"].toDouble();
|
|
variable->danger_high.delay = m_alarm["danger_high_delay"].toInt();
|
|
variable->danger_high.enable = m_alarm["danger_high_enable"].toBool();
|
|
variable->danger_high.latch = m_alarm["danger_high_latch"].toBool();
|
|
variable->alert_high.level = m_alarm["alert_high_level"].toDouble();
|
|
variable->alert_high.hysteresis = m_alarm["alert_high_hysteresis"].toDouble();
|
|
variable->alert_high.delay = m_alarm["alert_high_delay"].toInt();
|
|
variable->alert_high.enable = m_alarm["alert_high_enable"].toBool();
|
|
variable->alert_high.latch = m_alarm["alert_high_latch"].toBool();
|
|
// variable->danger_low.level = m_alarm["danger_low_level"].toDouble();
|
|
// variable->danger_low.hysteresis = m_alarm["danger_low_hysteresis"].toDouble();
|
|
// variable->danger_low.delay = m_alarm["danger_low_delay"].toInt();
|
|
// variable->danger_low.enable = m_alarm["danger_low_enable"].toBool();
|
|
// variable->danger_low.latch = m_alarm["danger_low_latch"].toBool();
|
|
// variable->alert_low.level = m_alarm["alert_low_level"].toDouble();
|
|
// variable->alert_low.hysteresis = m_alarm["alert_low_hysteresis"].toDouble();
|
|
// variable->alert_low.delay = m_alarm["alert_low_delay"].toInt();
|
|
// variable->alert_low.enable = m_alarm["alert_low_enable"].toBool();
|
|
// variable->alert_low.latch = m_alarm["alert_low_latch"].toBool();
|
|
|
|
variable->gap_general.output_used = g_general["output_used"].toBool();
|
|
variable->gap_general.engineering_unit = g_general["engieneering_unit"].toInt();
|
|
variable->gap_general.rectifier_function = g_general["rectifier_function"].toInt();
|
|
variable->gap_danger_high.level = g_alarm["danger_high_level"].toDouble();
|
|
variable->gap_danger_high.hysteresis = g_alarm["danger_high_hysteresis"].toDouble();
|
|
variable->gap_danger_high.delay = g_alarm["danger_high_delay"].toInt();
|
|
variable->gap_danger_high.enable = g_alarm["danger_high_enable"].toBool();
|
|
variable->gap_danger_high.latch = g_alarm["danger_high_latch"].toBool();
|
|
variable->gap_alert_high.level = g_alarm["alert_high_level"].toDouble();
|
|
variable->gap_alert_high.hysteresis = g_alarm["alert_high_hysteresis"].toDouble();
|
|
variable->gap_alert_high.delay = g_alarm["alert_high_delay"].toInt();
|
|
variable->gap_alert_high.enable = g_alarm["alert_high_enable"].toBool();
|
|
variable->gap_alert_high.latch = g_alarm["alert_high_latch"].toBool();
|
|
// variable->gap_danger_low.level = g_alarm["danger_low_level"].toDouble();
|
|
// variable->gap_danger_low.hysteresis = g_alarm["danger_low_hysteresis"].toDouble();
|
|
// variable->gap_danger_low.delay = g_alarm["danger_low_delay"].toInt();
|
|
// variable->gap_danger_low.enable = g_alarm["danger_low_enable"].toBool();
|
|
// variable->gap_danger_low.latch = g_alarm["danger_low_latch"].toBool();
|
|
// variable->gap_alert_low.level = g_alarm["alert_low_level"].toDouble();
|
|
// variable->gap_alert_low.hysteresis = g_alarm["alert_low_hysteresis"].toDouble();
|
|
// variable->gap_alert_low.delay = g_alarm["alert_low_delay"].toInt();
|
|
// variable->gap_alert_low.enable = g_alarm["alert_low_enable"].toBool();
|
|
// variable->gap_alert_low.latch = g_alarm["alert_low_latch"].toBool();
|
|
|
|
vib_data->variables_.push_back(variable);
|
|
break;
|
|
}
|
|
case kVibThrust: {
|
|
std::shared_ptr<ThrustVariable> variable = std::make_shared<ThrustVariable>();
|
|
// filter
|
|
QJsonArray filter_array = tmp_variable["filter"].toArray();
|
|
for (int k = 0; k < filter_array.size(); k++) {
|
|
QJsonObject filter_ele = filter_array[k].toObject();
|
|
variable->filter_[k].low = filter_ele["low"].toInt();
|
|
variable->filter_[k].high = filter_ele["high"].toInt();
|
|
variable->filter_[k].checked = filter_ele["checked"].toBool();
|
|
}
|
|
variable->id_ = j + 1;
|
|
QJsonObject gap,g_general,g_alarm;
|
|
gap = tmp_variable["gap"].toObject();
|
|
g_general = gap["general"].toObject();
|
|
g_alarm = gap["alarm"].toObject();
|
|
variable->gap_general.output_used = g_general["output_used"].toBool();
|
|
variable->gap_general.engineering_unit = g_general["engieneering_unit"].toInt();
|
|
variable->gap_danger_high.level = g_alarm["danger_high_level"].toDouble();
|
|
variable->gap_danger_high.hysteresis = g_alarm["danger_high_hysteresis"].toDouble();
|
|
variable->gap_danger_high.delay = g_alarm["danger_high_delay"].toInt();
|
|
variable->gap_danger_high.enable = g_alarm["danger_high_enable"].toBool();
|
|
variable->gap_danger_high.latch = g_alarm["danger_high_latch"].toBool();
|
|
variable->gap_alert_high.level = g_alarm["alert_high_level"].toDouble();
|
|
variable->gap_alert_high.hysteresis = g_alarm["alert_high_hysteresis"].toDouble();
|
|
variable->gap_alert_high.delay = g_alarm["alert_high_delay"].toInt();
|
|
variable->gap_alert_high.enable = g_alarm["alert_high_enable"].toBool();
|
|
variable->gap_alert_high.latch = g_alarm["alert_high_latch"].toBool();
|
|
variable->gap_danger_low.level = g_alarm["danger_low_level"].toDouble();
|
|
variable->gap_danger_low.hysteresis = g_alarm["danger_low_hysteresis"].toDouble();
|
|
variable->gap_danger_low.delay = g_alarm["danger_low_delay"].toInt();
|
|
variable->gap_danger_low.enable = g_alarm["danger_low_enable"].toBool();
|
|
variable->gap_danger_low.latch = g_alarm["danger_low_latch"].toBool();
|
|
variable->gap_alert_low.level = g_alarm["alert_low_level"].toDouble();
|
|
variable->gap_alert_low.hysteresis = g_alarm["alert_low_hysteresis"].toDouble();
|
|
variable->gap_alert_low.delay = g_alarm["alert_low_delay"].toInt();
|
|
variable->gap_alert_low.enable = g_alarm["alert_low_enable"].toBool();
|
|
variable->gap_alert_low.latch = g_alarm["alert_low_latch"].toBool();
|
|
variable->zero_position.value = tmp_variable["zero_position"].toDouble();
|
|
variable->zero_position.negation = tmp_variable["negation"].toBool();
|
|
vib_data->variables_.push_back(variable);
|
|
break;
|
|
}
|
|
case kVibPressurePulsation:{
|
|
std::shared_ptr<PressurePulsationVariable> variable = std::make_shared<PressurePulsationVariable>();
|
|
// filter
|
|
QJsonArray filter_array = tmp_variable["filter"].toArray();
|
|
for (int k = 0; k < filter_array.size(); k++) {
|
|
QJsonObject filter_ele = filter_array[k].toObject();
|
|
variable->filter_[k].low = filter_ele["low"].toInt();
|
|
variable->filter_[k].high = filter_ele["high"].toInt();
|
|
variable->filter_[k].checked = filter_ele["checked"].toBool();
|
|
}
|
|
variable->id_ = j + 1;
|
|
QJsonObject processed_output, general, alarm;
|
|
processed_output = tmp_variable["processed_output"].toObject();
|
|
general = processed_output["general"].toObject();
|
|
alarm = processed_output["alarm"].toObject();
|
|
variable->general.output_used = general["output_used"].toBool();
|
|
variable->general.engineering_unit = general["engieneering_unit"].toInt();
|
|
variable->general.rectifier_function = general["rectifier_function"].toInt();
|
|
variable->danger_high.level = alarm["danger_high_level"].toDouble();
|
|
variable->danger_high.hysteresis = alarm["danger_high_hysteresis"].toDouble();
|
|
variable->danger_high.delay = alarm["danger_high_delay"].toInt();
|
|
variable->danger_high.enable = alarm["danger_high_enable"].toBool();
|
|
variable->danger_high.latch = alarm["danger_high_latch"].toBool();
|
|
variable->alert_high.level = alarm["alert_high_level"].toDouble();
|
|
variable->alert_high.hysteresis = alarm["alert_high_hysteresis"].toDouble();
|
|
variable->alert_high.delay = alarm["alert_high_delay"].toInt();
|
|
variable->alert_high.enable = alarm["alert_high_enable"].toBool();
|
|
variable->alert_high.latch = alarm["alert_high_latch"].toBool();
|
|
// variable->danger_low.level = alarm["danger_low_level"].toDouble();
|
|
// variable->danger_low.hysteresis = alarm["danger_low_hysteresis"].toDouble();
|
|
// variable->danger_low.delay = alarm["danger_low_delay"].toInt();
|
|
// variable->danger_low.enable = alarm["danger_low_enable"].toBool();
|
|
// variable->danger_low.latch = alarm["danger_low_latch"].toBool();
|
|
// variable->alert_low.level = alarm["alert_low_level"].toDouble();
|
|
// variable->alert_low.hysteresis = alarm["alert_low_hysteresis"].toDouble();
|
|
// variable->alert_low.delay = alarm["alert_low_delay"].toInt();
|
|
// variable->alert_low.enable = alarm["alert_low_enable"].toBool();
|
|
// variable->alert_low.latch = alarm["alert_low_latch"].toBool();
|
|
QJsonObject freband_output_obj = tmp_variable["freband_output"].toObject();
|
|
QJsonObject number_obj;
|
|
for (int k = 0; k < 10; ++k) {
|
|
number_obj = freband_output_obj[QString::number(k + 1)].toObject();
|
|
if(number_obj.isEmpty())
|
|
continue;
|
|
FrequencybandOutput output;
|
|
output.enable = number_obj["enable"].toBool();
|
|
output.start = number_obj["start"].toInt();
|
|
output.end = number_obj["end"].toInt();
|
|
variable->freband_output[k] = output;
|
|
}
|
|
vib_data->variables_.push_back(variable);
|
|
break;
|
|
}
|
|
case kVibVelocity:{
|
|
std::shared_ptr<AccVelVariable> variable = std::make_shared<AccVelVariable>();
|
|
// filter
|
|
QJsonArray filter_array = tmp_variable["filter"].toArray();
|
|
for (int k = 0; k < filter_array.size(); k++) {
|
|
QJsonObject filter_ele = filter_array[k].toObject();
|
|
variable->filter_[k].low = filter_ele["low"].toInt();
|
|
variable->filter_[k].high = filter_ele["high"].toInt();
|
|
variable->filter_[k].checked = filter_ele["checked"].toBool();
|
|
}
|
|
variable->id_ = j + 1;
|
|
QJsonObject processed_output, general, alarm;
|
|
processed_output = tmp_variable["processed_output"].toObject();
|
|
general = processed_output["general"].toObject();
|
|
alarm = processed_output["alarm"].toObject();
|
|
variable->general.output_used = general["output_used"].toBool();
|
|
variable->general.engineering_unit = general["engieneering_unit"].toInt();
|
|
variable->general.rectifier_function = general["rectifier_function"].toInt();
|
|
variable->danger_high.level = alarm["danger_high_level"].toDouble();
|
|
variable->danger_high.hysteresis = alarm["danger_high_hysteresis"].toDouble();
|
|
variable->danger_high.delay = alarm["danger_high_delay"].toInt();
|
|
variable->danger_high.enable = alarm["danger_high_enable"].toBool();
|
|
variable->danger_high.latch = alarm["danger_high_latch"].toBool();
|
|
variable->alert_high.level = alarm["alert_high_level"].toDouble();
|
|
variable->alert_high.hysteresis = alarm["alert_high_hysteresis"].toDouble();
|
|
variable->alert_high.delay = alarm["alert_high_delay"].toInt();
|
|
variable->alert_high.enable = alarm["alert_high_enable"].toBool();
|
|
variable->alert_high.latch = alarm["alert_high_latch"].toBool();
|
|
// variable->danger_low.level = alarm["danger_low_level"].toDouble();
|
|
// variable->danger_low.hysteresis = alarm["danger_low_hysteresis"].toDouble();
|
|
// variable->danger_low.delay = alarm["danger_low_delay"].toInt();
|
|
// variable->danger_low.enable = alarm["danger_low_enable"].toBool();
|
|
// variable->danger_low.latch = alarm["danger_low_latch"].toBool();
|
|
// variable->alert_low.level = alarm["alert_low_level"].toDouble();
|
|
// variable->alert_low.hysteresis = alarm["alert_low_hysteresis"].toDouble();
|
|
// variable->alert_low.delay = alarm["alert_low_delay"].toInt();
|
|
// variable->alert_low.enable = alarm["alert_low_enable"].toBool();
|
|
// variable->alert_low.latch = alarm["alert_low_latch"].toBool();
|
|
vib_data->variables_.push_back(variable);
|
|
break;
|
|
}
|
|
case kVibAcc: {
|
|
std::shared_ptr<AccVelVariable> variable = std::make_shared<AccVelVariable>();
|
|
// filter
|
|
QJsonArray filter_array = tmp_variable["filter"].toArray();
|
|
for (int k = 0; k < filter_array.size(); k++) {
|
|
QJsonObject filter_ele = filter_array[k].toObject();
|
|
variable->filter_[k].low = filter_ele["low"].toInt();
|
|
variable->filter_[k].high = filter_ele["high"].toInt();
|
|
variable->filter_[k].checked = filter_ele["checked"].toBool();
|
|
}
|
|
variable->id_ = j + 1;
|
|
QJsonObject processed_output, general, alarm;
|
|
processed_output = tmp_variable["processed_output"].toObject();
|
|
general = processed_output["general"].toObject();
|
|
alarm = processed_output["alarm"].toObject();
|
|
variable->general.output_used = general["output_used"].toBool();
|
|
variable->general.engineering_unit = general["engieneering_unit"].toInt();
|
|
variable->general.rectifier_function = general["rectifier_function"].toInt();
|
|
variable->danger_high.level = alarm["danger_high_level"].toDouble();
|
|
variable->danger_high.hysteresis = alarm["danger_high_hysteresis"].toDouble();
|
|
variable->danger_high.delay = alarm["danger_high_delay"].toInt();
|
|
variable->danger_high.enable = alarm["danger_high_enable"].toBool();
|
|
variable->danger_high.latch = alarm["danger_high_latch"].toBool();
|
|
variable->alert_high.level = alarm["alert_high_level"].toDouble();
|
|
variable->alert_high.hysteresis = alarm["alert_high_hysteresis"].toDouble();
|
|
variable->alert_high.delay = alarm["alert_high_delay"].toInt();
|
|
variable->alert_high.enable = alarm["alert_high_enable"].toBool();
|
|
variable->alert_high.latch = alarm["alert_high_latch"].toBool();
|
|
// variable->danger_low.level = alarm["danger_low_level"].toDouble();
|
|
// variable->danger_low.hysteresis = alarm["danger_low_hysteresis"].toDouble();
|
|
// variable->danger_low.delay = alarm["danger_low_delay"].toInt();
|
|
// variable->danger_low.enable = alarm["danger_low_enable"].toBool();
|
|
// variable->danger_low.latch = alarm["danger_low_latch"].toBool();
|
|
// variable->alert_low.level = alarm["alert_low_level"].toDouble();
|
|
// variable->alert_low.hysteresis = alarm["alert_low_hysteresis"].toDouble();
|
|
// variable->alert_low.delay = alarm["alert_low_delay"].toInt();
|
|
// variable->alert_low.enable = alarm["alert_low_enable"].toBool();
|
|
// variable->alert_low.latch = alarm["alert_low_latch"].toBool();
|
|
QJsonObject freband_output_obj = tmp_variable["freband_output"].toObject();
|
|
QJsonObject number_obj;
|
|
for (int k = 0; k < 10; ++k) {
|
|
number_obj = freband_output_obj[QString::number(k + 1)].toObject();
|
|
if(number_obj.isEmpty())
|
|
continue;
|
|
FrequencybandOutput output;
|
|
output.enable = number_obj["enable"].toBool();
|
|
output.start = number_obj["start"].toInt();
|
|
output.end = number_obj["end"].toInt();
|
|
variable->freband_output[k] = output;
|
|
}
|
|
vib_data->variables_.push_back(variable);
|
|
break;
|
|
}
|
|
case kVib12: {
|
|
std::shared_ptr<DefaultVariable> variable = std::make_shared<DefaultVariable>();
|
|
variable->id_ = j + 1;
|
|
QJsonObject processed_output, general, alarm;
|
|
processed_output = tmp_variable["processed_output"].toObject();
|
|
general = processed_output["general"].toObject();
|
|
alarm = processed_output["alarm"].toObject();
|
|
variable->general.output_used = general["output_used"].toBool();
|
|
variable->general.engineering_unit = general["engieneering_unit"].toInt();
|
|
variable->general.rectifier_function = general["rectifier_function"].toInt();
|
|
variable->danger_high.level = alarm["danger_high_level"].toDouble();
|
|
variable->danger_high.hysteresis = alarm["danger_high_hysteresis"].toDouble();
|
|
variable->danger_high.delay = alarm["danger_high_delay"].toInt();
|
|
variable->danger_high.enable = alarm["danger_high_enable"].toBool();
|
|
variable->danger_high.latch = alarm["danger_high_latch"].toBool();
|
|
variable->alert_high.level = alarm["alert_high_level"].toDouble();
|
|
variable->alert_high.hysteresis = alarm["alert_high_hysteresis"].toDouble();
|
|
variable->alert_high.delay = alarm["alert_high_delay"].toInt();
|
|
variable->alert_high.enable = alarm["alert_high_enable"].toBool();
|
|
variable->alert_high.latch = alarm["alert_high_latch"].toBool();
|
|
vib_data->variables_.push_back(variable);
|
|
break;
|
|
}
|
|
case kVib34: {
|
|
std::shared_ptr<DefaultVariable> variable = std::make_shared<DefaultVariable>();
|
|
variable->id_ = j + 1;
|
|
QJsonObject processed_output, general, alarm;
|
|
processed_output = tmp_variable["processed_output"].toObject();
|
|
general = processed_output["general"].toObject();
|
|
alarm = processed_output["alarm"].toObject();
|
|
variable->general.output_used = general["output_used"].toBool();
|
|
variable->general.engineering_unit = general["engieneering_unit"].toInt();
|
|
variable->general.rectifier_function = general["rectifier_function"].toInt();
|
|
variable->danger_high.level = alarm["danger_high_level"].toDouble();
|
|
variable->danger_high.hysteresis = alarm["danger_high_hysteresis"].toDouble();
|
|
variable->danger_high.delay = alarm["danger_high_delay"].toInt();
|
|
variable->danger_high.enable = alarm["danger_high_enable"].toBool();
|
|
variable->danger_high.latch = alarm["danger_high_latch"].toBool();
|
|
variable->alert_high.level = alarm["alert_high_level"].toDouble();
|
|
variable->alert_high.hysteresis = alarm["alert_high_hysteresis"].toDouble();
|
|
variable->alert_high.delay = alarm["alert_high_delay"].toInt();
|
|
variable->alert_high.enable = alarm["alert_high_enable"].toBool();
|
|
variable->alert_high.latch = alarm["alert_high_latch"].toBool();
|
|
vib_data->variables_.push_back(variable);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
cards_.push_back(vib_data);
|
|
} else if (card_type_[i] == kCardSpeedSingle ||
|
|
card_type_[i] == kCardSpeedTMRPrimary) {
|
|
std::shared_ptr<TachometerData> speed_data = std::make_shared<TachometerData>();
|
|
speed_data->slot_ = slot;
|
|
speed_data->card_type_ = static_cast<CardType>(card_type_[i]);
|
|
speed_data->version_ = temp_obj["version"].toInt();
|
|
for (int j = 0; j < CHANNEL_COUNT_SPEED; ++j) {
|
|
channel = temp_obj[QString::number(j + 1)].toObject();
|
|
speed_data->variables_[j].active = channel["active"].toBool();
|
|
QJsonArray voltage_range_array = channel["normal_voltage_range"].toArray();
|
|
speed_data->variables_[j].normal_voltage_high = voltage_range_array[1].toDouble();
|
|
speed_data->variables_[j].normal_voltage_low = voltage_range_array[0].toDouble();
|
|
speed_data->variables_[j].threshold = channel["threshold"].toDouble();
|
|
speed_data->variables_[j].hysteresis = channel["hysteresis"].toDouble();
|
|
speed_data->variables_[j].events_per_revolution = channel["events_per_revolution"].toInt();
|
|
speed_data->variables_[j].record_output = channel["record_output"].toInt();
|
|
speed_data->variables_[j].two_ma_clamp = channel["two_ma_clamp"].toBool();
|
|
speed_data->variables_[j].alert_latching = channel["alert_latching"].toBool();
|
|
speed_data->variables_[j].overspeed_latching = channel["overspeed_latching"].toBool();
|
|
speed_data->variables_[j].normal_latching = channel["normal_latching"].toBool();
|
|
speed_data->variables_[j].speed_peek = channel["speed_peak"].toInt();
|
|
speed_data->variables_[j].default_speed = channel["default_speed"].toInt();
|
|
speed_data->variables_[j].automatic_threshold = channel["automatic_threshold"].toBool();
|
|
speed_data->variables_[j].point_name = channel["point_name"].toString();
|
|
if(channel.contains("alarmn")){
|
|
QJsonObject alarm = channel["alarm"].toObject();
|
|
speed_data->danger_high[j].level = alarm["danger_high_level"].toDouble();
|
|
speed_data->danger_high[j].hysteresis = alarm["danger_high_hysteresis"].toDouble();
|
|
speed_data->danger_high[j].delay = alarm["danger_high_delay"].toInt();
|
|
speed_data->danger_high[j].enable = alarm["danger_high_enable"].toBool();
|
|
speed_data->danger_high[j].latch = alarm["danger_high_latch"].toBool();
|
|
speed_data->alert_high[j].level = alarm["alert_high_level"].toDouble();
|
|
speed_data->alert_high[j].hysteresis = alarm["alert_high_hysteresis"].toDouble();
|
|
speed_data->alert_high[j].delay = alarm["alert_high_delay"].toInt();
|
|
speed_data->alert_high[j].enable = alarm["alert_high_enable"].toBool();
|
|
speed_data->alert_high[j].latch = alarm["alert_high_latch"].toBool();
|
|
}
|
|
}
|
|
cards_.push_back(speed_data);
|
|
} else if (card_type_[i] == kCardKeyphaseSingle) {
|
|
std::shared_ptr<KeyphaseData> keyphase_data = std::make_shared<KeyphaseData>();
|
|
keyphase_data->slot_ = slot;
|
|
keyphase_data->card_type_ = static_cast<CardType>(card_type_[i]);
|
|
keyphase_data->version_ = temp_obj["version"].toInt();
|
|
for (int j = 0; j < CHANNEL_COUNT_SPEED; ++j) {
|
|
channel = temp_obj[QString::number(j + 1)].toObject();
|
|
keyphase_data->variables_[j].active = channel["active"].toBool();
|
|
QJsonArray voltage_range_array = channel["normal_voltage_range"].toArray();
|
|
if(voltage_range_array.size() > 0){
|
|
keyphase_data->variables_[j].normal_voltage_high = voltage_range_array[1].toDouble();
|
|
keyphase_data->variables_[j].normal_voltage_low = voltage_range_array[0].toDouble();
|
|
}
|
|
keyphase_data->variables_[j].threshold = channel["threshold"].toDouble();
|
|
keyphase_data->variables_[j].hysteresis = channel["hysteresis"].toDouble();
|
|
keyphase_data->variables_[j].events_per_revolution = channel["events_per_revolution"].toInt();
|
|
keyphase_data->variables_[j].automatic_threshold = channel["automatic_threshold"].toBool();
|
|
keyphase_data->variables_[j].point_name = channel["point_name"].toString();
|
|
|
|
}
|
|
cards_.push_back(keyphase_data);
|
|
}else if (card_type_[i] == kCardRelaySingle ){
|
|
std::shared_ptr<SingleRelayData> singlerelay_data = std::make_shared<SingleRelayData>();
|
|
singlerelay_data->slot_ = slot;
|
|
singlerelay_data->card_type_ = static_cast<CardType>(card_type_[i]);
|
|
singlerelay_data->version_ = temp_obj["version"].toInt();
|
|
for (int j = 0; j < RELAY_COUNT; ++j) {
|
|
channel = temp_obj[QString::number(j + 1)].toObject();
|
|
if(channel["vote"].toBool()){
|
|
singlerelay_data->single_relay[j].count_vote = channel["count_vote"].toInt();
|
|
singlerelay_data->single_relay[j].vote = channel["vote"].toBool();
|
|
QJsonArray array_logic = channel["logic_vote"].toArray();
|
|
for(int var = 0;var < array_logic.size();++var){
|
|
singlerelay_data->single_relay[j].logic[var] = array_logic[var].toString();
|
|
}
|
|
}else{
|
|
singlerelay_data->single_relay[j].logic_expression = channel["logic_expression"].toString();
|
|
}
|
|
singlerelay_data->single_relay[j].active = channel["active"].toBool();
|
|
singlerelay_data->single_relay[j].group = channel["group"].toInt();
|
|
}
|
|
cards_.push_back(singlerelay_data);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<CardBase> ConfigMgr::GetSlotPtr(int slot) {
|
|
for (auto &item : cards_) {
|
|
if (item->slot_ == slot) {
|
|
return item;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void ConfigMgr::AddCard(std::shared_ptr<CardBase> ptr) {
|
|
cards_.push_back(ptr);
|
|
}
|
|
void ConfigMgr::RemoveCard(std::shared_ptr<CardBase> ptr) {
|
|
cards_.erase(remove(cards_.begin(), cards_.end(), ptr));
|
|
}
|