#include "config_mgr.h" #include #include #include #include #include "data_config.h" #include "vibrationdata.h" #include "tachometer_data.h" #include "keyphase_data.h" #include "singlerelay_data.h" #include "tmrrelayassociation_data.h" #include 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 base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot); if (base_ptr == nullptr) { continue; } std::shared_ptr ptr = std::dynamic_pointer_cast(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 base_channel_ptr = ptr->GetChannelPtr(cid + 1); if (base_channel_ptr == nullptr) { continue; } if (ptr->base_config_[cid].channel_type == kVibRadial) { std::shared_ptr radial_ptr = std::dynamic_pointer_cast(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 thrust_ptr = std::dynamic_pointer_cast(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 pressure_ptr = std::dynamic_pointer_cast(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 av_ptr = std::dynamic_pointer_cast(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 vel_ptr = std::dynamic_pointer_cast(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 av_ptr = std::dynamic_pointer_cast(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 av_ptr = std::dynamic_pointer_cast(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 base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot); if (base_ptr == nullptr || cid > 3) { continue; } std::shared_ptr ptr = std::dynamic_pointer_cast(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 base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot); if (base_ptr == nullptr || cid > 3) { continue; } std::shared_ptr ptr = std::dynamic_pointer_cast(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 base_ptr = ConfigMgr::Instance()->GetSlotPtr(slot); if (base_ptr == nullptr) { continue; } std::shared_ptr ptr = std::dynamic_pointer_cast(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(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 vib_data = std::make_shared(); vib_data->version_ = temp_obj["version"].toInt(); vib_data->card_type_ = static_cast(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 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 variable = std::make_shared(); // 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 variable = std::make_shared(); // 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 variable = std::make_shared(); // 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 variable = std::make_shared(); // 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 variable = std::make_shared(); // 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 variable = std::make_shared(); 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 variable = std::make_shared(); 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 speed_data = std::make_shared(); speed_data->slot_ = slot; speed_data->card_type_ = static_cast(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 keyphase_data = std::make_shared(); keyphase_data->slot_ = slot; keyphase_data->card_type_ = static_cast(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 singlerelay_data = std::make_shared(); singlerelay_data->slot_ = slot; singlerelay_data->card_type_ = static_cast(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 ConfigMgr::GetSlotPtr(int slot) { for (auto &item : cards_) { if (item->slot_ == slot) { return item; } } return nullptr; } void ConfigMgr::AddCard(std::shared_ptr ptr) { cards_.push_back(ptr); } void ConfigMgr::RemoveCard(std::shared_ptr ptr) { cards_.erase(remove(cards_.begin(), cards_.end(), ptr)); }