mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-15 04:30:33 +00:00
Code Issues Releases Wiki Activity

Get TOW in E6 channels

Browse Source
This commit is contained in:
Carles Fernandez 2022-06-04 11:49:44 +02:00
parent 92e3d043d2
commit ac0209f16f
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
6 changed files with 92 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_telemetry_decoder_gs.cc
View File

@ -88,7 +88,7 @@ galileo_telemetry_decoder_gs::galileo_telemetry_decoder_gs(
d_stat(0), d_stat(0),
d_TOW_at_Preamble_ms(0), d_TOW_at_Preamble_ms(0),
d_TOW_at_current_symbol_ms(0), d_TOW_at_current_symbol_ms(0),
d_received_tow(std::numeric_limits<uint32_t>::max()), d_received_tow_ms(std::numeric_limits<uint32_t>::max()),
d_band('1'), d_band('1'),
d_sent_tlm_failed_msg(false), d_sent_tlm_failed_msg(false),
d_flag_frame_sync(false), d_flag_frame_sync(false),
@ -104,7 +104,8 @@ galileo_telemetry_decoder_gs::galileo_telemetry_decoder_gs(
d_dump_crc_stats(conf.dump_crc_stats), d_dump_crc_stats(conf.dump_crc_stats),
d_enable_reed_solomon_inav(false), d_enable_reed_solomon_inav(false),
d_valid_timetag(false), d_valid_timetag(false),
d_E6_TOW_set(false) d_E6_TOW_set(false),
d_there_are_e6_channels(conf.there_are_e6_channels)
{ {
// prevent telemetry symbols accumulation in output buffers // prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1); this->set_max_noutput_items(1);
@ -112,17 +113,13 @@ galileo_telemetry_decoder_gs::galileo_telemetry_decoder_gs(
this->message_port_register_out(pmt::mp("telemetry")); this->message_port_register_out(pmt::mp("telemetry"));
// Control messages to tracking block // Control messages to tracking block
this->message_port_register_out(pmt::mp("telemetry_to_trk")); this->message_port_register_out(pmt::mp("telemetry_to_trk"));
if (d_there_are_e6_channels)
{
// register Gal E6 messages HAS out // register Gal E6 messages HAS out
this->message_port_register_out(pmt::mp("E6_HAS_from_TLM")); this->message_port_register_out(pmt::mp("E6_HAS_from_TLM"));
// register TOW from map out // register TOW from map out
this->message_port_register_out(pmt::mp("TOW_from_TLM")); this->message_port_register_out(pmt::mp("TOW_from_TLM"));
if (d_enable_navdata_monitor)
{
// register nav message monitor out
this->message_port_register_out(pmt::mp("Nav_msg_from_TLM"));
}
// register TOW to TLM input // register TOW to TLM input
this->message_port_register_in(pmt::mp("TOW_to_TLM")); this->message_port_register_in(pmt::mp("TOW_to_TLM"));
// handler for input port // handler for input port
@ -136,6 +133,13 @@ galileo_telemetry_decoder_gs::galileo_telemetry_decoder_gs(
boost::bind(&galileo_telemetry_decoder_gs::msg_handler_read_galileo_tow_map, this, _1)); boost::bind(&galileo_telemetry_decoder_gs::msg_handler_read_galileo_tow_map, this, _1));
#endif #endif
#endif #endif
}
if (d_enable_navdata_monitor)
{
// register nav message monitor out
this->message_port_register_out(pmt::mp("Nav_msg_from_TLM"));
}
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN()); d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
@ -319,7 +323,6 @@ void galileo_telemetry_decoder_gs::msg_handler_read_galileo_tow_map(const pmt::p
{ {
if (d_frame_type == 3) if (d_frame_type == 3)
{ {
// Check if the input has the right format
try try
{ {
const size_t msg_type_hash_code = pmt::any_ref(msg).type().hash_code(); const size_t msg_type_hash_code = pmt::any_ref(msg).type().hash_code();
@ -327,9 +330,9 @@ void galileo_telemetry_decoder_gs::msg_handler_read_galileo_tow_map(const pmt::p
{ {
const auto received_tow_map = wht::any_cast<std::shared_ptr<std::map<uint32_t, std::pair<uint32_t, uint64_t>>>>(pmt::any_ref(msg)); const auto received_tow_map = wht::any_cast<std::shared_ptr<std::map<uint32_t, std::pair<uint32_t, uint64_t>>>>(pmt::any_ref(msg));
const std::pair<uint32_t, uint64_t> received_tow_sample = received_tow_map->at(d_satellite.get_PRN()); const std::pair<uint32_t, uint64_t> received_tow_sample = received_tow_map->at(d_satellite.get_PRN());
if (received_tow_sample.first < 604800) if (received_tow_sample.first < 604800000)
{ {
d_received_tow = received_tow_sample.first; d_received_tow_ms = received_tow_sample.first;
d_received_sample_counter = received_tow_sample.second; d_received_sample_counter = received_tow_sample.second;
} }
} }
@ -615,6 +618,12 @@ void galileo_telemetry_decoder_gs::decode_CNAV_word(uint64_t time_stamp, float *
page_String.push_back('0'); page_String.push_back('0');
} }
} }
if (d_enable_navdata_monitor)
{
d_nav_msg_packet.nav_message = page_String;
}
d_cnav_nav.read_HAS_page(page_String); d_cnav_nav.read_HAS_page(page_String);
d_cnav_nav.set_time_stamp(time_stamp); d_cnav_nav.set_time_stamp(time_stamp);
// 4. If we have a new HAS page, read it // 4. If we have a new HAS page, read it
@ -969,9 +978,12 @@ int galileo_telemetry_decoder_gs::general_work(int noutput_items __attribute__((
d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_inav_nav.get_TOW5() * 1000.0); d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_inav_nav.get_TOW5() * 1000.0);
d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>(GALILEO_INAV_PAGE_PART_MS + (d_required_symbols + 1) * d_PRN_code_period_ms); d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>(GALILEO_INAV_PAGE_PART_MS + (d_required_symbols + 1) * d_PRN_code_period_ms);
d_inav_nav.set_TOW5_flag(false); d_inav_nav.set_TOW5_flag(false);
const std::pair<uint32_t, uint64_t> tow_and_sample{d_inav_nav.get_TOW5(), current_symbol.Tracking_sample_counter}; if (d_there_are_e6_channels && !d_valid_timetag)
{
const std::pair<uint32_t, uint64_t> tow_and_sample{d_TOW_at_current_symbol_ms, current_symbol.Tracking_sample_counter};
const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample); const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample);
this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj)); this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj));
}
// timetag debug // timetag debug
if (d_valid_timetag == true) if (d_valid_timetag == true)
{ {
@ -992,9 +1004,12 @@ int galileo_telemetry_decoder_gs::general_work(int noutput_items __attribute__((
d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_inav_nav.get_TOW6() * 1000.0); d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_inav_nav.get_TOW6() * 1000.0);
d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>(GALILEO_INAV_PAGE_PART_MS + (d_required_symbols + 1) * d_PRN_code_period_ms); d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>(GALILEO_INAV_PAGE_PART_MS + (d_required_symbols + 1) * d_PRN_code_period_ms);
d_inav_nav.set_TOW6_flag(false); d_inav_nav.set_TOW6_flag(false);
const std::pair<uint32_t, uint64_t> tow_and_sample{d_inav_nav.get_TOW6(), current_symbol.Tracking_sample_counter}; if (d_there_are_e6_channels && !d_valid_timetag)
{
const std::pair<uint32_t, uint64_t> tow_and_sample{d_TOW_at_current_symbol_ms, current_symbol.Tracking_sample_counter};
const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample); const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample);
this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj)); this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj));
}
// timetag debug // timetag debug
if (d_valid_timetag == true) if (d_valid_timetag == true)
{ {
@ -1014,9 +1029,12 @@ int galileo_telemetry_decoder_gs::general_work(int noutput_items __attribute__((
d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_inav_nav.get_TOW0() * 1000.0); d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_inav_nav.get_TOW0() * 1000.0);
d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>(GALILEO_INAV_PAGE_PART_MS + (d_required_symbols + 1) * d_PRN_code_period_ms); d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>(GALILEO_INAV_PAGE_PART_MS + (d_required_symbols + 1) * d_PRN_code_period_ms);
d_inav_nav.set_TOW0_flag(false); d_inav_nav.set_TOW0_flag(false);
const std::pair<uint32_t, uint64_t> tow_and_sample{d_inav_nav.get_TOW0(), current_symbol.Tracking_sample_counter}; if (d_there_are_e6_channels && !d_valid_timetag)
{
const std::pair<uint32_t, uint64_t> tow_and_sample{d_TOW_at_current_symbol_ms, current_symbol.Tracking_sample_counter};
const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample); const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample);
this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj)); this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj));
}
// timetag debug // timetag debug
if (d_valid_timetag == true) if (d_valid_timetag == true)
{ {
@ -1056,42 +1074,50 @@ int galileo_telemetry_decoder_gs::general_work(int noutput_items __attribute__((
{ {
d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_fnav_nav.get_TOW1() * 1000.0); d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_fnav_nav.get_TOW1() * 1000.0);
d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS); d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS);
// d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((GALILEO_FNAV_CODES_PER_PAGE + GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD_MS);
d_fnav_nav.set_TOW1_flag(false); d_fnav_nav.set_TOW1_flag(false);
const std::pair<uint32_t, uint64_t> tow_and_sample{d_fnav_nav.get_TOW1(), current_symbol.Tracking_sample_counter}; if (d_there_are_e6_channels && !d_valid_timetag)
{
const std::pair<uint32_t, uint64_t> tow_and_sample{d_TOW_at_current_symbol_ms, current_symbol.Tracking_sample_counter};
const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample); const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample);
this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj)); this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj));
} }
}
else if (d_fnav_nav.is_TOW2_set() == true) else if (d_fnav_nav.is_TOW2_set() == true)
{ {
d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_fnav_nav.get_TOW2() * 1000.0); d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_fnav_nav.get_TOW2() * 1000.0);
// d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((GALILEO_FNAV_CODES_PER_PAGE + GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD_MS);
d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS); d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS);
d_fnav_nav.set_TOW2_flag(false); d_fnav_nav.set_TOW2_flag(false);
const std::pair<uint32_t, uint64_t> tow_and_sample{d_fnav_nav.get_TOW2(), current_symbol.Tracking_sample_counter}; if (d_there_are_e6_channels && !d_valid_timetag)
{
const std::pair<uint32_t, uint64_t> tow_and_sample{d_TOW_at_current_symbol_ms, current_symbol.Tracking_sample_counter};
const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample); const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample);
this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj)); this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj));
} }
}
else if (d_fnav_nav.is_TOW3_set() == true) else if (d_fnav_nav.is_TOW3_set() == true)
{ {
d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_fnav_nav.get_TOW3() * 1000.0); d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_fnav_nav.get_TOW3() * 1000.0);
// d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((GALILEO_FNAV_CODES_PER_PAGE + GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD_MS);
d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS); d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS);
d_fnav_nav.set_TOW3_flag(false); d_fnav_nav.set_TOW3_flag(false);
const std::pair<uint32_t, uint64_t> tow_and_sample{d_fnav_nav.get_TOW3(), current_symbol.Tracking_sample_counter}; if (d_there_are_e6_channels && !d_valid_timetag)
{
const std::pair<uint32_t, uint64_t> tow_and_sample{d_TOW_at_current_symbol_ms, current_symbol.Tracking_sample_counter};
const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample); const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample);
this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj)); this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj));
} }
}
else if (d_fnav_nav.is_TOW4_set() == true) else if (d_fnav_nav.is_TOW4_set() == true)
{ {
d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_fnav_nav.get_TOW4() * 1000.0); d_TOW_at_Preamble_ms = static_cast<uint32_t>(d_fnav_nav.get_TOW4() * 1000.0);
// d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((GALILEO_FNAV_CODES_PER_PAGE + GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD_MS);
d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS); d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS);
d_fnav_nav.set_TOW4_flag(false); d_fnav_nav.set_TOW4_flag(false);
const std::pair<uint32_t, uint64_t> tow_and_sample{d_fnav_nav.get_TOW4(), current_symbol.Tracking_sample_counter}; if (d_there_are_e6_channels && !d_valid_timetag)
{
const std::pair<uint32_t, uint64_t> tow_and_sample{d_TOW_at_current_symbol_ms, current_symbol.Tracking_sample_counter};
const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample); const auto tmp_obj = std::make_shared<std::pair<uint32_t, std::pair<uint32_t, uint64_t>>>(d_satellite.get_PRN(), tow_and_sample);
this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj)); this->message_port_pub(pmt::mp("TOW_from_TLM"), pmt::make_any(tmp_obj));
} }
}
else else
{ {
d_TOW_at_current_symbol_ms += static_cast<uint32_t>(GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS); d_TOW_at_current_symbol_ms += static_cast<uint32_t>(GALILEO_FNAV_CODES_PER_SYMBOL * GALILEO_E5A_CODE_PERIOD_MS);
@ -1113,18 +1139,15 @@ int galileo_telemetry_decoder_gs::general_work(int noutput_items __attribute__((
{ {
if (!d_valid_timetag) if (!d_valid_timetag)
{ {
if (d_received_tow < 604800) if (d_received_tow_ms < 604800000)
{ {
const int64_t diff = d_received_sample_counter - current_symbol.Tracking_sample_counter; const int64_t diff = current_symbol.Tracking_sample_counter - d_received_sample_counter;
bool overflowed = (diff < 0) ^ (d_received_sample_counter < current_symbol.Tracking_sample_counter); const double time_since_reference_ms = (double(diff) * 1000.0) / static_cast<double>(current_symbol.fs);
if (!overflowed && (std::abs(diff) / static_cast<int64_t>(current_symbol.fs) < 1.0)) d_TOW_at_current_symbol_ms = d_received_tow_ms + static_cast<uint32_t>(time_since_reference_ms);
{ d_TOW_at_Preamble_ms = (d_TOW_at_current_symbol_ms / 1000) * 1000;
d_TOW_at_Preamble_ms = d_received_tow * 1000;
d_TOW_at_current_symbol_ms = d_TOW_at_Preamble_ms + static_cast<uint32_t>((d_required_symbols + 1) * GALILEO_CNAV_SYMBOLS_PER_PAGE * GALILEO_CNAV_PAGE_MS);
d_E6_TOW_set = true; d_E6_TOW_set = true;
} }
} }
}
if (d_E6_TOW_set && d_enable_navdata_monitor && !d_nav_msg_packet.nav_message.empty()) if (d_E6_TOW_set && d_enable_navdata_monitor && !d_nav_msg_packet.nav_message.empty())
{ {
d_nav_msg_packet.system = std::string(1, current_symbol.System); d_nav_msg_packet.system = std::string(1, current_symbol.System);

3
src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_telemetry_decoder_gs.h
View File

@ -133,7 +133,7 @@ private:
uint32_t d_TOW_at_Preamble_ms; uint32_t d_TOW_at_Preamble_ms;
uint32_t d_TOW_at_current_symbol_ms; uint32_t d_TOW_at_current_symbol_ms;
uint32_t d_max_symbols_without_valid_frame; uint32_t d_max_symbols_without_valid_frame;
uint32_t d_received_tow; uint32_t d_received_tow_ms;
char d_band; // This variable will store which band we are dealing with (Galileo E1 or E5b) char d_band; // This variable will store which band we are dealing with (Galileo E1 or E5b)
@ -152,6 +152,7 @@ private:
bool d_enable_reed_solomon_inav; bool d_enable_reed_solomon_inav;
bool d_valid_timetag; bool d_valid_timetag;
bool d_E6_TOW_set; bool d_E6_TOW_set;
bool d_there_are_e6_channels;
}; };

4
src/algorithms/telemetry_decoder/libs/tlm_conf.cc
View File

@ -30,4 +30,8 @@ void Tlm_Conf::SetFromConfiguration(const ConfigurationInterface *configuration,
const std::string default_crc_stats_dumpname("telemetry_crc_stats"); const std::string default_crc_stats_dumpname("telemetry_crc_stats");
dump_crc_stats_filename = configuration->property(role + ".dump_crc_stats_filename", default_crc_stats_dumpname); dump_crc_stats_filename = configuration->property(role + ".dump_crc_stats_filename", default_crc_stats_dumpname);
enable_navdata_monitor = configuration->property("NavDataMonitor.enable_monitor", false); enable_navdata_monitor = configuration->property("NavDataMonitor.enable_monitor", false);
if (configuration->property("Channels_E6.count", 0) > 0)
{
there_are_e6_channels = true;
}
} }

1
src/algorithms/telemetry_decoder/libs/tlm_conf.h
View File

@ -42,6 +42,7 @@ public:
bool enable_reed_solomon{false}; // for INAV message in Galileo E1B bool enable_reed_solomon{false}; // for INAV message in Galileo E1B
bool dump_crc_stats{false}; // telemetry CRC statistics bool dump_crc_stats{false}; // telemetry CRC statistics
bool enable_navdata_monitor{false}; bool enable_navdata_monitor{false};
bool there_are_e6_channels{false};
}; };

14
src/core/libs/galileo_tow_map.cc
View File

@ -58,7 +58,7 @@ galileo_tow_map::galileo_tow_map() : gr::block("galileo_tow_map", gr::io_signatu
#endif #endif
#endif #endif
for (uint32_t prn = 1; prn < 37; prn++) for (uint32_t prn = 0; prn < 37; prn++)
{ {
d_galileo_tow[prn] = std::pair<uint32_t, uint64_t>(std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint64_t>::max()); d_galileo_tow[prn] = std::pair<uint32_t, uint64_t>(std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint64_t>::max());
} }
@ -67,9 +67,7 @@ galileo_tow_map::galileo_tow_map() : gr::block("galileo_tow_map", gr::io_signatu
void galileo_tow_map::msg_handler_galileo_tow_map(const pmt::pmt_t& msg) void galileo_tow_map::msg_handler_galileo_tow_map(const pmt::pmt_t& msg)
{ {
gr::thread::scoped_lock lock(d_setlock); // require mutex with msg_handler_galileo_e6_has function called by the scheduler gr::thread::scoped_lock lock(d_setlock);
// Check if the input has the right format
try try
{ {
const size_t msg_type_hash_code = pmt::any_ref(msg).type().hash_code(); const size_t msg_type_hash_code = pmt::any_ref(msg).type().hash_code();
@ -80,9 +78,8 @@ void galileo_tow_map::msg_handler_galileo_tow_map(const pmt::pmt_t& msg)
const uint32_t received_tow = received_tow_map->second.first; const uint32_t received_tow = received_tow_map->second.first;
const uint64_t received_sample_counter = received_tow_map->second.second; const uint64_t received_sample_counter = received_tow_map->second.second;
//uint64_t sample_counter = std::numeric_limits<uint32_t>::max();
d_galileo_tow.erase(received_prn); d_galileo_tow.erase(received_prn);
if (received_tow < 604800) if (received_tow < 604800000) // received TOW is in ms
{ {
d_galileo_tow[received_prn] = std::pair<uint32_t, uint64_t>(received_tow, received_sample_counter); d_galileo_tow[received_prn] = std::pair<uint32_t, uint64_t>(received_tow, received_sample_counter);
} }
@ -90,13 +87,12 @@ void galileo_tow_map::msg_handler_galileo_tow_map(const pmt::pmt_t& msg)
{ {
d_galileo_tow[received_prn] = std::pair<uint32_t, uint64_t>(std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint64_t>::max()); d_galileo_tow[received_prn] = std::pair<uint32_t, uint64_t>(std::numeric_limits<uint32_t>::max(), std::numeric_limits<uint64_t>::max());
} }
const std::shared_ptr<std::map<uint32_t, std::pair<uint32_t, uint64_t>>> tmp_obj = std::make_shared<std::map<uint32_t, std::pair<uint32_t, uint64_t>>>(d_galileo_tow);
this->message_port_pub(pmt::mp("TOW_to_TLM"), pmt::make_any(tmp_obj));
} }
} }
catch (const wht::bad_any_cast& e) catch (const wht::bad_any_cast& e)
{ {
LOG(WARNING) << "galileo_tow_map Bad any_cast: " << e.what(); LOG(WARNING) << "galileo_tow_map Bad any_cast: " << e.what();
} }
const std::shared_ptr<std::map<uint32_t, std::pair<uint32_t, uint64_t>>> tmp_obj = std::make_shared<std::map<uint32_t, std::pair<uint32_t, uint64_t>>>(d_galileo_tow);
this->message_port_pub(pmt::mp("TOW_to_TLM"), pmt::make_any(tmp_obj));
} }

2
src/core/libs/galileo_tow_map.h
View File

@ -39,8 +39,6 @@ class galileo_tow_map : public gr::block
{ {
public: public:
~galileo_tow_map() = default; //!< Default destructor ~galileo_tow_map() = default; //!< Default destructor
// void set_enable_navdata_monitor(bool enable);
// std::shared_ptr<Galileo_HAS_data> process_test_page(const pmt::pmt_t& msg); //!< For testing purposes only
private: private:
friend galileo_tow_map_sptr galileo_tow_map_make(); friend galileo_tow_map_sptr galileo_tow_map_make();