Parse RDA Status Data (Message Type 2)

wxdata/include/scwx/wsr88d/rda/rda_status_data.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <scwx/wsr88d/rda/message.hpp>
+
+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<RdaStatusData> Create(MessageHeader&& header,
+                                                std::istream&   is);
+
+private:
+   std::unique_ptr<RdaStatusDataImpl> p;
+};
+
+} // namespace rda
+} // namespace wsr88d
+} // namespace scwx

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);

wxdata/source/scwx/wsr88d/rda/message_factory.cpp

@@ -4,6 +4,7 @@
 #include <scwx/wsr88d/rda/clutter_filter_map.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>
 
 #include <unordered_map>
@@ -24,6 +25,7 @@ typedef std::function<std::unique_ptr<Message>(MessageHeader&&, std::istream&)>
    CreateMessageFunction;
 
 static const std::unordered_map<uint8_t, CreateMessageFunction> create_ {
+   {2, RdaStatusData::Create},
    {3, PerformanceMaintenanceData::Create},
    {5, VolumeCoveragePatternData::Create},
    {15, ClutterFilterMap::Create},

wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp

@@ -0,0 +1,336 @@
+#include <scwx/wsr88d/rda/rda_status_data.hpp>
+
+#include <boost/log/trivial.hpp>
+
+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<uint16_t, 14> alarmCodes_;
+   uint16_t                 signalProcessingOptions_;
+   uint16_t                 statusVersion_;
+};
+
+RdaStatusData::RdaStatusData() :
+    Message(), p(std::make_unique<RdaStatusDataImpl>())
+{
+}
+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<char*>(&p->rdaStatus_), 2);                    // 1
+   is.read(reinterpret_cast<char*>(&p->operabilityStatus_), 2);            // 2
+   is.read(reinterpret_cast<char*>(&p->controlStatus_), 2);                // 3
+   is.read(reinterpret_cast<char*>(&p->auxiliaryPowerGeneratorState_), 2); // 4
+   is.read(reinterpret_cast<char*>(&p->averageTransmitterPower_), 2);      // 5
+   is.read(
+      reinterpret_cast<char*>(&p->horizontalReflectivityCalibrationCorrection_),
+      2);                                                                 // 6
+   is.read(reinterpret_cast<char*>(&p->dataTransmissionEnabled_), 2);     // 7
+   is.read(reinterpret_cast<char*>(&p->volumeCoveragePatternNumber_), 2); // 8
+   is.read(reinterpret_cast<char*>(&p->rdaControlAuthorization_), 2);     // 9
+   is.read(reinterpret_cast<char*>(&p->rdaBuildNumber_), 2);              // 10
+   is.read(reinterpret_cast<char*>(&p->operationalMode_), 2);             // 11
+   is.read(reinterpret_cast<char*>(&p->superResolutionStatus_), 2);       // 12
+   is.read(reinterpret_cast<char*>(&p->clutterMitigationDecisionStatus_),
+           2);                                                         // 13
+   is.read(reinterpret_cast<char*>(&p->avsetEbcRdaLogDataStatus_), 2); // 14
+   is.read(reinterpret_cast<char*>(&p->rdaAlarmSummary_), 2);          // 15
+   is.read(reinterpret_cast<char*>(&p->commandAcknowledgement_), 2);   // 16
+   is.read(reinterpret_cast<char*>(&p->channelControlStatus_), 2);     // 17
+   is.read(reinterpret_cast<char*>(&p->spotBlankingStatus_), 2);       // 18
+   is.read(reinterpret_cast<char*>(&p->bypassMapGenerationDate_), 2);  // 19
+   is.read(reinterpret_cast<char*>(&p->bypassMapGenerationTime_), 2);  // 20
+   is.read(reinterpret_cast<char*>(&p->clutterFilterMapGenerationDate_),
+           2); // 21
+   is.read(reinterpret_cast<char*>(&p->clutterFilterMapGenerationTime_),
+           2); // 22
+   is.read(
+      reinterpret_cast<char*>(&p->verticalReflectivityCalibrationCorrection_),
+      2);                                                                 // 23
+   is.read(reinterpret_cast<char*>(&p->transitionPowerSourceStatus_), 2); // 24
+   is.read(reinterpret_cast<char*>(&p->rmsControlStatus_), 2);            // 25
+   is.read(reinterpret_cast<char*>(&p->performanceCheckStatus_), 2);      // 26
+   is.read(reinterpret_cast<char*>(&p->alarmCodes_),
+           p->alarmCodes_.size() * 2);                                // 27-40
+   is.read(reinterpret_cast<char*>(&p->signalProcessingOptions_), 2); // 41
+   is.seekg(36, std::ios_base::cur);                                  // 42-59
+   is.read(reinterpret_cast<char*>(&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> RdaStatusData::Create(MessageHeader&& header,
+                                                     std::istream&   is)
+{
+   std::unique_ptr<RdaStatusData> message = std::make_unique<RdaStatusData>();
+   message->set_header(std::move(header));
+   message->Parse(is);
+   return message;
+}
+
+} // namespace rda
+} // namespace wsr88d
+} // namespace scwx

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}