blakeridgway/supercell-wx
1
0
Fork 0
mirror of https://github.com/ciphervance/supercell-wx.git synced 2025-10-30 06:50:06 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Parse RDA Status Data (Message Type 2)

Browse source
This commit is contained in:
Dan Paulat 2021-06-20 11:15:35 -05:00
parent 517c77cb5f
commit 6acb6a8c9d
5 changed files with 408 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

67
wxdata/include/scwx/wsr88d/rda/rda_status_data.hpp Normal file
View file

@ -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

2
wxdata/source/scwx/wsr88d/ar2v_file.cpp
View file

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

2
wxdata/source/scwx/wsr88d/rda/message_factory.cpp
View file

@ -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},

336
wxdata/source/scwx/wsr88d/rda/rda_status_data.cpp Normal file
View file

@ -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

2
wxdata/wxdata.cmake
View file

@ -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}