mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-09-02 02:48:00 +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);
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
// Settings 1

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

@@ -54,6 +54,7 @@
#include "nmea_printer.h"
#include "osnma_data.h"
#include "pvt_conf.h"
#include "receiver_type.h"
#include "rinex_printer.h"
#include "rtcm_printer.h"
#include "rtklib_rtkcmn.h"
@@ -169,7 +170,7 @@ rtklib_pvt_gs::rtklib_pvt_gs(uint32_t nchannels,
d_report_rate_ms(1000),
d_max_obs_block_rx_clock_offset_ms(conf_.max_obs_block_rx_clock_offset_ms),
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_pvt_errors_counter(0),
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;
}
const Signal_Enabled_Flags signal_enabled_flags(d_signal_enabled_flags);
// 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)
{
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
// 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);
// internal PVT solver, mainly used to estimate the receiver clock
rtk_t internal_rtk = rtk;
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);
}
else
{
// 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_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!
std::map<int32_t, Gps_Ephemeris> new_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;
@@ -1300,7 +1303,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record!
std::map<int32_t, Gps_CNAV_Ephemeris> new_cnav_eph;
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;
@@ -1392,7 +1395,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record!
std::map<int32_t, Galileo_Ephemeris> new_gal_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;
@@ -1515,7 +1518,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record!
std::map<int32_t, Glonass_Gnav_Ephemeris> new_glo_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;
@@ -1578,7 +1581,7 @@ void rtklib_pvt_gs::msg_handler_telemetry(const pmt::pmt_t& msg)
// New record!
std::map<int32_t, Beidou_Dnav_Ephemeris> new_bds_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;
@@ -2451,14 +2454,16 @@ int rtklib_pvt_gs::work(int noutput_items, gr_vector_const_void_star& input_item
}
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)
{
const Signal_Enabled_Flags flags(d_signal_enabled_flags);
d_rtcm_printer->Print_Rtcm_Messages(d_user_pvt_solver.get(),
d_gnss_observables_map,
d_rx_time,
d_type_of_rx,
get_type_of_receiver(flags),
d_rtcm_MSM_rate_ms,
d_rtcm_MT1019_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;
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_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 log_source_timetag_file;
uint32_t type_of_receiver = 0;
uint32_t signal_enabled_flags = 0;
uint32_t observable_interval_ms = 20;
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 <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 = {
{GPS_1C, "Channels_1C.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_B3, "Channels_B3.count"}};
#if NO_FOLD_EXPRESSIONS
for (const auto& pair_aux : signal_flag_to_prop)
{
auto flag = pair_aux.first;
auto prop = pair_aux.second;
#else
for (const auto& [flag, prop] : signal_flag_to_prop)
{
#endif
const auto enabled = configuration->property(prop, 0) > 0;
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:
explicit Signal_Enabled_Flags(const ConfigurationInterface* configuration);
explicit Signal_Enabled_Flags(uint32_t flags_);
#if NO_FOLD_EXPRESSIONS
template <typename T>
uint32_t or_all(const T& value) const
{
@@ -57,30 +57,16 @@ public:
template <typename... Args>
bool check_only_enabled(const Args&... args) const
{
return (flags_ ^ or_all(args...)) == 0;
return (flags ^ or_all(args...)) == 0;
}
template <typename... Args>
bool check_any_enabled(const Args&... args) const
{
return (flags_ & or_all(args...)) > 0;
}
#else
template <typename... Args>
bool check_only_enabled(const Args&... args) const
{
return (flags_ ^ (args | ...)) == 0;
return (flags & or_all(args...)) > 0;
}
template <typename... Args>
bool check_any_enabled(const Args&... args) const
{
return (flags_ & (args | ...)) > 0;
}
#endif
private:
uint32_t flags_;
const uint32_t flags;
};
// 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,
const std::map<int, Gnss_Synchro>& gnss_observables_map,
double rx_time,
int type_of_rx,
uint32_t signal_enabled_flags,
bool flag_write_RINEX_obs_output);
/*!
* \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);
/*!
* \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);
/*!
* \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);
/*!
* \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);
/*!
* \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);
/*!
@@ -1002,7 +1002,7 @@ private:
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 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::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 "Beidou_DNAV.h"
#include "gnss_sdr_filesystem.h"
#include "receiver_type.h"
#include "rtklib_rtkpos.h"
#include "rtklib_solution.h"
#include <matio.h>
#include <algorithm>
#include <cmath>
#include <exception>
#include <utility>
@@ -51,12 +50,12 @@
Rtklib_Solver::Rtklib_Solver(const rtk_t &rtk,
const Pvt_Conf &conf,
const std::string &dump_filename,
uint32_t type_of_rx,
uint32_t signal_enabled_flags,
bool flag_dump_to_file,
bool flag_dump_to_mat) : d_dump_filename(dump_filename),
d_rtk(rtk),
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_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["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;
break;
case 11: // GPS L1 C/A + Galileo 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
}
else if (flags.check_only_enabled(GAL_E5a, GAL_E5b))
{
d_rtklib_band_index["5X"] = 0;
d_rtklib_freq_index[0] = 2;
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_freq_index[0] = 2;
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;
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_freq_index[1] = 3;
break;
case 102: // E5a + E6B
d_rtklib_band_index["E6"] = 1;
d_rtklib_freq_index[1] = 3;
break;
case 103: // E5b + E6B
}
else if (flags.check_only_enabled(GAL_E5b, GAL_E6) ||
flags.check_only_enabled(GAL_1B, GAL_E5b, GAL_E6))
{
d_rtklib_band_index["E6"] = 1;
d_rtklib_freq_index[1] = 3;
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_freq_index[1] = 3;
break;
case 105: // Galileo E1B + Galileo E5b + Galileo E6B
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
}
else if (flags.check_only_enabled(GPS_1C, GAL_1B, GPS_L5, GAL_E5a, GAL_E5b))
{
d_rtklib_band_index["E6"] = 2;
d_rtklib_freq_index[2] = 3;
break;
}
// auto empty_map = std::map < int, HAS_obs_corrections >> ();
// 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,
const Pvt_Conf& conf,
const std::string& dump_filename,
uint32_t type_of_rx,
uint32_t signal_enabled_flags,
bool flag_dump_to_file,
bool flag_dump_to_mat);
@@ -155,7 +155,7 @@ private:
Monitor_Pvt d_monitor_pvt{};
Pvt_Conf d_conf;
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_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 "pvt_conf.h"
#include "receiver_type.h"
#include "rtklib_rtkpos.h"
#include "rtklib_solver.h"
#include <gtest/gtest.h>
#include <fstream>
#include <string>
@@ -147,7 +148,7 @@ TEST_F(NmeaPrinterTest, PrintLine)
std::string filename("nmea_test.nmea");
Pvt_Conf conf;
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::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 "receiver_type.h"
#include "rinex_printer.h"
#include "rtklib_rtkpos.h"
#include "rtklib_solver.h"
#include <gtest/gtest.h>
#include <fstream>
#include <string>
#include <utility>
@@ -146,7 +147,8 @@ TEST_F(RinexPrinterTest, GalileoObsHeader)
{
Pvt_Conf conf;
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();
eph.PRN = 1;
pvt_solution->galileo_ephemeris_map[1] = std::move(eph);
@@ -158,11 +160,7 @@ TEST_F(RinexPrinterTest, GalileoObsHeader)
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
4,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -196,11 +194,7 @@ TEST_F(RinexPrinterTest, GalileoObsHeader)
auto rp2 = std::make_shared<Rinex_Printer>();
rp2->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
15,
true);
rp2->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, GAL_1B | GAL_E5b, true);
obsfile = rp2->get_obsfilename();
navfile = rp2->get_navfilename()[0];
@@ -234,7 +228,8 @@ TEST_F(RinexPrinterTest, GlonassObsHeader)
{
Pvt_Conf conf;
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();
eph.PRN = 1;
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);
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
23,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -296,7 +287,8 @@ TEST_F(RinexPrinterTest, MixedObsHeader)
eph_gps.PRN = 1;
Pvt_Conf conf;
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->gps_ephemeris_map[1] = std::move(eph_gps);
@@ -309,11 +301,7 @@ TEST_F(RinexPrinterTest, MixedObsHeader)
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
33,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -368,7 +356,8 @@ TEST_F(RinexPrinterTest, MixedObsHeaderGpsGlo)
eph_gps.PRN = 1;
Pvt_Conf conf;
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->gps_ephemeris_map[1] = std::move(eph_gps);
@@ -381,11 +370,7 @@ TEST_F(RinexPrinterTest, MixedObsHeaderGpsGlo)
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
26,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -437,7 +422,8 @@ TEST_F(RinexPrinterTest, GalileoObsLog)
eph.PRN = 1;
Pvt_Conf conf;
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;
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));
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
4,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -519,7 +501,8 @@ TEST_F(RinexPrinterTest, GlonassObsLog)
eph.PRN = 22;
Pvt_Conf conf;
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;
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));
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
23,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -603,7 +582,8 @@ TEST_F(RinexPrinterTest, GpsObsLogDualBand)
eph_cnav.PRN = 1;
Pvt_Conf conf;
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_cnav_ephemeris_map[1] = std::move(eph_cnav);
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));
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
7,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -693,7 +669,8 @@ TEST_F(RinexPrinterTest, GalileoObsLogDualBand)
{
Pvt_Conf conf;
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();
eph.PRN = 1;
pvt_solution->galileo_ephemeris_map[1] = eph;
@@ -745,11 +722,7 @@ TEST_F(RinexPrinterTest, GalileoObsLogDualBand)
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
14,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -795,7 +768,8 @@ TEST_F(RinexPrinterTest, MixedObsLog)
eph_gal.PRN = 1;
Pvt_Conf conf;
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->galileo_ephemeris_map[1] = std::move(eph_gal);
std::map<int, Gnss_Synchro> gnss_observables_map;
@@ -875,11 +849,7 @@ TEST_F(RinexPrinterTest, MixedObsLog)
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
9,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];
@@ -921,7 +891,8 @@ TEST_F(RinexPrinterTest, MixedObsLogGpsGlo)
eph_glo.PRN = 1;
Pvt_Conf conf;
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->glonass_gnav_ephemeris_map[1] = std::move(eph_glo);
std::map<int, Gnss_Synchro> gnss_observables_map;
@@ -999,11 +970,7 @@ TEST_F(RinexPrinterTest, MixedObsLogGpsGlo)
auto rp = std::make_shared<Rinex_Printer>();
rp->print_rinex_annotation(pvt_solution.get(),
gnss_observables_map,
0.0,
26,
true);
rp->print_rinex_annotation(pvt_solution.get(), gnss_observables_map, 0.0, signal_enabled_flags, true);
std::string obsfile = rp->get_obsfilename();
std::string navfile = rp->get_navfilename()[0];