mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-09-02 19:07:59 +00:00
Code Issues Releases Wiki Activity

First pass to remove receiver_type

Browse Source
This commit is contained in:
Mathieu Favreau
2025-07-23 19:05:11 +00:00
parent 18a7bbd648
commit 18006bbbe9
12 changed files with 727 additions and 1346 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/algorithms/PVT/adapters/rtklib_pvt.cc
View File

@@ -191,7 +191,7 @@ Rtklib_Pvt::Rtklib_Pvt(const ConfigurationInterface* configuration,
pvt_output_parameters.an_rate_ms = configuration->property(role + ".an_rate_ms", pvt_output_parameters.an_rate_ms); pvt_output_parameters.an_rate_ms = configuration->property(role + ".an_rate_ms", pvt_output_parameters.an_rate_ms);
const Signal_Enabled_Flags signal_enabled_flags(configuration); const Signal_Enabled_Flags signal_enabled_flags(configuration);
pvt_output_parameters.type_of_receiver = get_type_of_receiver(signal_enabled_flags); pvt_output_parameters.signal_enabled_flags = signal_enabled_flags.flags;
// RTKLIB PVT solver options // RTKLIB PVT solver options
// Settings 1 // Settings 1

29
src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_gs.cc
View File

@@ -54,6 +54,7 @@
#include "nmea_printer.h" #include "nmea_printer.h"
#include "osnma_data.h" #include "osnma_data.h"
#include "pvt_conf.h" #include "pvt_conf.h"
#include "receiver_type.h"
#include "rinex_printer.h" #include "rinex_printer.h"
#include "rtcm_printer.h" #include "rtcm_printer.h"
#include "rtklib_rtkcmn.h" #include "rtklib_rtkcmn.h"
@@ -169,7 +170,7 @@ rtklib_pvt_gs::rtklib_pvt_gs(uint32_t nchannels,
d_report_rate_ms(1000), d_report_rate_ms(1000),
d_max_obs_block_rx_clock_offset_ms(conf_.max_obs_block_rx_clock_offset_ms), d_max_obs_block_rx_clock_offset_ms(conf_.max_obs_block_rx_clock_offset_ms),
d_nchannels(nchannels), d_nchannels(nchannels),
d_type_of_rx(conf_.type_of_receiver), d_signal_enabled_flags(conf_.signal_enabled_flags),
d_observable_interval_ms(conf_.observable_interval_ms), d_observable_interval_ms(conf_.observable_interval_ms),
d_pvt_errors_counter(0), d_pvt_errors_counter(0),
d_dump(conf_.dump), d_dump(conf_.dump),
@@ -455,8 +456,10 @@ rtklib_pvt_gs::rtklib_pvt_gs(uint32_t nchannels,
d_xml_base_path = d_xml_base_path + fs::path::preferred_separator; d_xml_base_path = d_xml_base_path + fs::path::preferred_separator;
} }
const Signal_Enabled_Flags signal_enabled_flags(d_signal_enabled_flags);
// Initialize HAS simple printer // Initialize HAS simple printer
d_enable_has_messages = (((d_type_of_rx >= 100) && (d_type_of_rx < 109)) && (conf_.output_enabled)); d_enable_has_messages = (signal_enabled_flags.check_any_enabled(GAL_E6) && (conf_.output_enabled));
if (d_enable_has_messages) if (d_enable_has_messages)
{ {
d_has_simple_printer = std::make_unique<Has_Simple_Printer>(conf_.has_output_file_path); d_has_simple_printer = std::make_unique<Has_Simple_Printer>(conf_.has_output_file_path);
@@ -573,19 +576,19 @@ rtklib_pvt_gs::rtklib_pvt_gs(uint32_t nchannels,
{ {
// setup two PVT solvers: internal solver for rx clock and user solver // setup two PVT solvers: internal solver for rx clock and user solver
// user PVT solver // user PVT solver
d_user_pvt_solver = std::make_shared<Rtklib_Solver>(rtk, conf_, dump_ls_pvt_filename, d_type_of_rx, d_dump, d_dump_mat); d_user_pvt_solver = std::make_shared<Rtklib_Solver>(rtk, conf_, dump_ls_pvt_filename, d_signal_enabled_flags, d_dump, d_dump_mat);
d_user_pvt_solver->set_pre_2009_file(conf_.pre_2009_file); d_user_pvt_solver->set_pre_2009_file(conf_.pre_2009_file);
// internal PVT solver, mainly used to estimate the receiver clock // internal PVT solver, mainly used to estimate the receiver clock
rtk_t internal_rtk = rtk; rtk_t internal_rtk = rtk;
internal_rtk.opt.mode = PMODE_SINGLE; // use single positioning mode in internal PVT solver internal_rtk.opt.mode = PMODE_SINGLE; // use single positioning mode in internal PVT solver
d_internal_pvt_solver = std::make_shared<Rtklib_Solver>(internal_rtk, conf_, dump_ls_pvt_filename, d_type_of_rx, false, false); d_internal_pvt_solver = std::make_shared<Rtklib_Solver>(internal_rtk, conf_, dump_ls_pvt_filename, d_signal_enabled_flags, false, false);
d_internal_pvt_solver->set_pre_2009_file(conf_.pre_2009_file); d_internal_pvt_solver->set_pre_2009_file(conf_.pre_2009_file);
} }
else else
{ {
// only one solver, customized by the user options // only one solver, customized by the user options
d_internal_pvt_solver = std::make_shared<Rtklib_Solver>(rtk, conf_, dump_ls_pvt_filename, d_type_of_rx, d_dump, d_dump_mat); d_internal_pvt_solver = std::make_shared<Rtklib_Solver>(rtk, conf_, dump_ls_pvt_filename, d_signal_enabled_flags, d_dump, d_dump_mat);
d_internal_pvt_solver->set_pre_2009_file(conf_.pre_2009_file); d_internal_pvt_solver->set_pre_2009_file(conf_.pre_2009_file);
d_user_pvt_solver = d_internal_pvt_solver; d_user_pvt_solver = d_internal_pvt_solver;
} }
@@ -1232,7 +1235,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record! // New record!
std::map<int32_t, Gps_Ephemeris> new_eph; std::map<int32_t, Gps_Ephemeris> new_eph;
new_eph[gps_eph->PRN] = *gps_eph; new_eph[gps_eph->PRN] = *gps_eph;
d_rp->log_rinex_nav_gps_nav(d_type_of_rx, new_eph); d_rp->log_rinex_nav_gps_nav(d_signal_enabled_flags, new_eph);
} }
} }
d_internal_pvt_solver->gps_ephemeris_map[gps_eph->PRN] = *gps_eph; d_internal_pvt_solver->gps_ephemeris_map[gps_eph->PRN] = *gps_eph;
@@ -1300,7 +1303,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record! // New record!
std::map<int32_t, Gps_CNAV_Ephemeris> new_cnav_eph; std::map<int32_t, Gps_CNAV_Ephemeris> new_cnav_eph;
new_cnav_eph[gps_cnav_ephemeris->PRN] = *gps_cnav_ephemeris; new_cnav_eph[gps_cnav_ephemeris->PRN] = *gps_cnav_ephemeris;
d_rp->log_rinex_nav_gps_cnav(d_type_of_rx, new_cnav_eph); d_rp->log_rinex_nav_gps_cnav(d_signal_enabled_flags, new_cnav_eph);
} }
} }
d_internal_pvt_solver->gps_cnav_ephemeris_map[gps_cnav_ephemeris->PRN] = *gps_cnav_ephemeris; d_internal_pvt_solver->gps_cnav_ephemeris_map[gps_cnav_ephemeris->PRN] = *gps_cnav_ephemeris;
@@ -1392,7 +1395,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record! // New record!
std::map<int32_t, Galileo_Ephemeris> new_gal_eph; std::map<int32_t, Galileo_Ephemeris> new_gal_eph;
new_gal_eph[galileo_eph->PRN] = *galileo_eph; new_gal_eph[galileo_eph->PRN] = *galileo_eph;
d_rp->log_rinex_nav_gal_nav(d_type_of_rx, new_gal_eph); d_rp->log_rinex_nav_gal_nav(d_signal_enabled_flags, new_gal_eph);
} }
} }
d_internal_pvt_solver->galileo_ephemeris_map[galileo_eph->PRN] = *galileo_eph; d_internal_pvt_solver->galileo_ephemeris_map[galileo_eph->PRN] = *galileo_eph;
@@ -1515,7 +1518,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record! // New record!
std::map<int32_t, Glonass_Gnav_Ephemeris> new_glo_eph; std::map<int32_t, Glonass_Gnav_Ephemeris> new_glo_eph;
new_glo_eph[glonass_gnav_eph->PRN] = *glonass_gnav_eph; new_glo_eph[glonass_gnav_eph->PRN] = *glonass_gnav_eph;
d_rp->log_rinex_nav_glo_gnav(d_type_of_rx, new_glo_eph); d_rp->log_rinex_nav_glo_gnav(d_signal_enabled_flags, new_glo_eph);
} }
} }
d_internal_pvt_solver->glonass_gnav_ephemeris_map[glonass_gnav_eph->PRN] = *glonass_gnav_eph; d_internal_pvt_solver->glonass_gnav_ephemeris_map[glonass_gnav_eph->PRN] = *glonass_gnav_eph;
@@ -1578,7 +1581,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record! // New record!
std::map<int32_t, Beidou_Dnav_Ephemeris> new_bds_eph; std::map<int32_t, Beidou_Dnav_Ephemeris> new_bds_eph;
new_bds_eph[bds_dnav_eph->PRN] = *bds_dnav_eph; new_bds_eph[bds_dnav_eph->PRN] = *bds_dnav_eph;
d_rp->log_rinex_nav_bds_dnav(d_type_of_rx, new_bds_eph); d_rp->log_rinex_nav_bds_dnav(d_signal_enabled_flags, new_bds_eph);
} }
} }
d_internal_pvt_solver->beidou_dnav_ephemeris_map[bds_dnav_eph->PRN] = *bds_dnav_eph; d_internal_pvt_solver->beidou_dnav_ephemeris_map[bds_dnav_eph->PRN] = *bds_dnav_eph;
@@ -2451,14 +2454,16 @@ int rtklib_pvt_gs::work(int noutput_items, gr_vector_const_void_star& input_item
} }
if (d_rinex_output_enabled) if (d_rinex_output_enabled)
{ {
d_rp->print_rinex_annotation(d_user_pvt_solver.get(), d_gnss_observables_map, d_rx_time, d_type_of_rx, flag_write_RINEX_obs_output); d_rp->print_rinex_annotation(d_user_pvt_solver.get(), d_gnss_observables_map, d_rx_time, d_signal_enabled_flags, flag_write_RINEX_obs_output);
} }
if (d_rtcm_enabled) if (d_rtcm_enabled)
{ {
const Signal_Enabled_Flags flags(d_signal_enabled_flags);
d_rtcm_printer->Print_Rtcm_Messages(d_user_pvt_solver.get(), d_rtcm_printer->Print_Rtcm_Messages(d_user_pvt_solver.get(),
d_gnss_observables_map, d_gnss_observables_map,
d_rx_time, d_rx_time,
d_type_of_rx, get_type_of_receiver(flags),
d_rtcm_MSM_rate_ms, d_rtcm_MSM_rate_ms,
d_rtcm_MT1019_rate_ms, d_rtcm_MT1019_rate_ms,
d_rtcm_MT1020_rate_ms, d_rtcm_MT1020_rate_ms,

2
src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_gs.h
View File

@@ -262,7 +262,7 @@ private:
int32_t d_max_obs_block_rx_clock_offset_ms; int32_t d_max_obs_block_rx_clock_offset_ms;
uint32_t d_nchannels; uint32_t d_nchannels;
uint32_t d_type_of_rx; uint32_t d_signal_enabled_flags;
uint32_t d_observable_interval_ms; uint32_t d_observable_interval_ms;
uint32_t d_pvt_errors_counter; uint32_t d_pvt_errors_counter;

2
src/algorithms/PVT/libs/pvt_conf.h
View File

@@ -52,7 +52,7 @@ public:
std::string udp_eph_addresses; std::string udp_eph_addresses;
std::string log_source_timetag_file; std::string log_source_timetag_file;
uint32_t type_of_receiver = 0; uint32_t signal_enabled_flags = 0;
uint32_t observable_interval_ms = 20; uint32_t observable_interval_ms = 20;
int32_t output_rate_ms = 0; int32_t output_rate_ms = 0;

26
src/algorithms/PVT/libs/receiver_type.cc
View File

@@ -18,8 +18,12 @@
#include "configuration_interface.h" // for ConfigurationInterface #include "configuration_interface.h" // for ConfigurationInterface
#include <vector> // for vector #include <vector> // for vector
Signal_Enabled_Flags::Signal_Enabled_Flags(const ConfigurationInterface* configuration) : flags_(0) namespace
{ {
uint32_t flags_from_config(const ConfigurationInterface* configuration)
{
uint32_t flags = 0;
const std::vector<std::pair<uint32_t, std::string>> signal_flag_to_prop = { const std::vector<std::pair<uint32_t, std::string>> signal_flag_to_prop = {
{GPS_1C, "Channels_1C.count"}, {GPS_1C, "Channels_1C.count"},
{GPS_2S, "Channels_2S.count"}, {GPS_2S, "Channels_2S.count"},
@@ -33,22 +37,30 @@ Signal_Enabled_Flags::Signal_Enabled_Flags(const ConfigurationInterface* configu
{BDS_B1, "Channels_B1.count"}, {BDS_B1, "Channels_B1.count"},
{BDS_B3, "Channels_B3.count"}}; {BDS_B3, "Channels_B3.count"}};
#if NO_FOLD_EXPRESSIONS
for (const auto& pair_aux : signal_flag_to_prop) for (const auto& pair_aux : signal_flag_to_prop)
{ {
auto flag = pair_aux.first; auto flag = pair_aux.first;
auto prop = pair_aux.second; auto prop = pair_aux.second;
#else
for (const auto& [flag, prop] : signal_flag_to_prop)
{
#endif
const auto enabled = configuration->property(prop, 0) > 0; const auto enabled = configuration->property(prop, 0) > 0;
if (enabled) if (enabled)
{ {
flags_ |= flag; flags |= flag;
} }
} }
return flags;
}
} // namespace
Signal_Enabled_Flags::Signal_Enabled_Flags(const ConfigurationInterface* configuration) : flags(flags_from_config(configuration))
{
}
Signal_Enabled_Flags::Signal_Enabled_Flags(uint32_t flags_) : flags(flags_)
{
} }

22
src/algorithms/PVT/libs/receiver_type.h
View File

@@ -40,8 +40,8 @@ class Signal_Enabled_Flags
{ {
public: public:
explicit Signal_Enabled_Flags(const ConfigurationInterface* configuration); explicit Signal_Enabled_Flags(const ConfigurationInterface* configuration);
explicit Signal_Enabled_Flags(uint32_t flags_);
#if NO_FOLD_EXPRESSIONS
template <typename T> template <typename T>
uint32_t or_all(const T& value) const uint32_t or_all(const T& value) const
{ {
@@ -57,30 +57,16 @@ public:
template <typename... Args> template <typename... Args>
bool check_only_enabled(const Args&... args) const bool check_only_enabled(const Args&... args) const
{ {
return (flags_ ^ or_all(args...)) == 0; return (flags ^ or_all(args...)) == 0;
} }
template <typename... Args> template <typename... Args>
bool check_any_enabled(const Args&... args) const bool check_any_enabled(const Args&... args) const
{ {
return (flags_ & or_all(args...)) > 0; return (flags & or_all(args...)) > 0;
}
#else
template <typename... Args>
bool check_only_enabled(const Args&... args) const
{
return (flags_ ^ (args | ...)) == 0;
} }
template <typename... Args> const uint32_t flags;
bool check_any_enabled(const Args&... args) const
{
return (flags_ & (args | ...)) > 0;
}
#endif
private:
uint32_t flags_;
}; };
// Infer the type of receiver // Infer the type of receiver

1340
src/algorithms/PVT/libs/rinex_printer.cc
View File

File diff suppressed because it is too large Load Diff

14
src/algorithms/PVT/libs/rinex_printer.h
View File

@@ -170,37 +170,37 @@ public:
void print_rinex_annotation(const Rtklib_Solver* pvt_solver, void print_rinex_annotation(const Rtklib_Solver* pvt_solver,
const std::map<int, Gnss_Synchro>& gnss_observables_map, const std::map<int, Gnss_Synchro>& gnss_observables_map,
double rx_time, double rx_time,
int type_of_rx, uint32_t signal_enabled_flags,
bool flag_write_RINEX_obs_output); bool flag_write_RINEX_obs_output);
/*! /*!
* \brief Print RINEX annotation for GPS NAV message * \brief Print RINEX annotation for GPS NAV message
*/ */
void log_rinex_nav_gps_nav(int type_of_rx, void log_rinex_nav_gps_nav(uint32_t signal_enabled_flags,
const std::map<int32_t, Gps_Ephemeris>& new_eph); const std::map<int32_t, Gps_Ephemeris>& new_eph);
/*! /*!
* \brief Print RINEX annotation for GPS CNAV message * \brief Print RINEX annotation for GPS CNAV message
*/ */
void log_rinex_nav_gps_cnav(int type_of_rx, void log_rinex_nav_gps_cnav(uint32_t signal_enabled_flags,
const std::map<int32_t, Gps_CNAV_Ephemeris>& new_cnav_eph); const std::map<int32_t, Gps_CNAV_Ephemeris>& new_cnav_eph);
/*! /*!
* \brief Print RINEX annotation for Galileo NAV message * \brief Print RINEX annotation for Galileo NAV message
*/ */
void log_rinex_nav_gal_nav(int type_of_rx, void log_rinex_nav_gal_nav(uint32_t signal_enabled_flags,
const std::map<int32_t, Galileo_Ephemeris>& new_gal_eph); const std::map<int32_t, Galileo_Ephemeris>& new_gal_eph);
/*! /*!
* \brief Print RINEX annotation for Glonass GNAV message * \brief Print RINEX annotation for Glonass GNAV message
*/ */
void log_rinex_nav_glo_gnav(int type_of_rx, void log_rinex_nav_glo_gnav(uint32_t signal_enabled_flags,
const std::map<int32_t, Glonass_Gnav_Ephemeris>& new_glo_eph); const std::map<int32_t, Glonass_Gnav_Ephemeris>& new_glo_eph);
/*! /*!
* \brief Print RINEX annotation for BeiDou DNAV message * \brief Print RINEX annotation for BeiDou DNAV message
*/ */
void log_rinex_nav_bds_dnav(int type_of_rx, void log_rinex_nav_bds_dnav(uint32_t signal_enabled_flags,
const std::map<int32_t, Beidou_Dnav_Ephemeris>& new_bds_eph); const std::map<int32_t, Beidou_Dnav_Ephemeris>& new_bds_eph);
/*! /*!
@@ -1002,7 +1002,7 @@ private:
std::fstream sbsFile; // Output file stream for RINEX SBAS raw data file std::fstream sbsFile; // Output file stream for RINEX SBAS raw data file
std::fstream navGalFile; // Output file stream for RINEX Galileo navigation data file std::fstream navGalFile; // Output file stream for RINEX Galileo navigation data file
std::fstream navGloFile; // Output file stream for RINEX GLONASS navigation data file std::fstream navGloFile; // Output file stream for RINEX GLONASS navigation data file
std::fstream navBdsFile; // Output file stream for RINEX Galileo navigation data file std::fstream navBdsFile; // Output file stream for RINEX Beidou navigation data file
std::fstream navMixFile; // Output file stream for RINEX Mixed navigation data file std::fstream navMixFile; // Output file stream for RINEX Mixed navigation data file
std::string navfilename; // Name of RINEX navigation file for GPS L1 std::string navfilename; // Name of RINEX navigation file for GPS L1

80
src/algorithms/PVT/libs/rtklib_solver.cc
View File

@@ -33,10 +33,9 @@
#include "rtklib_solver.h" #include "rtklib_solver.h"
#include "Beidou_DNAV.h" #include "Beidou_DNAV.h"
#include "gnss_sdr_filesystem.h" #include "gnss_sdr_filesystem.h"
#include "receiver_type.h"
#include "rtklib_rtkpos.h" #include "rtklib_rtkpos.h"
#include "rtklib_solution.h"
#include <matio.h> #include <matio.h>
#include <algorithm>
#include <cmath> #include <cmath>
#include <exception> #include <exception>
#include <utility> #include <utility>
@@ -51,12 +50,12 @@
Rtklib_Solver::Rtklib_Solver(const rtk_t &rtk, Rtklib_Solver::Rtklib_Solver(const rtk_t &rtk,
const Pvt_Conf &conf, const Pvt_Conf &conf,
const std::string &dump_filename, const std::string &dump_filename,
uint32_t type_of_rx, uint32_t signal_enabled_flags,
bool flag_dump_to_file, bool flag_dump_to_file,
bool flag_dump_to_mat) : d_dump_filename(dump_filename), bool flag_dump_to_mat) : d_dump_filename(dump_filename),
d_rtk(rtk), d_rtk(rtk),
d_conf(conf), d_conf(conf),
d_type_of_rx(type_of_rx), d_signal_enabled_flags(signal_enabled_flags),
d_flag_dump_enabled(flag_dump_to_file), d_flag_dump_enabled(flag_dump_to_file),
d_flag_dump_mat_enabled(flag_dump_to_mat) d_flag_dump_mat_enabled(flag_dump_to_mat)
{ {
@@ -78,65 +77,58 @@ Rtklib_Solver::Rtklib_Solver(const rtk_t &rtk,
d_rtklib_band_index["L5"] = 2; d_rtklib_band_index["L5"] = 2;
d_rtklib_band_index["E6"] = 0; d_rtklib_band_index["E6"] = 0;
switch (d_type_of_rx) const Signal_Enabled_Flags flags(d_signal_enabled_flags);
if (flags.check_only_enabled(GAL_E5b) ||
flags.check_only_enabled(GPS_1C, GAL_E5b) ||
flags.check_only_enabled(GAL_1B, GAL_E5b) ||
flags.check_only_enabled(GPS_2S, GAL_E5b))
{ {
case 6: // E5b only
d_rtklib_freq_index[2] = 4; d_rtklib_freq_index[2] = 4;
break; }
case 11: // GPS L1 C/A + Galileo E5b else if (flags.check_only_enabled(GAL_E5a, GAL_E5b))
d_rtklib_freq_index[2] = 4; {
break;
case 15: // Galileo E1B + Galileo E5b
d_rtklib_freq_index[2] = 4;
break;
case 18: // GPS L2C + Galileo E5b
d_rtklib_freq_index[2] = 4;
break;
case 19: // Galileo E5a + Galileo E5b
d_rtklib_band_index["5X"] = 0; d_rtklib_band_index["5X"] = 0;
d_rtklib_freq_index[0] = 2; d_rtklib_freq_index[0] = 2;
d_rtklib_freq_index[2] = 4; d_rtklib_freq_index[2] = 4;
break; }
case 20: // GPS L5 + Galileo E5b else if (flags.check_only_enabled(GPS_L5, GAL_E5b))
{
d_rtklib_band_index["L5"] = 0; d_rtklib_band_index["L5"] = 0;
d_rtklib_freq_index[0] = 2; d_rtklib_freq_index[0] = 2;
d_rtklib_freq_index[2] = 4; d_rtklib_freq_index[2] = 4;
break; }
case 100: // E6B only else if (flags.check_only_enabled(GAL_E6))
{
d_rtklib_freq_index[0] = 3; d_rtklib_freq_index[0] = 3;
break; }
case 101: // E1 + E6B else if (flags.check_only_enabled(GAL_1B, GAL_E6) ||
flags.check_only_enabled(GAL_E5a, GAL_E6) ||
flags.check_only_enabled(GAL_1B, GAL_E5a, GAL_E6))
{
d_rtklib_band_index["E6"] = 1; d_rtklib_band_index["E6"] = 1;
d_rtklib_freq_index[1] = 3; d_rtklib_freq_index[1] = 3;
break; }
case 102: // E5a + E6B else if (flags.check_only_enabled(GAL_E5b, GAL_E6) ||
d_rtklib_band_index["E6"] = 1; flags.check_only_enabled(GAL_1B, GAL_E5b, GAL_E6))
d_rtklib_freq_index[1] = 3; {
break;
case 103: // E5b + E6B
d_rtklib_band_index["E6"] = 1; d_rtklib_band_index["E6"] = 1;
d_rtklib_freq_index[1] = 3; d_rtklib_freq_index[1] = 3;
d_rtklib_freq_index[2] = 4; d_rtklib_freq_index[2] = 4;
break; }
case 104: // Galileo E1B + Galileo E5a + Galileo E6B else if (flags.check_only_enabled(GAL_1B, GAL_E5a, GAL_E6) ||
flags.check_only_enabled(GPS_1C, GAL_1B, GAL_E6) ||
flags.check_only_enabled(GPS_1C, GAL_E6))
{
d_rtklib_band_index["E6"] = 1; d_rtklib_band_index["E6"] = 1;
d_rtklib_freq_index[1] = 3; d_rtklib_freq_index[1] = 3;
break; }
case 105: // Galileo E1B + Galileo E5b + Galileo E6B else if (flags.check_only_enabled(GPS_1C, GAL_1B, GPS_L5, GAL_E5a, GAL_E5b))
d_rtklib_freq_index[2] = 4; {
d_rtklib_band_index["E6"] = 1;
d_rtklib_freq_index[1] = 3;
break;
case 106: // GPS L1 C/A + Galileo E1B + Galileo E6B
case 107: // GPS L1 C/A + Galileo E6B
d_rtklib_band_index["E6"] = 1;
d_rtklib_freq_index[1] = 3;
break;
case 108: // GPS L1 C/A + Galileo E1B + GPS L5 + Galileo E5a + Galileo E6B
d_rtklib_band_index["E6"] = 2; d_rtklib_band_index["E6"] = 2;
d_rtklib_freq_index[2] = 3; d_rtklib_freq_index[2] = 3;
break;
} }
// auto empty_map = std::map < int, HAS_obs_corrections >> (); // auto empty_map = std::map < int, HAS_obs_corrections >> ();
// d_has_obs_corr_map["L1 C/A"] = empty_map; // d_has_obs_corr_map["L1 C/A"] = empty_map;

4
src/algorithms/PVT/libs/rtklib_solver.h
View File

@@ -85,7 +85,7 @@ public:
Rtklib_Solver(const rtk_t& rtk, Rtklib_Solver(const rtk_t& rtk,
const Pvt_Conf& conf, const Pvt_Conf& conf,
const std::string& dump_filename, const std::string& dump_filename,
uint32_t type_of_rx, uint32_t signal_enabled_flags,
bool flag_dump_to_file, bool flag_dump_to_file,
bool flag_dump_to_mat); bool flag_dump_to_mat);
@@ -155,7 +155,7 @@ private:
Monitor_Pvt d_monitor_pvt{}; Monitor_Pvt d_monitor_pvt{};
Pvt_Conf d_conf; Pvt_Conf d_conf;
Pvt_Kf d_pvt_kf; Pvt_Kf d_pvt_kf;
uint32_t d_type_of_rx; uint32_t d_signal_enabled_flags;
bool d_flag_dump_enabled; bool d_flag_dump_enabled;
bool d_flag_dump_mat_enabled; bool d_flag_dump_mat_enabled;
}; };

5
tests/unit-tests/signal-processing-blocks/pvt/nmea_printer_test.cc
View File

@@ -15,11 +15,12 @@
*/ */
#include "gnss_sdr_filesystem.h"
#include "nmea_printer.h" #include "nmea_printer.h"
#include "pvt_conf.h" #include "pvt_conf.h"
#include "receiver_type.h"
#include "rtklib_rtkpos.h" #include "rtklib_rtkpos.h"
#include "rtklib_solver.h" #include "rtklib_solver.h"
#include <gtest/gtest.h>
#include <fstream> #include <fstream>
#include <string> #include <string>
@@ -147,7 +148,7 @@ TEST_F(NmeaPrinterTest, PrintLine)
std::string filename("nmea_test.nmea"); std::string filename("nmea_test.nmea");
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
std::shared_ptr<Rtklib_Solver> pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 1, false, false); std::shared_ptr<Rtklib_Solver> pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", GPS_1C, false, false);
boost::posix_time::ptime pt(boost::gregorian::date(1994, boost::date_time::Nov, 19), boost::posix_time::ptime pt(boost::gregorian::date(1994, boost::date_time::Nov, 19),
boost::posix_time::hours(22) + boost::posix_time::minutes(54) + boost::posix_time::seconds(46)); boost::posix_time::hours(22) + boost::posix_time::minutes(54) + boost::posix_time::seconds(46));

99
tests/unit-tests/signal-processing-blocks/pvt/rinex_printer_test.cc
View File

@@ -14,11 +14,12 @@
* ----------------------------------------------------------------------------- * -----------------------------------------------------------------------------
*/ */
#include "gnss_sdr_filesystem.h"
#include "pvt_conf.h" #include "pvt_conf.h"
#include "receiver_type.h"
#include "rinex_printer.h" #include "rinex_printer.h"
#include "rtklib_rtkpos.h" #include "rtklib_rtkpos.h"
#include "rtklib_solver.h" #include "rtklib_solver.h"
#include <gtest/gtest.h>
#include <fstream> #include <fstream>
#include <string> #include <string>
#include <utility> #include <utility>
@@ -146,7 +147,8 @@ TEST_F(RinexPrinterTest, GalileoObsHeader)
{ {
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 4, false, false); const auto signal_enabled_flags = GAL_1B;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
auto eph = Galileo_Ephemeris(); auto eph = Galileo_Ephemeris();
eph.PRN = 1; eph.PRN = 1;
pvt_solution->galileo_ephemeris_map[1] = std::move(eph); pvt_solution->galileo_ephemeris_map[1] = std::move(eph);
@@ -158,11 +160,7 @@ TEST_F(RinexPrinterTest, GalileoObsHeader)
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
4,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -196,11 +194,7 @@ TEST_F(RinexPrinterTest, GalileoObsHeader)
auto rp2 = std::make_shared<Rinex_Printer>(); auto rp2 = std::make_shared<Rinex_Printer>();
rp2->print_rinex_annotation(pvt_solution.get(), rp2->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, GAL_1B | GAL_E5b, true);
gnss_observables_map,
0.0,
15,
true);
obsfile = rp2->get_obsfilename(); obsfile = rp2->get_obsfilename();
navfile = rp2->get_navfilename()[0]; navfile = rp2->get_navfilename()[0];
@@ -234,7 +228,8 @@ TEST_F(RinexPrinterTest, GlonassObsHeader)
{ {
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 28, false, false); const auto signal_enabled_flags = GLO_1G;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
auto eph = Glonass_Gnav_Ephemeris(); auto eph = Glonass_Gnav_Ephemeris();
eph.PRN = 1; eph.PRN = 1;
pvt_solution->glonass_gnav_ephemeris_map[1] = std::move(eph); pvt_solution->glonass_gnav_ephemeris_map[1] = std::move(eph);
@@ -246,11 +241,7 @@ TEST_F(RinexPrinterTest, GlonassObsHeader)
auto rp = std::make_shared<Rinex_Printer>(3); auto rp = std::make_shared<Rinex_Printer>(3);
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
23,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -296,7 +287,8 @@ TEST_F(RinexPrinterTest, MixedObsHeader)
eph_gps.PRN = 1; eph_gps.PRN = 1;
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 106, false, false); const auto signal_enabled_flags = GPS_1C | GAL_1B | GAL_E5a;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
pvt_solution->galileo_ephemeris_map[1] = std::move(eph_gal); pvt_solution->galileo_ephemeris_map[1] = std::move(eph_gal);
pvt_solution->gps_ephemeris_map[1] = std::move(eph_gps); pvt_solution->gps_ephemeris_map[1] = std::move(eph_gps);
@@ -309,11 +301,7 @@ TEST_F(RinexPrinterTest, MixedObsHeader)
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
33,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -368,7 +356,8 @@ TEST_F(RinexPrinterTest, MixedObsHeaderGpsGlo)
eph_gps.PRN = 1; eph_gps.PRN = 1;
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 26, false, false); const auto signal_enabled_flags = GPS_1C | GLO_1G;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
pvt_solution->glonass_gnav_ephemeris_map[1] = std::move(eph_glo); pvt_solution->glonass_gnav_ephemeris_map[1] = std::move(eph_glo);
pvt_solution->gps_ephemeris_map[1] = std::move(eph_gps); pvt_solution->gps_ephemeris_map[1] = std::move(eph_gps);
@@ -381,11 +370,7 @@ TEST_F(RinexPrinterTest, MixedObsHeaderGpsGlo)
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
26,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -437,7 +422,8 @@ TEST_F(RinexPrinterTest, GalileoObsLog)
eph.PRN = 1; eph.PRN = 1;
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 4, false, false); const auto signal_enabled_flags = GAL_1B;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
pvt_solution->galileo_ephemeris_map[1] = eph; pvt_solution->galileo_ephemeris_map[1] = eph;
std::map<int, Gnss_Synchro> gnss_observables_map; std::map<int, Gnss_Synchro> gnss_observables_map;
@@ -474,11 +460,7 @@ TEST_F(RinexPrinterTest, GalileoObsLog)
gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(4, gs4)); gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(4, gs4));
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
4,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -519,7 +501,8 @@ TEST_F(RinexPrinterTest, GlonassObsLog)
eph.PRN = 22; eph.PRN = 22;
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 23, false, false); const auto signal_enabled_flags = GLO_1G;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
pvt_solution->glonass_gnav_ephemeris_map[1] = eph; pvt_solution->glonass_gnav_ephemeris_map[1] = eph;
std::map<int, Gnss_Synchro> gnss_observables_map; std::map<int, Gnss_Synchro> gnss_observables_map;
@@ -556,11 +539,7 @@ TEST_F(RinexPrinterTest, GlonassObsLog)
gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(4, gs4)); gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(4, gs4));
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
23,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -603,7 +582,8 @@ TEST_F(RinexPrinterTest, GpsObsLogDualBand)
eph_cnav.PRN = 1; eph_cnav.PRN = 1;
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 7, false, false); const auto signal_enabled_flags = GPS_1C | GPS_2S;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
pvt_solution->gps_ephemeris_map[1] = std::move(eph); pvt_solution->gps_ephemeris_map[1] = std::move(eph);
pvt_solution->gps_cnav_ephemeris_map[1] = std::move(eph_cnav); pvt_solution->gps_cnav_ephemeris_map[1] = std::move(eph_cnav);
std::map<int, Gnss_Synchro> gnss_observables_map; std::map<int, Gnss_Synchro> gnss_observables_map;
@@ -653,11 +633,7 @@ TEST_F(RinexPrinterTest, GpsObsLogDualBand)
gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(4, gs4)); gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(4, gs4));
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
7,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -693,7 +669,8 @@ TEST_F(RinexPrinterTest, GalileoObsLogDualBand)
{ {
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 14, false, false); const auto signal_enabled_flags = GAL_1B | GAL_E5a;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
auto eph = Galileo_Ephemeris(); auto eph = Galileo_Ephemeris();
eph.PRN = 1; eph.PRN = 1;
pvt_solution->galileo_ephemeris_map[1] = eph; pvt_solution->galileo_ephemeris_map[1] = eph;
@@ -745,11 +722,7 @@ TEST_F(RinexPrinterTest, GalileoObsLogDualBand)
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
14,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -795,7 +768,8 @@ TEST_F(RinexPrinterTest, MixedObsLog)
eph_gal.PRN = 1; eph_gal.PRN = 1;
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 9, false, false); const auto signal_enabled_flags = GPS_1C | GAL_1B;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
pvt_solution->gps_ephemeris_map[1] = std::move(eph_gps); pvt_solution->gps_ephemeris_map[1] = std::move(eph_gps);
pvt_solution->galileo_ephemeris_map[1] = std::move(eph_gal); pvt_solution->galileo_ephemeris_map[1] = std::move(eph_gal);
std::map<int, Gnss_Synchro> gnss_observables_map; std::map<int, Gnss_Synchro> gnss_observables_map;
@@ -875,11 +849,7 @@ TEST_F(RinexPrinterTest, MixedObsLog)
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
9,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];
@@ -921,7 +891,8 @@ TEST_F(RinexPrinterTest, MixedObsLogGpsGlo)
eph_glo.PRN = 1; eph_glo.PRN = 1;
Pvt_Conf conf; Pvt_Conf conf;
conf.use_e6_for_pvt = false; conf.use_e6_for_pvt = false;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", 26, false, false); const auto signal_enabled_flags = GPS_1C | GLO_1G;
auto pvt_solution = std::make_shared<Rtklib_Solver>(rtk, conf, "filename", signal_enabled_flags, false, false);
pvt_solution->gps_ephemeris_map[1] = std::move(eph_gps); pvt_solution->gps_ephemeris_map[1] = std::move(eph_gps);
pvt_solution->glonass_gnav_ephemeris_map[1] = std::move(eph_glo); pvt_solution->glonass_gnav_ephemeris_map[1] = std::move(eph_glo);
std::map<int, Gnss_Synchro> gnss_observables_map; std::map<int, Gnss_Synchro> gnss_observables_map;
@@ -999,11 +970,7 @@ TEST_F(RinexPrinterTest, MixedObsLogGpsGlo)
auto rp = std::make_shared<Rinex_Printer>(); auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(), rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
gnss_observables_map,
0.0,
26,
true);
std::string obsfile = rp->get_obsfilename(); std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0]; std::string navfile = rp->get_navfilename()[0];