diff --git a/wxdata/include/scwx/wsr88d/rda/message.hpp b/wxdata/include/scwx/wsr88d/rda/message.hpp index 202788f0..5479ddec 100644 --- a/wxdata/include/scwx/wsr88d/rda/message.hpp +++ b/wxdata/include/scwx/wsr88d/rda/message.hpp @@ -2,6 +2,18 @@ #include +#include +#include +#include +#include +#include + +#ifdef WIN32 +# include +#else +# include +#endif + namespace scwx { namespace wsr88d @@ -22,7 +34,54 @@ protected: Message(Message&&) noexcept; Message& operator=(Message&&) noexcept; - bool ValidateSize(std::istream& is, size_t bytesRead) const; + bool ValidateMessage(std::istream& is, size_t bytesRead) const; + + static void ReadBoolean(std::istream& is, bool& value) + { + std::string data(4, ' '); + is.read(reinterpret_cast(&data[0]), 4); + value = (data.at(0) == 'T'); + } + + static void ReadChar(std::istream& is, char& value) + { + std::string data(4, ' '); + is.read(reinterpret_cast(&data[0]), 4); + value = data.at(0); + } + + static float SwapFloat(float f) + { + return ntohf(*reinterpret_cast(&f)); + } + + template + static void SwapFloatArray(std::array& arr) + { + std::transform(std::execution::par_unseq, + arr.begin(), + arr.end(), + arr.begin(), + [](float f) { return SwapFloat(f); }); + } + + template + static void SwapUInt16Array(std::array& arr) + { + std::transform(std::execution::par_unseq, + arr.begin(), + arr.end(), + arr.begin(), + [](uint16_t u) { return ntohs(u); }); + } + + template + static void SwapFloatMap(std::map& m) + { + std::for_each(std::execution::par_unseq, m.begin(), m.end(), [](auto& p) { + p.second = SwapFloat(p.second); + }); + } public: virtual ~Message(); diff --git a/wxdata/include/scwx/wsr88d/rda/performance_maintenance_data.hpp b/wxdata/include/scwx/wsr88d/rda/performance_maintenance_data.hpp new file mode 100644 index 00000000..ce3448c3 --- /dev/null +++ b/wxdata/include/scwx/wsr88d/rda/performance_maintenance_data.hpp @@ -0,0 +1,290 @@ +#pragma once + +#include + +namespace scwx +{ +namespace wsr88d +{ +namespace rda +{ + +class PerformanceMaintenanceDataImpl; + +class PerformanceMaintenanceData : public Message +{ +public: + explicit PerformanceMaintenanceData(); + ~PerformanceMaintenanceData(); + + PerformanceMaintenanceData(const Message&) = delete; + PerformanceMaintenanceData& + operator=(const PerformanceMaintenanceData&) = delete; + + PerformanceMaintenanceData(PerformanceMaintenanceData&&) noexcept; + PerformanceMaintenanceData& operator=(PerformanceMaintenanceData&&) noexcept; + + uint16_t loop_back_set_status() const; + uint32_t t1_output_frames() const; + uint32_t t1_input_frames() const; + uint32_t router_memory_used() const; + uint32_t router_memory_free() const; + uint16_t router_memory_utilization() const; + uint16_t route_to_rpg() const; + uint32_t csu_loss_of_signal() const; + uint32_t csu_loss_of_frames() const; + uint32_t csu_yellow_alarms() const; + uint32_t csu_blue_alarms() const; + uint32_t csu_24hr_errored_seconds() const; + uint32_t csu_24hr_severely_errored_seconds() const; + uint32_t csu_24hr_severely_errored_framing_seconds() const; + uint32_t csu_24hr_unavailable_seconds() const; + uint32_t csu_24hr_controlled_slip_seconds() const; + uint32_t csu_24hr_path_coding_violations() const; + uint32_t csu_24hr_line_errored_seconds() const; + uint32_t csu_24hr_bursty_errored_seconds() const; + uint32_t csu_24hr_degraded_minutes() const; + uint32_t lan_switch_cpu_utilization() const; + uint16_t lan_switch_memory_utilization() const; + uint16_t ifdr_chasis_temperature() const; + uint16_t ifdr_fpga_temperature() const; + int32_t gps_satellites() const; + uint16_t ipc_status() const; + uint16_t commanded_channel_control() const; + uint16_t polarization() const; + float ame_internal_temperature() const; + float ame_receiver_module_temperature() const; + float ame_bite_cal_module_temperature() const; + uint16_t ame_peltier_pulse_width_modulation() const; + uint16_t ame_peltier_status() const; + uint16_t ame_a_d_converter_status() const; + uint16_t ame_state() const; + float ame_3_3v_ps_voltage() const; + float ame_5v_ps_voltage() const; + float ame_6_5v_ps_voltage() const; + float ame_15v_ps_voltage() const; + float ame_48v_ps_voltage() const; + float ame_stalo_power() const; + float peltier_current() const; + float adc_calibration_reference_voltage() const; + uint16_t ame_mode() const; + uint16_t ame_peltier_mode() const; + float ame_peltier_inside_fan_current() const; + float ame_peltier_outside_fan_current() const; + float horizontal_tr_limiter_voltage() const; + float vertical_tr_limiter_voltage() const; + float adc_calibration_offset_voltage() const; + float adc_calibration_gain_correction() const; + uint16_t rcp_status() const; + const std::string& rcp_string() const; + uint16_t spip_power_buttons() const; + float master_power_administrator_load() const; + float expansion_power_administrator_load() const; + uint16_t _5vdc_ps() const; + uint16_t _15vdc_ps() const; + uint16_t _28vdc_ps() const; + uint16_t neg_15vdc_ps() const; + uint16_t _45vdc_ps() const; + uint16_t filament_ps_voltage() const; + uint16_t vacuum_pump_ps_voltage() const; + uint16_t focus_coil_ps_voltage() const; + uint16_t filament_ps() const; + uint16_t klystron_warmup() const; + uint16_t transmitter_available() const; + uint16_t wg_switch_position() const; + uint16_t wg_pfn_transfer_interlock() const; + uint16_t maintenance_mode() const; + uint16_t maintenance_required() const; + uint16_t pfn_switch_position() const; + uint16_t modulator_overload() const; + uint16_t modulator_inv_current() const; + uint16_t modulator_switch_fail() const; + uint16_t main_power_voltage() const; + uint16_t charging_system_fail() const; + uint16_t inverse_diode_current() const; + uint16_t trigger_amplifier() const; + uint16_t circulator_temperature() const; + uint16_t spectrum_filter_pressure() const; + uint16_t wg_arc_vswr() const; + uint16_t cabinet_interlock() const; + uint16_t cabinet_air_temperature() const; + uint16_t cabinet_airflow() const; + uint16_t klystron_current() const; + uint16_t klystron_filament_current() const; + uint16_t klystron_vacion_current() const; + uint16_t klystron_air_temperature() const; + uint16_t klystron_airflow() const; + uint16_t modulator_switch_maintenance() const; + uint16_t post_charge_regulator_maintenance() const; + uint16_t wg_pressure_humidity() const; + uint16_t transmitter_overvoltage() const; + uint16_t transmitter_overcurrent() const; + uint16_t focus_coil_current() const; + uint16_t focus_coil_airflow() const; + uint16_t oil_temperature() const; + uint16_t prf_limit() const; + uint16_t transmitter_oil_level() const; + uint16_t transmitter_battery_charging() const; + uint16_t high_voltage_status() const; + uint16_t transmitter_recycling_summary() const; + uint16_t transmitter_inoperable() const; + uint16_t transmitter_air_filter() const; + uint16_t zero_test_bit(unsigned i) const; + uint16_t one_test_bit(unsigned i) const; + uint16_t xmtr_spip_interface() const; + uint16_t transmitter_summary_status() const; + float transmitter_rf_power() const; + float horizontal_xmtr_peak_power() const; + float xmtr_peak_power() const; + float vertical_xmtr_peak_power() const; + float xmtr_rf_avg_power() const; + uint32_t xmtr_recycle_count() const; + float receiver_bias() const; + float transmit_imbalance() const; + float xmtr_power_meter_zero() const; + uint16_t ac_unit1_compressor_shut_off() const; + uint16_t ac_unit2_compressor_shut_off() const; + uint16_t generator_maintenance_required() const; + uint16_t generator_battery_voltage() const; + uint16_t generator_engine() const; + uint16_t generator_volt_frequency() const; + uint16_t power_source() const; + uint16_t transitional_power_source() const; + uint16_t generator_auto_run_off_switch() const; + uint16_t aircraft_hazard_lighting() const; + uint16_t equipment_shelter_fire_detection_system() const; + uint16_t equipment_shelter_fire_smoke() const; + uint16_t generator_shelter_fire_smoke() const; + uint16_t utility_voltage_frequency() const; + uint16_t site_security_alarm() const; + uint16_t security_equipment() const; + uint16_t security_system() const; + uint16_t receiver_connected_to_antenna() const; + uint16_t radome_hatch() const; + uint16_t ac_unit1_filter_dirty() const; + uint16_t ac_unit2_filter_dirty() const; + float equipment_shelter_temperature() const; + float outside_ambient_temperature() const; + float transmitter_leaving_air_temp() const; + float ac_unit1_discharge_air_temp() const; + float generator_shelter_temperature() const; + float radome_air_temperature() const; + float ac_unit2_discharge_air_temp() const; + float spip_15v_ps() const; + float spip_neg_15v_ps() const; + uint16_t spip_28v_ps_status() const; + float spip_5v_ps() const; + uint16_t converted_generator_fuel_level() const; + uint16_t elevation_pos_dead_limit() const; + uint16_t _150v_overvoltage() const; + uint16_t _150v_undervoltage() const; + uint16_t elevation_servo_amp_inhibit() const; + uint16_t elevation_servo_amp_short_circuit() const; + uint16_t elevation_servo_amp_overtemp() const; + uint16_t elevation_motor_overtemp() const; + uint16_t elevation_stow_pin() const; + uint16_t elevation_housing_5v_ps() const; + uint16_t elevation_neg_dead_limit() const; + uint16_t elevation_pos_normal_limit() const; + uint16_t elevation_neg_normal_limit() const; + uint16_t elevation_encoder_light() const; + uint16_t elevation_gearbox_oil() const; + uint16_t elevation_handwheel() const; + uint16_t elevation_amp_ps() const; + uint16_t azimuth_servo_amp_inhibit() const; + uint16_t azimuth_servo_amp_short_circuit() const; + uint16_t azimuth_servo_amp_overtemp() const; + uint16_t azimuth_motor_overtemp() const; + uint16_t azimuth_stow_pin() const; + uint16_t azimuth_housing_5v_ps() const; + uint16_t azimuth_encoder_light() const; + uint16_t azimuth_gearbox_oil() const; + uint16_t azimuth_bull_gear_oil() const; + uint16_t azimuth_handwheel() const; + uint16_t azimuth_servo_amp_ps() const; + uint16_t servo() const; + uint16_t pedestal_interlock_switch() const; + uint16_t coho_clock() const; + uint16_t rf_generator_frequency_select_oscillator() const; + uint16_t rf_generator_rf_stalo() const; + uint16_t rf_generator_phase_shifted_coho() const; + uint16_t _9v_receiver_ps() const; + uint16_t _5v_receiver_ps() const; + uint16_t _18v_receiver_ps() const; + uint16_t neg_9v_receiver_ps() const; + uint16_t _5v_single_channel_rdaiu_ps() const; + float horizontal_short_pulse_noise() const; + float horizontal_long_pulse_noise() const; + float horizontal_noise_temperature() const; + float vertical_short_pulse_noise() const; + float vertical_long_pulse_noise() const; + float vertical_noise_temperature() const; + float horizontal_linearity() const; + float horizontal_dynamic_range() const; + float horizontal_delta_dbz0() const; + float vertical_delta_dbz0() const; + float kd_peak_measured() const; + float short_pulse_horizontal_dbz0() const; + float long_pulse_horizontal_dbz0() const; + uint16_t velocity_processed() const; + uint16_t width_processed() const; + uint16_t velocity_rf_gen() const; + uint16_t width_rf_gen() const; + float horizontal_i0() const; + float vertical_i0() const; + float vertical_dynamic_range() const; + float short_pulse_vertical_dbz0() const; + float long_pulse_vertical_dbz0() const; + float horizontal_power_sense() const; + float vertical_power_sense() const; + float zdr_bias() const; + float clutter_suppression_delta() const; + float clutter_suppression_unfiltered_power() const; + float clutter_suppression_filtered_power() const; + float vertical_linearity() const; + uint16_t state_file_read_status() const; + uint16_t state_file_write_status() const; + uint16_t bypass_map_file_read_status() const; + uint16_t bypass_map_file_write_status() const; + uint16_t current_adaptation_file_read_status() const; + uint16_t current_adaptation_file_write_status() const; + uint16_t censor_zone_file_read_status() const; + uint16_t censor_zone_file_write_status() const; + uint16_t remote_vcp_file_read_status() const; + uint16_t remote_vcp_file_write_status() const; + uint16_t baseline_adaptation_file_read_status() const; + uint16_t read_status_of_prf_sets() const; + uint16_t clutter_filter_map_file_read_status() const; + uint16_t clutter_filter_map_file_write_status() const; + uint16_t generatl_disk_io_error() const; + uint8_t rsp_status() const; + uint8_t motherboard_temperature() const; + uint8_t cpu1_temperature() const; + uint8_t cpu2_temperature() const; + uint16_t cpu1_fan_speed() const; + uint16_t cpu2_fan_speed() const; + uint16_t rsp_fan1_speed() const; + uint16_t rsp_fan2_speed() const; + uint16_t rsp_fan3_speed() const; + uint16_t spip_comm_status() const; + uint16_t hci_comm_status() const; + uint16_t signal_processor_command_status() const; + uint16_t ame_communication_status() const; + uint16_t rms_link_status() const; + uint16_t rpg_link_status() const; + uint16_t interpanel_link_status() const; + uint32_t performance_check_time() const; + uint16_t version() const; + + bool Parse(std::istream& is); + + static std::unique_ptr + Create(MessageHeader&& header, std::istream& is); + +private: + std::unique_ptr p; +}; + +} // namespace rda +} // namespace wsr88d +} // namespace scwx diff --git a/wxdata/include/scwx/wsr88d/rda/rda_adaptation_data.hpp b/wxdata/include/scwx/wsr88d/rda/rda_adaptation_data.hpp index 05af62a9..074861af 100644 --- a/wxdata/include/scwx/wsr88d/rda/rda_adaptation_data.hpp +++ b/wxdata/include/scwx/wsr88d/rda/rda_adaptation_data.hpp @@ -2,8 +2,6 @@ #include -#include - namespace scwx { namespace wsr88d diff --git a/wxdata/source/scwx/wsr88d/ar2v_file.cpp b/wxdata/source/scwx/wsr88d/ar2v_file.cpp index 8bdcbbbf..a1f772f1 100644 --- a/wxdata/source/scwx/wsr88d/ar2v_file.cpp +++ b/wxdata/source/scwx/wsr88d/ar2v_file.cpp @@ -10,12 +10,6 @@ #include #include -#ifdef WIN32 -# include -#else -# include -#endif - namespace scwx { namespace wsr88d diff --git a/wxdata/source/scwx/wsr88d/rda/clutter_filter_map.cpp b/wxdata/source/scwx/wsr88d/rda/clutter_filter_map.cpp index 1b3bf8c3..4a31f7ef 100644 --- a/wxdata/source/scwx/wsr88d/rda/clutter_filter_map.cpp +++ b/wxdata/source/scwx/wsr88d/rda/clutter_filter_map.cpp @@ -1,16 +1,9 @@ #include -#include #include #include -#ifdef WIN32 -# include -#else -# include -#endif - namespace scwx { namespace wsr88d @@ -205,7 +198,7 @@ bool ClutterFilterMap::Parse(std::istream& is) } } - if (!ValidateSize(is, bytesRead)) + if (!ValidateMessage(is, bytesRead)) { messageValid = false; } diff --git a/wxdata/source/scwx/wsr88d/rda/message.cpp b/wxdata/source/scwx/wsr88d/rda/message.cpp index 3230ea69..4ea4ad9e 100644 --- a/wxdata/source/scwx/wsr88d/rda/message.cpp +++ b/wxdata/source/scwx/wsr88d/rda/message.cpp @@ -1,7 +1,5 @@ #include -#include - #include namespace scwx @@ -28,12 +26,23 @@ Message::~Message() = default; Message::Message(Message&&) noexcept = default; Message& Message::operator=(Message&&) noexcept = default; -bool Message::ValidateSize(std::istream& is, size_t bytesRead) const +bool Message::ValidateMessage(std::istream& is, size_t bytesRead) const { bool messageValid = true; size_t dataSize = header().message_size() * 2 - header().SIZE; - if (bytesRead != dataSize) + if (is.eof()) + { + BOOST_LOG_TRIVIAL(warning) << logPrefix_ << "Reached end of file"; + messageValid = false; + } + else if (is.fail()) + { + BOOST_LOG_TRIVIAL(warning) + << logPrefix_ << "Could not read from input stream"; + messageValid = false; + } + else if (bytesRead != dataSize) { is.seekg(static_cast(dataSize) - static_cast(bytesRead), diff --git a/wxdata/source/scwx/wsr88d/rda/message_factory.cpp b/wxdata/source/scwx/wsr88d/rda/message_factory.cpp index d059799c..715d2f7b 100644 --- a/wxdata/source/scwx/wsr88d/rda/message_factory.cpp +++ b/wxdata/source/scwx/wsr88d/rda/message_factory.cpp @@ -2,9 +2,9 @@ #include #include +#include #include -#include #include #include @@ -23,7 +23,9 @@ typedef std::function(MessageHeader&&, std::istream&)> CreateMessageFunction; static const std::unordered_map create_ { - {15, ClutterFilterMap::Create}, {18, RdaAdaptationData::Create}}; + {3, PerformanceMaintenanceData::Create}, + {15, ClutterFilterMap::Create}, + {18, RdaAdaptationData::Create}}; static std::vector messageData_; static size_t bufferedSize_; diff --git a/wxdata/source/scwx/wsr88d/rda/performance_maintenance_data.cpp b/wxdata/source/scwx/wsr88d/rda/performance_maintenance_data.cpp new file mode 100644 index 00000000..0dd7bfa6 --- /dev/null +++ b/wxdata/source/scwx/wsr88d/rda/performance_maintenance_data.cpp @@ -0,0 +1,2483 @@ +#include + +#include + +#include + +namespace scwx +{ +namespace wsr88d +{ +namespace rda +{ + +static const std::string logPrefix_ = + "[scwx::wsr88d::rda::performance_maintenance_data] "; + +class PerformanceMaintenanceDataImpl +{ +public: + explicit PerformanceMaintenanceDataImpl() : + loopBackSetStatus_ {0}, + t1OutputFrames_ {0}, + t1InputFrames_ {0}, + routerMemoryUsed_ {0}, + routerMemoryFree_ {0}, + routerMemoryUtilization_ {0}, + routeToRpg_ {0}, + csuLossOfSignal_ {0}, + csuLossOfFrames_ {0}, + csuYellowAlarms_ {0}, + csuBlueAlarms_ {0}, + csu24HrErroredSeconds_ {0}, + csu24HrSeverelyErroredSeconds_ {0}, + csu24HrSeverelyErroredFramingSeconds_ {0}, + csu24HrUnavailableSeconds_ {0}, + csu24HrControlledSlipSeconds_ {0}, + csu24HrPathCodingViolations_ {0}, + csu24HrLineErroredSeconds_ {0}, + csu24HrBurstyErroredSeconds_ {0}, + csu24HrDegradedMinutes_ {0}, + lanSwitchCpuUtilization_ {0}, + lanSwitchMemoryUtilization_ {0}, + ifdrChasisTemperature_ {0}, + ifdrFpgaTemperature_ {0}, + gpsSatellites_ {0}, + ipcStatus_ {0}, + commandedChannelControl_ {0}, + polarization_ {0}, + ameInternalTemperature_ {0.0f}, + ameReceiverModuleTemperature_ {0.0f}, + ameBiteCalModuleTemperature_ {0.0f}, + amePeltierPulseWidthModulation_ {0}, + amePeltierStatus_ {0}, + ameADConverterStatus_ {0}, + ameState_ {0}, + ame3_3VPsVoltage_ {0.0f}, + ame5VPsVoltage_ {0.0f}, + ame6_5VPsVoltage_ {0.0f}, + ame15VPsVoltage_ {0.0f}, + ame48VPsVoltage_ {0.0f}, + ameStaloPower_ {0.0f}, + peltierCurrent_ {0.0f}, + adcCalibrationReferenceVoltage_ {0.0f}, + ameMode_ {0}, + amePeltierMode_ {0}, + amePeltierInsideFanCurrent_ {0.0f}, + amePeltierOutsideFanCurrent_ {0.0f}, + horizontalTrLimiterVoltage_ {0.0f}, + verticalTrLimiterVoltage_ {0.0f}, + adcCalibrationOffsetVoltage_ {0.0f}, + adcCalibrationGainCorrection_ {0.0f}, + rcpStatus_ {0}, + rcpString_ {}, + spipPowerButtons_ {0}, + masterPowerAdministratorLoad_ {0.0f}, + expansionPowerAdministratorLoad_ {0.0f}, + _5VdcPs_ {0}, + _15VdcPs_ {0}, + _28VdcPs_ {0}, + neg15VdcPs_ {0}, + _45VdcPs_ {0}, + filamentPsVoltage_ {0}, + vacuumPumpPsVoltage_ {0}, + focusCoilPsVoltage_ {0}, + filamentPs_ {0}, + klystronWarmup_ {0}, + transmitterAvailable_ {0}, + wgSwitchPosition_ {0}, + wgPfnTransferInterlock_ {0}, + maintenanceMode_ {0}, + maintenanceRequired_ {0}, + pfnSwitchPosition_ {0}, + modulatorOverload_ {0}, + modulatorInvCurrent_ {0}, + modulatorSwitchFail_ {0}, + mainPowerVoltage_ {0}, + chargingSystemFail_ {0}, + inverseDiodeCurrent_ {0}, + triggerAmplifier_ {0}, + circulatorTemperature_ {0}, + spectrumFilterPressure_ {0}, + wgArcVswr_ {0}, + cabinetInterlock_ {0}, + cabinetAirTemperature_ {0}, + cabinetAirflow_ {0}, + klystronCurrent_ {0}, + klystronFilamentCurrent_ {0}, + klystronVacionCurrent_ {0}, + klystronAirTemperature_ {0}, + klystronAirflow_ {0}, + modulatorSwitchMaintenance_ {0}, + postChargeRegulatorMaintenance_ {0}, + wgPressureHumidity_ {0}, + transmitterOvervoltage_ {0}, + transmitterOvercurrent_ {0}, + focusCoilCurrent_ {0}, + focusCoilAirflow_ {0}, + oilTemperature_ {0}, + prfLimit_ {0}, + transmitterOilLevel_ {0}, + transmitterBatteryCharging_ {0}, + highVoltageStatus_ {0}, + transmitterRecyclingSummary_ {0}, + transmitterInoperable_ {0}, + transmitterAirFilter_ {0}, + zeroTestBit_ {0}, + oneTestBit_ {0}, + xmtrSpipInterface_ {0}, + transmitterSummaryStatus_ {0}, + transmitterRfPower_ {0.0f}, + horizontalXmtrPeakPower_ {0.0f}, + xmtrPeakPower_ {0.0f}, + verticalXmtrPeakPower_ {0.0f}, + xmtrRfAvgPower_ {0.0f}, + xmtrRecycleCount_ {0}, + receiverBias_ {0.0f}, + transmitImbalance_ {0.0f}, + xmtrPowerMeterZero_ {0.0f}, + acUnit1CompressorShutOff_ {0}, + acUnit2CompressorShutOff_ {0}, + generatorMaintenanceRequired_ {0}, + generatorBatteryVoltage_ {0}, + generatorEngine_ {0}, + generatorVoltFrequency_ {0}, + powerSource_ {0}, + transitionalPowerSource_ {0}, + generatorAutoRunOffSwitch_ {0}, + aircraftHazardLighting_ {0}, + equipmentShelterFireDetectionSystem_ {0}, + equipmentShelterFireSmoke_ {0}, + generatorShelterFireSmoke_ {0}, + utilityVoltageFrequency_ {0}, + siteSecurityAlarm_ {0}, + securityEquipment_ {0}, + securitySystem_ {0}, + receiverConnectedToAntenna_ {0}, + radomeHatch_ {0}, + acUnit1FilterDirty_ {0}, + acUnit2FilterDirty_ {0}, + equipmentShelterTemperature_ {0.0f}, + outsideAmbientTemperature_ {0.0f}, + transmitterLeavingAirTemp_ {0.0f}, + acUnit1DischargeAirTemp_ {0.0f}, + generatorShelterTemperature_ {0.0f}, + radomeAirTemperature_ {0.0f}, + acUnit2DischargeAirTemp_ {0.0f}, + spip15VPs_ {0.0f}, + spipNeg15VPs_ {0.0f}, + spip28VPsStatus_ {0}, + spip5VPs_ {0.0f}, + convertedGeneratorFuelLevel_ {0}, + elevationPosDeadLimit_ {0}, + _150VOvervoltage_ {0}, + _150VUndervoltage_ {0}, + elevationServoAmpInhibit_ {0}, + elevationServoAmpShortCircuit_ {0}, + elevationServoAmpOvertemp_ {0}, + elevationMotorOvertemp_ {0}, + elevationStowPin_ {0}, + elevationHousing5VPs_ {0}, + elevationNegDeadLimit_ {0}, + elevationPosNormalLimit_ {0}, + elevationNegNormalLimit_ {0}, + elevationEncoderLight_ {0}, + elevationGearboxOil_ {0}, + elevationHandwheel_ {0}, + elevationAmpPs_ {0}, + azimuthServoAmpInhibit_ {0}, + azimuthServoAmpShortCircuit_ {0}, + azimuthServoAmpOvertemp_ {0}, + azimuthMotorOvertemp_ {0}, + azimuthStowPin_ {0}, + azimuthHousing5VPs_ {0}, + azimuthEncoderLight_ {0}, + azimuthGearboxOil_ {0}, + azimuthBullGearOil_ {0}, + azimuthHandwheel_ {0}, + azimuthServoAmpPs_ {0}, + servo_ {0}, + pedestalInterlockSwitch_ {0}, + cohoClock_ {0}, + rfGeneratorFrequencySelectOscillator_ {0}, + rfGeneratorRfStalo_ {0}, + rfGeneratorPhaseShiftedCoho_ {0}, + _9VReceiverPs_ {0}, + _5VReceiverPs_ {0}, + _18VReceiverPs_ {0}, + neg9VReceiverPs_ {0}, + _5VSingleChannelRdaiuPs_ {0}, + horizontalShortPulseNoise_ {0.0f}, + horizontalLongPulseNoise_ {0.0f}, + horizontalNoiseTemperature_ {0.0f}, + verticalShortPulseNoise_ {0.0f}, + verticalLongPulseNoise_ {0.0f}, + verticalNoiseTemperature_ {0.0f}, + horizontalLinearity_ {0.0f}, + horizontalDynamicRange_ {0.0f}, + horizontalDeltaDbz0_ {0.0f}, + verticalDeltaDbz0_ {0.0f}, + kdPeakMeasured_ {0.0f}, + shortPulseHorizontalDbz0_ {0.0f}, + longPulseHorizontalDbz0_ {0.0f}, + velocityProcessed_ {0}, + widthProcessed_ {0}, + velocityRfGen_ {0}, + widthRfGen_ {0}, + horizontalI0_ {0.0f}, + verticalI0_ {0.0f}, + verticalDynamicRange_ {0.0f}, + shortPulseVerticalDbz0_ {0.0f}, + longPulseVerticalDbz0_ {0.0f}, + horizontalPowerSense_ {0.0f}, + verticalPowerSense_ {0.0f}, + zdrBias_ {0.0f}, + clutterSuppressionDelta_ {0.0f}, + clutterSuppressionUnfilteredPower_ {0.0f}, + clutterSuppressionFilteredPower_ {0.0f}, + verticalLinearity_ {0.0f}, + stateFileReadStatus_ {0}, + stateFileWriteStatus_ {0}, + bypassMapFileReadStatus_ {0}, + bypassMapFileWriteStatus_ {0}, + currentAdaptationFileReadStatus_ {0}, + currentAdaptationFileWriteStatus_ {0}, + censorZoneFileReadStatus_ {0}, + censorZoneFileWriteStatus_ {0}, + remoteVcpFileReadStatus_ {0}, + remoteVcpFileWriteStatus_ {0}, + baselineAdaptationFileReadStatus_ {0}, + readStatusOfPrfSets_ {0}, + clutterFilterMapFileReadStatus_ {0}, + clutterFilterMapFileWriteStatus_ {0}, + generatlDiskIoError_ {0}, + rspStatus_ {0}, + motherboardTemperature_ {0}, + cpu1Temperature_ {0}, + cpu2Temperature_ {0}, + cpu1FanSpeed_ {0}, + cpu2FanSpeed_ {0}, + rspFan1Speed_ {0}, + rspFan2Speed_ {0}, + rspFan3Speed_ {0}, + spipCommStatus_ {0}, + hciCommStatus_ {0}, + signalProcessorCommandStatus_ {0}, + ameCommunicationStatus_ {0}, + rmsLinkStatus_ {0}, + rpgLinkStatus_ {0}, + interpanelLinkStatus_ {0}, + performanceCheckTime_ {0}, + version_ {0} + { + } + ~PerformanceMaintenanceDataImpl() = default; + + // Communications + uint16_t loopBackSetStatus_; + uint32_t t1OutputFrames_; + uint32_t t1InputFrames_; + uint32_t routerMemoryUsed_; + uint32_t routerMemoryFree_; + uint16_t routerMemoryUtilization_; + uint16_t routeToRpg_; + uint32_t csuLossOfSignal_; + uint32_t csuLossOfFrames_; + uint32_t csuYellowAlarms_; + uint32_t csuBlueAlarms_; + uint32_t csu24HrErroredSeconds_; + uint32_t csu24HrSeverelyErroredSeconds_; + uint32_t csu24HrSeverelyErroredFramingSeconds_; + uint32_t csu24HrUnavailableSeconds_; + uint32_t csu24HrControlledSlipSeconds_; + uint32_t csu24HrPathCodingViolations_; + uint32_t csu24HrLineErroredSeconds_; + uint32_t csu24HrBurstyErroredSeconds_; + uint32_t csu24HrDegradedMinutes_; + uint32_t lanSwitchCpuUtilization_; + uint16_t lanSwitchMemoryUtilization_; + uint16_t ifdrChasisTemperature_; + uint16_t ifdrFpgaTemperature_; + int32_t gpsSatellites_; + uint16_t ipcStatus_; + uint16_t commandedChannelControl_; + + // AME + uint16_t polarization_; + float ameInternalTemperature_; + float ameReceiverModuleTemperature_; + float ameBiteCalModuleTemperature_; + uint16_t amePeltierPulseWidthModulation_; + uint16_t amePeltierStatus_; + uint16_t ameADConverterStatus_; + uint16_t ameState_; + float ame3_3VPsVoltage_; + float ame5VPsVoltage_; + float ame6_5VPsVoltage_; + float ame15VPsVoltage_; + float ame48VPsVoltage_; + float ameStaloPower_; + float peltierCurrent_; + float adcCalibrationReferenceVoltage_; + uint16_t ameMode_; + uint16_t amePeltierMode_; + float amePeltierInsideFanCurrent_; + float amePeltierOutsideFanCurrent_; + float horizontalTrLimiterVoltage_; + float verticalTrLimiterVoltage_; + float adcCalibrationOffsetVoltage_; + float adcCalibrationGainCorrection_; + + // RCP/SPIP Power Button Status + uint16_t rcpStatus_; + std::string rcpString_; + uint16_t spipPowerButtons_; + + // Power + float masterPowerAdministratorLoad_; + float expansionPowerAdministratorLoad_; + + // Transmitter + uint16_t _5VdcPs_; + uint16_t _15VdcPs_; + uint16_t _28VdcPs_; + uint16_t neg15VdcPs_; + uint16_t _45VdcPs_; + uint16_t filamentPsVoltage_; + uint16_t vacuumPumpPsVoltage_; + uint16_t focusCoilPsVoltage_; + uint16_t filamentPs_; + uint16_t klystronWarmup_; + uint16_t transmitterAvailable_; + uint16_t wgSwitchPosition_; + uint16_t wgPfnTransferInterlock_; + uint16_t maintenanceMode_; + uint16_t maintenanceRequired_; + uint16_t pfnSwitchPosition_; + uint16_t modulatorOverload_; + uint16_t modulatorInvCurrent_; + uint16_t modulatorSwitchFail_; + uint16_t mainPowerVoltage_; + uint16_t chargingSystemFail_; + uint16_t inverseDiodeCurrent_; + uint16_t triggerAmplifier_; + uint16_t circulatorTemperature_; + uint16_t spectrumFilterPressure_; + uint16_t wgArcVswr_; + uint16_t cabinetInterlock_; + uint16_t cabinetAirTemperature_; + uint16_t cabinetAirflow_; + uint16_t klystronCurrent_; + uint16_t klystronFilamentCurrent_; + uint16_t klystronVacionCurrent_; + uint16_t klystronAirTemperature_; + uint16_t klystronAirflow_; + uint16_t modulatorSwitchMaintenance_; + uint16_t postChargeRegulatorMaintenance_; + uint16_t wgPressureHumidity_; + uint16_t transmitterOvervoltage_; + uint16_t transmitterOvercurrent_; + uint16_t focusCoilCurrent_; + uint16_t focusCoilAirflow_; + uint16_t oilTemperature_; + uint16_t prfLimit_; + uint16_t transmitterOilLevel_; + uint16_t transmitterBatteryCharging_; + uint16_t highVoltageStatus_; + uint16_t transmitterRecyclingSummary_; + uint16_t transmitterInoperable_; + uint16_t transmitterAirFilter_; + std::array zeroTestBit_; + std::array oneTestBit_; + uint16_t xmtrSpipInterface_; + uint16_t transmitterSummaryStatus_; + float transmitterRfPower_; + float horizontalXmtrPeakPower_; + float xmtrPeakPower_; + float verticalXmtrPeakPower_; + float xmtrRfAvgPower_; + uint32_t xmtrRecycleCount_; + float receiverBias_; + float transmitImbalance_; + float xmtrPowerMeterZero_; + + // Tower/Utilities + uint16_t acUnit1CompressorShutOff_; + uint16_t acUnit2CompressorShutOff_; + uint16_t generatorMaintenanceRequired_; + uint16_t generatorBatteryVoltage_; + uint16_t generatorEngine_; + uint16_t generatorVoltFrequency_; + uint16_t powerSource_; + uint16_t transitionalPowerSource_; + uint16_t generatorAutoRunOffSwitch_; + uint16_t aircraftHazardLighting_; + + // Equipment Shelter + uint16_t equipmentShelterFireDetectionSystem_; + uint16_t equipmentShelterFireSmoke_; + uint16_t generatorShelterFireSmoke_; + uint16_t utilityVoltageFrequency_; + uint16_t siteSecurityAlarm_; + uint16_t securityEquipment_; + uint16_t securitySystem_; + uint16_t receiverConnectedToAntenna_; + uint16_t radomeHatch_; + uint16_t acUnit1FilterDirty_; + uint16_t acUnit2FilterDirty_; + float equipmentShelterTemperature_; + float outsideAmbientTemperature_; + float transmitterLeavingAirTemp_; + float acUnit1DischargeAirTemp_; + float generatorShelterTemperature_; + float radomeAirTemperature_; + float acUnit2DischargeAirTemp_; + float spip15VPs_; + float spipNeg15VPs_; + uint16_t spip28VPsStatus_; + float spip5VPs_; + uint16_t convertedGeneratorFuelLevel_; + + // Antenna/Pedestal + uint16_t elevationPosDeadLimit_; + uint16_t _150VOvervoltage_; + uint16_t _150VUndervoltage_; + uint16_t elevationServoAmpInhibit_; + uint16_t elevationServoAmpShortCircuit_; + uint16_t elevationServoAmpOvertemp_; + uint16_t elevationMotorOvertemp_; + uint16_t elevationStowPin_; + uint16_t elevationHousing5VPs_; + uint16_t elevationNegDeadLimit_; + uint16_t elevationPosNormalLimit_; + uint16_t elevationNegNormalLimit_; + uint16_t elevationEncoderLight_; + uint16_t elevationGearboxOil_; + uint16_t elevationHandwheel_; + uint16_t elevationAmpPs_; + uint16_t azimuthServoAmpInhibit_; + uint16_t azimuthServoAmpShortCircuit_; + uint16_t azimuthServoAmpOvertemp_; + uint16_t azimuthMotorOvertemp_; + uint16_t azimuthStowPin_; + uint16_t azimuthHousing5VPs_; + uint16_t azimuthEncoderLight_; + uint16_t azimuthGearboxOil_; + uint16_t azimuthBullGearOil_; + uint16_t azimuthHandwheel_; + uint16_t azimuthServoAmpPs_; + uint16_t servo_; + uint16_t pedestalInterlockSwitch_; + + // RF Generator/Receiver + uint16_t cohoClock_; + uint16_t rfGeneratorFrequencySelectOscillator_; + uint16_t rfGeneratorRfStalo_; + uint16_t rfGeneratorPhaseShiftedCoho_; + uint16_t _9VReceiverPs_; + uint16_t _5VReceiverPs_; + uint16_t _18VReceiverPs_; + uint16_t neg9VReceiverPs_; + uint16_t _5VSingleChannelRdaiuPs_; + float horizontalShortPulseNoise_; + float horizontalLongPulseNoise_; + float horizontalNoiseTemperature_; + float verticalShortPulseNoise_; + float verticalLongPulseNoise_; + float verticalNoiseTemperature_; + + // Calibration + float horizontalLinearity_; + float horizontalDynamicRange_; + float horizontalDeltaDbz0_; + float verticalDeltaDbz0_; + float kdPeakMeasured_; + float shortPulseHorizontalDbz0_; + float longPulseHorizontalDbz0_; + uint16_t velocityProcessed_; + uint16_t widthProcessed_; + uint16_t velocityRfGen_; + uint16_t widthRfGen_; + float horizontalI0_; + float verticalI0_; + float verticalDynamicRange_; + float shortPulseVerticalDbz0_; + float longPulseVerticalDbz0_; + float horizontalPowerSense_; + float verticalPowerSense_; + float zdrBias_; + float clutterSuppressionDelta_; + float clutterSuppressionUnfilteredPower_; + float clutterSuppressionFilteredPower_; + float verticalLinearity_; + + // File Status + uint16_t stateFileReadStatus_; + uint16_t stateFileWriteStatus_; + uint16_t bypassMapFileReadStatus_; + uint16_t bypassMapFileWriteStatus_; + uint16_t currentAdaptationFileReadStatus_; + uint16_t currentAdaptationFileWriteStatus_; + uint16_t censorZoneFileReadStatus_; + uint16_t censorZoneFileWriteStatus_; + uint16_t remoteVcpFileReadStatus_; + uint16_t remoteVcpFileWriteStatus_; + uint16_t baselineAdaptationFileReadStatus_; + uint16_t readStatusOfPrfSets_; + uint16_t clutterFilterMapFileReadStatus_; + uint16_t clutterFilterMapFileWriteStatus_; + uint16_t generatlDiskIoError_; + uint8_t rspStatus_; + uint8_t motherboardTemperature_; + uint8_t cpu1Temperature_; + uint8_t cpu2Temperature_; + uint16_t cpu1FanSpeed_; + uint16_t cpu2FanSpeed_; + uint16_t rspFan1Speed_; + uint16_t rspFan2Speed_; + uint16_t rspFan3Speed_; + + // Device Status + uint16_t spipCommStatus_; + uint16_t hciCommStatus_; + uint16_t signalProcessorCommandStatus_; + uint16_t ameCommunicationStatus_; + uint16_t rmsLinkStatus_; + uint16_t rpgLinkStatus_; + uint16_t interpanelLinkStatus_; + uint32_t performanceCheckTime_; + uint16_t version_; +}; + +PerformanceMaintenanceData::PerformanceMaintenanceData() : + Message(), p(std::make_unique()) +{ +} +PerformanceMaintenanceData::~PerformanceMaintenanceData() = default; + +PerformanceMaintenanceData::PerformanceMaintenanceData( + PerformanceMaintenanceData&&) noexcept = default; +PerformanceMaintenanceData& PerformanceMaintenanceData::operator=( + PerformanceMaintenanceData&&) noexcept = default; + +uint16_t PerformanceMaintenanceData::loop_back_set_status() const +{ + return p->loopBackSetStatus_; +} + +uint32_t PerformanceMaintenanceData::t1_output_frames() const +{ + return p->t1OutputFrames_; +} + +uint32_t PerformanceMaintenanceData::t1_input_frames() const +{ + return p->t1InputFrames_; +} + +uint32_t PerformanceMaintenanceData::router_memory_used() const +{ + return p->routerMemoryUsed_; +} + +uint32_t PerformanceMaintenanceData::router_memory_free() const +{ + return p->routerMemoryFree_; +} + +uint16_t PerformanceMaintenanceData::router_memory_utilization() const +{ + return p->routerMemoryUtilization_; +} + +uint16_t PerformanceMaintenanceData::route_to_rpg() const +{ + return p->routeToRpg_; +} + +uint32_t PerformanceMaintenanceData::csu_loss_of_signal() const +{ + return p->csuLossOfSignal_; +} + +uint32_t PerformanceMaintenanceData::csu_loss_of_frames() const +{ + return p->csuLossOfFrames_; +} + +uint32_t PerformanceMaintenanceData::csu_yellow_alarms() const +{ + return p->csuYellowAlarms_; +} + +uint32_t PerformanceMaintenanceData::csu_blue_alarms() const +{ + return p->csuBlueAlarms_; +} + +uint32_t PerformanceMaintenanceData::csu_24hr_errored_seconds() const +{ + return p->csu24HrErroredSeconds_; +} + +uint32_t PerformanceMaintenanceData::csu_24hr_severely_errored_seconds() const +{ + return p->csu24HrSeverelyErroredSeconds_; +} + +uint32_t +PerformanceMaintenanceData::csu_24hr_severely_errored_framing_seconds() const +{ + return p->csu24HrSeverelyErroredFramingSeconds_; +} + +uint32_t PerformanceMaintenanceData::csu_24hr_unavailable_seconds() const +{ + return p->csu24HrUnavailableSeconds_; +} + +uint32_t PerformanceMaintenanceData::csu_24hr_controlled_slip_seconds() const +{ + return p->csu24HrControlledSlipSeconds_; +} + +uint32_t PerformanceMaintenanceData::csu_24hr_path_coding_violations() const +{ + return p->csu24HrPathCodingViolations_; +} + +uint32_t PerformanceMaintenanceData::csu_24hr_line_errored_seconds() const +{ + return p->csu24HrLineErroredSeconds_; +} + +uint32_t PerformanceMaintenanceData::csu_24hr_bursty_errored_seconds() const +{ + return p->csu24HrBurstyErroredSeconds_; +} + +uint32_t PerformanceMaintenanceData::csu_24hr_degraded_minutes() const +{ + return p->csu24HrDegradedMinutes_; +} + +uint32_t PerformanceMaintenanceData::lan_switch_cpu_utilization() const +{ + return p->lanSwitchCpuUtilization_; +} + +uint16_t PerformanceMaintenanceData::lan_switch_memory_utilization() const +{ + return p->lanSwitchMemoryUtilization_; +} + +uint16_t PerformanceMaintenanceData::ifdr_chasis_temperature() const +{ + return p->ifdrChasisTemperature_; +} + +uint16_t PerformanceMaintenanceData::ifdr_fpga_temperature() const +{ + return p->ifdrFpgaTemperature_; +} + +int32_t PerformanceMaintenanceData::gps_satellites() const +{ + return p->gpsSatellites_; +} + +uint16_t PerformanceMaintenanceData::ipc_status() const +{ + return p->ipcStatus_; +} + +uint16_t PerformanceMaintenanceData::commanded_channel_control() const +{ + return p->commandedChannelControl_; +} + +uint16_t PerformanceMaintenanceData::polarization() const +{ + return p->polarization_; +} + +float PerformanceMaintenanceData::ame_internal_temperature() const +{ + return p->ameInternalTemperature_; +} + +float PerformanceMaintenanceData::ame_receiver_module_temperature() const +{ + return p->ameReceiverModuleTemperature_; +} + +float PerformanceMaintenanceData::ame_bite_cal_module_temperature() const +{ + return p->ameBiteCalModuleTemperature_; +} + +uint16_t PerformanceMaintenanceData::ame_peltier_pulse_width_modulation() const +{ + return p->amePeltierPulseWidthModulation_; +} + +uint16_t PerformanceMaintenanceData::ame_peltier_status() const +{ + return p->amePeltierStatus_; +} + +uint16_t PerformanceMaintenanceData::ame_a_d_converter_status() const +{ + return p->ameADConverterStatus_; +} + +uint16_t PerformanceMaintenanceData::ame_state() const +{ + return p->ameState_; +} + +float PerformanceMaintenanceData::ame_3_3v_ps_voltage() const +{ + return p->ame3_3VPsVoltage_; +} + +float PerformanceMaintenanceData::ame_5v_ps_voltage() const +{ + return p->ame5VPsVoltage_; +} + +float PerformanceMaintenanceData::ame_6_5v_ps_voltage() const +{ + return p->ame6_5VPsVoltage_; +} + +float PerformanceMaintenanceData::ame_15v_ps_voltage() const +{ + return p->ame15VPsVoltage_; +} + +float PerformanceMaintenanceData::ame_48v_ps_voltage() const +{ + return p->ame48VPsVoltage_; +} + +float PerformanceMaintenanceData::ame_stalo_power() const +{ + return p->ameStaloPower_; +} + +float PerformanceMaintenanceData::peltier_current() const +{ + return p->peltierCurrent_; +} + +float PerformanceMaintenanceData::adc_calibration_reference_voltage() const +{ + return p->adcCalibrationReferenceVoltage_; +} + +uint16_t PerformanceMaintenanceData::ame_mode() const +{ + return p->ameMode_; +} + +uint16_t PerformanceMaintenanceData::ame_peltier_mode() const +{ + return p->amePeltierMode_; +} + +float PerformanceMaintenanceData::ame_peltier_inside_fan_current() const +{ + return p->amePeltierInsideFanCurrent_; +} + +float PerformanceMaintenanceData::ame_peltier_outside_fan_current() const +{ + return p->amePeltierOutsideFanCurrent_; +} + +float PerformanceMaintenanceData::horizontal_tr_limiter_voltage() const +{ + return p->horizontalTrLimiterVoltage_; +} + +float PerformanceMaintenanceData::vertical_tr_limiter_voltage() const +{ + return p->verticalTrLimiterVoltage_; +} + +float PerformanceMaintenanceData::adc_calibration_offset_voltage() const +{ + return p->adcCalibrationOffsetVoltage_; +} + +float PerformanceMaintenanceData::adc_calibration_gain_correction() const +{ + return p->adcCalibrationGainCorrection_; +} + +uint16_t PerformanceMaintenanceData::rcp_status() const +{ + return p->rcpStatus_; +} + +const std::string& PerformanceMaintenanceData::rcp_string() const +{ + return p->rcpString_; +} + +uint16_t PerformanceMaintenanceData::spip_power_buttons() const +{ + return p->spipPowerButtons_; +} + +float PerformanceMaintenanceData::master_power_administrator_load() const +{ + return p->masterPowerAdministratorLoad_; +} + +float PerformanceMaintenanceData::expansion_power_administrator_load() const +{ + return p->expansionPowerAdministratorLoad_; +} + +uint16_t PerformanceMaintenanceData::_5vdc_ps() const +{ + return p->_5VdcPs_; +} + +uint16_t PerformanceMaintenanceData::_15vdc_ps() const +{ + return p->_15VdcPs_; +} + +uint16_t PerformanceMaintenanceData::_28vdc_ps() const +{ + return p->_28VdcPs_; +} + +uint16_t PerformanceMaintenanceData::neg_15vdc_ps() const +{ + return p->neg15VdcPs_; +} + +uint16_t PerformanceMaintenanceData::_45vdc_ps() const +{ + return p->_45VdcPs_; +} + +uint16_t PerformanceMaintenanceData::filament_ps_voltage() const +{ + return p->filamentPsVoltage_; +} + +uint16_t PerformanceMaintenanceData::vacuum_pump_ps_voltage() const +{ + return p->vacuumPumpPsVoltage_; +} + +uint16_t PerformanceMaintenanceData::focus_coil_ps_voltage() const +{ + return p->focusCoilPsVoltage_; +} + +uint16_t PerformanceMaintenanceData::filament_ps() const +{ + return p->filamentPs_; +} + +uint16_t PerformanceMaintenanceData::klystron_warmup() const +{ + return p->klystronWarmup_; +} + +uint16_t PerformanceMaintenanceData::transmitter_available() const +{ + return p->transmitterAvailable_; +} + +uint16_t PerformanceMaintenanceData::wg_switch_position() const +{ + return p->wgSwitchPosition_; +} + +uint16_t PerformanceMaintenanceData::wg_pfn_transfer_interlock() const +{ + return p->wgPfnTransferInterlock_; +} + +uint16_t PerformanceMaintenanceData::maintenance_mode() const +{ + return p->maintenanceMode_; +} + +uint16_t PerformanceMaintenanceData::maintenance_required() const +{ + return p->maintenanceRequired_; +} + +uint16_t PerformanceMaintenanceData::pfn_switch_position() const +{ + return p->pfnSwitchPosition_; +} + +uint16_t PerformanceMaintenanceData::modulator_overload() const +{ + return p->modulatorOverload_; +} + +uint16_t PerformanceMaintenanceData::modulator_inv_current() const +{ + return p->modulatorInvCurrent_; +} + +uint16_t PerformanceMaintenanceData::modulator_switch_fail() const +{ + return p->modulatorSwitchFail_; +} + +uint16_t PerformanceMaintenanceData::main_power_voltage() const +{ + return p->mainPowerVoltage_; +} + +uint16_t PerformanceMaintenanceData::charging_system_fail() const +{ + return p->chargingSystemFail_; +} + +uint16_t PerformanceMaintenanceData::inverse_diode_current() const +{ + return p->inverseDiodeCurrent_; +} + +uint16_t PerformanceMaintenanceData::trigger_amplifier() const +{ + return p->triggerAmplifier_; +} + +uint16_t PerformanceMaintenanceData::circulator_temperature() const +{ + return p->circulatorTemperature_; +} + +uint16_t PerformanceMaintenanceData::spectrum_filter_pressure() const +{ + return p->spectrumFilterPressure_; +} + +uint16_t PerformanceMaintenanceData::wg_arc_vswr() const +{ + return p->wgArcVswr_; +} + +uint16_t PerformanceMaintenanceData::cabinet_interlock() const +{ + return p->cabinetInterlock_; +} + +uint16_t PerformanceMaintenanceData::cabinet_air_temperature() const +{ + return p->cabinetAirTemperature_; +} + +uint16_t PerformanceMaintenanceData::cabinet_airflow() const +{ + return p->cabinetAirflow_; +} + +uint16_t PerformanceMaintenanceData::klystron_current() const +{ + return p->klystronCurrent_; +} + +uint16_t PerformanceMaintenanceData::klystron_filament_current() const +{ + return p->klystronFilamentCurrent_; +} + +uint16_t PerformanceMaintenanceData::klystron_vacion_current() const +{ + return p->klystronVacionCurrent_; +} + +uint16_t PerformanceMaintenanceData::klystron_air_temperature() const +{ + return p->klystronAirTemperature_; +} + +uint16_t PerformanceMaintenanceData::klystron_airflow() const +{ + return p->klystronAirflow_; +} + +uint16_t PerformanceMaintenanceData::modulator_switch_maintenance() const +{ + return p->modulatorSwitchMaintenance_; +} + +uint16_t PerformanceMaintenanceData::post_charge_regulator_maintenance() const +{ + return p->postChargeRegulatorMaintenance_; +} + +uint16_t PerformanceMaintenanceData::wg_pressure_humidity() const +{ + return p->wgPressureHumidity_; +} + +uint16_t PerformanceMaintenanceData::transmitter_overvoltage() const +{ + return p->transmitterOvervoltage_; +} + +uint16_t PerformanceMaintenanceData::transmitter_overcurrent() const +{ + return p->transmitterOvercurrent_; +} + +uint16_t PerformanceMaintenanceData::focus_coil_current() const +{ + return p->focusCoilCurrent_; +} + +uint16_t PerformanceMaintenanceData::focus_coil_airflow() const +{ + return p->focusCoilAirflow_; +} + +uint16_t PerformanceMaintenanceData::oil_temperature() const +{ + return p->oilTemperature_; +} + +uint16_t PerformanceMaintenanceData::prf_limit() const +{ + return p->prfLimit_; +} + +uint16_t PerformanceMaintenanceData::transmitter_oil_level() const +{ + return p->transmitterOilLevel_; +} + +uint16_t PerformanceMaintenanceData::transmitter_battery_charging() const +{ + return p->transmitterBatteryCharging_; +} + +uint16_t PerformanceMaintenanceData::high_voltage_status() const +{ + return p->highVoltageStatus_; +} + +uint16_t PerformanceMaintenanceData::transmitter_recycling_summary() const +{ + return p->transmitterRecyclingSummary_; +} + +uint16_t PerformanceMaintenanceData::transmitter_inoperable() const +{ + return p->transmitterInoperable_; +} + +uint16_t PerformanceMaintenanceData::transmitter_air_filter() const +{ + return p->transmitterAirFilter_; +} + +uint16_t PerformanceMaintenanceData::zero_test_bit(unsigned i) const +{ + return p->zeroTestBit_[i]; +} + +uint16_t PerformanceMaintenanceData::one_test_bit(unsigned i) const +{ + return p->oneTestBit_[i]; +} + +uint16_t PerformanceMaintenanceData::xmtr_spip_interface() const +{ + return p->xmtrSpipInterface_; +} + +uint16_t PerformanceMaintenanceData::transmitter_summary_status() const +{ + return p->transmitterSummaryStatus_; +} + +float PerformanceMaintenanceData::transmitter_rf_power() const +{ + return p->transmitterRfPower_; +} + +float PerformanceMaintenanceData::horizontal_xmtr_peak_power() const +{ + return p->horizontalXmtrPeakPower_; +} + +float PerformanceMaintenanceData::xmtr_peak_power() const +{ + return p->xmtrPeakPower_; +} + +float PerformanceMaintenanceData::vertical_xmtr_peak_power() const +{ + return p->verticalXmtrPeakPower_; +} + +float PerformanceMaintenanceData::xmtr_rf_avg_power() const +{ + return p->xmtrRfAvgPower_; +} + +uint32_t PerformanceMaintenanceData::xmtr_recycle_count() const +{ + return p->xmtrRecycleCount_; +} + +float PerformanceMaintenanceData::receiver_bias() const +{ + return p->receiverBias_; +} + +float PerformanceMaintenanceData::transmit_imbalance() const +{ + return p->transmitImbalance_; +} + +float PerformanceMaintenanceData::xmtr_power_meter_zero() const +{ + return p->xmtrPowerMeterZero_; +} + +uint16_t PerformanceMaintenanceData::ac_unit1_compressor_shut_off() const +{ + return p->acUnit1CompressorShutOff_; +} + +uint16_t PerformanceMaintenanceData::ac_unit2_compressor_shut_off() const +{ + return p->acUnit2CompressorShutOff_; +} + +uint16_t PerformanceMaintenanceData::generator_maintenance_required() const +{ + return p->generatorMaintenanceRequired_; +} + +uint16_t PerformanceMaintenanceData::generator_battery_voltage() const +{ + return p->generatorBatteryVoltage_; +} + +uint16_t PerformanceMaintenanceData::generator_engine() const +{ + return p->generatorEngine_; +} + +uint16_t PerformanceMaintenanceData::generator_volt_frequency() const +{ + return p->generatorVoltFrequency_; +} + +uint16_t PerformanceMaintenanceData::power_source() const +{ + return p->powerSource_; +} + +uint16_t PerformanceMaintenanceData::transitional_power_source() const +{ + return p->transitionalPowerSource_; +} + +uint16_t PerformanceMaintenanceData::generator_auto_run_off_switch() const +{ + return p->generatorAutoRunOffSwitch_; +} + +uint16_t PerformanceMaintenanceData::aircraft_hazard_lighting() const +{ + return p->aircraftHazardLighting_; +} + +uint16_t +PerformanceMaintenanceData::equipment_shelter_fire_detection_system() const +{ + return p->equipmentShelterFireDetectionSystem_; +} + +uint16_t PerformanceMaintenanceData::equipment_shelter_fire_smoke() const +{ + return p->equipmentShelterFireSmoke_; +} + +uint16_t PerformanceMaintenanceData::generator_shelter_fire_smoke() const +{ + return p->generatorShelterFireSmoke_; +} + +uint16_t PerformanceMaintenanceData::utility_voltage_frequency() const +{ + return p->utilityVoltageFrequency_; +} + +uint16_t PerformanceMaintenanceData::site_security_alarm() const +{ + return p->siteSecurityAlarm_; +} + +uint16_t PerformanceMaintenanceData::security_equipment() const +{ + return p->securityEquipment_; +} + +uint16_t PerformanceMaintenanceData::security_system() const +{ + return p->securitySystem_; +} + +uint16_t PerformanceMaintenanceData::receiver_connected_to_antenna() const +{ + return p->receiverConnectedToAntenna_; +} + +uint16_t PerformanceMaintenanceData::radome_hatch() const +{ + return p->radomeHatch_; +} + +uint16_t PerformanceMaintenanceData::ac_unit1_filter_dirty() const +{ + return p->acUnit1FilterDirty_; +} + +uint16_t PerformanceMaintenanceData::ac_unit2_filter_dirty() const +{ + return p->acUnit2FilterDirty_; +} + +float PerformanceMaintenanceData::equipment_shelter_temperature() const +{ + return p->equipmentShelterTemperature_; +} + +float PerformanceMaintenanceData::outside_ambient_temperature() const +{ + return p->outsideAmbientTemperature_; +} + +float PerformanceMaintenanceData::transmitter_leaving_air_temp() const +{ + return p->transmitterLeavingAirTemp_; +} + +float PerformanceMaintenanceData::ac_unit1_discharge_air_temp() const +{ + return p->acUnit1DischargeAirTemp_; +} + +float PerformanceMaintenanceData::generator_shelter_temperature() const +{ + return p->generatorShelterTemperature_; +} + +float PerformanceMaintenanceData::radome_air_temperature() const +{ + return p->radomeAirTemperature_; +} + +float PerformanceMaintenanceData::ac_unit2_discharge_air_temp() const +{ + return p->acUnit2DischargeAirTemp_; +} + +float PerformanceMaintenanceData::spip_15v_ps() const +{ + return p->spip15VPs_; +} + +float PerformanceMaintenanceData::spip_neg_15v_ps() const +{ + return p->spipNeg15VPs_; +} + +uint16_t PerformanceMaintenanceData::spip_28v_ps_status() const +{ + return p->spip28VPsStatus_; +} + +float PerformanceMaintenanceData::spip_5v_ps() const +{ + return p->spip5VPs_; +} + +uint16_t PerformanceMaintenanceData::converted_generator_fuel_level() const +{ + return p->convertedGeneratorFuelLevel_; +} + +uint16_t PerformanceMaintenanceData::elevation_pos_dead_limit() const +{ + return p->elevationPosDeadLimit_; +} + +uint16_t PerformanceMaintenanceData::_150v_overvoltage() const +{ + return p->_150VOvervoltage_; +} + +uint16_t PerformanceMaintenanceData::_150v_undervoltage() const +{ + return p->_150VUndervoltage_; +} + +uint16_t PerformanceMaintenanceData::elevation_servo_amp_inhibit() const +{ + return p->elevationServoAmpInhibit_; +} + +uint16_t PerformanceMaintenanceData::elevation_servo_amp_short_circuit() const +{ + return p->elevationServoAmpShortCircuit_; +} + +uint16_t PerformanceMaintenanceData::elevation_servo_amp_overtemp() const +{ + return p->elevationServoAmpOvertemp_; +} + +uint16_t PerformanceMaintenanceData::elevation_motor_overtemp() const +{ + return p->elevationMotorOvertemp_; +} + +uint16_t PerformanceMaintenanceData::elevation_stow_pin() const +{ + return p->elevationStowPin_; +} + +uint16_t PerformanceMaintenanceData::elevation_housing_5v_ps() const +{ + return p->elevationHousing5VPs_; +} + +uint16_t PerformanceMaintenanceData::elevation_neg_dead_limit() const +{ + return p->elevationNegDeadLimit_; +} + +uint16_t PerformanceMaintenanceData::elevation_pos_normal_limit() const +{ + return p->elevationPosNormalLimit_; +} + +uint16_t PerformanceMaintenanceData::elevation_neg_normal_limit() const +{ + return p->elevationNegNormalLimit_; +} + +uint16_t PerformanceMaintenanceData::elevation_encoder_light() const +{ + return p->elevationEncoderLight_; +} + +uint16_t PerformanceMaintenanceData::elevation_gearbox_oil() const +{ + return p->elevationGearboxOil_; +} + +uint16_t PerformanceMaintenanceData::elevation_handwheel() const +{ + return p->elevationHandwheel_; +} + +uint16_t PerformanceMaintenanceData::elevation_amp_ps() const +{ + return p->elevationAmpPs_; +} + +uint16_t PerformanceMaintenanceData::azimuth_servo_amp_inhibit() const +{ + return p->azimuthServoAmpInhibit_; +} + +uint16_t PerformanceMaintenanceData::azimuth_servo_amp_short_circuit() const +{ + return p->azimuthServoAmpShortCircuit_; +} + +uint16_t PerformanceMaintenanceData::azimuth_servo_amp_overtemp() const +{ + return p->azimuthServoAmpOvertemp_; +} + +uint16_t PerformanceMaintenanceData::azimuth_motor_overtemp() const +{ + return p->azimuthMotorOvertemp_; +} + +uint16_t PerformanceMaintenanceData::azimuth_stow_pin() const +{ + return p->azimuthStowPin_; +} + +uint16_t PerformanceMaintenanceData::azimuth_housing_5v_ps() const +{ + return p->azimuthHousing5VPs_; +} + +uint16_t PerformanceMaintenanceData::azimuth_encoder_light() const +{ + return p->azimuthEncoderLight_; +} + +uint16_t PerformanceMaintenanceData::azimuth_gearbox_oil() const +{ + return p->azimuthGearboxOil_; +} + +uint16_t PerformanceMaintenanceData::azimuth_bull_gear_oil() const +{ + return p->azimuthBullGearOil_; +} + +uint16_t PerformanceMaintenanceData::azimuth_handwheel() const +{ + return p->azimuthHandwheel_; +} + +uint16_t PerformanceMaintenanceData::azimuth_servo_amp_ps() const +{ + return p->azimuthServoAmpPs_; +} + +uint16_t PerformanceMaintenanceData::servo() const +{ + return p->servo_; +} + +uint16_t PerformanceMaintenanceData::pedestal_interlock_switch() const +{ + return p->pedestalInterlockSwitch_; +} + +uint16_t PerformanceMaintenanceData::coho_clock() const +{ + return p->cohoClock_; +} + +uint16_t +PerformanceMaintenanceData::rf_generator_frequency_select_oscillator() const +{ + return p->rfGeneratorFrequencySelectOscillator_; +} + +uint16_t PerformanceMaintenanceData::rf_generator_rf_stalo() const +{ + return p->rfGeneratorRfStalo_; +} + +uint16_t PerformanceMaintenanceData::rf_generator_phase_shifted_coho() const +{ + return p->rfGeneratorPhaseShiftedCoho_; +} + +uint16_t PerformanceMaintenanceData::_9v_receiver_ps() const +{ + return p->_9VReceiverPs_; +} + +uint16_t PerformanceMaintenanceData::_5v_receiver_ps() const +{ + return p->_5VReceiverPs_; +} + +uint16_t PerformanceMaintenanceData::_18v_receiver_ps() const +{ + return p->_18VReceiverPs_; +} + +uint16_t PerformanceMaintenanceData::neg_9v_receiver_ps() const +{ + return p->neg9VReceiverPs_; +} + +uint16_t PerformanceMaintenanceData::_5v_single_channel_rdaiu_ps() const +{ + return p->_5VSingleChannelRdaiuPs_; +} + +float PerformanceMaintenanceData::horizontal_short_pulse_noise() const +{ + return p->horizontalShortPulseNoise_; +} + +float PerformanceMaintenanceData::horizontal_long_pulse_noise() const +{ + return p->horizontalLongPulseNoise_; +} + +float PerformanceMaintenanceData::horizontal_noise_temperature() const +{ + return p->horizontalNoiseTemperature_; +} + +float PerformanceMaintenanceData::vertical_short_pulse_noise() const +{ + return p->verticalShortPulseNoise_; +} + +float PerformanceMaintenanceData::vertical_long_pulse_noise() const +{ + return p->verticalLongPulseNoise_; +} + +float PerformanceMaintenanceData::vertical_noise_temperature() const +{ + return p->verticalNoiseTemperature_; +} + +float PerformanceMaintenanceData::horizontal_linearity() const +{ + return p->horizontalLinearity_; +} + +float PerformanceMaintenanceData::horizontal_dynamic_range() const +{ + return p->horizontalDynamicRange_; +} + +float PerformanceMaintenanceData::horizontal_delta_dbz0() const +{ + return p->horizontalDeltaDbz0_; +} + +float PerformanceMaintenanceData::vertical_delta_dbz0() const +{ + return p->verticalDeltaDbz0_; +} + +float PerformanceMaintenanceData::kd_peak_measured() const +{ + return p->kdPeakMeasured_; +} + +float PerformanceMaintenanceData::short_pulse_horizontal_dbz0() const +{ + return p->shortPulseHorizontalDbz0_; +} + +float PerformanceMaintenanceData::long_pulse_horizontal_dbz0() const +{ + return p->longPulseHorizontalDbz0_; +} + +uint16_t PerformanceMaintenanceData::velocity_processed() const +{ + return p->velocityProcessed_; +} + +uint16_t PerformanceMaintenanceData::width_processed() const +{ + return p->widthProcessed_; +} + +uint16_t PerformanceMaintenanceData::velocity_rf_gen() const +{ + return p->velocityRfGen_; +} + +uint16_t PerformanceMaintenanceData::width_rf_gen() const +{ + return p->widthRfGen_; +} + +float PerformanceMaintenanceData::horizontal_i0() const +{ + return p->horizontalI0_; +} + +float PerformanceMaintenanceData::vertical_i0() const +{ + return p->verticalI0_; +} + +float PerformanceMaintenanceData::vertical_dynamic_range() const +{ + return p->verticalDynamicRange_; +} + +float PerformanceMaintenanceData::short_pulse_vertical_dbz0() const +{ + return p->shortPulseVerticalDbz0_; +} + +float PerformanceMaintenanceData::long_pulse_vertical_dbz0() const +{ + return p->longPulseVerticalDbz0_; +} + +float PerformanceMaintenanceData::horizontal_power_sense() const +{ + return p->horizontalPowerSense_; +} + +float PerformanceMaintenanceData::vertical_power_sense() const +{ + return p->verticalPowerSense_; +} + +float PerformanceMaintenanceData::zdr_bias() const +{ + return p->zdrBias_; +} + +float PerformanceMaintenanceData::clutter_suppression_delta() const +{ + return p->clutterSuppressionDelta_; +} + +float PerformanceMaintenanceData::clutter_suppression_unfiltered_power() const +{ + return p->clutterSuppressionUnfilteredPower_; +} + +float PerformanceMaintenanceData::clutter_suppression_filtered_power() const +{ + return p->clutterSuppressionFilteredPower_; +} + +float PerformanceMaintenanceData::vertical_linearity() const +{ + return p->verticalLinearity_; +} + +uint16_t PerformanceMaintenanceData::state_file_read_status() const +{ + return p->stateFileReadStatus_; +} + +uint16_t PerformanceMaintenanceData::state_file_write_status() const +{ + return p->stateFileWriteStatus_; +} + +uint16_t PerformanceMaintenanceData::bypass_map_file_read_status() const +{ + return p->bypassMapFileReadStatus_; +} + +uint16_t PerformanceMaintenanceData::bypass_map_file_write_status() const +{ + return p->bypassMapFileWriteStatus_; +} + +uint16_t PerformanceMaintenanceData::current_adaptation_file_read_status() const +{ + return p->currentAdaptationFileReadStatus_; +} + +uint16_t +PerformanceMaintenanceData::current_adaptation_file_write_status() const +{ + return p->currentAdaptationFileWriteStatus_; +} + +uint16_t PerformanceMaintenanceData::censor_zone_file_read_status() const +{ + return p->censorZoneFileReadStatus_; +} + +uint16_t PerformanceMaintenanceData::censor_zone_file_write_status() const +{ + return p->censorZoneFileWriteStatus_; +} + +uint16_t PerformanceMaintenanceData::remote_vcp_file_read_status() const +{ + return p->remoteVcpFileReadStatus_; +} + +uint16_t PerformanceMaintenanceData::remote_vcp_file_write_status() const +{ + return p->remoteVcpFileWriteStatus_; +} + +uint16_t +PerformanceMaintenanceData::baseline_adaptation_file_read_status() const +{ + return p->baselineAdaptationFileReadStatus_; +} + +uint16_t PerformanceMaintenanceData::read_status_of_prf_sets() const +{ + return p->readStatusOfPrfSets_; +} + +uint16_t PerformanceMaintenanceData::clutter_filter_map_file_read_status() const +{ + return p->clutterFilterMapFileReadStatus_; +} + +uint16_t +PerformanceMaintenanceData::clutter_filter_map_file_write_status() const +{ + return p->clutterFilterMapFileWriteStatus_; +} + +uint16_t PerformanceMaintenanceData::generatl_disk_io_error() const +{ + return p->generatlDiskIoError_; +} + +uint8_t PerformanceMaintenanceData::rsp_status() const +{ + return p->rspStatus_; +} + +uint8_t PerformanceMaintenanceData::motherboard_temperature() const +{ + return p->motherboardTemperature_; +} + +uint8_t PerformanceMaintenanceData::cpu1_temperature() const +{ + return p->cpu1Temperature_; +} + +uint8_t PerformanceMaintenanceData::cpu2_temperature() const +{ + return p->cpu2Temperature_; +} + +uint16_t PerformanceMaintenanceData::cpu1_fan_speed() const +{ + return p->cpu1FanSpeed_; +} + +uint16_t PerformanceMaintenanceData::cpu2_fan_speed() const +{ + return p->cpu2FanSpeed_; +} + +uint16_t PerformanceMaintenanceData::rsp_fan1_speed() const +{ + return p->rspFan1Speed_; +} + +uint16_t PerformanceMaintenanceData::rsp_fan2_speed() const +{ + return p->rspFan2Speed_; +} + +uint16_t PerformanceMaintenanceData::rsp_fan3_speed() const +{ + return p->rspFan3Speed_; +} + +uint16_t PerformanceMaintenanceData::spip_comm_status() const +{ + return p->spipCommStatus_; +} + +uint16_t PerformanceMaintenanceData::hci_comm_status() const +{ + return p->hciCommStatus_; +} + +uint16_t PerformanceMaintenanceData::signal_processor_command_status() const +{ + return p->signalProcessorCommandStatus_; +} + +uint16_t PerformanceMaintenanceData::ame_communication_status() const +{ + return p->ameCommunicationStatus_; +} + +uint16_t PerformanceMaintenanceData::rms_link_status() const +{ + return p->rmsLinkStatus_; +} + +uint16_t PerformanceMaintenanceData::rpg_link_status() const +{ + return p->rpgLinkStatus_; +} + +uint16_t PerformanceMaintenanceData::interpanel_link_status() const +{ + return p->interpanelLinkStatus_; +} + +uint32_t PerformanceMaintenanceData::performance_check_time() const +{ + return p->performanceCheckTime_; +} + +uint16_t PerformanceMaintenanceData::version() const +{ + return p->version_; +} + +bool PerformanceMaintenanceData::Parse(std::istream& is) +{ + BOOST_LOG_TRIVIAL(debug) + << logPrefix_ << "Parsing Performance/Maintenance Data (Message Type 3)"; + + bool messageValid = true; + size_t bytesRead = 0; + + p->rcpString_.resize(16); + + // Communications + is.seekg(2, std::ios_base::cur); // 1 + is.read(reinterpret_cast(&p->loopBackSetStatus_), 2); // 2 + is.read(reinterpret_cast(&p->t1OutputFrames_), 4); // 3-4 + is.read(reinterpret_cast(&p->t1InputFrames_), 4); // 5-6 + is.read(reinterpret_cast(&p->routerMemoryUsed_), 4); // 7-8 + is.read(reinterpret_cast(&p->routerMemoryFree_), 4); // 9-10 + is.read(reinterpret_cast(&p->routerMemoryUtilization_), 2); // 11 + is.read(reinterpret_cast(&p->routeToRpg_), 2); // 12 + is.read(reinterpret_cast(&p->csuLossOfSignal_), 4); // 13-14 + is.read(reinterpret_cast(&p->csuLossOfFrames_), 4); // 15-16 + is.read(reinterpret_cast(&p->csuYellowAlarms_), 4); // 17-18 + is.read(reinterpret_cast(&p->csuBlueAlarms_), 4); // 19-20 + is.read(reinterpret_cast(&p->csu24HrErroredSeconds_), 4); // 21-22 + is.read(reinterpret_cast(&p->csu24HrSeverelyErroredSeconds_), + 4); // 23-24 + is.read(reinterpret_cast(&p->csu24HrSeverelyErroredFramingSeconds_), + 4); // 25-26 + is.read(reinterpret_cast(&p->csu24HrUnavailableSeconds_), 4); // 27-28 + is.read(reinterpret_cast(&p->csu24HrControlledSlipSeconds_), + 4); // 29-30 + is.read(reinterpret_cast(&p->csu24HrPathCodingViolations_), + 4); // 31-32 + is.read(reinterpret_cast(&p->csu24HrLineErroredSeconds_), 4); // 33-34 + is.read(reinterpret_cast(&p->csu24HrBurstyErroredSeconds_), + 4); // 35-36 + is.read(reinterpret_cast(&p->csu24HrDegradedMinutes_), 4); // 37-38 + is.seekg(4, std::ios_base::cur); // 39-40 + is.read(reinterpret_cast(&p->lanSwitchCpuUtilization_), 4); // 41-42 + is.read(reinterpret_cast(&p->lanSwitchMemoryUtilization_), 2); // 43 + is.seekg(2, std::ios_base::cur); // 44 + is.read(reinterpret_cast(&p->ifdrChasisTemperature_), 2); // 45 + is.read(reinterpret_cast(&p->ifdrFpgaTemperature_), 2); // 46 + is.seekg(4, std::ios_base::cur); // 47-48 + is.read(reinterpret_cast(&p->gpsSatellites_), 4); // 49-50 + is.seekg(4, std::ios_base::cur); // 51-52 + is.read(reinterpret_cast(&p->ipcStatus_), 2); // 53 + is.read(reinterpret_cast(&p->commandedChannelControl_), 2); // 54 + is.seekg(6, std::ios_base::cur); // 55-57 + + // AME + is.read(reinterpret_cast(&p->polarization_), 2); // 58 + is.read(reinterpret_cast(&p->ameInternalTemperature_), 4); // 59-60 + is.read(reinterpret_cast(&p->ameReceiverModuleTemperature_), + 4); // 61-62 + is.read(reinterpret_cast(&p->ameBiteCalModuleTemperature_), + 4); // 63-64 + is.read(reinterpret_cast(&p->amePeltierPulseWidthModulation_), + 2); // 65 + is.read(reinterpret_cast(&p->amePeltierStatus_), 2); // 66 + is.read(reinterpret_cast(&p->ameADConverterStatus_), 2); // 67 + is.read(reinterpret_cast(&p->ameState_), 2); // 68 + is.read(reinterpret_cast(&p->ame3_3VPsVoltage_), 4); // 69-70 + is.read(reinterpret_cast(&p->ame5VPsVoltage_), 4); // 71-72 + is.read(reinterpret_cast(&p->ame6_5VPsVoltage_), 4); // 73-74 + is.read(reinterpret_cast(&p->ame15VPsVoltage_), 4); // 75-76 + is.read(reinterpret_cast(&p->ame48VPsVoltage_), 4); // 77-78 + is.read(reinterpret_cast(&p->ameStaloPower_), 4); // 79-80 + is.read(reinterpret_cast(&p->peltierCurrent_), 4); // 81-82 + is.read(reinterpret_cast(&p->adcCalibrationReferenceVoltage_), + 4); // 83-84 + is.read(reinterpret_cast(&p->ameMode_), 2); // 85 + is.read(reinterpret_cast(&p->amePeltierMode_), 2); // 86 + is.read(reinterpret_cast(&p->amePeltierInsideFanCurrent_), + 4); // 87-88 + is.read(reinterpret_cast(&p->amePeltierOutsideFanCurrent_), + 4); // 89-90 + is.read(reinterpret_cast(&p->horizontalTrLimiterVoltage_), + 4); // 91-92 + is.read(reinterpret_cast(&p->verticalTrLimiterVoltage_), 4); // 93-94 + is.read(reinterpret_cast(&p->adcCalibrationOffsetVoltage_), + 4); // 95-96 + is.read(reinterpret_cast(&p->adcCalibrationGainCorrection_), + 4); // 97-98 + + // RCP/SPIP Power Button Status + is.read(reinterpret_cast(&p->rcpStatus_), 2); // 99 + is.read(&p->rcpString_[0], 16); // 100-107 + is.read(reinterpret_cast(&p->spipPowerButtons_), 2); // 108 + is.seekg(4, std::ios_base::cur); // 109-110 + + // Power + is.read(reinterpret_cast(&p->masterPowerAdministratorLoad_), + 4); // 111-112 + is.read(reinterpret_cast(&p->expansionPowerAdministratorLoad_), + 4); // 113-114 + is.seekg(44, std::ios_base::cur); // 115-136 + + // Transmitter + is.read(reinterpret_cast(&p->_5VdcPs_), 2); // 137 + is.read(reinterpret_cast(&p->_15VdcPs_), 2); // 138 + is.read(reinterpret_cast(&p->_28VdcPs_), 2); // 139 + is.read(reinterpret_cast(&p->neg15VdcPs_), 2); // 140 + is.read(reinterpret_cast(&p->_45VdcPs_), 2); // 141 + is.read(reinterpret_cast(&p->filamentPsVoltage_), 2); // 142 + is.read(reinterpret_cast(&p->vacuumPumpPsVoltage_), 2); // 143 + is.read(reinterpret_cast(&p->focusCoilPsVoltage_), 2); // 144 + is.read(reinterpret_cast(&p->filamentPs_), 2); // 145 + is.read(reinterpret_cast(&p->klystronWarmup_), 2); // 146 + is.read(reinterpret_cast(&p->transmitterAvailable_), 2); // 147 + is.read(reinterpret_cast(&p->wgSwitchPosition_), 2); // 148 + is.read(reinterpret_cast(&p->wgPfnTransferInterlock_), 2); // 149 + is.read(reinterpret_cast(&p->maintenanceMode_), 2); // 150 + is.read(reinterpret_cast(&p->maintenanceRequired_), 2); // 151 + is.read(reinterpret_cast(&p->pfnSwitchPosition_), 2); // 152 + is.read(reinterpret_cast(&p->modulatorOverload_), 2); // 153 + is.read(reinterpret_cast(&p->modulatorInvCurrent_), 2); // 154 + is.read(reinterpret_cast(&p->modulatorSwitchFail_), 2); // 155 + is.read(reinterpret_cast(&p->mainPowerVoltage_), 2); // 156 + is.read(reinterpret_cast(&p->chargingSystemFail_), 2); // 157 + is.read(reinterpret_cast(&p->inverseDiodeCurrent_), 2); // 158 + is.read(reinterpret_cast(&p->triggerAmplifier_), 2); // 159 + is.read(reinterpret_cast(&p->circulatorTemperature_), 2); // 160 + is.read(reinterpret_cast(&p->spectrumFilterPressure_), 2); // 161 + is.read(reinterpret_cast(&p->wgArcVswr_), 2); // 162 + is.read(reinterpret_cast(&p->cabinetInterlock_), 2); // 163 + is.read(reinterpret_cast(&p->cabinetAirTemperature_), 2); // 164 + is.read(reinterpret_cast(&p->cabinetAirflow_), 2); // 165 + is.read(reinterpret_cast(&p->klystronCurrent_), 2); // 166 + is.read(reinterpret_cast(&p->klystronFilamentCurrent_), 2); // 167 + is.read(reinterpret_cast(&p->klystronVacionCurrent_), 2); // 168 + is.read(reinterpret_cast(&p->klystronAirTemperature_), 2); // 169 + is.read(reinterpret_cast(&p->klystronAirflow_), 2); // 170 + is.read(reinterpret_cast(&p->modulatorSwitchMaintenance_), 2); // 171 + is.read(reinterpret_cast(&p->postChargeRegulatorMaintenance_), + 2); // 172 + is.read(reinterpret_cast(&p->wgPressureHumidity_), 2); // 173 + is.read(reinterpret_cast(&p->transmitterOvervoltage_), 2); // 174 + is.read(reinterpret_cast(&p->transmitterOvercurrent_), 2); // 175 + is.read(reinterpret_cast(&p->focusCoilCurrent_), 2); // 176 + is.read(reinterpret_cast(&p->focusCoilAirflow_), 2); // 177 + is.read(reinterpret_cast(&p->oilTemperature_), 2); // 178 + is.read(reinterpret_cast(&p->prfLimit_), 2); // 179 + is.read(reinterpret_cast(&p->transmitterOilLevel_), 2); // 180 + is.read(reinterpret_cast(&p->transmitterBatteryCharging_), 2); // 181 + is.read(reinterpret_cast(&p->highVoltageStatus_), 2); // 182 + is.read(reinterpret_cast(&p->transmitterRecyclingSummary_), 2); // 183 + is.read(reinterpret_cast(&p->transmitterInoperable_), 2); // 184 + is.read(reinterpret_cast(&p->transmitterAirFilter_), 2); // 185 + is.read(reinterpret_cast(&p->zeroTestBit_[0]), + p->zeroTestBit_.size() * 2); // 186-193 + is.read(reinterpret_cast(&p->oneTestBit_[0]), + p->oneTestBit_.size() * 2); // 194-201 + is.read(reinterpret_cast(&p->xmtrSpipInterface_), 2); // 202 + is.read(reinterpret_cast(&p->transmitterSummaryStatus_), 2); // 203 + is.seekg(2, std::ios_base::cur); // 204 + is.read(reinterpret_cast(&p->transmitterRfPower_), 4); // 205-206 + is.read(reinterpret_cast(&p->horizontalXmtrPeakPower_), 4); // 207-208 + is.read(reinterpret_cast(&p->xmtrPeakPower_), 4); // 209-210 + is.read(reinterpret_cast(&p->verticalXmtrPeakPower_), 4); // 211-212 + is.read(reinterpret_cast(&p->xmtrRfAvgPower_), 4); // 213-214 + is.seekg(4, std::ios_base::cur); // 215-216 + is.read(reinterpret_cast(&p->xmtrRecycleCount_), 4); // 217-218 + is.read(reinterpret_cast(&p->receiverBias_), 4); // 219-220 + is.read(reinterpret_cast(&p->transmitImbalance_), 4); // 221-222 + is.read(reinterpret_cast(&p->xmtrPowerMeterZero_), 4); // 223-224 + is.seekg(8, std::ios_base::cur); // 225-228 + + // Tower/Utilities + is.read(reinterpret_cast(&p->acUnit1CompressorShutOff_), 2); // 229 + is.read(reinterpret_cast(&p->acUnit2CompressorShutOff_), 2); // 230 + is.read(reinterpret_cast(&p->generatorMaintenanceRequired_), + 2); // 231 + is.read(reinterpret_cast(&p->generatorBatteryVoltage_), 2); // 232 + is.read(reinterpret_cast(&p->generatorEngine_), 2); // 233 + is.read(reinterpret_cast(&p->generatorVoltFrequency_), 2); // 234 + is.read(reinterpret_cast(&p->powerSource_), 2); // 235 + is.read(reinterpret_cast(&p->transitionalPowerSource_), 2); // 236 + is.read(reinterpret_cast(&p->generatorAutoRunOffSwitch_), 2); // 237 + is.read(reinterpret_cast(&p->aircraftHazardLighting_), 2); // 238 + is.seekg(22, std::ios_base::cur); // 239-249 + + // Equipment Shelter + is.read(reinterpret_cast(&p->equipmentShelterFireDetectionSystem_), + 2); // 250 + is.read(reinterpret_cast(&p->equipmentShelterFireSmoke_), 2); // 251 + is.read(reinterpret_cast(&p->generatorShelterFireSmoke_), 2); // 252 + is.read(reinterpret_cast(&p->utilityVoltageFrequency_), 2); // 253 + is.read(reinterpret_cast(&p->siteSecurityAlarm_), 2); // 254 + is.read(reinterpret_cast(&p->securityEquipment_), 2); // 255 + is.read(reinterpret_cast(&p->securitySystem_), 2); // 256 + is.read(reinterpret_cast(&p->receiverConnectedToAntenna_), 2); // 257 + is.read(reinterpret_cast(&p->radomeHatch_), 2); // 258 + is.read(reinterpret_cast(&p->acUnit1FilterDirty_), 2); // 259 + is.read(reinterpret_cast(&p->acUnit2FilterDirty_), 2); // 260 + is.read(reinterpret_cast(&p->equipmentShelterTemperature_), + 4); // 261-262 + is.read(reinterpret_cast(&p->outsideAmbientTemperature_), + 4); // 263-264 + is.read(reinterpret_cast(&p->transmitterLeavingAirTemp_), + 4); // 265-266 + is.read(reinterpret_cast(&p->acUnit1DischargeAirTemp_), 4); // 267-268 + is.read(reinterpret_cast(&p->generatorShelterTemperature_), + 4); // 269-270 + is.read(reinterpret_cast(&p->radomeAirTemperature_), 4); // 271-272 + is.read(reinterpret_cast(&p->acUnit2DischargeAirTemp_), 4); // 273-274 + is.read(reinterpret_cast(&p->spip15VPs_), 4); // 275-276 + is.read(reinterpret_cast(&p->spipNeg15VPs_), 4); // 277-278 + is.read(reinterpret_cast(&p->spip28VPsStatus_), 2); // 279 + is.seekg(2, std::ios_base::cur); // 280 + is.read(reinterpret_cast(&p->spip5VPs_), 4); // 281-282 + is.read(reinterpret_cast(&p->convertedGeneratorFuelLevel_), 2); // 283 + is.seekg(32, std::ios_base::cur); // 284-299 + + // Antenna/Pedestal + is.read(reinterpret_cast(&p->elevationPosDeadLimit_), 2); // 300 + is.read(reinterpret_cast(&p->_150VOvervoltage_), 2); // 301 + is.read(reinterpret_cast(&p->_150VUndervoltage_), 2); // 302 + is.read(reinterpret_cast(&p->elevationServoAmpInhibit_), 2); // 303 + is.read(reinterpret_cast(&p->elevationServoAmpShortCircuit_), + 2); // 304 + is.read(reinterpret_cast(&p->elevationServoAmpOvertemp_), 2); // 305 + is.read(reinterpret_cast(&p->elevationMotorOvertemp_), 2); // 306 + is.read(reinterpret_cast(&p->elevationStowPin_), 2); // 307 + is.read(reinterpret_cast(&p->elevationHousing5VPs_), 2); // 308 + is.read(reinterpret_cast(&p->elevationNegDeadLimit_), 2); // 309 + is.read(reinterpret_cast(&p->elevationPosNormalLimit_), 2); // 310 + is.read(reinterpret_cast(&p->elevationNegNormalLimit_), 2); // 311 + is.read(reinterpret_cast(&p->elevationEncoderLight_), 2); // 312 + is.read(reinterpret_cast(&p->elevationGearboxOil_), 2); // 313 + is.read(reinterpret_cast(&p->elevationHandwheel_), 2); // 314 + is.read(reinterpret_cast(&p->elevationAmpPs_), 2); // 315 + is.read(reinterpret_cast(&p->azimuthServoAmpInhibit_), 2); // 316 + is.read(reinterpret_cast(&p->azimuthServoAmpShortCircuit_), 2); // 317 + is.read(reinterpret_cast(&p->azimuthServoAmpOvertemp_), 2); // 318 + is.read(reinterpret_cast(&p->azimuthMotorOvertemp_), 2); // 319 + is.read(reinterpret_cast(&p->azimuthStowPin_), 2); // 320 + is.read(reinterpret_cast(&p->azimuthHousing5VPs_), 2); // 321 + is.read(reinterpret_cast(&p->azimuthEncoderLight_), 2); // 322 + is.read(reinterpret_cast(&p->azimuthGearboxOil_), 2); // 323 + is.read(reinterpret_cast(&p->azimuthBullGearOil_), 2); // 324 + is.read(reinterpret_cast(&p->azimuthHandwheel_), 2); // 325 + is.read(reinterpret_cast(&p->azimuthServoAmpPs_), 2); // 326 + is.read(reinterpret_cast(&p->servo_), 2); // 327 + is.read(reinterpret_cast(&p->pedestalInterlockSwitch_), 2); // 328 + is.seekg(24, std::ios_base::cur); // 329-340 + + // RF Generator/Receiver + is.read(reinterpret_cast(&p->cohoClock_), 2); // 341 + is.read(reinterpret_cast(&p->rfGeneratorFrequencySelectOscillator_), + 2); // 342 + is.read(reinterpret_cast(&p->rfGeneratorRfStalo_), 2); // 343 + is.read(reinterpret_cast(&p->rfGeneratorPhaseShiftedCoho_), 2); // 344 + is.read(reinterpret_cast(&p->_9VReceiverPs_), 2); // 345 + is.read(reinterpret_cast(&p->_5VReceiverPs_), 2); // 346 + is.read(reinterpret_cast(&p->_18VReceiverPs_), 2); // 347 + is.read(reinterpret_cast(&p->neg9VReceiverPs_), 2); // 348 + is.read(reinterpret_cast(&p->_5VSingleChannelRdaiuPs_), 2); // 349 + is.seekg(2, std::ios_base::cur); // 350 + is.read(reinterpret_cast(&p->horizontalShortPulseNoise_), + 4); // 351-352 + is.read(reinterpret_cast(&p->horizontalLongPulseNoise_), + 4); // 353-354 + is.read(reinterpret_cast(&p->horizontalNoiseTemperature_), + 4); // 355-356 + is.read(reinterpret_cast(&p->verticalShortPulseNoise_), 4); // 357-358 + is.read(reinterpret_cast(&p->verticalLongPulseNoise_), 4); // 359-360 + is.read(reinterpret_cast(&p->verticalNoiseTemperature_), + 4); // 361-362 + + // Calibration + is.read(reinterpret_cast(&p->horizontalLinearity_), 4); // 363-364 + is.read(reinterpret_cast(&p->horizontalDynamicRange_), 4); // 365-366 + is.read(reinterpret_cast(&p->horizontalDeltaDbz0_), 4); // 367-368 + is.read(reinterpret_cast(&p->verticalDeltaDbz0_), 4); // 369-370 + is.read(reinterpret_cast(&p->kdPeakMeasured_), 4); // 371-372 + is.seekg(4, std::ios_base::cur); // 373-374 + is.read(reinterpret_cast(&p->shortPulseHorizontalDbz0_), + 4); // 375-376 + is.read(reinterpret_cast(&p->longPulseHorizontalDbz0_), 4); // 377-378 + is.read(reinterpret_cast(&p->velocityProcessed_), 2); // 379 + is.read(reinterpret_cast(&p->widthProcessed_), 2); // 380 + is.read(reinterpret_cast(&p->velocityRfGen_), 2); // 381 + is.read(reinterpret_cast(&p->widthRfGen_), 2); // 382 + is.read(reinterpret_cast(&p->horizontalI0_), 4); // 383-384 + is.read(reinterpret_cast(&p->verticalI0_), 4); // 385-386 + is.read(reinterpret_cast(&p->verticalDynamicRange_), 4); // 387-388 + is.read(reinterpret_cast(&p->shortPulseVerticalDbz0_), 4); // 389-390 + is.read(reinterpret_cast(&p->longPulseVerticalDbz0_), 4); // 391-392 + is.seekg(8, std::ios_base::cur); // 393-396 + is.read(reinterpret_cast(&p->horizontalPowerSense_), 4); // 397-398 + is.read(reinterpret_cast(&p->verticalPowerSense_), 4); // 399-400 + is.read(reinterpret_cast(&p->zdrBias_), 4); // 401-402 + is.seekg(12, std::ios_base::cur); // 403-408 + is.read(reinterpret_cast(&p->clutterSuppressionDelta_), 4); // 409-410 + is.read(reinterpret_cast(&p->clutterSuppressionUnfilteredPower_), + 4); // 411-412 + is.read(reinterpret_cast(&p->clutterSuppressionFilteredPower_), + 4); // 413-414 + is.seekg(20, std::ios_base::cur); // 415-424 + is.read(reinterpret_cast(&p->verticalLinearity_), 4); // 425-426 + is.seekg(8, std::ios_base::cur); // 427-430 + + // File Status + is.read(reinterpret_cast(&p->stateFileReadStatus_), 2); // 431 + is.read(reinterpret_cast(&p->stateFileWriteStatus_), 2); // 432 + is.read(reinterpret_cast(&p->bypassMapFileReadStatus_), 2); // 433 + is.read(reinterpret_cast(&p->bypassMapFileWriteStatus_), 2); // 434 + is.seekg(4, std::ios_base::cur); // 435-436 + is.read(reinterpret_cast(&p->currentAdaptationFileReadStatus_), + 2); // 437 + is.read(reinterpret_cast(&p->currentAdaptationFileWriteStatus_), + 2); // 438 + is.read(reinterpret_cast(&p->censorZoneFileReadStatus_), 2); // 439 + is.read(reinterpret_cast(&p->censorZoneFileWriteStatus_), 2); // 440 + is.read(reinterpret_cast(&p->remoteVcpFileReadStatus_), 2); // 441 + is.read(reinterpret_cast(&p->remoteVcpFileWriteStatus_), 2); // 442 + is.read(reinterpret_cast(&p->baselineAdaptationFileReadStatus_), + 2); // 443 + is.read(reinterpret_cast(&p->readStatusOfPrfSets_), 2); // 444 + is.read(reinterpret_cast(&p->clutterFilterMapFileReadStatus_), + 2); // 445 + is.read(reinterpret_cast(&p->clutterFilterMapFileWriteStatus_), + 2); // 446 + is.read(reinterpret_cast(&p->generatlDiskIoError_), 2); // 447 + is.read(reinterpret_cast(&p->rspStatus_), 1); // 448 + is.read(reinterpret_cast(&p->motherboardTemperature_), 1); // 448 + is.read(reinterpret_cast(&p->cpu1Temperature_), 1); // 449 + is.read(reinterpret_cast(&p->cpu2Temperature_), 1); // 449 + is.read(reinterpret_cast(&p->cpu1FanSpeed_), 2); // 450 + is.read(reinterpret_cast(&p->cpu2FanSpeed_), 2); // 451 + is.read(reinterpret_cast(&p->rspFan1Speed_), 2); // 452 + is.read(reinterpret_cast(&p->rspFan2Speed_), 2); // 453 + is.read(reinterpret_cast(&p->rspFan3Speed_), 2); // 454 + is.seekg(12, std::ios_base::cur); // 455-460 + + // Device Status + is.read(reinterpret_cast(&p->spipCommStatus_), 2); // 461 + is.read(reinterpret_cast(&p->hciCommStatus_), 2); // 462 + is.seekg(2, std::ios_base::cur); // 463 + is.read(reinterpret_cast(&p->signalProcessorCommandStatus_), + 2); // 464 + is.read(reinterpret_cast(&p->ameCommunicationStatus_), 2); // 465 + is.read(reinterpret_cast(&p->rmsLinkStatus_), 2); // 466 + is.read(reinterpret_cast(&p->rpgLinkStatus_), 2); // 467 + is.read(reinterpret_cast(&p->interpanelLinkStatus_), 2); // 468 + is.read(reinterpret_cast(&p->performanceCheckTime_), 4); // 469 + is.seekg(18, std::ios_base::cur); // 471-479 + is.read(reinterpret_cast(&p->version_), 2); // 480 + + bytesRead += 960; + + // Communications + p->loopBackSetStatus_ = htons(p->loopBackSetStatus_); + p->t1OutputFrames_ = htonl(p->t1OutputFrames_); + p->t1InputFrames_ = htonl(p->t1InputFrames_); + p->routerMemoryUsed_ = htonl(p->routerMemoryUsed_); + p->routerMemoryFree_ = htonl(p->routerMemoryFree_); + p->routerMemoryUtilization_ = htons(p->routerMemoryUtilization_); + p->routeToRpg_ = htons(p->routeToRpg_); + p->csuLossOfSignal_ = htonl(p->csuLossOfSignal_); + p->csuLossOfFrames_ = htonl(p->csuLossOfFrames_); + p->csuYellowAlarms_ = htonl(p->csuYellowAlarms_); + p->csuBlueAlarms_ = htonl(p->csuBlueAlarms_); + p->csu24HrErroredSeconds_ = htonl(p->csu24HrErroredSeconds_); + p->csu24HrSeverelyErroredSeconds_ = htonl(p->csu24HrSeverelyErroredSeconds_); + p->csu24HrSeverelyErroredFramingSeconds_ = + htonl(p->csu24HrSeverelyErroredFramingSeconds_); + p->csu24HrUnavailableSeconds_ = htonl(p->csu24HrUnavailableSeconds_); + p->csu24HrControlledSlipSeconds_ = htonl(p->csu24HrControlledSlipSeconds_); + p->csu24HrPathCodingViolations_ = htonl(p->csu24HrPathCodingViolations_); + p->csu24HrLineErroredSeconds_ = htonl(p->csu24HrLineErroredSeconds_); + p->csu24HrBurstyErroredSeconds_ = htonl(p->csu24HrBurstyErroredSeconds_); + p->csu24HrDegradedMinutes_ = htonl(p->csu24HrDegradedMinutes_); + p->lanSwitchCpuUtilization_ = htonl(p->lanSwitchCpuUtilization_); + p->lanSwitchMemoryUtilization_ = htons(p->lanSwitchMemoryUtilization_); + p->ifdrChasisTemperature_ = htons(p->ifdrChasisTemperature_); + p->ifdrFpgaTemperature_ = htons(p->ifdrFpgaTemperature_); + p->gpsSatellites_ = htonl(p->gpsSatellites_); + p->ipcStatus_ = htons(p->ipcStatus_); + p->commandedChannelControl_ = htons(p->commandedChannelControl_); + + // AME + p->polarization_ = htons(p->polarization_); + p->ameInternalTemperature_ = SwapFloat(p->ameInternalTemperature_); + p->ameReceiverModuleTemperature_ = + SwapFloat(p->ameReceiverModuleTemperature_); + p->ameBiteCalModuleTemperature_ = SwapFloat(p->ameBiteCalModuleTemperature_); + p->amePeltierPulseWidthModulation_ = + htons(p->amePeltierPulseWidthModulation_); + p->amePeltierStatus_ = htons(p->amePeltierStatus_); + p->ameADConverterStatus_ = htons(p->ameADConverterStatus_); + p->ameState_ = htons(p->ameState_); + p->ame3_3VPsVoltage_ = SwapFloat(p->ame3_3VPsVoltage_); + p->ame5VPsVoltage_ = SwapFloat(p->ame5VPsVoltage_); + p->ame6_5VPsVoltage_ = SwapFloat(p->ame6_5VPsVoltage_); + p->ame15VPsVoltage_ = SwapFloat(p->ame15VPsVoltage_); + p->ame48VPsVoltage_ = SwapFloat(p->ame48VPsVoltage_); + p->ameStaloPower_ = SwapFloat(p->ameStaloPower_); + p->peltierCurrent_ = SwapFloat(p->peltierCurrent_); + p->adcCalibrationReferenceVoltage_ = + SwapFloat(p->adcCalibrationReferenceVoltage_); + p->ameMode_ = htons(p->ameMode_); + p->amePeltierMode_ = htons(p->amePeltierMode_); + p->amePeltierInsideFanCurrent_ = SwapFloat(p->amePeltierInsideFanCurrent_); + p->amePeltierOutsideFanCurrent_ = SwapFloat(p->amePeltierOutsideFanCurrent_); + p->horizontalTrLimiterVoltage_ = SwapFloat(p->horizontalTrLimiterVoltage_); + p->verticalTrLimiterVoltage_ = SwapFloat(p->verticalTrLimiterVoltage_); + p->adcCalibrationOffsetVoltage_ = SwapFloat(p->adcCalibrationOffsetVoltage_); + p->adcCalibrationGainCorrection_ = + SwapFloat(p->adcCalibrationGainCorrection_); + + // RCP/SPIP Power Button Status + p->rcpStatus_ = htons(p->rcpStatus_); + p->spipPowerButtons_ = htons(p->spipPowerButtons_); + + // Power + p->masterPowerAdministratorLoad_ = + SwapFloat(p->masterPowerAdministratorLoad_); + p->expansionPowerAdministratorLoad_ = + SwapFloat(p->expansionPowerAdministratorLoad_); + + // Transmitter + p->_5VdcPs_ = htons(p->_5VdcPs_); + p->_15VdcPs_ = htons(p->_15VdcPs_); + p->_28VdcPs_ = htons(p->_28VdcPs_); + p->neg15VdcPs_ = htons(p->neg15VdcPs_); + p->_45VdcPs_ = htons(p->_45VdcPs_); + p->filamentPsVoltage_ = htons(p->filamentPsVoltage_); + p->vacuumPumpPsVoltage_ = htons(p->vacuumPumpPsVoltage_); + p->focusCoilPsVoltage_ = htons(p->focusCoilPsVoltage_); + p->filamentPs_ = htons(p->filamentPs_); + p->klystronWarmup_ = htons(p->klystronWarmup_); + p->transmitterAvailable_ = htons(p->transmitterAvailable_); + p->wgSwitchPosition_ = htons(p->wgSwitchPosition_); + p->wgPfnTransferInterlock_ = htons(p->wgPfnTransferInterlock_); + p->maintenanceMode_ = htons(p->maintenanceMode_); + p->maintenanceRequired_ = htons(p->maintenanceRequired_); + p->pfnSwitchPosition_ = htons(p->pfnSwitchPosition_); + p->modulatorOverload_ = htons(p->modulatorOverload_); + p->modulatorInvCurrent_ = htons(p->modulatorInvCurrent_); + p->modulatorSwitchFail_ = htons(p->modulatorSwitchFail_); + p->mainPowerVoltage_ = htons(p->mainPowerVoltage_); + p->chargingSystemFail_ = htons(p->chargingSystemFail_); + p->inverseDiodeCurrent_ = htons(p->inverseDiodeCurrent_); + p->triggerAmplifier_ = htons(p->triggerAmplifier_); + p->circulatorTemperature_ = htons(p->circulatorTemperature_); + p->spectrumFilterPressure_ = htons(p->spectrumFilterPressure_); + p->wgArcVswr_ = htons(p->wgArcVswr_); + p->cabinetInterlock_ = htons(p->cabinetInterlock_); + p->cabinetAirTemperature_ = htons(p->cabinetAirTemperature_); + p->cabinetAirflow_ = htons(p->cabinetAirflow_); + p->klystronCurrent_ = htons(p->klystronCurrent_); + p->klystronFilamentCurrent_ = htons(p->klystronFilamentCurrent_); + p->klystronVacionCurrent_ = htons(p->klystronVacionCurrent_); + p->klystronAirTemperature_ = htons(p->klystronAirTemperature_); + p->klystronAirflow_ = htons(p->klystronAirflow_); + p->modulatorSwitchMaintenance_ = htons(p->modulatorSwitchMaintenance_); + p->postChargeRegulatorMaintenance_ = + htons(p->postChargeRegulatorMaintenance_); + p->wgPressureHumidity_ = htons(p->wgPressureHumidity_); + p->transmitterOvervoltage_ = htons(p->transmitterOvervoltage_); + p->transmitterOvercurrent_ = htons(p->transmitterOvercurrent_); + p->focusCoilCurrent_ = htons(p->focusCoilCurrent_); + p->focusCoilAirflow_ = htons(p->focusCoilAirflow_); + p->oilTemperature_ = htons(p->oilTemperature_); + p->prfLimit_ = htons(p->prfLimit_); + p->transmitterOilLevel_ = htons(p->transmitterOilLevel_); + p->transmitterBatteryCharging_ = htons(p->transmitterBatteryCharging_); + p->highVoltageStatus_ = htons(p->highVoltageStatus_); + p->transmitterRecyclingSummary_ = htons(p->transmitterRecyclingSummary_); + p->transmitterInoperable_ = htons(p->transmitterInoperable_); + p->transmitterAirFilter_ = htons(p->transmitterAirFilter_); + SwapUInt16Array(p->zeroTestBit_); + SwapUInt16Array(p->oneTestBit_); + p->xmtrSpipInterface_ = htons(p->xmtrSpipInterface_); + p->transmitterSummaryStatus_ = htons(p->transmitterSummaryStatus_); + p->transmitterRfPower_ = SwapFloat(p->transmitterRfPower_); + p->horizontalXmtrPeakPower_ = SwapFloat(p->horizontalXmtrPeakPower_); + p->xmtrPeakPower_ = SwapFloat(p->xmtrPeakPower_); + p->verticalXmtrPeakPower_ = SwapFloat(p->verticalXmtrPeakPower_); + p->xmtrRfAvgPower_ = SwapFloat(p->xmtrRfAvgPower_); + p->xmtrRecycleCount_ = htonl(p->xmtrRecycleCount_); + p->receiverBias_ = SwapFloat(p->receiverBias_); + p->transmitImbalance_ = SwapFloat(p->transmitImbalance_); + p->xmtrPowerMeterZero_ = SwapFloat(p->xmtrPowerMeterZero_); + + // Tower/Utilities + p->acUnit1CompressorShutOff_ = htons(p->acUnit1CompressorShutOff_); + p->acUnit2CompressorShutOff_ = htons(p->acUnit2CompressorShutOff_); + p->generatorMaintenanceRequired_ = htons(p->generatorMaintenanceRequired_); + p->generatorBatteryVoltage_ = htons(p->generatorBatteryVoltage_); + p->generatorEngine_ = htons(p->generatorEngine_); + p->generatorVoltFrequency_ = htons(p->generatorVoltFrequency_); + p->powerSource_ = htons(p->powerSource_); + p->transitionalPowerSource_ = htons(p->transitionalPowerSource_); + p->generatorAutoRunOffSwitch_ = htons(p->generatorAutoRunOffSwitch_); + p->aircraftHazardLighting_ = htons(p->aircraftHazardLighting_); + + // Equipment Shelter + p->equipmentShelterFireDetectionSystem_ = + htons(p->equipmentShelterFireDetectionSystem_); + p->equipmentShelterFireSmoke_ = htons(p->equipmentShelterFireSmoke_); + p->generatorShelterFireSmoke_ = htons(p->generatorShelterFireSmoke_); + p->utilityVoltageFrequency_ = htons(p->utilityVoltageFrequency_); + p->siteSecurityAlarm_ = htons(p->siteSecurityAlarm_); + p->securityEquipment_ = htons(p->securityEquipment_); + p->securitySystem_ = htons(p->securitySystem_); + p->receiverConnectedToAntenna_ = htons(p->receiverConnectedToAntenna_); + p->radomeHatch_ = htons(p->radomeHatch_); + p->acUnit1FilterDirty_ = htons(p->acUnit1FilterDirty_); + p->acUnit2FilterDirty_ = htons(p->acUnit2FilterDirty_); + p->equipmentShelterTemperature_ = SwapFloat(p->equipmentShelterTemperature_); + p->outsideAmbientTemperature_ = SwapFloat(p->outsideAmbientTemperature_); + p->transmitterLeavingAirTemp_ = SwapFloat(p->transmitterLeavingAirTemp_); + p->acUnit1DischargeAirTemp_ = SwapFloat(p->acUnit1DischargeAirTemp_); + p->generatorShelterTemperature_ = SwapFloat(p->generatorShelterTemperature_); + p->radomeAirTemperature_ = SwapFloat(p->radomeAirTemperature_); + p->acUnit2DischargeAirTemp_ = SwapFloat(p->acUnit2DischargeAirTemp_); + p->spip15VPs_ = SwapFloat(p->spip15VPs_); + p->spipNeg15VPs_ = SwapFloat(p->spipNeg15VPs_); + p->spip28VPsStatus_ = htons(p->spip28VPsStatus_); + p->spip5VPs_ = SwapFloat(p->spip5VPs_); + p->convertedGeneratorFuelLevel_ = htons(p->convertedGeneratorFuelLevel_); + + // Antenna/Pedestal + p->elevationPosDeadLimit_ = htons(p->elevationPosDeadLimit_); + p->_150VOvervoltage_ = htons(p->_150VOvervoltage_); + p->_150VUndervoltage_ = htons(p->_150VUndervoltage_); + p->elevationServoAmpInhibit_ = htons(p->elevationServoAmpInhibit_); + p->elevationServoAmpShortCircuit_ = htons(p->elevationServoAmpShortCircuit_); + p->elevationServoAmpOvertemp_ = htons(p->elevationServoAmpOvertemp_); + p->elevationMotorOvertemp_ = htons(p->elevationMotorOvertemp_); + p->elevationStowPin_ = htons(p->elevationStowPin_); + p->elevationHousing5VPs_ = htons(p->elevationHousing5VPs_); + p->elevationNegDeadLimit_ = htons(p->elevationNegDeadLimit_); + p->elevationPosNormalLimit_ = htons(p->elevationPosNormalLimit_); + p->elevationNegNormalLimit_ = htons(p->elevationNegNormalLimit_); + p->elevationEncoderLight_ = htons(p->elevationEncoderLight_); + p->elevationGearboxOil_ = htons(p->elevationGearboxOil_); + p->elevationHandwheel_ = htons(p->elevationHandwheel_); + p->elevationAmpPs_ = htons(p->elevationAmpPs_); + p->azimuthServoAmpInhibit_ = htons(p->azimuthServoAmpInhibit_); + p->azimuthServoAmpShortCircuit_ = htons(p->azimuthServoAmpShortCircuit_); + p->azimuthServoAmpOvertemp_ = htons(p->azimuthServoAmpOvertemp_); + p->azimuthMotorOvertemp_ = htons(p->azimuthMotorOvertemp_); + p->azimuthStowPin_ = htons(p->azimuthStowPin_); + p->azimuthHousing5VPs_ = htons(p->azimuthHousing5VPs_); + p->azimuthEncoderLight_ = htons(p->azimuthEncoderLight_); + p->azimuthGearboxOil_ = htons(p->azimuthGearboxOil_); + p->azimuthBullGearOil_ = htons(p->azimuthBullGearOil_); + p->azimuthHandwheel_ = htons(p->azimuthHandwheel_); + p->azimuthServoAmpPs_ = htons(p->azimuthServoAmpPs_); + p->servo_ = htons(p->servo_); + p->pedestalInterlockSwitch_ = htons(p->pedestalInterlockSwitch_); + + // RF Generator/Receiver + p->cohoClock_ = htons(p->cohoClock_); + p->rfGeneratorFrequencySelectOscillator_ = + htons(p->rfGeneratorFrequencySelectOscillator_); + p->rfGeneratorRfStalo_ = htons(p->rfGeneratorRfStalo_); + p->rfGeneratorPhaseShiftedCoho_ = htons(p->rfGeneratorPhaseShiftedCoho_); + p->_9VReceiverPs_ = htons(p->_9VReceiverPs_); + p->_5VReceiverPs_ = htons(p->_5VReceiverPs_); + p->_18VReceiverPs_ = htons(p->_18VReceiverPs_); + p->neg9VReceiverPs_ = htons(p->neg9VReceiverPs_); + p->_5VSingleChannelRdaiuPs_ = htons(p->_5VSingleChannelRdaiuPs_); + p->horizontalShortPulseNoise_ = SwapFloat(p->horizontalShortPulseNoise_); + p->horizontalLongPulseNoise_ = SwapFloat(p->horizontalLongPulseNoise_); + p->horizontalNoiseTemperature_ = SwapFloat(p->horizontalNoiseTemperature_); + p->verticalShortPulseNoise_ = SwapFloat(p->verticalShortPulseNoise_); + p->verticalLongPulseNoise_ = SwapFloat(p->verticalLongPulseNoise_); + p->verticalNoiseTemperature_ = SwapFloat(p->verticalNoiseTemperature_); + + // Calibration + p->horizontalLinearity_ = SwapFloat(p->horizontalLinearity_); + p->horizontalDynamicRange_ = SwapFloat(p->horizontalDynamicRange_); + p->horizontalDeltaDbz0_ = SwapFloat(p->horizontalDeltaDbz0_); + p->verticalDeltaDbz0_ = SwapFloat(p->verticalDeltaDbz0_); + p->kdPeakMeasured_ = SwapFloat(p->kdPeakMeasured_); + p->shortPulseHorizontalDbz0_ = SwapFloat(p->shortPulseHorizontalDbz0_); + p->longPulseHorizontalDbz0_ = SwapFloat(p->longPulseHorizontalDbz0_); + p->velocityProcessed_ = htons(p->velocityProcessed_); + p->widthProcessed_ = htons(p->widthProcessed_); + p->velocityRfGen_ = htons(p->velocityRfGen_); + p->widthRfGen_ = htons(p->widthRfGen_); + p->horizontalI0_ = SwapFloat(p->horizontalI0_); + p->verticalI0_ = SwapFloat(p->verticalI0_); + p->verticalDynamicRange_ = SwapFloat(p->verticalDynamicRange_); + p->shortPulseVerticalDbz0_ = SwapFloat(p->shortPulseVerticalDbz0_); + p->longPulseVerticalDbz0_ = SwapFloat(p->longPulseVerticalDbz0_); + p->horizontalPowerSense_ = SwapFloat(p->horizontalPowerSense_); + p->verticalPowerSense_ = SwapFloat(p->verticalPowerSense_); + p->zdrBias_ = SwapFloat(p->zdrBias_); + p->clutterSuppressionDelta_ = SwapFloat(p->clutterSuppressionDelta_); + p->clutterSuppressionUnfilteredPower_ = + SwapFloat(p->clutterSuppressionUnfilteredPower_); + p->clutterSuppressionFilteredPower_ = + SwapFloat(p->clutterSuppressionFilteredPower_); + p->verticalLinearity_ = SwapFloat(p->verticalLinearity_); + + // File Status + p->stateFileReadStatus_ = htons(p->stateFileReadStatus_); + p->stateFileWriteStatus_ = htons(p->stateFileWriteStatus_); + p->bypassMapFileReadStatus_ = htons(p->bypassMapFileReadStatus_); + p->bypassMapFileWriteStatus_ = htons(p->bypassMapFileWriteStatus_); + p->currentAdaptationFileReadStatus_ = + htons(p->currentAdaptationFileReadStatus_); + p->currentAdaptationFileWriteStatus_ = + htons(p->currentAdaptationFileWriteStatus_); + p->censorZoneFileReadStatus_ = htons(p->censorZoneFileReadStatus_); + p->censorZoneFileWriteStatus_ = htons(p->censorZoneFileWriteStatus_); + p->remoteVcpFileReadStatus_ = htons(p->remoteVcpFileReadStatus_); + p->remoteVcpFileWriteStatus_ = htons(p->remoteVcpFileWriteStatus_); + p->baselineAdaptationFileReadStatus_ = + htons(p->baselineAdaptationFileReadStatus_); + p->readStatusOfPrfSets_ = htons(p->readStatusOfPrfSets_); + p->clutterFilterMapFileReadStatus_ = + htons(p->clutterFilterMapFileReadStatus_); + p->clutterFilterMapFileWriteStatus_ = + htons(p->clutterFilterMapFileWriteStatus_); + p->generatlDiskIoError_ = htons(p->generatlDiskIoError_); + p->cpu1FanSpeed_ = htons(p->cpu1FanSpeed_); + p->cpu2FanSpeed_ = htons(p->cpu2FanSpeed_); + p->rspFan1Speed_ = htons(p->rspFan1Speed_); + p->rspFan2Speed_ = htons(p->rspFan2Speed_); + p->rspFan3Speed_ = htons(p->rspFan3Speed_); + + // Device Status + p->spipCommStatus_ = htons(p->spipCommStatus_); + p->hciCommStatus_ = htons(p->hciCommStatus_); + p->signalProcessorCommandStatus_ = htons(p->signalProcessorCommandStatus_); + p->ameCommunicationStatus_ = htons(p->ameCommunicationStatus_); + p->rmsLinkStatus_ = htons(p->rmsLinkStatus_); + p->rpgLinkStatus_ = htons(p->rpgLinkStatus_); + p->interpanelLinkStatus_ = htons(p->interpanelLinkStatus_); + p->performanceCheckTime_ = htonl(p->performanceCheckTime_); + p->version_ = htons(p->version_); + + if (!ValidateMessage(is, bytesRead)) + { + messageValid = false; + } + + return messageValid; +} + +std::unique_ptr +PerformanceMaintenanceData::Create(MessageHeader&& header, std::istream& is) +{ + std::unique_ptr message = + std::make_unique(); + message->set_header(std::move(header)); + message->Parse(is); + return message; +} + +} // namespace rda +} // namespace wsr88d +} // namespace scwx diff --git a/wxdata/source/scwx/wsr88d/rda/rda_adaptation_data.cpp b/wxdata/source/scwx/wsr88d/rda/rda_adaptation_data.cpp index 5b9455d3..016298df 100644 --- a/wxdata/source/scwx/wsr88d/rda/rda_adaptation_data.cpp +++ b/wxdata/source/scwx/wsr88d/rda/rda_adaptation_data.cpp @@ -1,18 +1,7 @@ #include -#include -#include -#include -#include - #include -#ifdef WIN32 -# include -#else -# include -#endif - namespace scwx { namespace wsr88d @@ -23,14 +12,6 @@ namespace rda static const std::string logPrefix_ = "[scwx::wsr88d::rda::rda_adaptation_data] "; -static void ReadBoolean(std::istream& is, bool& value); -static void ReadChar(std::istream& is, char& value); -static float SwapFloat(float f); -template -static void SwapFloatArray(std::array& arr); -template -static void SwapFloatMap(std::map& m); - struct AntManualSetup { int32_t ielmin_; @@ -1757,13 +1738,7 @@ bool RdaAdaptationData::Parse(std::istream& is) p->txbBaseline_ = SwapFloat(p->txbBaseline_); p->txbAlarmThresh_ = SwapFloat(p->txbAlarmThresh_); - if (is.eof()) - { - BOOST_LOG_TRIVIAL(warning) << logPrefix_ << "Reached end of file (1)"; - messageValid = false; - } - - if (!ValidateSize(is, bytesRead)) + if (!ValidateMessage(is, bytesRead)) { messageValid = false; } @@ -1781,43 +1756,6 @@ RdaAdaptationData::Create(MessageHeader&& header, std::istream& is) return message; } -static void ReadBoolean(std::istream& is, bool& value) -{ - std::string data(4, ' '); - is.read(reinterpret_cast(&data[0]), 4); - value = (data.at(0) == 'T'); -} - -static void ReadChar(std::istream& is, char& value) -{ - std::string data(4, ' '); - is.read(reinterpret_cast(&data[0]), 4); - value = data.at(0); -} - -static float SwapFloat(float f) -{ - return ntohf(*reinterpret_cast(&f)); -} - -template -static void SwapFloatArray(std::array& arr) -{ - std::transform(std::execution::par_unseq, - arr.begin(), - arr.end(), - arr.begin(), - [](float f) { return SwapFloat(f); }); -} - -template -static void SwapFloatMap(std::map& m) -{ - std::for_each(std::execution::par_unseq, m.begin(), m.end(), [](auto& p) { - p.second = SwapFloat(p.second); - }); -} - } // namespace rda } // namespace wsr88d } // namespace scwx diff --git a/wxdata/wxdata.cmake b/wxdata/wxdata.cmake index 7b99e88f..80ebf147 100644 --- a/wxdata/wxdata.cmake +++ b/wxdata/wxdata.cmake @@ -12,11 +12,13 @@ set(HDR_WSR88D_RDA include/scwx/wsr88d/rda/clutter_filter_map.hpp include/scwx/wsr88d/rda/message.hpp include/scwx/wsr88d/rda/message_factory.hpp include/scwx/wsr88d/rda/message_header.hpp + include/scwx/wsr88d/rda/performance_maintenance_data.hpp include/scwx/wsr88d/rda/rda_adaptation_data.hpp) set(SRC_WSR88D_RDA source/scwx/wsr88d/rda/clutter_filter_map.cpp source/scwx/wsr88d/rda/message.cpp source/scwx/wsr88d/rda/message_factory.cpp source/scwx/wsr88d/rda/message_header.cpp + source/scwx/wsr88d/rda/performance_maintenance_data.cpp source/scwx/wsr88d/rda/rda_adaptation_data.cpp) add_library(wxdata OBJECT ${HDR_UTIL}