From c6cb41cfe3201fc01c4822be039a93440d274962 Mon Sep 17 00:00:00 2001 From: Javier Arribas Date: Wed, 25 Jan 2017 11:58:05 +0100 Subject: [PATCH] GPS L1 CA DLL/PLL tracking fixes and gnss_synchro code refactoring --- .../galileo_e1_dll_pll_veml_tracking_cc.cc | 2 - .../galileo_e1_tcp_connector_tracking_cc.cc | 1 - .../galileo_e5a_dll_pll_tracking_cc.cc | 3 - .../gps_l1_ca_dll_pll_c_aid_tracking_cc.cc | 4 - .../gps_l1_ca_dll_pll_c_aid_tracking_sc.cc | 2 - .../gps_l1_ca_dll_pll_tracking_cc.cc | 40 +- .../gps_l1_ca_tcp_connector_tracking_cc.cc | 2 - .../gps_l2_m_dll_pll_tracking_cc.cc | 3 - src/core/system_parameters/gnss_synchro.h | 1 - .../system-tests/pvt_gps_l1_system_test.cc | 719 ++++++++++++++++++ src/tests/test_main.cc | 1 + .../gps_l1_ca_dll_pll_tracking_test.cc | 210 +++++ 12 files changed, 948 insertions(+), 40 deletions(-) create mode 100644 src/tests/system-tests/pvt_gps_l1_system_test.cc create mode 100644 src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc diff --git a/src/algorithms/tracking/gnuradio_blocks/galileo_e1_dll_pll_veml_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/galileo_e1_dll_pll_veml_tracking_cc.cc index bc86e9781..6f8db9cc7 100755 --- a/src/algorithms/tracking/gnuradio_blocks/galileo_e1_dll_pll_veml_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/galileo_e1_dll_pll_veml_tracking_cc.cc @@ -396,8 +396,6 @@ int galileo_e1_dll_pll_veml_tracking_cc::general_work (int noutput_items __attri current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + static_cast(d_rem_code_phase_samples)) / static_cast(d_fs_in); //compute remnant code phase samples AFTER the Tracking timestamp d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample - // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad; current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; diff --git a/src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc index da514e39f..6b85f664f 100644 --- a/src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc @@ -406,7 +406,6 @@ int Galileo_E1_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attr current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter + (double)d_rem_code_phase_samples)/(double)d_fs_in; d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; current_synchro_data.Carrier_phase_rads = (double)d_acc_carrier_phase_rad; current_synchro_data.Carrier_Doppler_hz = (double)d_carrier_doppler_hz; current_synchro_data.CN0_dB_hz = (double)d_CN0_SNV_dB_Hz; diff --git a/src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc index 73a505caa..acf1e9bc6 100644 --- a/src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc @@ -421,7 +421,6 @@ int Galileo_E5a_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute current_synchro_data.Prompt_Q = 0.0; current_synchro_data.Tracking_timestamp_secs = static_cast(d_sample_counter) / static_cast(d_fs_in); current_synchro_data.Carrier_phase_rads = 0.0; - current_synchro_data.Code_phase_secs = 0.0; current_synchro_data.CN0_dB_hz = 0.0; *out[0] = current_synchro_data; consume_each(samples_offset); //shift input to perform alignment with local replica @@ -629,7 +628,6 @@ int Galileo_E5a_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute // Tracking_timestamp_secs is aligned with the PRN start sample current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + static_cast(d_current_prn_length_samples) + static_cast(d_rem_code_phase_samples)) / static_cast(d_fs_in); // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad; current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; @@ -642,7 +640,6 @@ int Galileo_E5a_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute current_synchro_data.Prompt_Q = 0.0; current_synchro_data.Tracking_timestamp_secs = static_cast(d_sample_counter) / static_cast(d_fs_in); current_synchro_data.Carrier_phase_rads = 0.0; - current_synchro_data.Code_phase_secs = 0.0; current_synchro_data.CN0_dB_hz = 0.0; } diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_cc.cc index 507080983..f537fdbb2 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_cc.cc @@ -555,8 +555,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items __attri current_synchro_data.Prompt_Q = static_cast((d_correlator_outs[1]).imag()); // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!) current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + old_d_rem_code_phase_samples) / static_cast(d_fs_in); - // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; current_synchro_data.Carrier_phase_rads = GPS_TWO_PI * d_acc_carrier_phase_cycles; current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; @@ -576,8 +574,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items __attri current_synchro_data.Prompt_Q = static_cast((d_correlator_outs[1]).imag()); // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!) current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + d_rem_code_phase_samples) / static_cast(d_fs_in); - // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; current_synchro_data.Carrier_phase_rads = GPS_TWO_PI * d_acc_carrier_phase_cycles; current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;// todo: project the carrier doppler current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_sc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_sc.cc index c9ebf604a..304d65ee2 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_sc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_sc.cc @@ -434,8 +434,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items __attri current_synchro_data.Prompt_Q = static_cast((d_correlator_outs_16sc[1]).imag()); // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!) current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + old_d_rem_code_phase_samples) / static_cast(d_fs_in); - // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; current_synchro_data.Carrier_phase_rads = GPS_TWO_PI * d_acc_carrier_phase_cycles; current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc index 7455ccabb..7804d2937 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc @@ -174,7 +174,6 @@ Gps_L1_Ca_Dll_Pll_Tracking_cc::Gps_L1_Ca_Dll_Pll_Tracking_cc( d_carrier_doppler_hz = 0.0; d_acc_carrier_phase_rad = 0.0; d_code_phase_samples = 0.0; - d_acc_code_phase_secs = 0.0; d_rem_code_phase_chips = 0.0; d_code_phase_step_chips = 0.0; d_carrier_phase_step_rad = 0.0; @@ -247,7 +246,6 @@ void Gps_L1_Ca_Dll_Pll_Tracking_cc::start_tracking() d_rem_carr_phase_rad = 0.0; d_rem_code_phase_chips = 0.0; d_acc_carrier_phase_rad = 0.0; - d_acc_code_phase_secs = 0.0; d_code_phase_samples = d_acq_code_phase_samples; @@ -313,6 +311,10 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + static_cast(d_rem_code_phase_samples)) / static_cast(d_fs_in); d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples d_pull_in = false; + //take into account the carrier cycles accumulated in the pull in signal alignement + d_acc_carrier_phase_rad -= d_carrier_phase_step_rad * samples_offset; + current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad; + current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; *out[0] = current_synchro_data; consume_each(samples_offset); //shift input to perform alignment with local replica return 1; @@ -335,14 +337,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ carr_error_filt_hz = d_carrier_loop_filter.get_carrier_nco(carr_error_hz); // New carrier Doppler frequency estimation d_carrier_doppler_hz = d_acq_carrier_doppler_hz + carr_error_filt_hz; - // New code Doppler frequency estimation d_code_freq_chips = GPS_L1_CA_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L1_CA_CODE_RATE_HZ) / GPS_L1_FREQ_HZ); - //carrier phase accumulator for (K) doppler estimation - d_acc_carrier_phase_rad -= GPS_TWO_PI * d_carrier_doppler_hz * GPS_L1_CA_CODE_PERIOD; - //remanent carrier phase to prevent overflow in the code NCO - d_rem_carr_phase_rad = d_rem_carr_phase_rad + GPS_TWO_PI * ( d_if_freq + d_carrier_doppler_hz ) * GPS_L1_CA_CODE_PERIOD; - d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, GPS_TWO_PI); // ################## DLL ########################################################## // DLL discriminator @@ -352,7 +348,6 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ //Code phase accumulator double code_error_filt_secs; code_error_filt_secs = (GPS_L1_CA_CODE_PERIOD * code_error_filt_chips) / GPS_L1_CA_CODE_RATE_HZ; //[seconds] - d_acc_code_phase_secs = d_acc_code_phase_secs + code_error_filt_secs; // ################## CARRIER AND CODE NCO BUFFER ALIGNEMENT ####################### // keep alignment parameters for the next input buffer @@ -370,12 +365,18 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ //################### PLL COMMANDS ################################################# //carrier phase step (NCO phase increment per sample) [rads/sample] d_carrier_phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz / static_cast(d_fs_in); + //remanent carrier phase to prevent overflow in the code NCO + d_rem_carr_phase_rad = d_rem_carr_phase_rad + d_carrier_phase_step_rad * d_current_prn_length_samples; + d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, GPS_TWO_PI); + //carrier phase accumulator for (K) doppler estimation + d_acc_carrier_phase_rad -= d_carrier_phase_step_rad * d_current_prn_length_samples; //################### DLL COMMANDS ################################################# //code phase step (Code resampler phase increment per sample) [chips/sample] d_code_phase_step_chips = d_code_freq_chips / static_cast(d_fs_in); //remnant code phase [chips] - d_rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / static_cast(d_fs_in)); + d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample + d_rem_code_phase_chips = d_code_freq_chips * (d_rem_code_phase_samples / static_cast(d_fs_in)); // ####### CN0 ESTIMATION AND LOCK DETECTORS ###### if (d_cn0_estimation_counter < CN0_ESTIMATION_SAMPLES) @@ -413,14 +414,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ current_synchro_data.Prompt_I = static_cast((d_correlator_outs[1]).real()); current_synchro_data.Prompt_Q = static_cast((d_correlator_outs[1]).imag()); - // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!, but some glitches??) - current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + static_cast(d_rem_code_phase_samples)) / static_cast(d_fs_in); - //compute remnant code phase samples AFTER the Tracking timestamp - d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample - - //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter)/static_cast(d_fs_in); - // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; + // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample + current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter+d_current_prn_length_samples) + static_cast(d_rem_code_phase_samples)) / static_cast(d_fs_in); current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad; current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; @@ -434,7 +429,7 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ d_correlator_outs[n] = gr_complex(0,0); } - current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + static_cast(d_rem_code_phase_samples)) / static_cast(d_fs_in); + current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter+d_current_prn_length_samples) + static_cast(d_rem_code_phase_samples)) / static_cast(d_fs_in); current_synchro_data.System = {'G'}; } @@ -447,6 +442,7 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ float prompt_Q; float tmp_E, tmp_P, tmp_L; double tmp_double; + unsigned long int tmp_long; prompt_I = d_correlator_outs[1].real(); prompt_Q = d_correlator_outs[1].imag(); tmp_E = std::abs(d_correlator_outs[0]); @@ -462,8 +458,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ d_dump_file.write(reinterpret_cast(&prompt_I), sizeof(float)); d_dump_file.write(reinterpret_cast(&prompt_Q), sizeof(float)); // PRN start sample stamp - //tmp_float=(float)d_sample_counter; - d_dump_file.write(reinterpret_cast(&d_sample_counter), sizeof(unsigned long int)); + tmp_long = d_sample_counter+d_current_prn_length_samples; + d_dump_file.write(reinterpret_cast(&tmp_long), sizeof(unsigned long int)); // accumulated carrier phase d_dump_file.write(reinterpret_cast(&d_acc_carrier_phase_rad), sizeof(double)); @@ -486,7 +482,7 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__ // AUX vars (for debug purposes) tmp_double = d_rem_code_phase_samples; d_dump_file.write(reinterpret_cast(&tmp_double), sizeof(double)); - tmp_double = static_cast(d_sample_counter + d_current_prn_length_samples); + tmp_double = static_cast(d_sample_counter); d_dump_file.write(reinterpret_cast(&tmp_double), sizeof(double)); } catch (const std::ifstream::failure &e) diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc index 7b0d2e973..ce01dffc4 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc @@ -456,11 +456,9 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attri d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; current_synchro_data.Tracking_timestamp_secs = d_sample_counter_seconds; current_synchro_data.Carrier_phase_rads = (double)d_acc_carrier_phase_rad; current_synchro_data.Carrier_Doppler_hz = (double)d_carrier_doppler_hz; - current_synchro_data.Code_phase_secs = (double)d_code_phase_samples * (1/(float)d_fs_in); current_synchro_data.CN0_dB_hz = (double)d_CN0_SNV_dB_Hz; current_synchro_data.Flag_valid_symbol_output = true; current_synchro_data.correlation_length_ms=1; diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc index 049b8a26a..f7b80c5c3 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc @@ -424,9 +424,6 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items __attribute__( //compute remnant code phase samples AFTER the Tracking timestamp d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample - //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter)/static_cast(d_fs_in); - // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 - current_synchro_data.Code_phase_secs = 0; current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad; current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; diff --git a/src/core/system_parameters/gnss_synchro.h b/src/core/system_parameters/gnss_synchro.h index c51335171..db4ba01d5 100644 --- a/src/core/system_parameters/gnss_synchro.h +++ b/src/core/system_parameters/gnss_synchro.h @@ -57,7 +57,6 @@ public: double CN0_dB_hz; //!< Set by Tracking processing block double Carrier_Doppler_hz; //!< Set by Tracking processing block double Carrier_phase_rads; //!< Set by Tracking processing block - double Code_phase_secs; //!< Set by Tracking processing block double Tracking_timestamp_secs; //!< Set by Tracking processing block bool Flag_valid_symbol_output; //!< Set by Tracking processing block diff --git a/src/tests/system-tests/pvt_gps_l1_system_test.cc b/src/tests/system-tests/pvt_gps_l1_system_test.cc new file mode 100644 index 000000000..9f9f67cfe --- /dev/null +++ b/src/tests/system-tests/pvt_gps_l1_system_test.cc @@ -0,0 +1,719 @@ +/*! + * \file obs_gps_l1_system_test.cc + * \brief This class implements a test for the validation of generated observables. + * \author Carles Fernandez-Prades, 2016. cfernandez(at)cttc.es + * + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2016 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "RinexUtilities.hpp" +#include "Rinex3ObsBase.hpp" +#include "Rinex3ObsData.hpp" +#include "Rinex3ObsHeader.hpp" +#include "Rinex3ObsStream.hpp" +#include "control_thread.h" +#include "concurrent_map.h" +#include "concurrent_queue.h" +#include "in_memory_configuration.h" + + + +DEFINE_string(generator_binary, std::string(SW_GENERATOR_BIN), "Path of software-defined signal generator binary"); +DEFINE_string(rinex_nav_file, std::string(DEFAULT_RINEX_NAV), "Input RINEX navigation file"); +DEFINE_int32(duration, 100, "Duration of the experiment [in seconds]"); +DEFINE_string(static_position, "30.286502,120.032669,100", "Static receiver position [log,lat,height]"); +DEFINE_string(dynamic_position, "", "Observer positions file, in .csv or .nmea format"); +DEFINE_string(filename_rinex_obs, "sim.16o", "Filename of output RINEX navigation file"); +DEFINE_string(filename_raw_data, "signal_out.bin", "Filename of output raw data file"); + +// For GPS NAVIGATION (L1) +concurrent_queue global_gps_acq_assist_queue; +concurrent_map global_gps_acq_assist_map; + +class Obs_Gps_L1_System_Test: public ::testing::Test +{ +public: + std::string generator_binary; + std::string p1; + std::string p2; + std::string p3; + std::string p4; + std::string p5; + + const int baseband_sampling_freq = 2.6e6; + + std::string filename_rinex_obs = FLAGS_filename_rinex_obs; + std::string filename_raw_data = FLAGS_filename_raw_data; + + int configure_generator(); + int generate_signal(); + int configure_receiver(); + int run_receiver(); + void check_results(); + bool check_valid_rinex_nav(std::string filename); // return true if the file is a valid Rinex navigation file. + bool check_valid_rinex_obs(std::string filename); // return true if the file is a valid Rinex observation file. + double compute_stdev(const std::vector & vec); + + std::shared_ptr config; + std::string generated_rinex_obs; +}; + + +bool Obs_Gps_L1_System_Test::check_valid_rinex_nav(std::string filename) +{ + bool res = false; + res = gpstk::isRinexNavFile(filename); + return res; +} + + +double Obs_Gps_L1_System_Test::compute_stdev(const std::vector & vec) +{ + double sum__ = std::accumulate(vec.begin(), vec.end(), 0.0); + double mean__ = sum__ / vec.size(); + double accum__ = 0.0; + std::for_each (std::begin(vec), std::end(vec), [&](const double d) { + accum__ += (d - mean__) * (d - mean__); + }); + double stdev__ = std::sqrt(accum__ / (vec.size() - 1)); + return stdev__; +} + + +bool Obs_Gps_L1_System_Test::check_valid_rinex_obs(std::string filename) +{ + bool res = false; + res = gpstk::isRinexObsFile(filename); + return res; +} + + +int Obs_Gps_L1_System_Test::configure_generator() +{ + // Configure signal generator + generator_binary = FLAGS_generator_binary; + + p1 = std::string("-rinex_nav_file=") + FLAGS_rinex_nav_file; + if(FLAGS_dynamic_position.empty()) + { + p2 = std::string("-static_position=") + FLAGS_static_position + std::string(",") + std::to_string(FLAGS_duration * 10); + } + else + { + p2 = std::string("-obs_pos_file=") + std::string(FLAGS_dynamic_position); + } + p3 = std::string("-rinex_obs_file=") + FLAGS_filename_rinex_obs; // RINEX 2.10 observation file output + p4 = std::string("-sig_out_file=") + FLAGS_filename_raw_data; // Baseband signal output file. Will be stored in int8_t IQ multiplexed samples + p5 = std::string("-sampling_freq=") + std::to_string(baseband_sampling_freq); //Baseband sampling frequency [MSps] + return 0; +} + + +int Obs_Gps_L1_System_Test::generate_signal() +{ + pid_t wait_result; + int child_status; + + char *const parmList[] = { &generator_binary[0], &generator_binary[0], &p1[0], &p2[0], &p3[0], &p4[0], &p5[0], NULL }; + + int pid; + if ((pid = fork()) == -1) + perror("fork error"); + else if (pid == 0) + { + execv(&generator_binary[0], parmList); + std::cout << "Return not expected. Must be an execv error." << std::endl; + std::terminate(); + } + + wait_result = waitpid(pid, &child_status, 0); + + EXPECT_EQ(true, check_valid_rinex_obs(filename_rinex_obs)); + std::cout << "Signal and Observables RINEX files created." << std::endl; + return 0; +} + + +int Obs_Gps_L1_System_Test::configure_receiver() +{ + config = std::make_shared(); + + const double central_freq = 1575420000.0; + const int sampling_rate_internal = baseband_sampling_freq; + const double gain_dB = 40.0; + + const int number_of_taps = 11; + const int number_of_bands = 2; + const float band1_begin = 0.0; + const float band1_end = 0.48; + const float band2_begin = 0.52; + const float band2_end = 1.0; + const float ampl1_begin = 1.0; + const float ampl1_end = 1.0; + const float ampl2_begin = 0.0; + const float ampl2_end = 0.0; + const float band1_error = 1.0; + const float band2_error = 1.0; + const int grid_density = 16; + const int decimation_factor = 1; + + const float zero = 0.0; + const int number_of_channels = 8; + const int in_acquisition = 1; + + const float threshold = 0.01; + const float doppler_max = 8000.0; + const float doppler_step = 500.0; + const int max_dwells = 1; + const int tong_init_val = 2; + const int tong_max_val = 10; + const int tong_max_dwells = 30; + const int coherent_integration_time_ms = 1; + + const float pll_bw_hz = 30.0; + const float dll_bw_hz = 4.0; + const float early_late_space_chips = 0.5; + + const int display_rate_ms = 500; + const int output_rate_ms = 100; + const int averaging_depth = 1; + + bool false_bool = false; + + config->set_property("GNSS-SDR.internal_fs_hz", std::to_string(sampling_rate_internal)); + + // Set the assistance system parameters + config->set_property("GNSS-SDR.SUPL_read_gps_assistance_xml", "false"); + config->set_property("GNSS-SDR.SUPL_gps_enabled", "false"); + config->set_property("GNSS-SDR.SUPL_gps_ephemeris_server", "supl.google.com"); + config->set_property("GNSS-SDR.SUPL_gps_ephemeris_port", std::to_string(7275)); + config->set_property("GNSS-SDR.SUPL_gps_acquisition_server", "supl.google.com"); + config->set_property("GNSS-SDR.SUPL_gps_acquisition_port", std::to_string(7275)); + config->set_property("GNSS-SDR.SUPL_MCC", std::to_string(244)); + config->set_property("GNSS-SDR.SUPL_MNS", std::to_string(5)); + config->set_property("GNSS-SDR.SUPL_LAC", "0x59e2"); + config->set_property("GNSS-SDR.SUPL_CI", "0x31b0"); + + // Set the Signal Source + config->set_property("SignalSource.implementation", "File_Signal_Source"); + config->set_property("SignalSource.filename", "./" + filename_raw_data); + config->set_property("SignalSource.sampling_frequency", std::to_string(sampling_rate_internal)); + config->set_property("SignalSource.item_type", "ibyte"); + config->set_property("SignalSource.samples", std::to_string(zero)); + + // Set the Signal Conditioner + config->set_property("SignalConditioner.implementation", "Signal_Conditioner"); + config->set_property("DataTypeAdapter.implementation", "Ibyte_To_Complex"); + config->set_property("InputFilter.implementation", "Fir_Filter"); + config->set_property("InputFilter.dump", "false"); + config->set_property("InputFilter.input_item_type", "gr_complex"); + config->set_property("InputFilter.output_item_type", "gr_complex"); + config->set_property("InputFilter.taps_item_type", "float"); + config->set_property("InputFilter.number_of_taps", std::to_string(number_of_taps)); + config->set_property("InputFilter.number_of_bands", std::to_string(number_of_bands)); + config->set_property("InputFilter.band1_begin", std::to_string(band1_begin)); + config->set_property("InputFilter.band1_end", std::to_string(band1_end)); + config->set_property("InputFilter.band2_begin", std::to_string(band2_begin)); + config->set_property("InputFilter.band2_end", std::to_string(band2_end)); + config->set_property("InputFilter.ampl1_begin", std::to_string(ampl1_begin)); + config->set_property("InputFilter.ampl1_end", std::to_string(ampl1_end)); + config->set_property("InputFilter.ampl2_begin", std::to_string(ampl2_begin)); + config->set_property("InputFilter.ampl2_end", std::to_string(ampl2_end)); + config->set_property("InputFilter.band1_error", std::to_string(band1_error)); + config->set_property("InputFilter.band2_error", std::to_string(band2_error)); + config->set_property("InputFilter.filter_type", "bandpass"); + config->set_property("InputFilter.grid_density", std::to_string(grid_density)); + config->set_property("InputFilter.sampling_frequency", std::to_string(sampling_rate_internal)); + config->set_property("InputFilter.IF", std::to_string(zero)); + config->set_property("Resampler.implementation", "Pass_Through"); + config->set_property("Resampler.dump", "false"); + config->set_property("Resampler.item_type", "gr_complex"); + config->set_property("Resampler.sample_freq_in", std::to_string(sampling_rate_internal)); + config->set_property("Resampler.sample_freq_out", std::to_string(sampling_rate_internal)); + + // Set the number of Channels + config->set_property("Channels_1C.count", std::to_string(number_of_channels)); + config->set_property("Channels.in_acquisition", std::to_string(in_acquisition)); + config->set_property("Channel.signal", "1C"); + + // Set Acquisition + config->set_property("Acquisition_1C.implementation", "GPS_L1_CA_PCPS_Tong_Acquisition"); + config->set_property("Acquisition_1C.item_type", "gr_complex"); + config->set_property("Acquisition_1C.if", std::to_string(zero)); + config->set_property("Acquisition_1C.coherent_integration_time_ms", std::to_string(coherent_integration_time_ms)); + config->set_property("Acquisition_1C.threshold", std::to_string(threshold)); + config->set_property("Acquisition_1C.doppler_max", std::to_string(doppler_max)); + config->set_property("Acquisition_1C.doppler_step", std::to_string(doppler_step)); + config->set_property("Acquisition_1C.bit_transition_flag", "false"); + config->set_property("Acquisition_1C.max_dwells", std::to_string(max_dwells)); + config->set_property("Acquisition_1C.tong_init_val", std::to_string(tong_init_val)); + config->set_property("Acquisition_1C.tong_max_val", std::to_string(tong_max_val)); + config->set_property("Acquisition_1C.tong_max_dwells", std::to_string(tong_max_dwells)); + + // Set Tracking + config->set_property("Tracking_1C.implementation", "GPS_L1_CA_DLL_PLL_Tracking"); + config->set_property("Tracking_1C.item_type", "gr_complex"); + config->set_property("Tracking_1C.if", std::to_string(zero)); + config->set_property("Tracking_1C.dump", "false"); + config->set_property("Tracking_1C.dump_filename", "./tracking_ch_"); + config->set_property("Tracking_1C.pll_bw_hz", std::to_string(pll_bw_hz)); + config->set_property("Tracking_1C.dll_bw_hz", std::to_string(dll_bw_hz)); + config->set_property("Tracking_1C.early_late_space_chips", std::to_string(early_late_space_chips)); + + // Set Telemetry + config->set_property("TelemetryDecoder_1C.implementation", "GPS_L1_CA_Telemetry_Decoder"); + config->set_property("TelemetryDecoder_1C.dump", "false"); + config->set_property("TelemetryDecoder_1C.decimation_factor", std::to_string(decimation_factor)); + + // Set Observables + config->set_property("Observables.implementation", "GPS_L1_CA_Observables"); + config->set_property("Observables.dump", "false"); + config->set_property("Observables.dump_filename", "./observables.dat"); + + // Set PVT + config->set_property("PVT.implementation", "GPS_L1_CA_PVT"); + config->set_property("PVT.averaging_depth", std::to_string(averaging_depth)); + config->set_property("PVT.flag_averaging", "true"); + config->set_property("PVT.output_rate_ms", std::to_string(output_rate_ms)); + config->set_property("PVT.display_rate_ms", std::to_string(display_rate_ms)); + config->set_property("PVT.dump_filename", "./PVT"); + config->set_property("PVT.nmea_dump_filename", "./gnss_sdr_pvt.nmea"); + config->set_property("PVT.flag_nmea_tty_port", "false"); + config->set_property("PVT.nmea_dump_devname", "/dev/pts/4"); + config->set_property("PVT.flag_rtcm_server", "false"); + config->set_property("PVT.flag_rtcm_tty_port", "false"); + config->set_property("PVT.rtcm_dump_devname", "/dev/pts/1"); + config->set_property("PVT.dump", "false"); + config->set_property("PVT.rinex_version", std::to_string(2)); + + return 0; +} + + +int Obs_Gps_L1_System_Test::run_receiver() +{ + std::shared_ptr control_thread; + control_thread = std::make_shared(config); + // start receiver + try + { + control_thread->run(); + } + catch( boost::exception & e ) + { + std::cout << "Boost exception: " << boost::diagnostic_information(e); + } + catch(std::exception const& ex) + { + std::cout << "STD exception: " << ex.what(); + } + // Get the name of the RINEX obs file generated by the receiver + FILE *fp; + std::string argum2 = std::string("/bin/ls *O | tail -1"); + char buffer[1035]; + fp = popen(&argum2[0], "r"); + if (fp == NULL) + { + std::cout << "Failed to run command: " << argum2 << std::endl; + } + char * without_trailing; + while (fgets(buffer, sizeof(buffer), fp) != NULL) + { + std::string aux = std::string(buffer); + without_trailing = strtok(&aux[0], "\n"); + } + generated_rinex_obs = std::string(without_trailing); + pclose(fp); + + return 0; +} + + +void Obs_Gps_L1_System_Test::check_results() +{ + std::vector> > pseudorange_ref(33); + std::vector> > carrierphase_ref(33); + std::vector> > doppler_ref(33); + + std::vector> > pseudorange_meas(33); + std::vector> > carrierphase_meas(33); + std::vector> > doppler_meas(33); + + // Open and read reference RINEX observables file + try + { + gpstk::Rinex3ObsStream r_ref(FLAGS_filename_rinex_obs); + r_ref.exceptions(std::ios::failbit); + gpstk::Rinex3ObsData r_ref_data; + gpstk::Rinex3ObsHeader r_ref_header; + + gpstk::RinexDatum dataobj; + + r_ref >> r_ref_header; + + while (r_ref >> r_ref_data) + { + for (int myprn = 1; myprn < 33; myprn++) + { + gpstk::SatID prn( myprn, gpstk::SatID::systemGPS ); + gpstk::CommonTime time = r_ref_data.time; + double sow(static_cast(time).sow); + + gpstk::Rinex3ObsData::DataMap::iterator pointer = r_ref_data.obs.find(prn); + if( pointer == r_ref_data.obs.end() ) + { + // PRN not present; do nothing + } + else + { + dataobj = r_ref_data.getObs(prn, "P1", r_ref_header); + double P1 = dataobj.data; + std::pair pseudo(sow,P1); + pseudorange_ref.at(myprn).push_back(pseudo); + + dataobj = r_ref_data.getObs(prn, "L1C", r_ref_header); + double L1 = dataobj.data; + std::pair carrier(sow, L1); + carrierphase_ref.at(myprn).push_back(carrier); + + dataobj = r_ref_data.getObs(prn, "D1C", r_ref_header); + double D1 = dataobj.data; + std::pair doppler(sow, D1); + doppler_ref.at(myprn).push_back(doppler); + } // End of 'if( pointer == roe.obs.end() )' + } // end for + } // end while + } // End of 'try' block + catch(gpstk::FFStreamError& e) + { + std::cout << e; + exit(1); + } + catch(gpstk::Exception& e) + { + std::cout << e; + exit(1); + } + catch (...) + { + std::cout << "unknown error. I don't feel so well..." << std::endl; + exit(1); + } + + try + { + std::string arg2_gen = std::string("./") + generated_rinex_obs; + gpstk::Rinex3ObsStream r_meas(arg2_gen); + r_meas.exceptions(std::ios::failbit); + gpstk::Rinex3ObsData r_meas_data; + gpstk::Rinex3ObsHeader r_meas_header; + gpstk::RinexDatum dataobj; + + r_meas >> r_meas_header; + + while (r_meas >> r_meas_data) + { + for (int myprn = 1; myprn < 33; myprn++) + { + gpstk::SatID prn( myprn, gpstk::SatID::systemGPS ); + gpstk::CommonTime time = r_meas_data.time; + double sow(static_cast(time).sow); + + gpstk::Rinex3ObsData::DataMap::iterator pointer = r_meas_data.obs.find(prn); + if( pointer == r_meas_data.obs.end() ) + { + // PRN not present; do nothing + } + else + { + dataobj = r_meas_data.getObs(prn, "C1", r_meas_header); + double P1 = dataobj.data; + std::pair pseudo(sow, P1); + pseudorange_meas.at(myprn).push_back(pseudo); + + dataobj = r_meas_data.getObs(prn, "L1C", r_meas_header); + double L1 = dataobj.data; + std::pair carrier(sow, L1); + carrierphase_meas.at(myprn).push_back(carrier); + + dataobj = r_meas_data.getObs(prn, "D1C", r_meas_header); + double D1 = dataobj.data; + std::pair doppler(sow, D1); + doppler_meas.at(myprn).push_back(doppler); + } // End of 'if( pointer == roe.obs.end() )' + } // end for + } // end while + } // End of 'try' block + catch(gpstk::FFStreamError& e) + { + std::cout << e; + exit(1); + } + catch(gpstk::Exception& e) + { + std::cout << e; + exit(1); + } + catch (...) + { + std::cout << "unknown error. I don't feel so well..." << std::endl; + exit(1); + } + + // Time alignment + std::vector> > pseudorange_ref_aligned(33); + std::vector> > carrierphase_ref_aligned(33); + std::vector> > doppler_ref_aligned(33); + + std::vector> >::iterator iter; + std::vector>::iterator it; + std::vector>::iterator it2; + + std::vector> pr_diff(33); + std::vector> cp_diff(33); + std::vector> doppler_diff(33); + + std::vector>::iterator iter_diff; + std::vector::iterator iter_v; + + int prn_id = 0; + for(iter = pseudorange_ref.begin(); iter != pseudorange_ref.end(); iter++) + { + for(it = iter->begin(); it != iter->end(); it++) + { + // If a measure exists for this sow, store it + for(it2 = pseudorange_meas.at(prn_id).begin(); it2 != pseudorange_meas.at(prn_id).end(); it2++) + { + if(std::abs(it->first - it2->first) < 0.001) // store measures closer than 1 ms. + { + pseudorange_ref_aligned.at(prn_id).push_back(*it); + pr_diff.at(prn_id).push_back(it->second - it2->second ); + } + } + } + prn_id++; + } + + prn_id = 0; + for(iter = carrierphase_ref.begin(); iter != carrierphase_ref.end(); iter++) + { + for(it = iter->begin(); it != iter->end(); it++) + { + // If a measure exists for this sow, store it + for(it2 = carrierphase_meas.at(prn_id).begin(); it2 != carrierphase_meas.at(prn_id).end(); it2++) + { + if(std::abs(it->first - it2->first) < 0.001) // store measures closer than 1 ms. + { + carrierphase_ref_aligned.at(prn_id).push_back(*it); + cp_diff.at(prn_id).push_back(it->second - it2->second ); + // std::cout << "Sat " << prn_id << ": " << "Carrier_ref=" << it->second << " Carrier_meas=" << it2->second << " Diff:" << it->second - it2->second << std::endl; + } + } + } + prn_id++; + } + prn_id = 0; + for(iter = doppler_ref.begin(); iter != doppler_ref.end(); iter++) + { + for(it = iter->begin(); it != iter->end(); it++) + { + // If a measure exists for this sow, store it + for(it2 = doppler_meas.at(prn_id).begin(); it2 != doppler_meas.at(prn_id).end(); it2++) + { + if(std::abs(it->first - it2->first) < 0.001) // store measures closer than 1 ms. + { + doppler_ref_aligned.at(prn_id).push_back(*it); + doppler_diff.at(prn_id).push_back(it->second - it2->second ); + } + } + } + prn_id++; + } + + // Compute pseudorange error + prn_id = 0; + std::vector mean_pr_diff_v; + for(iter_diff = pr_diff.begin(); iter_diff != pr_diff.end(); iter_diff++) + { + // For each satellite with reference and measurements aligned in time + int number_obs = 0; + double mean_diff = 0.0; + for(iter_v = iter_diff->begin(); iter_v != iter_diff->end(); iter_v++) + { + mean_diff = mean_diff + *iter_v; + number_obs = number_obs + 1; + } + if(number_obs > 0) + { + mean_diff = mean_diff / number_obs; + mean_pr_diff_v.push_back(mean_diff); + std::cout << "-- Mean pseudorange difference for sat " << prn_id << ": " << mean_diff << " [m]" << std::endl; + } + else + { + mean_diff = 0.0; + } + + prn_id++; + } + double stdev_pr = compute_stdev(mean_pr_diff_v); + std::cout << "Pseudorange diff error stdev = " << stdev_pr << " [m]" << std::endl; + ASSERT_LT(stdev_pr, 1.0); + + // Compute carrier phase error + prn_id = 0; + std::vector mean_cp_diff_v; + for(iter_diff = cp_diff.begin(); iter_diff != cp_diff.end(); iter_diff++) + { + // For each satellite with reference and measurements aligned in time + int number_obs = 0; + double mean_diff = 0.0; + for(iter_v = iter_diff->begin(); iter_v != iter_diff->end(); iter_v++) + { + mean_diff = mean_diff + *iter_v; + number_obs = number_obs + 1; + } + if(number_obs > 0) + { + mean_diff = mean_diff / number_obs; + mean_cp_diff_v.push_back(mean_diff); + std::cout << "-- Mean carrier phase difference for sat " << prn_id << ": " << mean_diff; + double stdev_pr_ = compute_stdev(*iter_diff); + std::cout << " +/- " << stdev_pr_ << " whole cycles (19 cm)" << std::endl; + } + else + { + mean_diff = 0.0; + } + + prn_id++; + } + + // Compute Doppler error + prn_id = 0; + std::vector mean_doppler_v; + for(iter_diff = doppler_diff.begin(); iter_diff != doppler_diff.end(); iter_diff++) + { + // For each satellite with reference and measurements aligned in time + int number_obs = 0; + double mean_diff = 0.0; + for(iter_v = iter_diff->begin(); iter_v != iter_diff->end(); iter_v++) + { + //std::cout << *iter_v << std::endl; + mean_diff = mean_diff + *iter_v; + number_obs = number_obs + 1; + } + if(number_obs > 0) + { + mean_diff = mean_diff / number_obs; + mean_doppler_v.push_back(mean_diff); + std::cout << "-- Mean Doppler difference for sat " << prn_id << ": " << mean_diff << " [Hz]" << std::endl; + } + else + { + mean_diff = 0.0; + } + + prn_id++; + } + + double stdev_dp = compute_stdev(mean_doppler_v); + std::cout << "Doppler error stdev = " << stdev_dp << " [Hz]" << std::endl; + ASSERT_LT(stdev_dp, 1.0); +} + + +TEST_F(Obs_Gps_L1_System_Test, Observables_system_test) +{ + std::cout << "Validating input RINEX nav file: " << FLAGS_rinex_nav_file << " ..." << std::endl; + bool is_rinex_nav_valid = check_valid_rinex_nav(FLAGS_rinex_nav_file); + ASSERT_EQ(true, is_rinex_nav_valid); + std::cout << "The file is valid." << std::endl; + + // Configure the signal generator + configure_generator(); + + // Generate signal raw signal samples and observations RINEX file + generate_signal(); + + std::cout << "Validating generated reference RINEX obs file: " << FLAGS_filename_rinex_obs << " ..." << std::endl; + bool is_gen_rinex_obs_valid = check_valid_rinex_obs( "./" + FLAGS_filename_rinex_obs); + ASSERT_EQ(true, is_gen_rinex_obs_valid); + std::cout << "The file is valid." << std::endl; + + // Configure receiver + configure_receiver(); + + // Run the receiver + run_receiver(); + + std::cout << "Validating RINEX obs file obtained by GNSS-SDR: " << generated_rinex_obs << " ..." << std::endl; + is_gen_rinex_obs_valid = check_valid_rinex_obs( "./" + generated_rinex_obs); + ASSERT_EQ(true, is_gen_rinex_obs_valid); + std::cout << "The file is valid." << std::endl; + + // Check results + check_results(); +} + + +int main(int argc, char **argv) +{ + std::cout << "Running Observables validation test..." << std::endl; + int res = 0; + try + { + testing::InitGoogleTest(&argc, argv); + } + catch(...) {} // catch the "testing::internal::::ClassUniqueToAlwaysTrue" from gtest + + google::ParseCommandLineFlags(&argc, &argv, true); + google::InitGoogleLogging(argv[0]); + + // Run the Tests + try + { + res = RUN_ALL_TESTS(); + } + catch(...) + { + LOG(WARNING) << "Unexpected catch"; + } + google::ShutDownCommandLineFlags(); + return res; +} diff --git a/src/tests/test_main.cc b/src/tests/test_main.cc index f6b663112..92b847cac 100644 --- a/src/tests/test_main.cc +++ b/src/tests/test_main.cc @@ -114,6 +114,7 @@ DECLARE_string(log_dir); #include "unit-tests/signal-processing-blocks/tracking/galileo_e1_dll_pll_veml_tracking_test.cc" #include "unit-tests/signal-processing-blocks/tracking/galileo_e5a_tracking_test.cc" #include "unit-tests/signal-processing-blocks/tracking/gps_l2_m_dll_pll_tracking_test.cc" +//#include "unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc" #include "unit-tests/signal-processing-blocks/tracking/tracking_loop_filter_test.cc" #include "unit-tests/signal-processing-blocks/tracking/cpu_multicorrelator_test.cc" #if CUDA_BLOCKS_TEST diff --git a/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc b/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc new file mode 100644 index 000000000..bc950527a --- /dev/null +++ b/src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc @@ -0,0 +1,210 @@ +/*! + * \file gps_l1_ca_dll_pll_tracking_test.cc + * \brief This class implements a tracking test for Galileo_E5a_DLL_PLL_Tracking + * implementation based on some input parameters. + * \author Javier Arribas, 2015. jarribas(at)cttc.es + * + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2012-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gnss_block_factory.h" +#include "gnss_block_interface.h" +#include "tracking_interface.h" +#include "in_memory_configuration.h" +#include "gnss_sdr_valve.h" +#include "gnss_synchro.h" +#include "gps_l1_ca_dll_pll_tracking.h" + +// ######## GNURADIO BLOCK MESSAGE RECEVER ######### +class GpsL1CADllPllTrackingTest_msg_rx; + +typedef boost::shared_ptr GpsL1CADllPllTrackingTest_msg_rx_sptr; + +GpsL1CADllPllTrackingTest_msg_rx_sptr GpsL1CADllPllTrackingTest_msg_rx_make(); + +class GpsL1CADllPllTrackingTest_msg_rx : public gr::block +{ +private: + friend GpsL1CADllPllTrackingTest_msg_rx_sptr GpsL1CADllPllTrackingTest_msg_rx_make(); + void msg_handler_events(pmt::pmt_t msg); + GpsL1CADllPllTrackingTest_msg_rx(); + +public: + int rx_message; + ~GpsL1CADllPllTrackingTest_msg_rx(); //!< Default destructor + +}; + +GpsL1CADllPllTrackingTest_msg_rx_sptr GpsL1CADllPllTrackingTest_msg_rx_make() +{ + return GpsL1CADllPllTrackingTest_msg_rx_sptr(new GpsL1CADllPllTrackingTest_msg_rx()); +} + +void GpsL1CADllPllTrackingTest_msg_rx::msg_handler_events(pmt::pmt_t msg) +{ + try + { + long int message = pmt::to_long(msg); + rx_message = message; + } + catch(boost::bad_any_cast& e) + { + LOG(WARNING) << "msg_handler_telemetry Bad any cast!"; + rx_message = 0; + } +} + +GpsL1CADllPllTrackingTest_msg_rx::GpsL1CADllPllTrackingTest_msg_rx() : + gr::block("GpsL1CADllPllTrackingTest_msg_rx", gr::io_signature::make(0, 0, 0), gr::io_signature::make(0, 0, 0)) +{ + this->message_port_register_in(pmt::mp("events")); + this->set_msg_handler(pmt::mp("events"), boost::bind(&GpsL1CADllPllTrackingTest_msg_rx::msg_handler_events, this, _1)); + rx_message = 0; +} + +GpsL1CADllPllTrackingTest_msg_rx::~GpsL1CADllPllTrackingTest_msg_rx() +{} + + +// ########################################################### + + +class GpsL1CADllPllTrackingTest: public ::testing::Test +{ +protected: + GpsL1CADllPllTrackingTest() + { + factory = std::make_shared(); + config = std::make_shared(); + item_size = sizeof(gr_complex); + gnss_synchro = Gnss_Synchro(); + } + + ~GpsL1CADllPllTrackingTest() + {} + + void init(); + + gr::msg_queue::sptr queue; + gr::top_block_sptr top_block; + std::shared_ptr factory; + std::shared_ptr config; + Gnss_Synchro gnss_synchro; + size_t item_size; +}; + + +void GpsL1CADllPllTrackingTest::init() +{ + gnss_synchro.Channel_ID = 0; + gnss_synchro.System = 'G'; + std::string signal = "1C"; + signal.copy(gnss_synchro.Signal, 2, 0); + gnss_synchro.PRN = 1; + + config->set_property("GNSS-SDR.internal_fs_hz", "2600000"); + // Set Tracking + config->set_property("Tracking_1C.implementation", "GPS_L1_CA_DLL_PLL_Tracking"); + config->set_property("Tracking_1C.item_type", "gr_complex"); + config->set_property("Tracking_1C.if", "0"); + config->set_property("Tracking_1C.dump", "true"); + config->set_property("Tracking_1C.dump_filename", "./tracking_ch_"); + config->set_property("Tracking_1C.pll_bw_hz", "30.0"); + config->set_property("Tracking_1C.dll_bw_hz", "4.0"); + config->set_property("Tracking_1C.early_late_space_chips", "0.5"); +} + +TEST_F(GpsL1CADllPllTrackingTest, ValidationOfResults) +{ + struct timeval tv; + long long int begin = 0; + long long int end = 0; + int fs_in = 2600000; + //int nsamples = fs_in*3; + + init(); + queue = gr::msg_queue::make(0); + top_block = gr::make_top_block("Tracking test"); + std::shared_ptr tracking = std::make_shared(config.get(), "Tracking_1C", 1, 1); + boost::shared_ptr msg_rx = GpsL1CADllPllTrackingTest_msg_rx_make(); + + gnss_synchro.Acq_delay_samples = (1023-994.622/1023)*fs_in*1e-3; + gnss_synchro.Acq_doppler_hz = -2583.86; + gnss_synchro.Acq_samplestamp_samples = 0; + + ASSERT_NO_THROW( { + tracking->set_channel(gnss_synchro.Channel_ID); + }) << "Failure setting channel." << std::endl; + + ASSERT_NO_THROW( { + tracking->set_gnss_synchro(&gnss_synchro); + }) << "Failure setting gnss_synchro." << std::endl; + + ASSERT_NO_THROW( { + tracking->connect(top_block); + }) << "Failure connecting tracking to the top_block." << std::endl; + + ASSERT_NO_THROW( { + std::string path = std::string(TEST_PATH); + std::string file = path + "data/gps_l1ca_prn1_2.6msps.dat"; + const char * file_name = file.c_str(); + gr::blocks::file_source::sptr file_source = gr::blocks::file_source::make(sizeof(int8_t), file_name, false); + //boost::shared_ptr valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue); + gr::blocks::interleaved_char_to_complex::sptr gr_interleaved_char_to_complex = gr::blocks::interleaved_char_to_complex::make(); + gr::blocks::null_sink::sptr sink = gr::blocks::null_sink::make(sizeof(Gnss_Synchro)); + top_block->connect(file_source, 0, gr_interleaved_char_to_complex, 0); + //top_block->connect(gr_interleaved_char_to_complex, 0, valve, 0); + top_block->connect(gr_interleaved_char_to_complex, 0, tracking->get_left_block(), 0); + top_block->connect(tracking->get_right_block(), 0, sink, 0); + top_block->msg_connect(tracking->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); + }) << "Failure connecting the blocks of tracking test." << std::endl; + + tracking->start_tracking(); + + EXPECT_NO_THROW( { + gettimeofday(&tv, NULL); + begin = tv.tv_sec *1000000 + tv.tv_usec; + top_block->run(); // Start threads and wait + gettimeofday(&tv, NULL); + end = tv.tv_sec *1000000 + tv.tv_usec; + }) << "Failure running the top_block." << std::endl; + + // TODO: Verify tracking results + std::cout << "Signal tracking completed in " << (end - begin) << " microseconds" << std::endl; +} +