From 6acb6a8c9db94d65369d423da08125d178a65e15 Mon Sep 17 00:00:00 2001 From: Dan Paulat Date: Sun, 20 Jun 2021 11:15:35 -0500 Subject: [PATCH] Parse RDA Status Data (Message Type 2) --- .../scwx/wsr88d/rda/rda_status_data.hpp | 67 ++++ wxdata/source/scwx/wsr88d/ar2v_file.cpp | 2 +- .../scwx/wsr88d/rda/message_factory.cpp | 2 + .../scwx/wsr88d/rda/rda_status_data.cpp | 336 ++++++++++++++++++ wxdata/wxdata.cmake | 2 + 5 files changed, 408 insertions(+), 1 deletion(-) create mode 100644 wxdata/include/scwx/wsr88d/rda/rda_status_data.hpp create mode 100644 wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp diff --git a/wxdata/include/scwx/wsr88d/rda/rda_status_data.hpp b/wxdata/include/scwx/wsr88d/rda/rda_status_data.hpp new file mode 100644 index 00000000..ef57ce3a --- /dev/null +++ b/wxdata/include/scwx/wsr88d/rda/rda_status_data.hpp @@ -0,0 +1,67 @@ +#pragma once + +#include + +namespace scwx +{ +namespace wsr88d +{ +namespace rda +{ + +class RdaStatusDataImpl; + +class RdaStatusData : public Message +{ +public: + explicit RdaStatusData(); + ~RdaStatusData(); + + RdaStatusData(const Message&) = delete; + RdaStatusData& operator=(const RdaStatusData&) = delete; + + RdaStatusData(RdaStatusData&&) noexcept; + RdaStatusData& operator=(RdaStatusData&&) noexcept; + + uint16_t rda_status() const; + uint16_t operability_status() const; + uint16_t control_status() const; + uint16_t auxiliary_power_generator_state() const; + uint16_t average_transmitter_power() const; + float horizontal_reflectivity_calibration_correction() const; + uint16_t data_transmission_enabled() const; + uint16_t volume_coverage_pattern_number() const; + uint16_t rda_control_authorization() const; + uint16_t rda_build_number() const; + uint16_t operational_mode() const; + uint16_t super_resolution_status() const; + uint16_t clutter_mitigation_decision_status() const; + uint16_t avset_ebc_rda_log_data_status() const; + uint16_t rda_alarm_summary() const; + uint16_t command_acknowledgement() const; + uint16_t channel_control_status() const; + uint16_t spot_blanking_status() const; + uint16_t bypass_map_generation_date() const; + uint16_t bypass_map_generation_time() const; + uint16_t clutter_filter_map_generation_date() const; + uint16_t clutter_filter_map_generation_time() const; + float vertical_reflectivity_calibration_correction() const; + uint16_t transition_power_source_status() const; + uint16_t rms_control_status() const; + uint16_t performance_check_status() const; + uint16_t alarm_codes(unsigned i) const; + uint16_t signal_processing_options() const; + uint16_t status_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/source/scwx/wsr88d/ar2v_file.cpp b/wxdata/source/scwx/wsr88d/ar2v_file.cpp index a1f772f1..e265e669 100644 --- a/wxdata/source/scwx/wsr88d/ar2v_file.cpp +++ b/wxdata/source/scwx/wsr88d/ar2v_file.cpp @@ -52,7 +52,7 @@ Ar2vFile& Ar2vFile::operator=(Ar2vFile&&) noexcept = default; bool Ar2vFile::LoadFile(const std::string& filename) { - BOOST_LOG_TRIVIAL(debug) << logPrefix_ << "LoadFile(" << filename << ")\n"; + BOOST_LOG_TRIVIAL(debug) << logPrefix_ << "LoadFile(" << filename << ")"; bool fileValid = true; std::ifstream f(filename, std::ios_base::in | std::ios_base::binary); diff --git a/wxdata/source/scwx/wsr88d/rda/message_factory.cpp b/wxdata/source/scwx/wsr88d/rda/message_factory.cpp index 6230c7f4..a3735bc1 100644 --- a/wxdata/source/scwx/wsr88d/rda/message_factory.cpp +++ b/wxdata/source/scwx/wsr88d/rda/message_factory.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include @@ -24,6 +25,7 @@ typedef std::function(MessageHeader&&, std::istream&)> CreateMessageFunction; static const std::unordered_map create_ { + {2, RdaStatusData::Create}, {3, PerformanceMaintenanceData::Create}, {5, VolumeCoveragePatternData::Create}, {15, ClutterFilterMap::Create}, diff --git a/wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp b/wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp new file mode 100644 index 00000000..92608937 --- /dev/null +++ b/wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp @@ -0,0 +1,336 @@ +#include + +#include + +namespace scwx +{ +namespace wsr88d +{ +namespace rda +{ + +static const std::string logPrefix_ = "[scwx::wsr88d::rda::rda_status_data] "; + +class RdaStatusDataImpl +{ +public: + explicit RdaStatusDataImpl() : + rdaStatus_ {0}, + operabilityStatus_ {0}, + controlStatus_ {0}, + auxiliaryPowerGeneratorState_ {0}, + averageTransmitterPower_ {0}, + horizontalReflectivityCalibrationCorrection_ {0}, + dataTransmissionEnabled_ {0}, + volumeCoveragePatternNumber_ {0}, + rdaControlAuthorization_ {0}, + rdaBuildNumber_ {0}, + operationalMode_ {0}, + superResolutionStatus_ {0}, + clutterMitigationDecisionStatus_ {0}, + avsetEbcRdaLogDataStatus_ {0}, + rdaAlarmSummary_ {0}, + commandAcknowledgement_ {0}, + channelControlStatus_ {0}, + spotBlankingStatus_ {0}, + bypassMapGenerationDate_ {0}, + bypassMapGenerationTime_ {0}, + clutterFilterMapGenerationDate_ {0}, + clutterFilterMapGenerationTime_ {0}, + verticalReflectivityCalibrationCorrection_ {0}, + transitionPowerSourceStatus_ {0}, + rmsControlStatus_ {0}, + performanceCheckStatus_ {0}, + alarmCodes_ {0}, + signalProcessingOptions_ {0}, + statusVersion_ {0} {}; + ~RdaStatusDataImpl() = default; + + uint16_t rdaStatus_; + uint16_t operabilityStatus_; + uint16_t controlStatus_; + uint16_t auxiliaryPowerGeneratorState_; + uint16_t averageTransmitterPower_; + int16_t horizontalReflectivityCalibrationCorrection_; + uint16_t dataTransmissionEnabled_; + uint16_t volumeCoveragePatternNumber_; + uint16_t rdaControlAuthorization_; + uint16_t rdaBuildNumber_; + uint16_t operationalMode_; + uint16_t superResolutionStatus_; + uint16_t clutterMitigationDecisionStatus_; + uint16_t avsetEbcRdaLogDataStatus_; + uint16_t rdaAlarmSummary_; + uint16_t commandAcknowledgement_; + uint16_t channelControlStatus_; + uint16_t spotBlankingStatus_; + uint16_t bypassMapGenerationDate_; + uint16_t bypassMapGenerationTime_; + uint16_t clutterFilterMapGenerationDate_; + uint16_t clutterFilterMapGenerationTime_; + int16_t verticalReflectivityCalibrationCorrection_; + uint16_t transitionPowerSourceStatus_; + uint16_t rmsControlStatus_; + uint16_t performanceCheckStatus_; + std::array alarmCodes_; + uint16_t signalProcessingOptions_; + uint16_t statusVersion_; +}; + +RdaStatusData::RdaStatusData() : + Message(), p(std::make_unique()) +{ +} +RdaStatusData::~RdaStatusData() = default; + +RdaStatusData::RdaStatusData(RdaStatusData&&) noexcept = default; +RdaStatusData& RdaStatusData::operator=(RdaStatusData&&) noexcept = default; + +uint16_t RdaStatusData::rda_status() const +{ + return p->rdaStatus_; +} + +uint16_t RdaStatusData::operability_status() const +{ + return p->operabilityStatus_; +} + +uint16_t RdaStatusData::control_status() const +{ + return p->controlStatus_; +} + +uint16_t RdaStatusData::auxiliary_power_generator_state() const +{ + return p->auxiliaryPowerGeneratorState_; +} + +uint16_t RdaStatusData::average_transmitter_power() const +{ + return p->averageTransmitterPower_; +} + +float RdaStatusData::horizontal_reflectivity_calibration_correction() const +{ + return p->horizontalReflectivityCalibrationCorrection_ * 0.01f; +} + +uint16_t RdaStatusData::data_transmission_enabled() const +{ + return p->dataTransmissionEnabled_; +} + +uint16_t RdaStatusData::volume_coverage_pattern_number() const +{ + return p->volumeCoveragePatternNumber_; +} + +uint16_t RdaStatusData::rda_control_authorization() const +{ + return p->rdaControlAuthorization_; +} + +uint16_t RdaStatusData::rda_build_number() const +{ + return p->rdaBuildNumber_; +} + +uint16_t RdaStatusData::operational_mode() const +{ + return p->operationalMode_; +} + +uint16_t RdaStatusData::super_resolution_status() const +{ + return p->superResolutionStatus_; +} + +uint16_t RdaStatusData::clutter_mitigation_decision_status() const +{ + return p->clutterMitigationDecisionStatus_; +} + +uint16_t RdaStatusData::avset_ebc_rda_log_data_status() const +{ + return p->avsetEbcRdaLogDataStatus_; +} + +uint16_t RdaStatusData::rda_alarm_summary() const +{ + return p->rdaAlarmSummary_; +} + +uint16_t RdaStatusData::command_acknowledgement() const +{ + return p->commandAcknowledgement_; +} + +uint16_t RdaStatusData::channel_control_status() const +{ + return p->channelControlStatus_; +} + +uint16_t RdaStatusData::spot_blanking_status() const +{ + return p->spotBlankingStatus_; +} + +uint16_t RdaStatusData::bypass_map_generation_date() const +{ + return p->bypassMapGenerationDate_; +} + +uint16_t RdaStatusData::bypass_map_generation_time() const +{ + return p->bypassMapGenerationTime_; +} + +uint16_t RdaStatusData::clutter_filter_map_generation_date() const +{ + return p->clutterFilterMapGenerationDate_; +} + +uint16_t RdaStatusData::clutter_filter_map_generation_time() const +{ + return p->clutterFilterMapGenerationTime_; +} + +float RdaStatusData::vertical_reflectivity_calibration_correction() const +{ + return p->verticalReflectivityCalibrationCorrection_ * 0.01f; +} + +uint16_t RdaStatusData::transition_power_source_status() const +{ + return p->transitionPowerSourceStatus_; +} + +uint16_t RdaStatusData::rms_control_status() const +{ + return p->rmsControlStatus_; +} + +uint16_t RdaStatusData::performance_check_status() const +{ + return p->performanceCheckStatus_; +} + +uint16_t RdaStatusData::alarm_codes(unsigned i) const +{ + return p->alarmCodes_[i]; +} + +uint16_t RdaStatusData::signal_processing_options() const +{ + return p->signalProcessingOptions_; +} + +uint16_t RdaStatusData::status_version() const +{ + return p->statusVersion_; +} + +bool RdaStatusData::Parse(std::istream& is) +{ + BOOST_LOG_TRIVIAL(debug) + << logPrefix_ << "Parsing RDA Status Data (Message Type 2)"; + + bool messageValid = true; + size_t bytesRead = 0; + + is.read(reinterpret_cast(&p->rdaStatus_), 2); // 1 + is.read(reinterpret_cast(&p->operabilityStatus_), 2); // 2 + is.read(reinterpret_cast(&p->controlStatus_), 2); // 3 + is.read(reinterpret_cast(&p->auxiliaryPowerGeneratorState_), 2); // 4 + is.read(reinterpret_cast(&p->averageTransmitterPower_), 2); // 5 + is.read( + reinterpret_cast(&p->horizontalReflectivityCalibrationCorrection_), + 2); // 6 + is.read(reinterpret_cast(&p->dataTransmissionEnabled_), 2); // 7 + is.read(reinterpret_cast(&p->volumeCoveragePatternNumber_), 2); // 8 + is.read(reinterpret_cast(&p->rdaControlAuthorization_), 2); // 9 + is.read(reinterpret_cast(&p->rdaBuildNumber_), 2); // 10 + is.read(reinterpret_cast(&p->operationalMode_), 2); // 11 + is.read(reinterpret_cast(&p->superResolutionStatus_), 2); // 12 + is.read(reinterpret_cast(&p->clutterMitigationDecisionStatus_), + 2); // 13 + is.read(reinterpret_cast(&p->avsetEbcRdaLogDataStatus_), 2); // 14 + is.read(reinterpret_cast(&p->rdaAlarmSummary_), 2); // 15 + is.read(reinterpret_cast(&p->commandAcknowledgement_), 2); // 16 + is.read(reinterpret_cast(&p->channelControlStatus_), 2); // 17 + is.read(reinterpret_cast(&p->spotBlankingStatus_), 2); // 18 + is.read(reinterpret_cast(&p->bypassMapGenerationDate_), 2); // 19 + is.read(reinterpret_cast(&p->bypassMapGenerationTime_), 2); // 20 + is.read(reinterpret_cast(&p->clutterFilterMapGenerationDate_), + 2); // 21 + is.read(reinterpret_cast(&p->clutterFilterMapGenerationTime_), + 2); // 22 + is.read( + reinterpret_cast(&p->verticalReflectivityCalibrationCorrection_), + 2); // 23 + is.read(reinterpret_cast(&p->transitionPowerSourceStatus_), 2); // 24 + is.read(reinterpret_cast(&p->rmsControlStatus_), 2); // 25 + is.read(reinterpret_cast(&p->performanceCheckStatus_), 2); // 26 + is.read(reinterpret_cast(&p->alarmCodes_), + p->alarmCodes_.size() * 2); // 27-40 + is.read(reinterpret_cast(&p->signalProcessingOptions_), 2); // 41 + is.seekg(36, std::ios_base::cur); // 42-59 + is.read(reinterpret_cast(&p->statusVersion_), 2); // 42 + bytesRead += 120; + + p->rdaStatus_ = htons(p->rdaStatus_); + p->operabilityStatus_ = htons(p->operabilityStatus_); + p->controlStatus_ = htons(p->controlStatus_); + p->auxiliaryPowerGeneratorState_ = htons(p->auxiliaryPowerGeneratorState_); + p->averageTransmitterPower_ = htons(p->averageTransmitterPower_); + p->horizontalReflectivityCalibrationCorrection_ = + htons(p->horizontalReflectivityCalibrationCorrection_); + p->dataTransmissionEnabled_ = htons(p->dataTransmissionEnabled_); + p->volumeCoveragePatternNumber_ = htons(p->volumeCoveragePatternNumber_); + p->rdaControlAuthorization_ = htons(p->rdaControlAuthorization_); + p->rdaBuildNumber_ = htons(p->rdaBuildNumber_); + p->operationalMode_ = htons(p->operationalMode_); + p->superResolutionStatus_ = htons(p->superResolutionStatus_); + p->clutterMitigationDecisionStatus_ = + htons(p->clutterMitigationDecisionStatus_); + p->avsetEbcRdaLogDataStatus_ = htons(p->avsetEbcRdaLogDataStatus_); + p->rdaAlarmSummary_ = htons(p->rdaAlarmSummary_); + p->commandAcknowledgement_ = htons(p->commandAcknowledgement_); + p->channelControlStatus_ = htons(p->channelControlStatus_); + p->spotBlankingStatus_ = htons(p->spotBlankingStatus_); + p->bypassMapGenerationDate_ = htons(p->bypassMapGenerationDate_); + p->bypassMapGenerationTime_ = htons(p->bypassMapGenerationTime_); + p->clutterFilterMapGenerationDate_ = + htons(p->clutterFilterMapGenerationDate_); + p->clutterFilterMapGenerationTime_ = + htons(p->clutterFilterMapGenerationTime_); + p->verticalReflectivityCalibrationCorrection_ = + htons(p->verticalReflectivityCalibrationCorrection_); + p->transitionPowerSourceStatus_ = htons(p->transitionPowerSourceStatus_); + p->rmsControlStatus_ = htons(p->rmsControlStatus_); + p->performanceCheckStatus_ = htons(p->performanceCheckStatus_); + SwapUInt16Array(p->alarmCodes_); + p->signalProcessingOptions_ = htons(p->signalProcessingOptions_); + p->statusVersion_ = htons(p->statusVersion_); + + if (!ValidateMessage(is, bytesRead)) + { + messageValid = false; + } + + return messageValid; +} + +std::unique_ptr RdaStatusData::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/wxdata.cmake b/wxdata/wxdata.cmake index 80ab7a2e..a76bbe0a 100644 --- a/wxdata/wxdata.cmake +++ b/wxdata/wxdata.cmake @@ -14,6 +14,7 @@ set(HDR_WSR88D_RDA include/scwx/wsr88d/rda/clutter_filter_map.hpp include/scwx/wsr88d/rda/message_header.hpp include/scwx/wsr88d/rda/performance_maintenance_data.hpp include/scwx/wsr88d/rda/rda_adaptation_data.hpp + include/scwx/wsr88d/rda/rda_status_data.hpp include/scwx/wsr88d/rda/volume_coverage_pattern_data.hpp) set(SRC_WSR88D_RDA source/scwx/wsr88d/rda/clutter_filter_map.cpp source/scwx/wsr88d/rda/message.cpp @@ -21,6 +22,7 @@ set(SRC_WSR88D_RDA source/scwx/wsr88d/rda/clutter_filter_map.cpp source/scwx/wsr88d/rda/message_header.cpp source/scwx/wsr88d/rda/performance_maintenance_data.cpp source/scwx/wsr88d/rda/rda_adaptation_data.cpp + source/scwx/wsr88d/rda/rda_status_data.cpp source/scwx/wsr88d/rda/volume_coverage_pattern_data.cpp) add_library(wxdata OBJECT ${HDR_UTIL}