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

Fix member initializations, potential data race conditions, and minor performance issues detected by Coverity Scan

Browse Source 
Never throw from main
This commit is contained in:
Carles Fernandez 2023-12-21 13:57:41 +01:00
parent d8fabdb4ac
commit 4916c6c8e8
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
16 changed files with 438 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -5651,7 +5651,7 @@ void Rinex_Printer::log_rinex_nav(std::fstream& out, const std::map<int32_t, Gal
std::string E1B_DVS = std::to_string(galileo_ephemeris_iter->second.E1B_DVS);
std::string SVhealth_str = std::move(E5B_HS) + std::to_string(galileo_ephemeris_iter->second.E5b_DVS) + "11" + "1" + std::string(E1B_DVS) + std::string(E1B_HS) + std::to_string(galileo_ephemeris_iter->second.E1B_DVS);
std::string SVhealth_str = std::move(E5B_HS) + std::to_string(galileo_ephemeris_iter->second.E5b_DVS) + "11" + "1" + std::move(E1B_DVS) + std::move(E1B_HS) + std::to_string(galileo_ephemeris_iter->second.E1B_DVS);
int32_t SVhealth = Rinex_Printer::toInt(SVhealth_str, 9);
line += Rinex_Printer::doub2for(static_cast<double>(SVhealth), 18, 2);
line += std::string(1, ' ');

3
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h
View File

@ -33,6 +33,7 @@
#include <cstdint> // for uint32_t
#include <memory> // for shared_ptr
#include <string> // for string
#include <utility> // for move
/** \addtogroup Acquisition
* \{ */
@ -118,7 +119,7 @@ public:
*/
inline void set_channel_fsm(std::weak_ptr<ChannelFsm> channel_fsm)
{
d_channel_fsm = channel_fsm;
d_channel_fsm = std::move(channel_fsm);
}
/*!

3
src/algorithms/acquisition/libs/acq_conf_fpga.cc
View File

@ -21,6 +21,7 @@
#include <glog/logging.h>
#include <cmath>
#include <iostream>
#include <utility>
void Acq_Conf_Fpga::SetFromConfiguration(const ConfigurationInterface *configuration,
const std::string &role, uint32_t sel_queue_fpga, uint32_t blk_exp, uint32_t downsampling_factor_default, double chip_rate, double code_length_chips)
@ -58,7 +59,7 @@ void Acq_Conf_Fpga::SetFromConfiguration(const ConfigurationInterface *configura
std::cout << "Cannot find the FPGA uio device file corresponding to device name " << acquisition_device_name << std::endl;
throw std::exception();
}
device_name = device_io_name;
device_name = std::move(device_io_name);
// exclusion limit
excludelimit = static_cast<unsigned int>(1 + ceil((1.0 / chip_rate) * static_cast<float>(fs_in)));

4
src/algorithms/signal_source/libs/ad9361_manager.cc
View File

@ -450,7 +450,7 @@ bool config_ad9361_rx_local(uint64_t bandwidth_,
{
return false;
}
if (setup_filter(filter_source_, bandwidth_, sample_rate_, freq1_, rf_port_select_, ad9361_phy_B, rx_chan1, chn, 0, filter_filename_, Fpass_, Fstop_) == -1)
if (setup_filter(filter_source_, bandwidth_, sample_rate_, freq1_, rf_port_select_, ad9361_phy_B, rx_chan1, chn, 0, std::move(filter_filename_), Fpass_, Fstop_) == -1)
{
return false;
}
@ -472,7 +472,7 @@ bool config_ad9361_rx_local(uint64_t bandwidth_,
std::cout << rx_stream_dev_a << " channel 1 not found\n";
throw std::runtime_error(rx_stream_dev_a + "RX channel 1 not found");
}
if (setup_filter(filter_source_, bandwidth_, sample_rate_, freq0_, rf_port_select_, ad9361_phy, rx_chan1, chn, 1, filter_filename_, Fpass_, Fstop_) == -1)
if (setup_filter(filter_source_, bandwidth_, sample_rate_, freq0_, rf_port_select_, ad9361_phy, rx_chan1, chn, 1, std::move(filter_filename_), Fpass_, Fstop_) == -1)
{
return false;
}

8
src/algorithms/signal_source/libs/fpga_dynamic_bit_selection.cc
View File

@ -29,6 +29,12 @@
Fpga_dynamic_bit_selection::Fpga_dynamic_bit_selection(bool enable_rx1_band, bool enable_rx2_band)
: d_enable_rx1_band(enable_rx1_band), d_enable_rx2_band(enable_rx2_band)
{
d_map_base_freq_band_1 = nullptr;
d_map_base_freq_band_2 = nullptr;
d_dev_descr_freq_band_1 = 0;
d_dev_descr_freq_band_2 = 0;
d_shift_out_bits_freq_band_1 = 0;
d_shift_out_bits_freq_band_2 = 0;
if (d_enable_rx1_band)
{
open_device(&d_map_base_freq_band_1, d_dev_descr_freq_band_1, 0);
@ -41,7 +47,7 @@ Fpga_dynamic_bit_selection::Fpga_dynamic_bit_selection(bool enable_rx1_band, boo
{
open_device(&d_map_base_freq_band_2, d_dev_descr_freq_band_2, 1);
// init bit selection corresponding to frequency band 1
// init bit selection corresponding to frequency band 2
d_shift_out_bits_freq_band_2 = shift_out_bits_default;
d_map_base_freq_band_2[0] = d_shift_out_bits_freq_band_2;
}

5
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.cc
View File

@ -446,7 +446,7 @@ dll_pll_veml_tracking_fpga::dll_pll_veml_tracking_fpga(const Dll_Pll_Conf_Fpga &
{
std::string dump_filename_ = d_dump_filename.substr(d_dump_filename.find_last_of('/') + 1);
dump_path = d_dump_filename.substr(0, d_dump_filename.find_last_of('/'));
d_dump_filename = dump_filename_;
d_dump_filename = std::move(dump_filename_);
}
else
{
@ -1383,6 +1383,7 @@ void dll_pll_veml_tracking_fpga::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro)
d_acquisition_gnss_synchro = p_gnss_synchro;
if (p_gnss_synchro->PRN > 0)
{
gr::thread::scoped_lock lock(d_setlock);
// A set_gnss_synchro command with a valid PRN is received when the system is going to run acquisition with that PRN.
// We can use this command to pre-initialize tracking parameters and variables before the actual acquisition process takes place.
// In this way we minimize the latency between acquisition and tracking once the acquisition has been made.
@ -1527,8 +1528,8 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
{
case 1: // Pull-in
{
d_worker_is_done = false;
boost::mutex::scoped_lock lock(d_mutex);
d_worker_is_done = false;
while (!d_worker_is_done)
{
d_m_condition.wait(lock);

9
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_gaussian_tracking_cc.cc
View File

@ -308,10 +308,6 @@ void Gps_L1_Ca_Gaussian_Tracking_cc::start_tracking()
sys = std::string(1, d_acquisition_gnss_synchro->System);
// DEBUG OUTPUT
std::cout << "Tracking of GPS L1 C/A signal started on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << '\n';
LOG(INFO) << "Starting tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel;
// enable tracking
d_pull_in = true;
d_enable_tracking = true;
@ -319,6 +315,10 @@ void Gps_L1_Ca_Gaussian_Tracking_cc::start_tracking()
LOG(INFO) << "PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz
<< " Code Phase correction [samples]=" << delay_correction_samples
<< " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
gr::thread::scoped_lock l(d_setlock);
std::cout << "Tracking of GPS L1 C/A signal started on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << '\n';
LOG(INFO) << "Starting tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel;
}
@ -776,6 +776,7 @@ int Gps_L1_Ca_Gaussian_Tracking_cc::general_work(int noutput_items __attribute__
}
if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail)
{
gr::thread::scoped_lock l(d_setlock);
std::cout << "Loss of lock in channel " << d_channel << "!\n";
LOG(INFO) << "Loss of lock in channel " << d_channel << "!";
this->message_port_pub(pmt::mp("events"), pmt::from_long(3)); // 3 -> loss of lock

14
src/algorithms/tracking/libs/fpga_multicorrelator.cc
View File

@ -57,20 +57,26 @@ Fpga_Multicorrelator_8sc::Fpga_Multicorrelator_8sc(int32_t n_correlators,
d_Prompt_Data(nullptr),
d_shifts_chips(nullptr),
d_prompt_data_shift(nullptr),
d_rem_code_phase_chips(0),
d_code_phase_step_chips(0),
d_rem_carrier_phase_in_rad(0),
d_phase_step_rad(0),
d_rem_code_phase_chips(0.0),
d_code_phase_step_chips(0.0),
d_code_phase_rate_step_chips(0.0),
d_rem_carrier_phase_in_rad(0.0),
d_phase_step_rad(0.0),
d_carrier_phase_rate_step_rad(0.0),
d_code_length_samples(code_length_chips * code_samples_per_chip),
d_n_correlators(n_correlators),
d_device_descriptor(0),
d_map_base(nullptr),
d_correlator_length_samples(0),
d_code_phase_step_chips_num(0),
d_code_phase_rate_step_chips_num(0),
d_rem_carr_phase_rad_int(0),
d_phase_step_rad_int(0),
d_carrier_phase_rate_step_rad_int(0),
d_ca_codes(ca_codes),
d_data_codes(data_codes),
d_secondary_code_0_length(0),
d_secondary_code_1_length(0),
d_track_pilot(track_pilot),
d_secondary_code_enabled(false)
{

1
src/core/receiver/gnss_flowgraph.cc
View File

@ -2097,6 +2097,7 @@ void GNSSFlowgraph::set_configuration(const std::shared_ptr<ConfigurationInterfa
#if ENABLE_FPGA
void GNSSFlowgraph::start_acquisition_helper()
{
std::lock_guard<std::mutex> lock(signal_list_mutex_);
for (int i = 0; i < channels_count_; i++)
{
if (channels_state_[i] == 1)

7
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_test_fpga.cc
View File

@ -91,6 +91,7 @@ GalileoE1PcpsAmbiguousAcquisitionTestFpga::GalileoE1PcpsAmbiguousAcquisitionTest
doppler_max = 5000;
doppler_step = 100;
nsamples_to_transfer = 0;
}
@ -280,7 +281,7 @@ public:
}
private:
bool acquisition_successful;
bool acquisition_successful{};
};
@ -310,7 +311,7 @@ bool GalileoE1PcpsAmbiguousAcquisitionTestFpga::acquire_signal()
args.scaling_factor = DMA_SIGNAL_SCALING_FACTOR;
std::string file = "data/Galileo_E1_ID_1_Fs_4Msps_8ms.dat";
args.file = file; // DMA file configuration
args.file = std::move(file); // DMA file configuration
// instantiate the FPGA switch and set the
// switch position to DMA.
@ -348,7 +349,7 @@ bool GalileoE1PcpsAmbiguousAcquisitionTestFpga::acquire_signal()
args.nsamples_tx = nsamples_to_transfer;
// run the acquisition. The acquisition must run in a separate thread because it is a blocking function
args_acq.acquisition = acquisition;
args_acq.acquisition = std::move(acquisition);
if (pthread_create(&thread_acquisition, nullptr, handler_acquisition_galileo_e1_pcps_ambiguous_acq_test, reinterpret_cast<void*>(&args_acq)) < 0)
{

6
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test_fpga.cc
View File

@ -279,7 +279,7 @@ public:
}
private:
bool acquisition_successful;
bool acquisition_successful{};
};
@ -309,7 +309,7 @@ bool GpsL1CaPcpsAcquisitionTestFpga::acquire_signal()
args.scaling_factor = DMA_SIGNAL_SCALING_FACTOR;
std::string file = "data/GPS_L1_CA_ID_1_Fs_4Msps_2ms.dat";
args.file = file; // DMA file configuration
args.file = std::move(file); // DMA file configuration
// instantiate the FPGA switch and set the
// switch position to DMA.
@ -347,7 +347,7 @@ bool GpsL1CaPcpsAcquisitionTestFpga::acquire_signal()
args.nsamples_tx = nsamples_to_transfer;
// run the acquisition. The acquisition must run in a separate thread because it is a blocking function
args_acq.acquisition = acquisition;
args_acq.acquisition = std::move(acquisition);
if (pthread_create(&thread_acquisition, nullptr, handler_acquisition_gps_l1_acq_test, reinterpret_cast<void*>(&args_acq)) < 0)
{

2
src/tests/unit-tests/signal-processing-blocks/filter/fir_filter_test.cc
View File

@ -224,7 +224,7 @@ TEST_F(FirFilterTest, ConnectAndRunGrcomplex)
config2->set_property("Test_Source.sampling_frequency", "4000000");
std::string path = std::string(TEST_PATH);
std::string filename = path + "signal_samples/GPS_L1_CA_ID_1_Fs_4Msps_2ms.dat";
config2->set_property("Test_Source.filename", filename);
config2->set_property("Test_Source.filename", std::move(filename));
config2->set_property("Test_Source.item_type", "gr_complex");
config2->set_property("Test_Source.repeat", "true");

3
src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_test.cc
View File

@ -21,6 +21,7 @@
#include <complex>
#include <cstdint>
#include <thread>
#include <utility>
#ifdef GR_GREATER_38
#include <gnuradio/analog/sig_source.h>
#else
@ -177,7 +178,7 @@ TEST_F(NotchFilterTest, ConnectAndRunGrcomplex)
config2->set_property("Test_Source.sampling_frequency", "4000000");
std::string path = std::string(TEST_PATH);
std::string filename = path + "signal_samples/GPS_L1_CA_ID_1_Fs_4Msps_2ms.dat";
config2->set_property("Test_Source.filename", filename);
config2->set_property("Test_Source.filename", std::move(filename));
config2->set_property("Test_Source.item_type", "gr_complex");
config2->set_property("Test_Source.repeat", "true");

3
src/tests/unit-tests/signal-processing-blocks/filter/pulse_blanking_filter_test.cc
View File

@ -21,6 +21,7 @@
#include <complex>
#include <cstdint>
#include <thread>
#include <utility>
#ifdef GR_GREATER_38
#include <gnuradio/analog/sig_source.h>
#else
@ -176,7 +177,7 @@ TEST_F(PulseBlankingFilterTest, ConnectAndRunGrcomplex)
config2->set_property("Test_Source.sampling_frequency", "4000000");
std::string path = std::string(TEST_PATH);
std::string filename = path + "signal_samples/GPS_L1_CA_ID_1_Fs_4Msps_2ms.dat";
config2->set_property("Test_Source.filename", filename);
config2->set_property("Test_Source.filename", std::move(filename));
config2->set_property("Test_Source.item_type", "gr_complex");
config2->set_property("Test_Source.repeat", "true");

682
src/utils/front-end-cal/main.cc
View File

@ -269,18 +269,26 @@ static time_t utc_time(int week, int64_t tow)
int main(int argc, char** argv)
{
const std::string intro_help(
std::string("\n RTL-SDR E4000 RF front-end center frequency and sampling rate calibration tool that uses GPS signals\n") +
"Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)\n" +
"This program comes with ABSOLUTELY NO WARRANTY;\n" +
"See COPYING file to see a copy of the General Public License\n \n");
try
{
const std::string intro_help(
std::string("\n RTL-SDR E4000 RF front-end center frequency and sampling rate calibration tool that uses GPS signals\n") +
"Copyright (C) 2010-2019 (see AUTHORS file for a list of contributors)\n" +
"This program comes with ABSOLUTELY NO WARRANTY;\n" +
"See COPYING file to see a copy of the General Public License\n \n");
gflags::SetUsageMessage(intro_help);
google::SetVersionString(FRONT_END_CAL_VERSION);
gflags::ParseCommandLineFlags(&argc, &argv, true);
std::cout << "Initializing... Please wait.\n";
gflags::SetUsageMessage(intro_help);
google::SetVersionString(FRONT_END_CAL_VERSION);
gflags::ParseCommandLineFlags(&argc, &argv, true);
std::cout << "Initializing... Please wait.\n";
}
catch (const std::exception& e)
{
std::cerr << e.what() << '\n';
std::cout << "front-end-cal program ended.\n";
return 1;
}
google::InitGoogleLogging(argv[0]);
if (FLAGS_log_dir.empty())
{
@ -292,358 +300,390 @@ int main(int argc, char** argv)
}
else
{
const fs::path p(FLAGS_log_dir);
if (!fs::exists(p))
try
{
std::cout << "The path "
<< FLAGS_log_dir
<< " does not exist, attempting to create it"
<< '\n';
fs::create_directory(p);
const fs::path p(FLAGS_log_dir);
if (!fs::exists(p))
{
std::cout << "The path "
<< FLAGS_log_dir
<< " does not exist, attempting to create it"
<< '\n';
errorlib::error_code ec;
if (!fs::create_directory(p, ec))
{
std::cerr << "Could not create the " << FLAGS_log_dir << " folder. Front-end-cal program ended.\n";
gflags::ShutDownCommandLineFlags();
return 1;
}
}
std::cout << "Logging with be done at "
<< FLAGS_log_dir << '\n';
}
catch (const std::exception& e)
{
std::cerr << e.what() << '\n';
std::cerr << "Could not create the " << FLAGS_log_dir << " folder. Front-end-cal program ended.\n";
gflags::ShutDownCommandLineFlags();
return 1;
}
std::cout << "Logging with be done at "
<< FLAGS_log_dir << '\n';
}
// 0. Instantiate the FrontEnd Calibration class
FrontEndCal front_end_cal;
// 1. Load configuration parameters from config file
std::shared_ptr<ConfigurationInterface> configuration = std::make_shared<FileConfiguration>(FLAGS_config_file);
front_end_cal.set_configuration(configuration);
// 2. Get SUPL information from server: Ephemeris record, assistance info and TOW
try
{
if (front_end_cal.get_ephemeris() == true)
{
std::cout << "SUPL data received OK!\n";
}
else
{
std::cout << "Failure connecting to SUPL server\n";
}
}
catch (const boost::exception& e)
{
std::cout << "Failure connecting to SUPL server\n";
}
FrontEndCal front_end_cal;
// 3. Capture some front-end samples to hard disk
try
{
if (front_end_capture(configuration))
{
std::cout << "Front-end RAW samples captured\n";
}
else
{
std::cout << "Failure capturing front-end samples\n";
}
}
catch (const boost::bad_lexical_cast& e)
{
std::cout << "Exception caught while capturing samples (bad lexical cast)\n";
}
catch (const std::exception& e)
{
std::cout << "Exception caught while capturing samples: " << e.what() << '\n';
}
catch (...)
{
std::cout << "Unexpected exception\n";
}
// 1. Load configuration parameters from config file
std::shared_ptr<ConfigurationInterface> configuration = std::make_shared<FileConfiguration>(FLAGS_config_file);
front_end_cal.set_configuration(configuration);
// 4. Setup GNU Radio flowgraph (file_source -> Acquisition_10m)
gr::top_block_sptr top_block;
top_block = gr::make_top_block("Acquisition test");
// Satellite signal definition
gnss_synchro = Gnss_Synchro();
gnss_synchro.Channel_ID = 0;
gnss_synchro.System = 'G';
std::string signal = "1C";
signal.copy(gnss_synchro.Signal, 2, 0);
gnss_synchro.PRN = 1;
int64_t fs_in_ = configuration->property("GNSS-SDR.internal_fs_sps", 2048000);
configuration->set_property("Acquisition.max_dwells", "10");
auto acquisition = std::make_shared<GpsL1CaPcpsAcquisitionFineDoppler>(configuration.get(), "Acquisition", 1, 1);
acquisition->set_channel(1);
acquisition->set_gnss_synchro(&gnss_synchro);
acquisition->set_threshold(configuration->property("Acquisition.threshold", 2.0));
acquisition->set_doppler_max(configuration->property("Acquisition.doppler_max", 10000));
acquisition->set_doppler_step(configuration->property("Acquisition.doppler_step", 250));
gr::block_sptr source;
source = gr::blocks::file_source::make(sizeof(gr_complex), "tmp_capture.dat");
#if GNURADIO_USES_STD_POINTERS
std::shared_ptr<FrontEndCal_msg_rx> msg_rx;
#else
boost::shared_ptr<FrontEndCal_msg_rx> msg_rx;
#endif
try
{
msg_rx = FrontEndCal_msg_rx_make();
}
catch (const std::exception& e)
{
std::cout << "Failure connecting the message port system: " << e.what() << '\n';
exit(0);
}
try
{
acquisition->connect(top_block);
top_block->connect(source, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
}
catch (const std::exception& e)
{
std::cout << "Failure connecting the GNU Radio blocks: " << e.what() << '\n';
}
// 5. Run the flowgraph
// Get visible GPS satellites (positive acquisitions with Doppler measurements)
// Compute Doppler estimations
// todo: Fix the front-end cal to support new channel internal message system (no more external queues)
std::map<int, double> doppler_measurements_map;
std::map<int, double> cn0_measurements_map;
std::thread ch_thread;
// record startup time
std::chrono::time_point<std::chrono::system_clock> start;
std::chrono::time_point<std::chrono::system_clock> end;
std::chrono::duration<double> elapsed_seconds{};
start = std::chrono::system_clock::now();
bool start_msg = true;
for (unsigned int PRN = 1; PRN < 33; PRN++)
{
gnss_synchro.PRN = PRN;
acquisition->set_gnss_synchro(&gnss_synchro);
acquisition->init();
acquisition->set_local_code();
acquisition->reset();
stop = false;
// 2. Get SUPL information from server: Ephemeris record, assistance info and TOW
try
{
ch_thread = std::thread(wait_message);
}
catch (const std::exception& e)
{
LOG(INFO) << "Exception caught (thread resource error)";
}
top_block->run();
if (start_msg == true)
{
std::cout << "Searching for GPS Satellites in L1 band...\n";
std::cout << "[";
start_msg = false;
}
if (!gnss_sync_vector.empty())
{
std::cout << " " << PRN << " ";
double doppler_measurement_hz = 0;
for (auto& it : gnss_sync_vector)
if (front_end_cal.get_ephemeris() == true)
{
doppler_measurement_hz += it.Acq_doppler_hz;
std::cout << "SUPL data received OK!\n";
}
else
{
std::cout << "Failure connecting to SUPL server\n";
}
doppler_measurement_hz = doppler_measurement_hz / gnss_sync_vector.size();
doppler_measurements_map.insert(std::pair<int, double>(PRN, doppler_measurement_hz));
}
else
{
std::cout << " . ";
}
try
{
channel_internal_queue.push(3);
}
catch (const boost::exception& e)
{
LOG(INFO) << "Exception caught while pushing to the internal queue.";
std::cout << "Failure connecting to SUPL server\n";
}
// 3. Capture some front-end samples to hard disk
try
{
ch_thread.join();
if (front_end_capture(configuration))
{
std::cout << "Front-end RAW samples captured\n";
}
else
{
std::cout << "Failure capturing front-end samples\n";
}
}
catch (const boost::bad_lexical_cast& e)
{
std::cout << "Exception caught while capturing samples (bad lexical cast)\n";
}
catch (const std::exception& e)
{
LOG(INFO) << "Exception caught while joining threads.";
std::cout << "Exception caught while capturing samples: " << e.what() << '\n';
}
gnss_sync_vector.clear();
catch (...)
{
std::cout << "Unexpected exception\n";
}
// 4. Setup GNU Radio flowgraph (file_source -> Acquisition_10m)
gr::top_block_sptr top_block;
top_block = gr::make_top_block("Acquisition test");
// Satellite signal definition
gnss_synchro = Gnss_Synchro();
gnss_synchro.Channel_ID = 0;
gnss_synchro.System = 'G';
std::string signal = "1C";
signal.copy(gnss_synchro.Signal, 2, 0);
gnss_synchro.PRN = 1;
int64_t fs_in_ = configuration->property("GNSS-SDR.internal_fs_sps", 2048000);
configuration->set_property("Acquisition.max_dwells", "10");
auto acquisition = std::make_shared<GpsL1CaPcpsAcquisitionFineDoppler>(configuration.get(), "Acquisition", 1, 1);
acquisition->set_channel(1);
acquisition->set_gnss_synchro(&gnss_synchro);
acquisition->set_threshold(configuration->property("Acquisition.threshold", 2.0));
acquisition->set_doppler_max(configuration->property("Acquisition.doppler_max", 10000));
acquisition->set_doppler_step(configuration->property("Acquisition.doppler_step", 250));
gr::block_sptr source;
source = gr::blocks::file_source::make(sizeof(gr_complex), "tmp_capture.dat");
#if GNURADIO_USES_STD_POINTERS
std::dynamic_pointer_cast<gr::blocks::file_source>(source)->seek(0, 0);
std::shared_ptr<FrontEndCal_msg_rx> msg_rx;
#else
boost::dynamic_pointer_cast<gr::blocks::file_source>(source)->seek(0, 0);
boost::shared_ptr<FrontEndCal_msg_rx> msg_rx;
#endif
std::cout.flush();
}
std::cout << "]\n";
// report the elapsed time
end = std::chrono::system_clock::now();
elapsed_seconds = end - start;
std::cout << "Total signal acquisition run time "
<< elapsed_seconds.count()
<< " [seconds]\n";
// 6. find TOW from SUPL assistance
double current_TOW = 0;
try
{
if (global_gps_ephemeris_map.size() > 0)
try
{
std::map<int, Gps_Ephemeris> Eph_map;
Eph_map = global_gps_ephemeris_map.get_map_copy();
current_TOW = Eph_map.begin()->second.tow;
time_t t = utc_time(Eph_map.begin()->second.WN, static_cast<int64_t>(current_TOW));
std::cout << "Reference Time:\n";
std::cout << " GPS Week: " << Eph_map.begin()->second.WN << '\n';
std::cout << " GPS TOW: " << static_cast<int64_t>(current_TOW) << " " << static_cast<int64_t>(current_TOW) * 0.08 << '\n';
std::cout << " ~ UTC: " << ctime(&t) << '\n';
std::cout << "Current TOW obtained from SUPL assistance = " << current_TOW << '\n';
msg_rx = FrontEndCal_msg_rx_make();
}
else
catch (const std::exception& e)
{
std::cout << "Unable to get Ephemeris SUPL assistance. TOW is unknown!\n";
std::cout << "Failure connecting the message port system: " << e.what() << '\n';
exit(0);
}
try
{
acquisition->connect(top_block);
top_block->connect(source, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
}
catch (const std::exception& e)
{
std::cout << "Failure connecting the GNU Radio blocks: " << e.what() << '\n';
}
// 5. Run the flowgraph
// Get visible GPS satellites (positive acquisitions with Doppler measurements)
// Compute Doppler estimations
// todo: Fix the front-end cal to support new channel internal message system (no more external queues)
std::map<int, double> doppler_measurements_map;
std::map<int, double> cn0_measurements_map;
std::thread ch_thread;
// record startup time
std::chrono::time_point<std::chrono::system_clock> start;
std::chrono::time_point<std::chrono::system_clock> end;
std::chrono::duration<double> elapsed_seconds{};
start = std::chrono::system_clock::now();
bool start_msg = true;
for (unsigned int PRN = 1; PRN < 33; PRN++)
{
gnss_synchro.PRN = PRN;
acquisition->set_gnss_synchro(&gnss_synchro);
acquisition->init();
acquisition->set_local_code();
acquisition->reset();
stop = false;
try
{
ch_thread = std::thread(wait_message);
}
catch (const std::exception& e)
{
LOG(INFO) << "Exception caught (thread resource error)";
}
top_block->run();
if (start_msg == true)
{
std::cout << "Searching for GPS Satellites in L1 band...\n";
std::cout << "[";
start_msg = false;
}
if (!gnss_sync_vector.empty())
{
std::cout << " " << PRN << " ";
double doppler_measurement_hz = 0;
for (auto& it : gnss_sync_vector)
{
doppler_measurement_hz += it.Acq_doppler_hz;
}
doppler_measurement_hz = doppler_measurement_hz / gnss_sync_vector.size();
doppler_measurements_map.insert(std::pair<int, double>(PRN, doppler_measurement_hz));
}
else
{
std::cout << " . ";
}
try
{
channel_internal_queue.push(3);
}
catch (const boost::exception& e)
{
LOG(INFO) << "Exception caught while pushing to the internal queue.";
}
try
{
ch_thread.join();
}
catch (const std::exception& e)
{
LOG(INFO) << "Exception caught while joining threads.";
}
gnss_sync_vector.clear();
#if GNURADIO_USES_STD_POINTERS
std::dynamic_pointer_cast<gr::blocks::file_source>(source)->seek(0, 0);
#else
boost::dynamic_pointer_cast<gr::blocks::file_source>(source)->seek(0, 0);
#endif
std::cout.flush();
}
std::cout << "]\n";
// report the elapsed time
end = std::chrono::system_clock::now();
elapsed_seconds = end - start;
std::cout << "Total signal acquisition run time "
<< elapsed_seconds.count()
<< " [seconds]\n";
// 6. find TOW from SUPL assistance
double current_TOW = 0;
try
{
if (global_gps_ephemeris_map.size() > 0)
{
std::map<int, Gps_Ephemeris> Eph_map;
Eph_map = global_gps_ephemeris_map.get_map_copy();
current_TOW = Eph_map.begin()->second.tow;
time_t t = utc_time(Eph_map.begin()->second.WN, static_cast<int64_t>(current_TOW));
std::cout << "Reference Time:\n";
std::cout << " GPS Week: " << Eph_map.begin()->second.WN << '\n';
std::cout << " GPS TOW: " << static_cast<int64_t>(current_TOW) << " " << static_cast<int64_t>(current_TOW) * 0.08 << '\n';
std::cout << " ~ UTC: " << ctime(&t) << '\n';
std::cout << "Current TOW obtained from SUPL assistance = " << current_TOW << '\n';
}
else
{
std::cout << "Unable to get Ephemeris SUPL assistance. TOW is unknown!\n";
gflags::ShutDownCommandLineFlags();
std::cout << "GNSS-SDR Front-end calibration program ended.\n";
return 0;
}
}
catch (const boost::exception& e)
{
std::cout << "Exception in getting Global ephemeris map\n";
gflags::ShutDownCommandLineFlags();
std::cout << "GNSS-SDR Front-end calibration program ended.\n";
return 0;
}
// Get user position from config file (or from SUPL using GSM Cell ID)
double lat_deg = configuration->property("GNSS-SDR.init_latitude_deg", 41.0);
double lon_deg = configuration->property("GNSS-SDR.init_longitude_deg", 2.0);
double altitude_m = configuration->property("GNSS-SDR.init_altitude_m", 100);
std::cout << "Reference location (defined in config file):\n";
std::cout << "Latitude=" << lat_deg << " [º]\n";
std::cout << "Longitude=" << lon_deg << " [º]\n";
std::cout << "Altitude=" << altitude_m << " [m]\n";
if (doppler_measurements_map.empty())
{
std::cout << "Sorry, no GPS satellites detected in the front-end capture, please check the antenna setup...\n";
gflags::ShutDownCommandLineFlags();
std::cout << "GNSS-SDR Front-end calibration program ended.\n";
return 0;
}
std::map<int, double> f_if_estimation_Hz_map;
std::map<int, double> f_fs_estimation_Hz_map;
std::map<int, double> f_ppm_estimation_Hz_map;
std::cout << std::setiosflags(std::ios::fixed) << std::setprecision(2) << "Doppler analysis results:\n";
std::cout << "SV ID Measured [Hz] Predicted [Hz]\n";
for (auto& it : doppler_measurements_map)
{
try
{
double doppler_estimated_hz;
doppler_estimated_hz = front_end_cal.estimate_doppler_from_eph(it.first, current_TOW, lat_deg, lon_deg, altitude_m);
std::cout << " " << it.first << " " << it.second << " " << doppler_estimated_hz << '\n';
// 7. Compute front-end IF and sampling frequency estimation
// Compare with the measurements and compute clock drift using FE model
double estimated_fs_Hz;
double estimated_f_if_Hz;
double f_osc_err_ppm;
front_end_cal.GPS_L1_front_end_model_E4000(doppler_estimated_hz, it.second, fs_in_, &estimated_fs_Hz, &estimated_f_if_Hz, &f_osc_err_ppm);
f_if_estimation_Hz_map.insert(std::pair<int, double>(it.first, estimated_f_if_Hz));
f_fs_estimation_Hz_map.insert(std::pair<int, double>(it.first, estimated_fs_Hz));
f_ppm_estimation_Hz_map.insert(std::pair<int, double>(it.first, f_osc_err_ppm));
}
catch (const std::logic_error& e)
{
std::cout << "Logic error caught: " << e.what() << '\n';
}
catch (const boost::lock_error& e)
{
std::cout << "Exception caught while reading ephemeris\n";
}
catch (const std::exception& ex)
{
std::cout << " " << it.first << " " << it.second << " (Eph not found)\n";
}
}
// FINAL FE estimations
double mean_f_if_Hz = 0;
double mean_fs_Hz = 0;
double mean_osc_err_ppm = 0;
int n_elements = f_if_estimation_Hz_map.size();
for (auto& it : f_if_estimation_Hz_map)
{
mean_f_if_Hz += it.second;
const auto est_fs = f_fs_estimation_Hz_map.find(it.first);
if (est_fs != f_fs_estimation_Hz_map.cend())
{
mean_fs_Hz += est_fs->second;
}
const auto est_ppm = f_ppm_estimation_Hz_map.find(it.first);
if (est_ppm != f_ppm_estimation_Hz_map.cend())
{
mean_osc_err_ppm += est_ppm->second;
}
}
mean_f_if_Hz /= n_elements;
mean_fs_Hz /= n_elements;
mean_osc_err_ppm /= n_elements;
std::cout << std::setiosflags(std::ios::fixed) << std::setprecision(2) << "Parameters estimation for Elonics E4000 Front-End:\n";
std::cout << "Sampling frequency =" << mean_fs_Hz << " [Hz]\n";
std::cout << "IF bias present in baseband=" << mean_f_if_Hz << " [Hz]\n";
std::cout << "Reference oscillator error =" << mean_osc_err_ppm << " [ppm]\n";
std::cout << std::setiosflags(std::ios::fixed) << std::setprecision(2)
<< "Corrected Doppler vs. Predicted\n";
std::cout << "SV ID Corrected [Hz] Predicted [Hz]\n";
for (auto& it : doppler_measurements_map)
{
try
{
double doppler_estimated_hz;
doppler_estimated_hz = front_end_cal.estimate_doppler_from_eph(it.first, current_TOW, lat_deg, lon_deg, altitude_m);
std::cout << " " << it.first << " " << it.second - mean_f_if_Hz << " " << doppler_estimated_hz << '\n';
}
catch (const std::logic_error& e)
{
std::cout << "Logic error caught: " << e.what() << '\n';
}
catch (const boost::lock_error& e)
{
std::cout << "Exception caught while reading ephemeris\n";
}
catch (const std::exception& ex)
{
std::cout << " " << it.first << " " << it.second - mean_f_if_Hz << " (Eph not found)\n";
}
}
}
catch (const boost::exception& e)
catch (const std::exception& e)
{
std::cout << "Exception in getting Global ephemeris map\n";
std::cerr << "Exception: " << e.what();
gflags::ShutDownCommandLineFlags();
std::cout << "GNSS-SDR Front-end calibration program ended.\n";
return 0;
return 1;
}
// Get user position from config file (or from SUPL using GSM Cell ID)
double lat_deg = configuration->property("GNSS-SDR.init_latitude_deg", 41.0);
double lon_deg = configuration->property("GNSS-SDR.init_longitude_deg", 2.0);
double altitude_m = configuration->property("GNSS-SDR.init_altitude_m", 100);
std::cout << "Reference location (defined in config file):\n";
std::cout << "Latitude=" << lat_deg << " [º]\n";
std::cout << "Longitude=" << lon_deg << " [º]\n";
std::cout << "Altitude=" << altitude_m << " [m]\n";
if (doppler_measurements_map.empty())
catch (...)
{
std::cout << "Sorry, no GPS satellites detected in the front-end capture, please check the antenna setup...\n";
std::cerr << "Unknown error\n";
gflags::ShutDownCommandLineFlags();
std::cout << "GNSS-SDR Front-end calibration program ended.\n";
return 0;
}
std::map<int, double> f_if_estimation_Hz_map;
std::map<int, double> f_fs_estimation_Hz_map;
std::map<int, double> f_ppm_estimation_Hz_map;
std::cout << std::setiosflags(std::ios::fixed) << std::setprecision(2) << "Doppler analysis results:\n";
std::cout << "SV ID Measured [Hz] Predicted [Hz]\n";
for (auto& it : doppler_measurements_map)
{
try
{
double doppler_estimated_hz;
doppler_estimated_hz = front_end_cal.estimate_doppler_from_eph(it.first, current_TOW, lat_deg, lon_deg, altitude_m);
std::cout << " " << it.first << " " << it.second << " " << doppler_estimated_hz << '\n';
// 7. Compute front-end IF and sampling frequency estimation
// Compare with the measurements and compute clock drift using FE model
double estimated_fs_Hz;
double estimated_f_if_Hz;
double f_osc_err_ppm;
front_end_cal.GPS_L1_front_end_model_E4000(doppler_estimated_hz, it.second, fs_in_, &estimated_fs_Hz, &estimated_f_if_Hz, &f_osc_err_ppm);
f_if_estimation_Hz_map.insert(std::pair<int, double>(it.first, estimated_f_if_Hz));
f_fs_estimation_Hz_map.insert(std::pair<int, double>(it.first, estimated_fs_Hz));
f_ppm_estimation_Hz_map.insert(std::pair<int, double>(it.first, f_osc_err_ppm));
}
catch (const std::logic_error& e)
{
std::cout << "Logic error caught: " << e.what() << '\n';
}
catch (const boost::lock_error& e)
{
std::cout << "Exception caught while reading ephemeris\n";
}
catch (const std::exception& ex)
{
std::cout << " " << it.first << " " << it.second << " (Eph not found)\n";
}
}
// FINAL FE estimations
double mean_f_if_Hz = 0;
double mean_fs_Hz = 0;
double mean_osc_err_ppm = 0;
int n_elements = f_if_estimation_Hz_map.size();
for (auto& it : f_if_estimation_Hz_map)
{
mean_f_if_Hz += it.second;
const auto est_fs = f_fs_estimation_Hz_map.find(it.first);
if (est_fs != f_fs_estimation_Hz_map.cend())
{
mean_fs_Hz += est_fs->second;
}
const auto est_ppm = f_ppm_estimation_Hz_map.find(it.first);
if (est_ppm != f_ppm_estimation_Hz_map.cend())
{
mean_osc_err_ppm += est_ppm->second;
}
}
mean_f_if_Hz /= n_elements;
mean_fs_Hz /= n_elements;
mean_osc_err_ppm /= n_elements;
std::cout << std::setiosflags(std::ios::fixed) << std::setprecision(2) << "Parameters estimation for Elonics E4000 Front-End:\n";
std::cout << "Sampling frequency =" << mean_fs_Hz << " [Hz]\n";
std::cout << "IF bias present in baseband=" << mean_f_if_Hz << " [Hz]\n";
std::cout << "Reference oscillator error =" << mean_osc_err_ppm << " [ppm]\n";
std::cout << std::setiosflags(std::ios::fixed) << std::setprecision(2)
<< "Corrected Doppler vs. Predicted\n";
std::cout << "SV ID Corrected [Hz] Predicted [Hz]\n";
for (auto& it : doppler_measurements_map)
{
try
{
double doppler_estimated_hz;
doppler_estimated_hz = front_end_cal.estimate_doppler_from_eph(it.first, current_TOW, lat_deg, lon_deg, altitude_m);
std::cout << " " << it.first << " " << it.second - mean_f_if_Hz << " " << doppler_estimated_hz << '\n';
}
catch (const std::logic_error& e)
{
std::cout << "Logic error caught: " << e.what() << '\n';
}
catch (const boost::lock_error& e)
{
std::cout << "Exception caught while reading ephemeris\n";
}
catch (const std::exception& ex)
{
std::cout << " " << it.first << " " << it.second - mean_f_if_Hz << " (Eph not found)\n";
}
return 1;
}
gflags::ShutDownCommandLineFlags();
std::cout << "GNSS-SDR Front-end calibration program ended.\n";
return 0;
}

43
src/utils/rinex-tools/obsdiff.cc
View File

@ -30,6 +30,7 @@
#include <set>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
#if GNSSTK_USES_GPSTK_NAMESPACE
@ -673,7 +674,7 @@ void carrier_doppler_single_diff(
{
// 2. RMSE
arma::vec err;
err = delta_measured_carrier_doppler_cycles;
err = std::move(delta_measured_carrier_doppler_cycles);
arma::vec err2 = arma::square(err);
double rmse = sqrt(arma::mean(err2));
@ -865,7 +866,7 @@ void code_pseudorange_single_diff(
// 2. RMSE
arma::vec err;
err = delta_measured_obs;
err = std::move(delta_measured_obs);
arma::vec err2 = arma::square(err);
double rmse = sqrt(arma::mean(err2));
@ -1014,7 +1015,7 @@ void coderate_phaserate_consistence(
// 2. RMSE
arma::vec err;
err = ratediff;
err = std::move(ratediff);
arma::vec err2 = arma::square(err);
double rmse = sqrt(arma::mean(err2));
@ -1098,7 +1099,7 @@ void code_phase_diff(
{
// 2. RMSE
arma::vec err;
err = code_minus_phase;
err = std::move(code_minus_phase);
arma::vec err2 = arma::square(err);
double rmse = sqrt(arma::mean(err2));
@ -1727,22 +1728,42 @@ int main(int argc, char** argv)
{
std::cout << "Running RINEX observables difference tool...\n";
gflags::ParseCommandLineFlags(&argc, &argv, true);
if (FLAGS_single_diff)
try
{
if (FLAGS_dupli_sat)
if (FLAGS_single_diff)
{
RINEX_doublediff_dupli_sat();
if (FLAGS_dupli_sat)
{
RINEX_doublediff_dupli_sat();
}
else
{
RINEX_singlediff();
}
}
else
{
RINEX_singlediff();
RINEX_doublediff(FLAGS_remove_rx_clock_error);
}
}
else
catch (const gnsstk::Exception& e)
{
RINEX_doublediff(FLAGS_remove_rx_clock_error);
std::cerr << e;
gflags::ShutDownCommandLineFlags();
return 1;
}
catch (const std::exception& e)
{
std::cerr << "Exception: " << e.what();
gflags::ShutDownCommandLineFlags();
return 1;
}
catch (...)
{
std::cerr << "Unknown error\n";
gflags::ShutDownCommandLineFlags();
return 1;
}
gflags::ShutDownCommandLineFlags();
return 0;
}