From 44635a41b35f1e03fc3d4b036667f8c6d8bfd608 Mon Sep 17 00:00:00 2001 From: Antonio Ramos Date: Wed, 4 Apr 2018 14:59:28 +0200 Subject: [PATCH 01/21] Add two step acquisition funcionality --- .../gnuradio_blocks/pcps_acquisition.cc | 314 ++++++++++++------ .../gnuradio_blocks/pcps_acquisition.h | 8 +- .../gnuradio_blocks/dll_pll_veml_tracking.cc | 1 + 3 files changed, 224 insertions(+), 99 deletions(-) diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc index 19faf843e..54bb52e8c 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc @@ -88,11 +88,13 @@ pcps_acquisition::pcps_acquisition( d_mag = 0; d_input_power = 0.0; d_num_doppler_bins = 0; + d_num_doppler_bins_step_two = 4; d_bit_transition_flag = bit_transition_flag; d_use_CFAR_algorithm_flag = use_CFAR_algorithm_flag; d_threshold = 0.0; d_doppler_step = 0; - d_code_phase = 0; + d_doppler_step_two = 0.0; + d_doppler_center_step_two = 0.0; d_test_statistics = 0.0; d_channel = 0; if (it_size == sizeof(gr_complex)) @@ -133,7 +135,8 @@ pcps_acquisition::pcps_acquisition( d_dump = dump; d_dump_filename = dump_filename; d_gnss_synchro = 0; - d_grid_doppler_wipeoffs = 0; + d_grid_doppler_wipeoffs = nullptr; + d_grid_doppler_wipeoffs_step_two = nullptr; d_blocking = blocking; d_worker_active = false; d_data_buffer = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); @@ -146,6 +149,7 @@ pcps_acquisition::pcps_acquisition( d_data_buffer_sc = nullptr; } grid_ = arma::fmat(); + d_step_two = false; } @@ -159,6 +163,14 @@ pcps_acquisition::~pcps_acquisition() } delete[] d_grid_doppler_wipeoffs; } + if (d_num_doppler_bins_step_two > 0) + { + for (unsigned int i = 0; i < d_num_doppler_bins_step_two; i++) + { + volk_gnsssdr_free(d_grid_doppler_wipeoffs_step_two[i]); + } + delete[] d_grid_doppler_wipeoffs_step_two; + } volk_gnsssdr_free(d_fft_codes); volk_gnsssdr_free(d_magnitude); delete d_ifft; @@ -249,13 +261,18 @@ void pcps_acquisition::init() // Create the carrier Doppler wipeoff signals d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins]; - + d_grid_doppler_wipeoffs_step_two = new gr_complex*[d_num_doppler_bins_step_two]; for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) { d_grid_doppler_wipeoffs[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); int doppler = -static_cast(d_doppler_max) + d_doppler_step * doppler_index; update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_freq + doppler); } + for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins_step_two; doppler_index++) + { + d_grid_doppler_wipeoffs_step_two[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); + } + d_worker_active = false; if (d_dump) @@ -270,12 +287,21 @@ void pcps_acquisition::update_grid_doppler_wipeoffs() { for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) { - d_grid_doppler_wipeoffs[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); + //CHECK IF CALLING MALLOC IS NEEDED!!! + //d_grid_doppler_wipeoffs[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); int doppler = -static_cast(d_doppler_max) + d_doppler_step * doppler_index; update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_freq + doppler); } } +void pcps_acquisition::update_grid_doppler_wipeoffs_step2() +{ + for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins_step_two; doppler_index++) + { + float doppler = (static_cast(doppler_index) - static_cast(d_num_doppler_bins_step_two) / 2.0) * d_doppler_step_two; + update_local_carrier(d_grid_doppler_wipeoffs_step_two[doppler_index], d_fft_size, d_doppler_center_step_two + doppler); + } +} void pcps_acquisition::set_state(int state) { @@ -354,10 +380,17 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)), */ gr::thread::scoped_lock lk(d_setlock); - if (!d_active || d_worker_active) + if (!d_active or d_worker_active) { d_sample_counter += d_fft_size * ninput_items[0]; consume_each(ninput_items[0]); + if (d_step_two) + { + d_doppler_center_step_two = static_cast(d_gnss_synchro->Acq_doppler_hz); + update_grid_doppler_wipeoffs_step2(); + d_state = 0; + d_active = true; + } return 0; } @@ -414,7 +447,6 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) gr::thread::scoped_lock lk(d_setlock); // initialize acquisition algorithm - int doppler; uint32_t indext = 0; float magt = 0.0; const gr_complex* in = d_data_buffer; //Get the input samples pointer @@ -445,105 +477,172 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) d_input_power /= static_cast(d_fft_size); } // 2- Doppler frequency search loop - for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) + if (!d_step_two) { - // doppler search steps - doppler = -static_cast(d_doppler_max) + d_doppler_step * doppler_index; - - volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index], d_fft_size); - - // 3- Perform the FFT-based convolution (parallel time search) - // Compute the FFT of the carrier wiped--off incoming signal - d_fft_if->execute(); - - // Multiply carrier wiped--off, Fourier transformed incoming signal - // with the local FFT'd code reference using SIMD operations with VOLK library - volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size); - - // compute the inverse FFT - d_ifft->execute(); - - // Search maximum - size_t offset = (d_bit_transition_flag ? effective_fft_size : 0); - volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size); - volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size); - magt = d_magnitude[indext]; - - if (d_use_CFAR_algorithm_flag) + for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) { - // Normalize the maximum value to correct the scale factor introduced by FFTW - magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor); - } - // 4- record the maximum peak and the associated synchronization parameters - if (d_mag < magt) - { - d_mag = magt; + // doppler search steps + int doppler = -static_cast(d_doppler_max) + d_doppler_step * doppler_index; - if (!d_use_CFAR_algorithm_flag) + volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index], d_fft_size); + + // 3- Perform the FFT-based convolution (parallel time search) + // Compute the FFT of the carrier wiped--off incoming signal + d_fft_if->execute(); + + // Multiply carrier wiped--off, Fourier transformed incoming signal + // with the local FFT'd code reference using SIMD operations with VOLK library + volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size); + + // compute the inverse FFT + d_ifft->execute(); + + // Search maximum + size_t offset = (d_bit_transition_flag ? effective_fft_size : 0); + volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size); + volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size); + magt = d_magnitude[indext]; + + if (d_use_CFAR_algorithm_flag) { - // Search grid noise floor approximation for this doppler line - volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size); - d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1); + // Normalize the maximum value to correct the scale factor introduced by FFTW + magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor); } - - // In case that d_bit_transition_flag = true, we compare the potentially - // new maximum test statistics (d_mag/d_input_power) with the value in - // d_test_statistics. When the second dwell is being processed, the value - // of d_mag/d_input_power could be lower than d_test_statistics (i.e, - // the maximum test statistics in the previous dwell is greater than - // current d_mag/d_input_power). Note that d_test_statistics is not - // restarted between consecutive dwells in multidwell operation. - - if (d_test_statistics < (d_mag / d_input_power) || !d_bit_transition_flag) + // 4- record the maximum peak and the associated synchronization parameters + if (d_mag < magt) { - d_gnss_synchro->Acq_delay_samples = static_cast(indext % d_samples_per_code); - d_gnss_synchro->Acq_doppler_hz = static_cast(doppler); - d_gnss_synchro->Acq_samplestamp_samples = samp_count; + d_mag = magt; - // 5- Compute the test statistics and compare to the threshold - //d_test_statistics = 2 * d_fft_size * d_mag / d_input_power; - d_test_statistics = d_mag / d_input_power; - } - } - // Record results to file if required - if (d_dump) - { - memcpy(grid_.colptr(doppler_index), d_magnitude, sizeof(float) * effective_fft_size); - if (doppler_index == (d_num_doppler_bins - 1)) - { - std::string filename = d_dump_filename; - filename.append("_"); - filename.append(1, d_gnss_synchro->System); - filename.append("_"); - filename.append(1, d_gnss_synchro->Signal[0]); - filename.append(1, d_gnss_synchro->Signal[1]); - filename.append("_sat_"); - filename.append(std::to_string(d_gnss_synchro->PRN)); - filename.append(".mat"); - mat_t* matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73); - if (matfp == NULL) + if (!d_use_CFAR_algorithm_flag) { - std::cout << "Unable to create or open Acquisition dump file" << std::endl; - d_dump = false; + // Search grid noise floor approximation for this doppler line + volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size); + d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1); } - else + + // In case that d_bit_transition_flag = true, we compare the potentially + // new maximum test statistics (d_mag/d_input_power) with the value in + // d_test_statistics. When the second dwell is being processed, the value + // of d_mag/d_input_power could be lower than d_test_statistics (i.e, + // the maximum test statistics in the previous dwell is greater than + // current d_mag/d_input_power). Note that d_test_statistics is not + // restarted between consecutive dwells in multidwell operation. + + if (d_test_statistics < (d_mag / d_input_power) or !d_bit_transition_flag) { - size_t dims[2] = {static_cast(effective_fft_size), static_cast(d_num_doppler_bins)}; - matvar_t* matvar = Mat_VarCreate("grid", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, grid_.memptr(), 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); + d_gnss_synchro->Acq_delay_samples = static_cast(indext % d_samples_per_code); + d_gnss_synchro->Acq_doppler_hz = static_cast(doppler); + d_gnss_synchro->Acq_samplestamp_samples = samp_count; - dims[0] = static_cast(1); - dims[1] = static_cast(1); - matvar = Mat_VarCreate("doppler_max", MAT_C_SINGLE, MAT_T_UINT32, 1, dims, &d_doppler_max, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); + // 5- Compute the test statistics and compare to the threshold + //d_test_statistics = 2 * d_fft_size * d_mag / d_input_power; + d_test_statistics = d_mag / d_input_power; + } + } + // Record results to file if required + if (d_dump) + { + memcpy(grid_.colptr(doppler_index), d_magnitude, sizeof(float) * effective_fft_size); + if (doppler_index == (d_num_doppler_bins - 1)) + { + std::string filename = d_dump_filename; + filename.append("_"); + filename.append(1, d_gnss_synchro->System); + filename.append("_"); + filename.append(1, d_gnss_synchro->Signal[0]); + filename.append(1, d_gnss_synchro->Signal[1]); + filename.append("_sat_"); + filename.append(std::to_string(d_gnss_synchro->PRN)); + filename.append(".mat"); + mat_t* matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73); + if (matfp == NULL) + { + std::cout << "Unable to create or open Acquisition dump file" << std::endl; + d_dump = false; + } + else + { + size_t dims[2] = {static_cast(effective_fft_size), static_cast(d_num_doppler_bins)}; + matvar_t* matvar = Mat_VarCreate("grid", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, grid_.memptr(), 0); + Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE + Mat_VarFree(matvar); - matvar = Mat_VarCreate("doppler_step", MAT_C_SINGLE, MAT_T_UINT32, 1, dims, &d_doppler_step, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); + dims[0] = static_cast(1); + dims[1] = static_cast(1); + matvar = Mat_VarCreate("doppler_max", MAT_C_SINGLE, MAT_T_UINT32, 1, dims, &d_doppler_max, 0); + Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE + Mat_VarFree(matvar); - Mat_Close(matfp); + matvar = Mat_VarCreate("doppler_step", MAT_C_SINGLE, MAT_T_UINT32, 1, dims, &d_doppler_step, 0); + Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE + Mat_VarFree(matvar); + + Mat_Close(matfp); + } + } + } + } + } + else + { + for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins_step_two; doppler_index++) + { + // doppler search steps + float doppler = d_doppler_center_step_two + (static_cast(doppler_index) - static_cast(d_num_doppler_bins_step_two) / 2.0) * d_doppler_step_two; + + volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs_step_two[doppler_index], d_fft_size); + + // 3- Perform the FFT-based convolution (parallel time search) + // Compute the FFT of the carrier wiped--off incoming signal + d_fft_if->execute(); + + // Multiply carrier wiped--off, Fourier transformed incoming signal + // with the local FFT'd code reference using SIMD operations with VOLK library + volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size); + + // compute the inverse FFT + d_ifft->execute(); + + // Search maximum + size_t offset = (d_bit_transition_flag ? effective_fft_size : 0); + volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size); + volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size); + magt = d_magnitude[indext]; + + if (d_use_CFAR_algorithm_flag) + { + // Normalize the maximum value to correct the scale factor introduced by FFTW + magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor); + } + // 4- record the maximum peak and the associated synchronization parameters + if (d_mag < magt) + { + d_mag = magt; + + if (!d_use_CFAR_algorithm_flag) + { + // Search grid noise floor approximation for this doppler line + volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size); + d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1); + } + + // In case that d_bit_transition_flag = true, we compare the potentially + // new maximum test statistics (d_mag/d_input_power) with the value in + // d_test_statistics. When the second dwell is being processed, the value + // of d_mag/d_input_power could be lower than d_test_statistics (i.e, + // the maximum test statistics in the previous dwell is greater than + // current d_mag/d_input_power). Note that d_test_statistics is not + // restarted between consecutive dwells in multidwell operation. + + if (d_test_statistics < (d_mag / d_input_power) or !d_bit_transition_flag) + { + d_gnss_synchro->Acq_delay_samples = static_cast(indext % d_samples_per_code); + d_gnss_synchro->Acq_doppler_hz = static_cast(doppler); + d_gnss_synchro->Acq_samplestamp_samples = samp_count; + + // 5- Compute the test statistics and compare to the threshold + //d_test_statistics = 2 * d_fft_size * d_mag / d_input_power; + d_test_statistics = d_mag / d_input_power; } } } @@ -553,14 +652,24 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) { if (d_test_statistics > d_threshold) { - d_state = 0; // Positive acquisition d_active = false; - send_positive_acquisition(); + if (d_step_two) + { + send_positive_acquisition(); + d_step_two = false; + d_state = 0; // Positive acquisition + } + else + { + d_step_two = true; // Clear input buffer and make small grid acquisition + d_state = 0; + } } else if (d_well_count == d_max_dwells) { d_state = 0; d_active = false; + d_step_two = false; send_negative_acquisition(); } } @@ -568,16 +677,25 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) { if (d_well_count == d_max_dwells) // d_max_dwells = 2 { + d_active = false; if (d_test_statistics > d_threshold) { - d_state = 0; // Positive acquisition - d_active = false; - send_positive_acquisition(); + if (d_step_two) + { + send_positive_acquisition(); + d_step_two = false; + d_state = 0; // Positive acquisition + } + else + { + d_step_two = true; // Clear input buffer and make small grid acquisition + d_state = 0; + } } else { d_state = 0; // Negative acquisition - d_active = false; + d_step_two = false; send_negative_acquisition(); } } diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h index d99ad3f6e..72bd1713e 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h @@ -98,6 +98,7 @@ private: void update_local_carrier(gr_complex* carrier_vector, int correlator_length_samples, float freq); void update_grid_doppler_wipeoffs(); + void update_grid_doppler_wipeoffs_step2(); bool is_fdma(); void acquisition_core(unsigned long int samp_count); @@ -113,6 +114,7 @@ private: bool d_worker_active; bool d_blocking; bool d_cshort; + bool d_step_two; float d_threshold; float d_mag; float d_input_power; @@ -127,14 +129,17 @@ private: unsigned int d_channel; unsigned int d_doppler_max; unsigned int d_doppler_step; + float d_doppler_step_two; + float d_doppler_center_step_two; unsigned int d_sampled_ms; unsigned int d_max_dwells; unsigned int d_well_count; unsigned int d_fft_size; unsigned int d_num_doppler_bins; - unsigned int d_code_phase; + unsigned int d_num_doppler_bins_step_two; unsigned long int d_sample_counter; gr_complex** d_grid_doppler_wipeoffs; + gr_complex** d_grid_doppler_wipeoffs_step_two; gr_complex* d_fft_codes; gr_complex* d_data_buffer; lv_16sc_t* d_data_buffer_sc; @@ -234,6 +239,7 @@ public: { gr::thread::scoped_lock lock(d_setlock); // require mutex with work function called by the scheduler d_doppler_step = doppler_step; + d_doppler_step_two = static_cast(d_doppler_step) / 2.0; } /*! diff --git a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc index a89dfefc9..9a6a412d6 100755 --- a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc +++ b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc @@ -430,6 +430,7 @@ void dll_pll_veml_tracking::start_tracking() long int acq_trk_diff_samples = static_cast(d_sample_counter) - static_cast(d_acq_sample_stamp); double acq_trk_diff_seconds = static_cast(acq_trk_diff_samples) / d_fs_in; + std::cout << "ACQ to TRK diff seconds = " << acq_trk_diff_seconds << std::endl; DLOG(INFO) << "Number of samples between Acquisition and Tracking = " << acq_trk_diff_samples; DLOG(INFO) << "Number of seconds between Acquisition and Tracking = " << acq_trk_diff_seconds; // Doppler effect Fd = (C / (C + Vr)) * F From e42149c9e521bb1833c74fdbf0e349dab913751e Mon Sep 17 00:00:00 2001 From: Antonio Ramos Date: Wed, 4 Apr 2018 17:03:49 +0200 Subject: [PATCH 02/21] Add number of doppler bins and doppler step in two step acquisition --- .../galileo_e1_pcps_ambiguous_acquisition.cc | 41 ++-- .../adapters/galileo_e5a_pcps_acquisition.cc | 27 ++- .../glonass_l1_ca_pcps_acquisition.cc | 28 ++- .../glonass_l2_ca_pcps_acquisition.cc | 25 +- .../adapters/gps_l1_ca_pcps_acquisition.cc | 27 ++- .../adapters/gps_l2_m_pcps_acquisition.cc | 28 ++- .../adapters/gps_l5i_pcps_acquisition.cc | 28 ++- .../gnuradio_blocks/pcps_acquisition.cc | 224 ++++++++---------- .../gnuradio_blocks/pcps_acquisition.h | 59 ++--- .../gnuradio_blocks/dll_pll_veml_tracking.cc | 1 - 10 files changed, 266 insertions(+), 222 deletions(-) diff --git a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc index a16e10573..7000a4066 100644 --- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc @@ -45,6 +45,7 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + pcpsconf_t acq_parameters; configuration_ = configuration; std::string default_item_type = "gr_complex"; std::string default_dump_filename = "./data/acquisition.dat"; @@ -55,32 +56,33 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition( long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 4000000); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + acq_parameters.fs_in = fs_in_; if_ = configuration_->property(role + ".if", 0); + acq_parameters.freq = if_; dump_ = configuration_->property(role + ".dump", false); + acq_parameters.dump = dump_; blocking_ = configuration_->property(role + ".blocking", true); + acq_parameters.blocking = blocking_; doppler_max_ = configuration_->property(role + ".doppler_max", 5000); if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max; - sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 4); - - if (sampled_ms_ % 4 != 0) - { - sampled_ms_ = static_cast(sampled_ms_ / 4) * 4; - LOG(WARNING) << "coherent_integration_time should be multiple of " - << "Galileo code length (4 ms). coherent_integration_time = " - << sampled_ms_ << " ms will be used."; - } - + acq_parameters.doppler_max = doppler_max_; + sampled_ms_ = 4; + acq_parameters.sampled_ms = sampled_ms_; bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false); + acq_parameters.bit_transition_flag = bit_transition_flag_; use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions - acquire_pilot_ = configuration_->property(role + ".acquire_pilot", false); //will be true in future versions + acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_; + acquire_pilot_ = configuration_->property(role + ".acquire_pilot", false); //will be true in future versions max_dwells_ = configuration_->property(role + ".max_dwells", 1); - + acq_parameters.max_dwells = max_dwells_; dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); - + acq_parameters.dump_filename = dump_filename_; //--- Find number of samples per spreading code (4 ms) ----------------- - code_length_ = round(fs_in_ / (Galileo_E1_CODE_CHIP_RATE_HZ / Galileo_E1_B_CODE_LENGTH_CHIPS)); - int samples_per_ms = round(code_length_ / 4.0); + code_length_ = static_cast(std::round(static_cast(fs_in_) / (Galileo_E1_CODE_CHIP_RATE_HZ / Galileo_E1_B_CODE_LENGTH_CHIPS))); + acq_parameters.samples_per_code = code_length_; + int samples_per_ms = static_cast(std::round(static_cast(fs_in_) * 0.001)); + acq_parameters.samples_per_ms = samples_per_ms; vector_length_ = sampled_ms_ * samples_per_ms; if (bit_transition_flag_) @@ -98,10 +100,11 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition( { item_size_ = sizeof(gr_complex); } - acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_, - doppler_max_, if_, fs_in_, samples_per_ms, code_length_, - bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, - dump_filename_, item_size_); + acq_parameters.it_size = item_size_; + acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4); + acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0); + acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false); + acquisition_ = pcps_make_acquisition(acq_parameters); DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")"; stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_); diff --git a/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc index fcc614792..e903ec877 100644 --- a/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc @@ -44,6 +44,7 @@ using google::LogMessage; GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + pcpsconf_t acq_parameters; configuration_ = configuration; std::string default_item_type = "gr_complex"; std::string default_dump_filename = "../data/acquisition.dat"; @@ -54,6 +55,8 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 32000000); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + acq_parameters.fs_in = fs_in_; + acq_parameters.freq = 0; acq_pilot_ = configuration_->property(role + ".acquire_pilot", false); acq_iq_ = configuration_->property(role + ".acquire_iq", false); if (acq_iq_) @@ -61,17 +64,23 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con acq_pilot_ = false; } dump_ = configuration_->property(role + ".dump", false); + acq_parameters.dump = dump_; doppler_max_ = configuration_->property(role + ".doppler_max", 5000); if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max; - sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1); + acq_parameters.doppler_max = doppler_max_; + sampled_ms_ = 1; max_dwells_ = configuration_->property(role + ".max_dwells", 1); + acq_parameters.max_dwells = max_dwells_; dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); + acq_parameters.dump_filename = dump_filename_; bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false); + acq_parameters.bit_transition_flag = bit_transition_flag_; use_CFAR_ = configuration_->property(role + ".use_CFAR_algorithm", false); + acq_parameters.use_CFAR_algorithm_flag = use_CFAR_; blocking_ = configuration_->property(role + ".blocking", true); - + acq_parameters.blocking = blocking_; //--- Find number of samples per spreading code (1ms)------------------------- - code_length_ = round(static_cast(fs_in_) / Galileo_E5a_CODE_CHIP_RATE_HZ * static_cast(Galileo_E5a_CODE_LENGTH_CHIPS)); + code_length_ = static_cast(std::round(static_cast(fs_in_) / Galileo_E5a_CODE_CHIP_RATE_HZ * static_cast(Galileo_E5a_CODE_LENGTH_CHIPS))); vector_length_ = code_length_ * sampled_ms_; code_ = new gr_complex[vector_length_]; @@ -89,10 +98,14 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con item_size_ = sizeof(gr_complex); LOG(WARNING) << item_type_ << " unknown acquisition item type"; } - - acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_, doppler_max_, 0, fs_in_, - code_length_, code_length_, bit_transition_flag_, use_CFAR_, dump_, blocking_, - dump_filename_, item_size_); + acq_parameters.it_size = item_size_; + acq_parameters.samples_per_code = code_length_; + acq_parameters.samples_per_ms = code_length_; + acq_parameters.sampled_ms = sampled_ms_; + acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4); + acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0); + acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false); + acquisition_ = pcps_make_acquisition(acq_parameters); stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_); channel_ = 0; diff --git a/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc index 685c93425..2ea0514d9 100644 --- a/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc @@ -46,6 +46,7 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + pcpsconf_t acq_parameters; configuration_ = configuration; std::string default_item_type = "gr_complex"; std::string default_dump_filename = "./data/acquisition.dat"; @@ -56,22 +57,28 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition( long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + acq_parameters.fs_in = fs_in_; if_ = configuration_->property(role + ".if", 0); + acq_parameters.freq = if_; dump_ = configuration_->property(role + ".dump", false); + acq_parameters.dump = dump_; blocking_ = configuration_->property(role + ".blocking", true); + acq_parameters.blocking = blocking_; doppler_max_ = configuration_->property(role + ".doppler_max", 5000); if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max; + acq_parameters.doppler_max = doppler_max_; sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1); - + acq_parameters.sampled_ms = sampled_ms_; bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false); + acq_parameters.bit_transition_flag = bit_transition_flag_; use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions - + acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_; max_dwells_ = configuration_->property(role + ".max_dwells", 1); - + acq_parameters.max_dwells = max_dwells_; dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); - + acq_parameters.dump_filename = dump_filename_; //--- Find number of samples per spreading code ------------------------- - code_length_ = round(fs_in_ / (GLONASS_L1_CA_CODE_RATE_HZ / GLONASS_L1_CA_CODE_LENGTH_CHIPS)); + code_length_ = static_cast(std::round(static_cast(fs_in_) / (GLONASS_L1_CA_CODE_RATE_HZ / GLONASS_L1_CA_CODE_LENGTH_CHIPS))); vector_length_ = code_length_ * sampled_ms_; @@ -90,9 +97,14 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition( { item_size_ = sizeof(gr_complex); } - acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_, - doppler_max_, if_, fs_in_, code_length_, code_length_, - bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, dump_filename_, item_size_); + acq_parameters.it_size = item_size_; + acq_parameters.sampled_ms = sampled_ms_; + acq_parameters.samples_per_ms = code_length_; + acq_parameters.samples_per_code = code_length_; + acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4); + acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0); + acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false); + acquisition_ = pcps_make_acquisition(acq_parameters); DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")"; stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_); diff --git a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc index a7584cb15..81773e326 100644 --- a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc @@ -45,6 +45,7 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + pcpsconf_t acq_parameters; configuration_ = configuration; std::string default_item_type = "gr_complex"; std::string default_dump_filename = "./data/acquisition.dat"; @@ -55,22 +56,27 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition( long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + acq_parameters.fs_in = fs_in_; if_ = configuration_->property(role + ".if", 0); + acq_parameters.freq = if_; dump_ = configuration_->property(role + ".dump", false); + acq_parameters.dump = dump_; blocking_ = configuration_->property(role + ".blocking", true); + acq_parameters.blocking = blocking_; doppler_max_ = configuration_->property(role + ".doppler_max", 5000); if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max; + acq_parameters.doppler_max = doppler_max_; sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1); - bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false); + acq_parameters.bit_transition_flag = bit_transition_flag_; use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions - + acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_; max_dwells_ = configuration_->property(role + ".max_dwells", 1); dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); - + acq_parameters.dump_filename = dump_filename_; //--- Find number of samples per spreading code ------------------------- - code_length_ = round(fs_in_ / (GLONASS_L2_CA_CODE_RATE_HZ / GLONASS_L2_CA_CODE_LENGTH_CHIPS)); + code_length_ = static_cast(std::round(static_cast(fs_in_) / (GLONASS_L2_CA_CODE_RATE_HZ / GLONASS_L2_CA_CODE_LENGTH_CHIPS))); vector_length_ = code_length_ * sampled_ms_; @@ -89,9 +95,14 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition( { item_size_ = sizeof(gr_complex); } - acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_, - doppler_max_, if_, fs_in_, code_length_, code_length_, - bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, dump_filename_, item_size_); + acq_parameters.it_size = item_size_; + acq_parameters.sampled_ms = sampled_ms_; + acq_parameters.samples_per_ms = code_length_; + acq_parameters.samples_per_code = code_length_; + acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4); + acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0); + acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false); + acquisition_ = pcps_make_acquisition(acq_parameters); DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")"; stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_); diff --git a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc index aa4ec18c6..5250619c4 100644 --- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc @@ -48,6 +48,7 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + pcpsconf_t acq_parameters; configuration_ = configuration; std::string default_item_type = "gr_complex"; std::string default_dump_filename = "./data/acquisition.dat"; @@ -57,22 +58,31 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition( item_type_ = configuration_->property(role + ".item_type", default_item_type); long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + acq_parameters.fs_in = fs_in_; if_ = configuration_->property(role + ".if", 0); + acq_parameters.freq = if_; dump_ = configuration_->property(role + ".dump", false); + acq_parameters.dump = dump_; blocking_ = configuration_->property(role + ".blocking", true); + acq_parameters.blocking = blocking_; doppler_max_ = configuration_->property(role + ".doppler_max", 5000); if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max; + acq_parameters.doppler_max = doppler_max_; sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1); - + acq_parameters.sampled_ms = sampled_ms_; bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false); + acq_parameters.bit_transition_flag = bit_transition_flag_; use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions - + acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_; max_dwells_ = configuration_->property(role + ".max_dwells", 1); - + acq_parameters.max_dwells = max_dwells_; dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); - + acq_parameters.dump_filename = dump_filename_; + acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4); + acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0); + acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false); //--- Find number of samples per spreading code ------------------------- - code_length_ = round(fs_in_ / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS)); + code_length_ = static_cast(std::round(static_cast(fs_in_) / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS))); vector_length_ = code_length_ * sampled_ms_; @@ -91,9 +101,10 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition( { item_size_ = sizeof(gr_complex); } - acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_, - doppler_max_, if_, fs_in_, code_length_, code_length_, - bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, dump_filename_, item_size_); + acq_parameters.samples_per_ms = code_length_; + acq_parameters.samples_per_code = code_length_; + acq_parameters.it_size = item_size_; + acquisition_ = pcps_make_acquisition(acq_parameters); DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")"; stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_); diff --git a/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc index 19dd1ef1a..dbcea69e5 100644 --- a/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc @@ -46,6 +46,7 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + pcpsconf_t acq_parameters; configuration_ = configuration; std::string default_item_type = "gr_complex"; std::string default_dump_filename = "./data/acquisition.dat"; @@ -57,21 +58,26 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition( long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + acq_parameters.fs_in = fs_in_; if_ = configuration_->property(role + ".if", 0); + acq_parameters.freq = if_; dump_ = configuration_->property(role + ".dump", false); + acq_parameters.dump = dump_; blocking_ = configuration_->property(role + ".blocking", true); + acq_parameters.blocking = blocking_; doppler_max_ = configuration->property(role + ".doppler_max", 5000); if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max; - + acq_parameters.doppler_max = doppler_max_; bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false); + acq_parameters.bit_transition_flag = bit_transition_flag_; use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions - + acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_; max_dwells_ = configuration_->property(role + ".max_dwells", 1); - + acq_parameters.max_dwells = max_dwells_; dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); - + acq_parameters.dump_filename = dump_filename_; //--- Find number of samples per spreading code ------------------------- - code_length_ = round(static_cast(fs_in_) / (GPS_L2_M_CODE_RATE_HZ / static_cast(GPS_L2_M_CODE_LENGTH_CHIPS))); + code_length_ = std::round(static_cast(fs_in_) / (GPS_L2_M_CODE_RATE_HZ / static_cast(GPS_L2_M_CODE_LENGTH_CHIPS))); vector_length_ = code_length_; @@ -90,10 +96,14 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition( { item_size_ = sizeof(gr_complex); } - acquisition_ = pcps_make_acquisition(1, max_dwells_, - doppler_max_, if_, fs_in_, code_length_, code_length_, - bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, - dump_filename_, item_size_); + acq_parameters.samples_per_ms = static_cast(std::round(static_cast(fs_in_) * 0.001)); + acq_parameters.samples_per_code = code_length_; + acq_parameters.it_size = item_size_; + acq_parameters.sampled_ms = 20; + acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4); + acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0); + acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", true); + acquisition_ = pcps_make_acquisition(acq_parameters); DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")"; stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_); diff --git a/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc index f61d078e5..cedc08d70 100644 --- a/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc @@ -46,6 +46,7 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + pcpsconf_t acq_parameters; configuration_ = configuration; std::string default_item_type = "gr_complex"; std::string default_dump_filename = "./data/acquisition.dat"; @@ -56,21 +57,26 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition( long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000); fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + acq_parameters.fs_in = fs_in_; if_ = configuration_->property(role + ".if", 0); + acq_parameters.freq = if_; dump_ = configuration_->property(role + ".dump", false); + acq_parameters.dump = dump_; blocking_ = configuration_->property(role + ".blocking", true); + acq_parameters.blocking = blocking_; doppler_max_ = configuration->property(role + ".doppler_max", 5000); if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max; - + acq_parameters.doppler_max = doppler_max_; bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false); + acq_parameters.bit_transition_flag = bit_transition_flag_; use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions - + acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_; max_dwells_ = configuration_->property(role + ".max_dwells", 1); - + acq_parameters.max_dwells = max_dwells_; dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); - + acq_parameters.dump_filename = dump_filename_; //--- Find number of samples per spreading code ------------------------- - code_length_ = round(static_cast(fs_in_) / (GPS_L5i_CODE_RATE_HZ / static_cast(GPS_L5i_CODE_LENGTH_CHIPS))); + code_length_ = static_cast(std::round(static_cast(fs_in_) / (GPS_L5i_CODE_RATE_HZ / static_cast(GPS_L5i_CODE_LENGTH_CHIPS)))); vector_length_ = code_length_; @@ -89,10 +95,14 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition( { item_size_ = sizeof(gr_complex); } - acquisition_ = pcps_make_acquisition(1, max_dwells_, - doppler_max_, if_, fs_in_, code_length_, code_length_, - bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, - dump_filename_, item_size_); + acq_parameters.samples_per_code = code_length_; + acq_parameters.samples_per_ms = code_length_; + acq_parameters.it_size = item_size_; + acq_parameters.sampled_ms = 1; + acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4); + acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0); + acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false); + acquisition_ = pcps_make_acquisition(acq_parameters); DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")"; stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_); diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc index 54bb52e8c..0eb0cd3dd 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc @@ -45,59 +45,34 @@ using google::LogMessage; -pcps_acquisition_sptr pcps_make_acquisition( - unsigned int sampled_ms, unsigned int max_dwells, - unsigned int doppler_max, long freq, long fs_in, - int samples_per_ms, int samples_per_code, - bool bit_transition_flag, bool use_CFAR_algorithm_flag, - bool dump, bool blocking, - std::string dump_filename, size_t it_size) +pcps_acquisition_sptr pcps_make_acquisition(pcpsconf_t conf_) { - return pcps_acquisition_sptr( - new pcps_acquisition(sampled_ms, max_dwells, doppler_max, freq, fs_in, samples_per_ms, - samples_per_code, bit_transition_flag, use_CFAR_algorithm_flag, dump, blocking, dump_filename, it_size)); + return pcps_acquisition_sptr(new pcps_acquisition(conf_)); } -pcps_acquisition::pcps_acquisition( - unsigned int sampled_ms, unsigned int max_dwells, - unsigned int doppler_max, long freq, long fs_in, - int samples_per_ms, int samples_per_code, - bool bit_transition_flag, bool use_CFAR_algorithm_flag, - bool dump, bool blocking, - std::string dump_filename, - size_t it_size) : gr::block("pcps_acquisition", - gr::io_signature::make(1, 1, it_size * sampled_ms * samples_per_ms * (bit_transition_flag ? 2 : 1)), - gr::io_signature::make(0, 0, it_size * sampled_ms * samples_per_ms * (bit_transition_flag ? 2 : 1))) +pcps_acquisition::pcps_acquisition(pcpsconf_t conf_) : gr::block("pcps_acquisition", + gr::io_signature::make(1, 1, conf_.it_size * conf_.sampled_ms * conf_.samples_per_ms * (conf_.bit_transition_flag ? 2 : 1)), + gr::io_signature::make(0, 0, conf_.it_size * conf_.sampled_ms * conf_.samples_per_ms * (conf_.bit_transition_flag ? 2 : 1))) { this->message_port_register_out(pmt::mp("events")); + acq_parameters = conf_; d_sample_counter = 0; // SAMPLE COUNTER d_active = false; d_state = 0; - d_freq = freq; - d_old_freq = freq; - d_fs_in = fs_in; - d_samples_per_ms = samples_per_ms; - d_samples_per_code = samples_per_code; - d_sampled_ms = sampled_ms; - d_max_dwells = max_dwells; + d_old_freq = conf_.freq; d_well_count = 0; - d_doppler_max = doppler_max; - d_fft_size = d_sampled_ms * d_samples_per_ms; + d_fft_size = acq_parameters.sampled_ms * acq_parameters.samples_per_ms; d_mag = 0; d_input_power = 0.0; d_num_doppler_bins = 0; - d_num_doppler_bins_step_two = 4; - d_bit_transition_flag = bit_transition_flag; - d_use_CFAR_algorithm_flag = use_CFAR_algorithm_flag; d_threshold = 0.0; d_doppler_step = 0; - d_doppler_step_two = 0.0; d_doppler_center_step_two = 0.0; d_test_statistics = 0.0; d_channel = 0; - if (it_size == sizeof(gr_complex)) + if (conf_.it_size == sizeof(gr_complex)) { d_cshort = false; } @@ -116,10 +91,10 @@ pcps_acquisition::pcps_acquisition( // // We can avoid this by doing linear correlation, effectively doubling the // size of the input buffer and padding the code with zeros. - if (d_bit_transition_flag) + if (acq_parameters.bit_transition_flag) { d_fft_size *= 2; - d_max_dwells = 1; //Activation of d_bit_transition_flag invalidates the value of d_max_dwells + acq_parameters.max_dwells = 1; //Activation of acq_parameters.bit_transition_flag invalidates the value of acq_parameters.max_dwells } d_fft_codes = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); @@ -131,13 +106,9 @@ pcps_acquisition::pcps_acquisition( // Inverse FFT d_ifft = new gr::fft::fft_complex(d_fft_size, false); - // For dumping samples into a file - d_dump = dump; - d_dump_filename = dump_filename; d_gnss_synchro = 0; d_grid_doppler_wipeoffs = nullptr; d_grid_doppler_wipeoffs_step_two = nullptr; - d_blocking = blocking; d_worker_active = false; d_data_buffer = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); if (d_cshort) @@ -163,9 +134,9 @@ pcps_acquisition::~pcps_acquisition() } delete[] d_grid_doppler_wipeoffs; } - if (d_num_doppler_bins_step_two > 0) + if (acq_parameters.make_2_steps) { - for (unsigned int i = 0; i < d_num_doppler_bins_step_two; i++) + for (unsigned int i = 0; i < acq_parameters.num_doppler_bins_step2; i++) { volk_gnsssdr_free(d_grid_doppler_wipeoffs_step_two[i]); } @@ -186,7 +157,7 @@ pcps_acquisition::~pcps_acquisition() void pcps_acquisition::set_local_code(std::complex* code) { // reset the intermediate frequency - d_freq = d_old_freq; + acq_parameters.freq = d_old_freq; // This will check if it's fdma, if yes will update the intermediate frequency and the doppler grid if (is_fdma()) { @@ -197,7 +168,7 @@ void pcps_acquisition::set_local_code(std::complex* code) // [ 0 0 0 ... 0 c_0 c_1 ... c_L] // where c_i is the local code and there are L zeros and L chips gr::thread::scoped_lock lock(d_setlock); // require mutex with work function called by the scheduler - if (d_bit_transition_flag) + if (acq_parameters.bit_transition_flag) { int offset = d_fft_size / 2; std::fill_n(d_fft_if->get_inbuf(), offset, gr_complex(0.0, 0.0)); @@ -218,14 +189,14 @@ bool pcps_acquisition::is_fdma() // Dealing with FDMA system if (strcmp(d_gnss_synchro->Signal, "1G") == 0) { - d_freq += DFRQ1_GLO * GLONASS_PRN.at(d_gnss_synchro->PRN); - LOG(INFO) << "Trying to acquire SV PRN " << d_gnss_synchro->PRN << " with freq " << d_freq << " in Glonass Channel " << GLONASS_PRN.at(d_gnss_synchro->PRN) << std::endl; + acq_parameters.freq += DFRQ1_GLO * GLONASS_PRN.at(d_gnss_synchro->PRN); + LOG(INFO) << "Trying to acquire SV PRN " << d_gnss_synchro->PRN << " with freq " << acq_parameters.freq << " in Glonass Channel " << GLONASS_PRN.at(d_gnss_synchro->PRN) << std::endl; return true; } else if (strcmp(d_gnss_synchro->Signal, "2G") == 0) { - d_freq += DFRQ2_GLO * GLONASS_PRN.at(d_gnss_synchro->PRN); - LOG(INFO) << "Trying to acquire SV PRN " << d_gnss_synchro->PRN << " with freq " << d_freq << " in Glonass Channel " << GLONASS_PRN.at(d_gnss_synchro->PRN) << std::endl; + acq_parameters.freq += DFRQ2_GLO * GLONASS_PRN.at(d_gnss_synchro->PRN); + LOG(INFO) << "Trying to acquire SV PRN " << d_gnss_synchro->PRN << " with freq " << acq_parameters.freq << " in Glonass Channel " << GLONASS_PRN.at(d_gnss_synchro->PRN) << std::endl; return true; } else @@ -237,7 +208,7 @@ bool pcps_acquisition::is_fdma() void pcps_acquisition::update_local_carrier(gr_complex* carrier_vector, int correlator_length_samples, float freq) { - float phase_step_rad = GPS_TWO_PI * freq / static_cast(d_fs_in); + float phase_step_rad = GPS_TWO_PI * freq / static_cast(acq_parameters.fs_in); float _phase[1]; _phase[0] = 0; volk_gnsssdr_s32f_sincos_32fc(carrier_vector, -phase_step_rad, _phase, correlator_length_samples); @@ -257,27 +228,29 @@ void pcps_acquisition::init() d_mag = 0.0; d_input_power = 0.0; - d_num_doppler_bins = static_cast(std::ceil(static_cast(static_cast(d_doppler_max) - static_cast(-d_doppler_max)) / static_cast(d_doppler_step))); + d_num_doppler_bins = static_cast(std::ceil(static_cast(static_cast(acq_parameters.doppler_max) - static_cast(-acq_parameters.doppler_max)) / static_cast(d_doppler_step))); // Create the carrier Doppler wipeoff signals d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins]; - d_grid_doppler_wipeoffs_step_two = new gr_complex*[d_num_doppler_bins_step_two]; + if (acq_parameters.make_2_steps) + { + d_grid_doppler_wipeoffs_step_two = new gr_complex*[acq_parameters.num_doppler_bins_step2]; + for (unsigned int doppler_index = 0; doppler_index < acq_parameters.num_doppler_bins_step2; doppler_index++) + { + d_grid_doppler_wipeoffs_step_two[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); + } + } for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) { d_grid_doppler_wipeoffs[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - int doppler = -static_cast(d_doppler_max) + d_doppler_step * doppler_index; - update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_freq + doppler); + int doppler = -static_cast(acq_parameters.doppler_max) + d_doppler_step * doppler_index; + update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, acq_parameters.freq + doppler); } - for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins_step_two; doppler_index++) - { - d_grid_doppler_wipeoffs_step_two[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - } - d_worker_active = false; - if (d_dump) + if (acq_parameters.dump) { - unsigned int effective_fft_size = (d_bit_transition_flag ? (d_fft_size / 2) : d_fft_size); + unsigned int effective_fft_size = (acq_parameters.bit_transition_flag ? (d_fft_size / 2) : d_fft_size); grid_ = arma::fmat(effective_fft_size, d_num_doppler_bins, arma::fill::zeros); } } @@ -287,18 +260,16 @@ void pcps_acquisition::update_grid_doppler_wipeoffs() { for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) { - //CHECK IF CALLING MALLOC IS NEEDED!!! - //d_grid_doppler_wipeoffs[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - int doppler = -static_cast(d_doppler_max) + d_doppler_step * doppler_index; - update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_freq + doppler); + int doppler = -static_cast(acq_parameters.doppler_max) + d_doppler_step * doppler_index; + update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, acq_parameters.freq + doppler); } } void pcps_acquisition::update_grid_doppler_wipeoffs_step2() { - for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins_step_two; doppler_index++) + for (unsigned int doppler_index = 0; doppler_index < acq_parameters.num_doppler_bins_step2; doppler_index++) { - float doppler = (static_cast(doppler_index) - static_cast(d_num_doppler_bins_step_two) / 2.0) * d_doppler_step_two; + float doppler = (static_cast(doppler_index) - static_cast(acq_parameters.num_doppler_bins_step2) / 2.0) * acq_parameters.doppler_step2; update_local_carrier(d_grid_doppler_wipeoffs_step_two[doppler_index], d_fft_size, d_doppler_center_step_two + doppler); } } @@ -423,7 +394,7 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)), { memcpy(d_data_buffer, input_items[0], d_fft_size * sizeof(gr_complex)); } - if (d_blocking) + if (acq_parameters.blocking) { lk.unlock(); acquisition_core(d_sample_counter); @@ -450,7 +421,7 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) uint32_t indext = 0; float magt = 0.0; const gr_complex* in = d_data_buffer; //Get the input samples pointer - int effective_fft_size = (d_bit_transition_flag ? d_fft_size / 2 : d_fft_size); + int effective_fft_size = (acq_parameters.bit_transition_flag ? d_fft_size / 2 : d_fft_size); if (d_cshort) { volk_gnsssdr_16ic_convert_32fc(d_data_buffer, d_data_buffer_sc, d_fft_size); @@ -464,12 +435,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) DLOG(INFO) << "Channel: " << d_channel << " , doing acquisition of satellite: " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN << " ,sample stamp: " << samp_count << ", threshold: " - << d_threshold << ", doppler_max: " << d_doppler_max + << d_threshold << ", doppler_max: " << acq_parameters.doppler_max << ", doppler_step: " << d_doppler_step - << ", use_CFAR_algorithm_flag: " << (d_use_CFAR_algorithm_flag ? "true" : "false"); + << ", use_CFAR_algorithm_flag: " << (acq_parameters.use_CFAR_algorithm_flag ? "true" : "false"); lk.unlock(); - if (d_use_CFAR_algorithm_flag) + if (acq_parameters.use_CFAR_algorithm_flag) { // 1- (optional) Compute the input signal power estimation volk_32fc_magnitude_squared_32f(d_magnitude, in, d_fft_size); @@ -482,7 +453,7 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) { // doppler search steps - int doppler = -static_cast(d_doppler_max) + d_doppler_step * doppler_index; + int doppler = -static_cast(acq_parameters.doppler_max) + d_doppler_step * doppler_index; volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index], d_fft_size); @@ -498,12 +469,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) d_ifft->execute(); // Search maximum - size_t offset = (d_bit_transition_flag ? effective_fft_size : 0); + size_t offset = (acq_parameters.bit_transition_flag ? effective_fft_size : 0); volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size); volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size); magt = d_magnitude[indext]; - if (d_use_CFAR_algorithm_flag) + if (acq_parameters.use_CFAR_algorithm_flag) { // Normalize the maximum value to correct the scale factor introduced by FFTW magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor); @@ -513,14 +484,14 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) { d_mag = magt; - if (!d_use_CFAR_algorithm_flag) + if (!acq_parameters.use_CFAR_algorithm_flag) { // Search grid noise floor approximation for this doppler line volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size); d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1); } - // In case that d_bit_transition_flag = true, we compare the potentially + // In case that acq_parameters.bit_transition_flag = true, we compare the potentially // new maximum test statistics (d_mag/d_input_power) with the value in // d_test_statistics. When the second dwell is being processed, the value // of d_mag/d_input_power could be lower than d_test_statistics (i.e, @@ -528,9 +499,9 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) // current d_mag/d_input_power). Note that d_test_statistics is not // restarted between consecutive dwells in multidwell operation. - if (d_test_statistics < (d_mag / d_input_power) or !d_bit_transition_flag) + if (d_test_statistics < (d_mag / d_input_power) or !acq_parameters.bit_transition_flag) { - d_gnss_synchro->Acq_delay_samples = static_cast(indext % d_samples_per_code); + d_gnss_synchro->Acq_delay_samples = static_cast(indext % acq_parameters.samples_per_code); d_gnss_synchro->Acq_doppler_hz = static_cast(doppler); d_gnss_synchro->Acq_samplestamp_samples = samp_count; @@ -540,12 +511,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) } } // Record results to file if required - if (d_dump) + if (acq_parameters.dump) { memcpy(grid_.colptr(doppler_index), d_magnitude, sizeof(float) * effective_fft_size); if (doppler_index == (d_num_doppler_bins - 1)) { - std::string filename = d_dump_filename; + std::string filename = acq_parameters.dump_filename; filename.append("_"); filename.append(1, d_gnss_synchro->System); filename.append("_"); @@ -558,7 +529,7 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) if (matfp == NULL) { std::cout << "Unable to create or open Acquisition dump file" << std::endl; - d_dump = false; + acq_parameters.dump = false; } else { @@ -569,7 +540,7 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) dims[0] = static_cast(1); dims[1] = static_cast(1); - matvar = Mat_VarCreate("doppler_max", MAT_C_SINGLE, MAT_T_UINT32, 1, dims, &d_doppler_max, 0); + matvar = Mat_VarCreate("doppler_max", MAT_C_SINGLE, MAT_T_UINT32, 1, dims, &acq_parameters.doppler_max, 0); Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE Mat_VarFree(matvar); @@ -585,10 +556,10 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) } else { - for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins_step_two; doppler_index++) + for (unsigned int doppler_index = 0; doppler_index < acq_parameters.num_doppler_bins_step2; doppler_index++) { // doppler search steps - float doppler = d_doppler_center_step_two + (static_cast(doppler_index) - static_cast(d_num_doppler_bins_step_two) / 2.0) * d_doppler_step_two; + float doppler = d_doppler_center_step_two + (static_cast(doppler_index) - static_cast(acq_parameters.num_doppler_bins_step2) / 2.0) * acq_parameters.doppler_step2; volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs_step_two[doppler_index], d_fft_size); @@ -604,12 +575,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) d_ifft->execute(); // Search maximum - size_t offset = (d_bit_transition_flag ? effective_fft_size : 0); + size_t offset = (acq_parameters.bit_transition_flag ? effective_fft_size : 0); volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size); volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size); magt = d_magnitude[indext]; - if (d_use_CFAR_algorithm_flag) + if (acq_parameters.use_CFAR_algorithm_flag) { // Normalize the maximum value to correct the scale factor introduced by FFTW magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor); @@ -619,14 +590,14 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) { d_mag = magt; - if (!d_use_CFAR_algorithm_flag) + if (!acq_parameters.use_CFAR_algorithm_flag) { // Search grid noise floor approximation for this doppler line volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size); d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1); } - // In case that d_bit_transition_flag = true, we compare the potentially + // In case that acq_parameters.bit_transition_flag = true, we compare the potentially // new maximum test statistics (d_mag/d_input_power) with the value in // d_test_statistics. When the second dwell is being processed, the value // of d_mag/d_input_power could be lower than d_test_statistics (i.e, @@ -634,9 +605,9 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) // current d_mag/d_input_power). Note that d_test_statistics is not // restarted between consecutive dwells in multidwell operation. - if (d_test_statistics < (d_mag / d_input_power) or !d_bit_transition_flag) + if (d_test_statistics < (d_mag / d_input_power) or !acq_parameters.bit_transition_flag) { - d_gnss_synchro->Acq_delay_samples = static_cast(indext % d_samples_per_code); + d_gnss_synchro->Acq_delay_samples = static_cast(indext % acq_parameters.samples_per_code); d_gnss_synchro->Acq_doppler_hz = static_cast(doppler); d_gnss_synchro->Acq_samplestamp_samples = samp_count; @@ -648,37 +619,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) } } lk.lock(); - if (!d_bit_transition_flag) + if (!acq_parameters.bit_transition_flag) { if (d_test_statistics > d_threshold) { d_active = false; - if (d_step_two) - { - send_positive_acquisition(); - d_step_two = false; - d_state = 0; // Positive acquisition - } - else - { - d_step_two = true; // Clear input buffer and make small grid acquisition - d_state = 0; - } - } - else if (d_well_count == d_max_dwells) - { - d_state = 0; - d_active = false; - d_step_two = false; - send_negative_acquisition(); - } - } - else - { - if (d_well_count == d_max_dwells) // d_max_dwells = 2 - { - d_active = false; - if (d_test_statistics > d_threshold) + if (acq_parameters.make_2_steps) { if (d_step_two) { @@ -694,11 +640,49 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count) } else { - d_state = 0; // Negative acquisition - d_step_two = false; - send_negative_acquisition(); + send_positive_acquisition(); + d_state = 0; // Positive acquisition } } + else if (d_well_count == acq_parameters.max_dwells) + { + d_state = 0; + d_active = false; + d_step_two = false; + send_negative_acquisition(); + } + } + else + { + d_active = false; + if (d_test_statistics > d_threshold) + { + if (acq_parameters.make_2_steps) + { + if (d_step_two) + { + send_positive_acquisition(); + d_step_two = false; + d_state = 0; // Positive acquisition + } + else + { + d_step_two = true; // Clear input buffer and make small grid acquisition + d_state = 0; + } + } + else + { + send_positive_acquisition(); + d_state = 0; // Positive acquisition + } + } + else + { + d_state = 0; // Negative acquisition + d_step_two = false; + send_negative_acquisition(); + } } d_worker_active = false; } diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h index 72bd1713e..97e314fdb 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h @@ -59,18 +59,33 @@ #include #include +typedef struct +{ + /* pcps acquisition configuration */ + unsigned int sampled_ms; + unsigned int max_dwells; + unsigned int doppler_max; + unsigned int num_doppler_bins_step2; + float doppler_step2; + long freq; + long fs_in; + int samples_per_ms; + int samples_per_code; + bool bit_transition_flag; + bool use_CFAR_algorithm_flag; + bool dump; + bool blocking; + bool make_2_steps; + std::string dump_filename; + size_t it_size; +} pcpsconf_t; class pcps_acquisition; typedef boost::shared_ptr pcps_acquisition_sptr; pcps_acquisition_sptr -pcps_make_acquisition(unsigned int sampled_ms, unsigned int max_dwells, - unsigned int doppler_max, long freq, long fs_in, - int samples_per_ms, int samples_per_code, - bool bit_transition_flag, bool use_CFAR_algorithm_flag, - bool dump, bool blocking, - std::string dump_filename, size_t it_size); +pcps_make_acquisition(pcpsconf_t conf_); /*! * \brief This class implements a Parallel Code Phase Search Acquisition. @@ -82,19 +97,9 @@ class pcps_acquisition : public gr::block { private: friend pcps_acquisition_sptr - pcps_make_acquisition(unsigned int sampled_ms, unsigned int max_dwells, - unsigned int doppler_max, long freq, long fs_in, - int samples_per_ms, int samples_per_code, - bool bit_transition_flag, bool use_CFAR_algorithm_flag, - bool dump, bool blocking, - std::string dump_filename, size_t it_size); + pcps_make_acquisition(pcpsconf_t conf_); - pcps_acquisition(unsigned int sampled_ms, unsigned int max_dwells, - unsigned int doppler_max, long freq, long fs_in, - int samples_per_ms, int samples_per_code, - bool bit_transition_flag, bool use_CFAR_algorithm_flag, - bool dump, bool blocking, - std::string dump_filename, size_t it_size); + pcps_acquisition(pcpsconf_t conf_); void update_local_carrier(gr_complex* carrier_vector, int correlator_length_samples, float freq); void update_grid_doppler_wipeoffs(); @@ -107,12 +112,9 @@ private: void send_positive_acquisition(); - bool d_bit_transition_flag; - bool d_use_CFAR_algorithm_flag; + pcpsconf_t acq_parameters; bool d_active; - bool d_dump; bool d_worker_active; - bool d_blocking; bool d_cshort; bool d_step_two; float d_threshold; @@ -120,23 +122,14 @@ private: float d_input_power; float d_test_statistics; float* d_magnitude; - long d_fs_in; - long d_freq; long d_old_freq; - int d_samples_per_ms; - int d_samples_per_code; int d_state; unsigned int d_channel; - unsigned int d_doppler_max; unsigned int d_doppler_step; - float d_doppler_step_two; float d_doppler_center_step_two; - unsigned int d_sampled_ms; - unsigned int d_max_dwells; unsigned int d_well_count; unsigned int d_fft_size; unsigned int d_num_doppler_bins; - unsigned int d_num_doppler_bins_step_two; unsigned long int d_sample_counter; gr_complex** d_grid_doppler_wipeoffs; gr_complex** d_grid_doppler_wipeoffs_step_two; @@ -146,7 +139,6 @@ private: gr::fft::fft_complex* d_fft_if; gr::fft::fft_complex* d_ifft; Gnss_Synchro* d_gnss_synchro; - std::string d_dump_filename; arma::fmat grid_; public: @@ -228,7 +220,7 @@ public: inline void set_doppler_max(unsigned int doppler_max) { gr::thread::scoped_lock lock(d_setlock); // require mutex with work function called by the scheduler - d_doppler_max = doppler_max; + acq_parameters.doppler_max = doppler_max; } /*! @@ -239,7 +231,6 @@ public: { gr::thread::scoped_lock lock(d_setlock); // require mutex with work function called by the scheduler d_doppler_step = doppler_step; - d_doppler_step_two = static_cast(d_doppler_step) / 2.0; } /*! diff --git a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc index 9a6a412d6..a89dfefc9 100755 --- a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc +++ b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc @@ -430,7 +430,6 @@ void dll_pll_veml_tracking::start_tracking() long int acq_trk_diff_samples = static_cast(d_sample_counter) - static_cast(d_acq_sample_stamp); double acq_trk_diff_seconds = static_cast(acq_trk_diff_samples) / d_fs_in; - std::cout << "ACQ to TRK diff seconds = " << acq_trk_diff_seconds << std::endl; DLOG(INFO) << "Number of samples between Acquisition and Tracking = " << acq_trk_diff_samples; DLOG(INFO) << "Number of seconds between Acquisition and Tracking = " << acq_trk_diff_seconds; // Doppler effect Fd = (C / (C + Vr)) * F From f283f7fab5df4bd14464f7c9830eb6f7884afcdb Mon Sep 17 00:00:00 2001 From: Antonio Ramos Date: Thu, 5 Apr 2018 15:00:34 +0200 Subject: [PATCH 03/21] Fix test --- .../acquisition/gps_l2_m_pcps_acquisition_test.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l2_m_pcps_acquisition_test.cc b/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l2_m_pcps_acquisition_test.cc index c5b14fd0c..1aac47b38 100644 --- a/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l2_m_pcps_acquisition_test.cc +++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l2_m_pcps_acquisition_test.cc @@ -168,6 +168,7 @@ void GpsL2MPcpsAcquisitionTest::init() config->set_property("Acquisition_2S.doppler_max", std::to_string(doppler_max)); config->set_property("Acquisition_2S.doppler_step", std::to_string(doppler_step)); config->set_property("Acquisition_2S.repeat_satellite", "false"); + config->set_property("Acquisition_2S.make_two_steps", "false"); } From dd04df5bc3fb440999f42c1eed597d1375f19841 Mon Sep 17 00:00:00 2001 From: Antonio Ramos Date: Thu, 5 Apr 2018 18:08:49 +0200 Subject: [PATCH 04/21] Add DLL PLL tracking configuration structure --- .../galileo_e1_dll_pll_veml_tracking.cc | 37 +-- .../adapters/gps_l1_ca_dll_pll_tracking.cc | 31 ++- .../adapters/gps_l2_m_dll_pll_tracking.cc | 28 ++- .../adapters/gps_l5i_dll_pll_tracking.cc | 30 ++- .../gnuradio_blocks/dll_pll_veml_tracking.cc | 225 +++++++----------- .../gnuradio_blocks/dll_pll_veml_tracking.h | 70 ++---- 6 files changed, 186 insertions(+), 235 deletions(-) diff --git a/src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc b/src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc index 012cc62ad..7395e5c90 100644 --- a/src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc +++ b/src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc @@ -48,24 +48,35 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + dllpllconf_t trk_param; DLOG(INFO) << "role " << role; //################# CONFIGURATION PARAMETERS ######################## std::string default_item_type = "gr_complex"; std::string item_type = configuration->property(role + ".item_type", default_item_type); int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + trk_param.fs_in = fs_in; bool dump = configuration->property(role + ".dump", false); + trk_param.dump = dump; float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 5.0); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast(FLAGS_pll_bw_hz); + trk_param.pll_bw_hz = pll_bw_hz; float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 0.5); if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast(FLAGS_dll_bw_hz); + trk_param.dll_bw_hz = dll_bw_hz; float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 2.0); + trk_param.pll_bw_narrow_hz = pll_bw_narrow_hz; float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 0.25); + trk_param.dll_bw_narrow_hz = dll_bw_narrow_hz; int extend_correlation_symbols = configuration->property(role + ".extend_correlation_symbols", 1); float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.15); + trk_param.early_late_space_chips = early_late_space_chips; float very_early_late_space_chips = configuration->property(role + ".very_early_late_space_chips", 0.6); + trk_param.very_early_late_space_chips = very_early_late_space_chips; float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.15); + trk_param.early_late_space_narrow_chips = early_late_space_narrow_chips; float very_early_late_space_narrow_chips = configuration->property(role + ".very_early_late_space_narrow_chips", 0.6); + trk_param.very_early_late_space_narrow_chips = very_early_late_space_narrow_chips; bool track_pilot = configuration->property(role + ".track_pilot", false); if (extend_correlation_symbols < 1) { @@ -81,31 +92,21 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking( { std::cout << TEXT_RED << "WARNING: Galileo E1. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << std::endl; } + trk_param.track_pilot = track_pilot; + trk_param.extend_correlation_symbols = extend_correlation_symbols; std::string default_dump_filename = "./track_ch"; std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); + trk_param.dump_filename = dump_filename; int vector_length = std::round(fs_in / (Galileo_E1_CODE_CHIP_RATE_HZ / Galileo_E1_B_CODE_LENGTH_CHIPS)); - + trk_param.vector_length = vector_length; + trk_param.system = 'E'; + char sig_[3] = "1B"; + std::memcpy(trk_param.signal, sig_, 3); //################# MAKE TRACKING GNURadio object ################### if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); - - char sig_[3] = "1B"; - tracking_ = dll_pll_veml_make_tracking( - fs_in, - vector_length, - dump, - dump_filename, - pll_bw_hz, - dll_bw_hz, - pll_bw_narrow_hz, - dll_bw_narrow_hz, - early_late_space_chips, - very_early_late_space_chips, - early_late_space_narrow_chips, - very_early_late_space_narrow_chips, - extend_correlation_symbols, - track_pilot, 'E', sig_); + tracking_ = dll_pll_veml_make_tracking(trk_param); } else { diff --git a/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc index 66e82aca9..c43c1de8a 100644 --- a/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc @@ -49,24 +49,35 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + dllpllconf_t trk_param; DLOG(INFO) << "role " << role; //################# CONFIGURATION PARAMETERS ######################## std::string default_item_type = "gr_complex"; std::string item_type = configuration->property(role + ".item_type", default_item_type); int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + trk_param.fs_in = fs_in; bool dump = configuration->property(role + ".dump", false); + trk_param.dump = dump; float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast(FLAGS_pll_bw_hz); + trk_param.pll_bw_hz = pll_bw_hz; float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 20.0); + trk_param.pll_bw_narrow_hz = pll_bw_narrow_hz; float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 2.0); + trk_param.dll_bw_narrow_hz = dll_bw_narrow_hz; float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0); if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast(FLAGS_dll_bw_hz); + trk_param.dll_bw_hz = dll_bw_hz; float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5); + trk_param.early_late_space_chips = early_late_space_chips; float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.5); + trk_param.early_late_space_narrow_chips = early_late_space_narrow_chips; std::string default_dump_filename = "./track_ch"; std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); + trk_param.dump_filename = dump_filename; int vector_length = std::round(fs_in / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS)); + trk_param.vector_length = vector_length; int symbols_extended_correlator = configuration->property(role + ".extend_correlation_symbols", 1); if (symbols_extended_correlator < 1) { @@ -78,6 +89,7 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking( symbols_extended_correlator = 20; std::cout << TEXT_RED << "WARNING: GPS L1 C/A. extend_correlation_symbols must be lower than 21. Coherent integration has been set to 20 symbols (20 ms)" << TEXT_RESET << std::endl; } + trk_param.extend_correlation_symbols = symbols_extended_correlator; bool track_pilot = configuration->property(role + ".track_pilot", false); if (track_pilot) { @@ -87,22 +99,17 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking( { std::cout << TEXT_RED << "WARNING: GPS L1 C/A. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << std::endl; } + trk_param.very_early_late_space_chips = 0.0; + trk_param.very_early_late_space_narrow_chips = 0.0; + trk_param.track_pilot = false; + trk_param.system = 'G'; + char sig_[3] = "1C"; + std::memcpy(trk_param.signal, sig_, 3); //################# MAKE TRACKING GNURadio object ################### if (item_type.compare("gr_complex") == 0) { - char sig_[3] = "1C"; item_size_ = sizeof(gr_complex); - tracking_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, - dump_filename, pll_bw_hz, dll_bw_hz, - pll_bw_narrow_hz, dll_bw_narrow_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_narrow_chips, - early_late_space_narrow_chips, - symbols_extended_correlator, - false, - 'G', sig_); + tracking_ = dll_pll_veml_make_tracking(trk_param); } else { diff --git a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc index 563316bf5..6e940f707 100644 --- a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc @@ -49,48 +49,58 @@ GpsL2MDllPllTracking::GpsL2MDllPllTracking( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + dllpllconf_t trk_param; DLOG(INFO) << "role " << role; //################# CONFIGURATION PARAMETERS ######################## std::string default_item_type = "gr_complex"; std::string item_type = configuration->property(role + ".item_type", default_item_type); int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + trk_param.fs_in = fs_in; bool dump = configuration->property(role + ".dump", false); + trk_param.dump = dump; float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 2.0); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast(FLAGS_pll_bw_hz); + trk_param.pll_bw_hz = pll_bw_hz; float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 0.75); if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast(FLAGS_dll_bw_hz); + trk_param.dll_bw_hz = dll_bw_hz; unified_ = configuration->property(role + ".unified", false); float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5); + trk_param.early_late_space_chips = early_late_space_chips; + trk_param.early_late_space_narrow_chips = 0.0; std::string default_dump_filename = "./track_ch"; std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); + trk_param.dump_filename = dump_filename; int vector_length = std::round(static_cast(fs_in) / (static_cast(GPS_L2_M_CODE_RATE_HZ) / static_cast(GPS_L2_M_CODE_LENGTH_CHIPS))); + trk_param.vector_length = vector_length; int symbols_extended_correlator = configuration->property(role + ".extend_correlation_symbols", 1); if (symbols_extended_correlator != 1) { std::cout << TEXT_RED << "WARNING: Extended coherent integration is not allowed in GPS L2. Coherent integration has been set to 20 ms (1 symbol)" << TEXT_RESET << std::endl; } + trk_param.extend_correlation_symbols = 1; bool track_pilot = configuration->property(role + ".track_pilot", false); if (track_pilot) { std::cout << TEXT_RED << "WARNING: GPS L2 does not have pilot signal. Data tracking has been enabled" << TEXT_RESET << std::endl; } + trk_param.track_pilot = false; + trk_param.very_early_late_space_chips = 0.0; + trk_param.very_early_late_space_narrow_chips = 0.0; + trk_param.pll_bw_narrow_hz = 0.0; + trk_param.dll_bw_narrow_hz = 0.0; + trk_param.system = 'G'; + char sig_[3] = "2S"; + std::memcpy(trk_param.signal, sig_, 3); //################# MAKE TRACKING GNURadio object ################### if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); if (unified_) { - char sig_[3] = "2S"; item_size_ = sizeof(gr_complex); - tracking_unified_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, pll_bw_hz, dll_bw_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_chips, - early_late_space_chips, - 1, false, 'G', sig_); + tracking_unified_ = dll_pll_veml_make_tracking(trk_param); } else { diff --git a/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc index d28255416..2fb4ffd0b 100644 --- a/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc @@ -49,26 +49,37 @@ GpsL5iDllPllTracking::GpsL5iDllPllTracking( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + dllpllconf_t trk_param; DLOG(INFO) << "role " << role; //################# CONFIGURATION PARAMETERS ######################## std::string default_item_type = "gr_complex"; std::string item_type = configuration->property(role + ".item_type", default_item_type); int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + trk_param.fs_in = fs_in; bool dump = configuration->property(role + ".dump", false); + trk_param.dump = dump; unified_ = configuration->property(role + ".unified", false); float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast(FLAGS_pll_bw_hz); + trk_param.pll_bw_hz = pll_bw_hz; float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0); if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast(FLAGS_dll_bw_hz); + trk_param.dll_bw_hz = dll_bw_hz; float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 2.0); + trk_param.pll_bw_narrow_hz = pll_bw_narrow_hz; float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 0.25); + trk_param.dll_bw_narrow_hz = dll_bw_narrow_hz; float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5); + trk_param.early_late_space_chips = early_late_space_chips; std::string default_dump_filename = "./track_ch"; std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); + trk_param.dump_filename = dump_filename; int vector_length = std::round(static_cast(fs_in) / (static_cast(GPS_L5i_CODE_RATE_HZ) / static_cast(GPS_L5i_CODE_LENGTH_CHIPS))); + trk_param.vector_length = vector_length; int extend_correlation_symbols = configuration->property(role + ".extend_correlation_symbols", 1); float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.15); + trk_param.early_late_space_narrow_chips = early_late_space_narrow_chips; bool track_pilot = configuration->property(role + ".track_pilot", false); if (extend_correlation_symbols < 1) { @@ -84,24 +95,21 @@ GpsL5iDllPllTracking::GpsL5iDllPllTracking( { std::cout << TEXT_RED << "WARNING: GPS L5. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << std::endl; } + trk_param.extend_correlation_symbols = extend_correlation_symbols; + trk_param.track_pilot = track_pilot; + trk_param.very_early_late_space_chips = 0.0; + trk_param.very_early_late_space_narrow_chips = 0.0; + trk_param.system = 'G'; + char sig_[3] = "L5"; + std::memcpy(trk_param.signal, sig_, 3); //################# MAKE TRACKING GNURadio object ################### if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); if (unified_) { - char sig_[3] = "L5"; item_size_ = sizeof(gr_complex); - tracking_unified_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, - pll_bw_narrow_hz, dll_bw_narrow_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_narrow_chips, - early_late_space_narrow_chips, - extend_correlation_symbols, - track_pilot, 'G', sig_); + tracking_unified_ = dll_pll_veml_make_tracking(trk_param); } else { diff --git a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc index a89dfefc9..83fabee12 100755 --- a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc +++ b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc @@ -61,38 +61,9 @@ using google::LogMessage; -dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking( - double fs_in, - unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float pll_bw_narrow_hz, - float dll_bw_narrow_hz, - float early_late_space_chips, - float very_early_late_space_chips, - float early_late_space_narrow_chips, - float very_early_late_space_narrow_chips, - int extend_correlation_symbols, - bool track_pilot, - char system, char signal[3]) +dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(dllpllconf_t conf_) { - return dll_pll_veml_tracking_sptr(new dll_pll_veml_tracking( - fs_in, - vector_length, - dump, - dump_filename, - pll_bw_hz, - dll_bw_hz, - pll_bw_narrow_hz, - dll_bw_narrow_hz, - early_late_space_chips, - very_early_late_space_chips, - early_late_space_narrow_chips, - very_early_late_space_narrow_chips, - extend_correlation_symbols, - track_pilot, system, signal)); + return dll_pll_veml_tracking_sptr(new dll_pll_veml_tracking(conf_)); } @@ -101,40 +72,29 @@ void dll_pll_veml_tracking::forecast(int noutput_items, { if (noutput_items != 0) { - ninput_items_required[0] = static_cast(d_vector_length) * 2; + ninput_items_required[0] = static_cast(trk_parameters.vector_length) * 2; } } -dll_pll_veml_tracking::dll_pll_veml_tracking( - double fs_in, unsigned int vector_length, bool dump, - std::string dump_filename, float pll_bw_hz, float dll_bw_hz, - float pll_bw_narrow_hz, float dll_bw_narrow_hz, - float early_late_space_chips, float very_early_late_space_chips, - float early_late_space_narrow_chips, float very_early_late_space_narrow_chips, - int extend_correlation_symbols, bool track_pilot, char system, - char signal[3]) : gr::block("dll_pll_veml_tracking", gr::io_signature::make(1, 1, sizeof(gr_complex)), - gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) +dll_pll_veml_tracking::dll_pll_veml_tracking(dllpllconf_t conf_) : gr::block("dll_pll_veml_tracking", gr::io_signature::make(1, 1, sizeof(gr_complex)), + gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) { // Telemetry bit synchronization message port input this->message_port_register_in(pmt::mp("preamble_timestamp_s")); this->message_port_register_out(pmt::mp("events")); - this->set_relative_rate(1.0 / static_cast(vector_length)); + this->set_relative_rate(1.0 / static_cast(trk_parameters.vector_length)); // initialize internal vars - d_dump = dump; + trk_parameters = conf_; d_veml = false; d_cloop = true; d_synchonizing = false; - d_track_pilot = track_pilot; - d_fs_in = fs_in; - d_vector_length = vector_length; - d_dump_filename = dump_filename; d_code_chip_rate = 0.0; d_secondary_code_length = 0; d_secondary_code_string = nullptr; - signal_type = std::string(signal); - if (system == 'G') + signal_type = std::string(trk_parameters.signal); + if (trk_parameters.system == 'G') { systemName = "GPS"; if (signal_type.compare("1C") == 0) @@ -148,7 +108,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_code_length_chips = static_cast(GPS_L1_CA_CODE_LENGTH_CHIPS); // GPS L1 C/A does not have pilot component nor secondary code d_secondary = false; - d_track_pilot = false; + trk_parameters.track_pilot = false; interchange_iq = false; } else if (signal_type.compare("2S") == 0) @@ -162,7 +122,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_code_samples_per_chip = 1; // GPS L2 does not have pilot component nor secondary code d_secondary = false; - d_track_pilot = false; + trk_parameters.track_pilot = false; interchange_iq = false; } else if (signal_type.compare("L5") == 0) @@ -176,7 +136,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_code_length_chips = static_cast(GPS_L5i_CODE_LENGTH_CHIPS); // GPS L5 does not have pilot secondary code d_secondary = true; - if (d_track_pilot) + if (trk_parameters.track_pilot) { d_secondary_code_length = static_cast(GPS_L5q_NH_CODE_LENGTH); d_secondary_code_string = const_cast(&GPS_L5q_NH_CODE_STR); @@ -203,7 +163,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_symbols_per_bit = 0; } } - else if (system == 'E') + else if (trk_parameters.system == 'E') { systemName = "Galileo"; if (signal_type.compare("1B") == 0) @@ -216,7 +176,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_correlation_length_ms = 4; d_code_samples_per_chip = 2; // CBOC disabled: 2 samples per chip. CBOC enabled: 12 samples per chip d_veml = true; - if (d_track_pilot) + if (trk_parameters.track_pilot) { d_secondary = true; d_secondary_code_length = static_cast(Galileo_E1_C_SECONDARY_CODE_LENGTH); @@ -238,7 +198,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_code_samples_per_chip = 1; d_code_length_chips = static_cast(Galileo_E5a_CODE_LENGTH_CHIPS); d_secondary = true; - if (d_track_pilot) + if (trk_parameters.track_pilot) { interchange_iq = true; d_secondary_code_length = static_cast(Galileo_E5a_Q_SECONDARY_CODE_LENGTH); @@ -284,23 +244,11 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( // Initialize tracking ========================================== - // Set bandwidth of code and carrier loop filters - d_dll_bw_hz = dll_bw_hz; - d_pll_bw_hz = pll_bw_hz; - d_dll_bw_narrow_hz = dll_bw_narrow_hz; - d_pll_bw_narrow_hz = pll_bw_narrow_hz; - - d_code_loop_filter.set_DLL_BW(d_dll_bw_hz); - d_carrier_loop_filter.set_PLL_BW(d_pll_bw_hz); + d_code_loop_filter.set_DLL_BW(trk_parameters.dll_bw_hz); + d_carrier_loop_filter.set_PLL_BW(trk_parameters.pll_bw_hz); d_code_loop_filter = Tracking_2nd_DLL_filter(static_cast(d_code_period)); d_carrier_loop_filter = Tracking_2nd_PLL_filter(static_cast(d_code_period)); - // Correlator spacing - d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips) - d_very_early_late_spc_chips = very_early_late_space_chips; // Define very-early-late offset (in chips) - d_early_late_spc_narrow_chips = early_late_space_narrow_chips; // Define narrow early-late offset (in chips) - d_very_early_late_spc_narrow_chips = very_early_late_space_narrow_chips; // Define narrow very-early-late offset (in chips) - // Initialization of local code replica // Get space for a vector with the sinboc(1,1) replica sampled 2x/chip d_tracking_code = static_cast(volk_gnsssdr_malloc(2 * d_code_length_chips * sizeof(float), volk_gnsssdr_get_alignment())); @@ -328,11 +276,11 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_Prompt = &d_correlator_outs[2]; d_Late = &d_correlator_outs[3]; d_Very_Late = &d_correlator_outs[4]; - d_local_code_shift_chips[0] = -d_very_early_late_spc_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[1] = -d_early_late_spc_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[0] = -trk_parameters.very_early_late_space_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[1] = -trk_parameters.early_late_space_chips * static_cast(d_code_samples_per_chip); d_local_code_shift_chips[2] = 0.0; - d_local_code_shift_chips[3] = d_early_late_spc_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[4] = d_very_early_late_spc_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[3] = trk_parameters.early_late_space_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[4] = trk_parameters.very_early_late_space_chips * static_cast(d_code_samples_per_chip); d_prompt_data_shift = &d_local_code_shift_chips[2]; } else @@ -342,30 +290,29 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_Prompt = &d_correlator_outs[1]; d_Late = &d_correlator_outs[2]; d_Very_Late = nullptr; - d_local_code_shift_chips[0] = -d_early_late_spc_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[0] = -trk_parameters.early_late_space_chips * static_cast(d_code_samples_per_chip); d_local_code_shift_chips[1] = 0.0; - d_local_code_shift_chips[2] = d_early_late_spc_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[2] = trk_parameters.early_late_space_chips * static_cast(d_code_samples_per_chip); d_prompt_data_shift = &d_local_code_shift_chips[1]; } - multicorrelator_cpu.init(2 * d_vector_length, d_n_correlator_taps); + multicorrelator_cpu.init(2 * trk_parameters.vector_length, d_n_correlator_taps); - if (extend_correlation_symbols > 1) + if (trk_parameters.extend_correlation_symbols > 1) { d_enable_extended_integration = true; - d_extend_correlation_symbols = extend_correlation_symbols; } else { d_enable_extended_integration = false; - d_extend_correlation_symbols = 1; + trk_parameters.extend_correlation_symbols = 1; } // Enable Data component prompt correlator (slave to Pilot prompt) if tracking uses Pilot signal - if (d_track_pilot) + if (trk_parameters.track_pilot) { // Extra correlator for the data component - correlator_data_cpu.init(2 * d_vector_length, 1); + correlator_data_cpu.init(2 * trk_parameters.vector_length, 1); d_Prompt_Data = static_cast(volk_gnsssdr_malloc(sizeof(gr_complex), volk_gnsssdr_get_alignment())); d_Prompt_Data[0] = gr_complex(0.0, 0.0); d_data_code = static_cast(volk_gnsssdr_malloc(2 * d_code_length_chips * sizeof(float), volk_gnsssdr_get_alignment())); @@ -388,7 +335,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking( d_sample_counter = 0; d_acq_sample_stamp = 0; - d_current_prn_length_samples = static_cast(d_vector_length); + d_current_prn_length_samples = static_cast(trk_parameters.vector_length); // CN0 estimation and lock detector buffers d_cn0_estimation_counter = 0; @@ -429,25 +376,25 @@ void dll_pll_veml_tracking::start_tracking() d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples; long int acq_trk_diff_samples = static_cast(d_sample_counter) - static_cast(d_acq_sample_stamp); - double acq_trk_diff_seconds = static_cast(acq_trk_diff_samples) / d_fs_in; + double acq_trk_diff_seconds = static_cast(acq_trk_diff_samples) / trk_parameters.fs_in; DLOG(INFO) << "Number of samples between Acquisition and Tracking = " << acq_trk_diff_samples; DLOG(INFO) << "Number of seconds between Acquisition and Tracking = " << acq_trk_diff_seconds; // Doppler effect Fd = (C / (C + Vr)) * F double radial_velocity = (d_signal_carrier_freq + d_acq_carrier_doppler_hz) / d_signal_carrier_freq; // new chip and prn sequence periods based on acq Doppler d_code_freq_chips = radial_velocity * d_code_chip_rate; - d_code_phase_step_chips = d_code_freq_chips / d_fs_in; + d_code_phase_step_chips = d_code_freq_chips / trk_parameters.fs_in; double T_chip_mod_seconds = 1.0 / d_code_freq_chips; double T_prn_mod_seconds = T_chip_mod_seconds * static_cast(d_code_length_chips); - double T_prn_mod_samples = T_prn_mod_seconds * d_fs_in; + double T_prn_mod_samples = T_prn_mod_seconds * trk_parameters.fs_in; d_current_prn_length_samples = std::round(T_prn_mod_samples); double T_prn_true_seconds = static_cast(d_code_length_chips) / d_code_chip_rate; - double T_prn_true_samples = T_prn_true_seconds * d_fs_in; + double T_prn_true_samples = T_prn_true_seconds * trk_parameters.fs_in; double T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds; double N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds; - double corrected_acq_phase_samples = std::fmod(d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * d_fs_in, T_prn_true_samples); + double corrected_acq_phase_samples = std::fmod(d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * trk_parameters.fs_in, T_prn_true_samples); if (corrected_acq_phase_samples < 0.0) { corrected_acq_phase_samples += T_prn_mod_samples; @@ -457,7 +404,7 @@ void dll_pll_veml_tracking::start_tracking() d_acq_code_phase_samples = corrected_acq_phase_samples; d_carrier_doppler_hz = d_acq_carrier_doppler_hz; - d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / d_fs_in; + d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / trk_parameters.fs_in; // DLL/PLL filter initialization d_carrier_loop_filter.initialize(); // initialize the carrier filter @@ -473,7 +420,7 @@ void dll_pll_veml_tracking::start_tracking() } else if (systemName.compare("GPS") == 0 and signal_type.compare("L5") == 0) { - if (d_track_pilot) + if (trk_parameters.track_pilot) { gps_l5q_code_gen_float(d_tracking_code, d_acquisition_gnss_synchro->PRN); gps_l5i_code_gen_float(d_data_code, d_acquisition_gnss_synchro->PRN); @@ -487,7 +434,7 @@ void dll_pll_veml_tracking::start_tracking() } else if (systemName.compare("Galileo") == 0 and signal_type.compare("1B") == 0) { - if (d_track_pilot) + if (trk_parameters.track_pilot) { char pilot_signal[3] = "1C"; galileo_e1_code_gen_sinboc11_float(d_tracking_code, pilot_signal, d_acquisition_gnss_synchro->PRN); @@ -504,7 +451,7 @@ void dll_pll_veml_tracking::start_tracking() { gr_complex *aux_code = static_cast(volk_gnsssdr_malloc(sizeof(gr_complex) * d_code_length_chips, volk_gnsssdr_get_alignment())); galileo_e5_a_code_gen_complex_primary(aux_code, d_acquisition_gnss_synchro->PRN, const_cast(signal_type.c_str())); - if (d_track_pilot) + if (trk_parameters.track_pilot) { d_secondary_code_string = const_cast(&Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1]); for (unsigned int i = 0; i < d_code_length_chips; i++) @@ -539,20 +486,20 @@ void dll_pll_veml_tracking::start_tracking() if (d_veml) { - d_local_code_shift_chips[0] = -d_very_early_late_spc_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[1] = -d_early_late_spc_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[3] = d_early_late_spc_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[4] = d_very_early_late_spc_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[0] = -trk_parameters.very_early_late_space_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[1] = -trk_parameters.early_late_space_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[3] = trk_parameters.early_late_space_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[4] = trk_parameters.very_early_late_space_chips * static_cast(d_code_samples_per_chip); } else { - d_local_code_shift_chips[0] = -d_early_late_spc_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[2] = d_early_late_spc_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[0] = -trk_parameters.early_late_space_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[2] = trk_parameters.early_late_space_chips * static_cast(d_code_samples_per_chip); } d_code_phase_samples = d_acq_code_phase_samples; - d_code_loop_filter.set_DLL_BW(d_dll_bw_hz); - d_carrier_loop_filter.set_PLL_BW(d_pll_bw_hz); + d_code_loop_filter.set_DLL_BW(trk_parameters.dll_bw_hz); + d_carrier_loop_filter.set_PLL_BW(trk_parameters.pll_bw_hz); d_carrier_loop_filter.set_pdi(static_cast(d_code_period)); d_code_loop_filter.set_pdi(static_cast(d_code_period)); @@ -585,7 +532,7 @@ dll_pll_veml_tracking::~dll_pll_veml_tracking() LOG(WARNING) << "Exception in destructor " << ex.what(); } } - if (d_dump) + if (trk_parameters.dump) { if (d_channel == 0) { @@ -602,7 +549,7 @@ dll_pll_veml_tracking::~dll_pll_veml_tracking() volk_gnsssdr_free(d_local_code_shift_chips); volk_gnsssdr_free(d_correlator_outs); volk_gnsssdr_free(d_tracking_code); - if (d_track_pilot) + if (trk_parameters.track_pilot) { volk_gnsssdr_free(d_Prompt_Data); volk_gnsssdr_free(d_data_code); @@ -673,7 +620,7 @@ bool dll_pll_veml_tracking::cn0_and_tracking_lock_status() { d_cn0_estimation_counter = 0; // Code lock indicator - d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, FLAGS_cn0_samples, static_cast(d_fs_in), static_cast(d_code_length_chips)); + d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, FLAGS_cn0_samples, static_cast(trk_parameters.fs_in), static_cast(d_code_length_chips)); // Carrier lock indicator d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, FLAGS_cn0_samples); // Loss of lock detection @@ -716,10 +663,10 @@ void dll_pll_veml_tracking::do_correlation_step(const gr_complex *input_samples) d_carrier_phase_step_rad, static_cast(d_rem_code_phase_chips) * static_cast(d_code_samples_per_chip), static_cast(d_code_phase_step_chips) * static_cast(d_code_samples_per_chip), - d_vector_length); + trk_parameters.vector_length); // DATA CORRELATOR (if tracking tracks the pilot signal) - if (d_track_pilot) + if (trk_parameters.track_pilot) { correlator_data_cpu.set_input_output_vectors(d_Prompt_Data, input_samples); correlator_data_cpu.Carrier_wipeoff_multicorrelator_resampler( @@ -727,7 +674,7 @@ void dll_pll_veml_tracking::do_correlation_step(const gr_complex *input_samples) d_carrier_phase_step_rad, static_cast(d_rem_code_phase_chips) * static_cast(d_code_samples_per_chip), static_cast(d_code_phase_step_chips) * static_cast(d_code_samples_per_chip), - d_vector_length); + trk_parameters.vector_length); } } @@ -772,7 +719,7 @@ void dll_pll_veml_tracking::run_dll_pll() void dll_pll_veml_tracking::clear_tracking_vars() { std::fill_n(d_correlator_outs, d_n_correlator_taps, gr_complex(0.0, 0.0)); - if (d_track_pilot) *d_Prompt_Data = gr_complex(0.0, 0.0); + if (trk_parameters.track_pilot) *d_Prompt_Data = gr_complex(0.0, 0.0); d_carr_error_hz = 0.0; d_carr_error_filt_hz = 0.0; d_code_error_chips = 0.0; @@ -792,13 +739,13 @@ void dll_pll_veml_tracking::update_tracking_vars() // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT ####################### // keep alignment parameters for the next input buffer // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation - T_prn_samples = T_prn_seconds * d_fs_in; - K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * d_fs_in; + T_prn_samples = T_prn_seconds * trk_parameters.fs_in; + K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * trk_parameters.fs_in; d_current_prn_length_samples = static_cast(round(K_blk_samples)); // round to a discrete number of samples //################### PLL COMMANDS ################################################# // carrier phase step (NCO phase increment per sample) [rads/sample] - d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / d_fs_in; + d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / trk_parameters.fs_in; // remnant carrier phase to prevent overflow in the code NCO d_rem_carr_phase_rad += d_carrier_phase_step_rad * static_cast(d_current_prn_length_samples); d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, PI_2); @@ -807,10 +754,10 @@ void dll_pll_veml_tracking::update_tracking_vars() //################### DLL COMMANDS ################################################# // code phase step (Code resampler phase increment per sample) [chips/sample] - d_code_phase_step_chips = d_code_freq_chips / d_fs_in; + d_code_phase_step_chips = d_code_freq_chips / trk_parameters.fs_in; // remnant code phase [chips] d_rem_code_phase_samples = K_blk_samples - static_cast(d_current_prn_length_samples); // rounding error < 1 sample - d_rem_code_phase_chips = d_code_freq_chips * d_rem_code_phase_samples / d_fs_in; + d_rem_code_phase_chips = d_code_freq_chips * d_rem_code_phase_samples / trk_parameters.fs_in; } @@ -858,7 +805,7 @@ void dll_pll_veml_tracking::save_correlation_results() d_current_symbol %= d_symbols_per_bit; } // If tracking pilot, disable Costas loop - if (d_track_pilot) + if (trk_parameters.track_pilot) d_cloop = false; else d_cloop = true; @@ -867,7 +814,7 @@ void dll_pll_veml_tracking::save_correlation_results() void dll_pll_veml_tracking::log_data(bool integrating) { - if (d_dump) + if (trk_parameters.dump) { // Dump results to file float prompt_I; @@ -875,7 +822,7 @@ void dll_pll_veml_tracking::log_data(bool integrating) float tmp_VE, tmp_E, tmp_P, tmp_L, tmp_VL; float tmp_float; double tmp_double; - if (d_track_pilot) + if (trk_parameters.track_pilot) { if (interchange_iq) { @@ -920,7 +867,7 @@ void dll_pll_veml_tracking::log_data(bool integrating) // It compensates the amplitude difference while integrating if (d_extend_correlation_symbols_count > 0) { - float scale_factor = static_cast(d_extend_correlation_symbols) / static_cast(d_extend_correlation_symbols_count); + float scale_factor = static_cast(trk_parameters.extend_correlation_symbols) / static_cast(d_extend_correlation_symbols_count); tmp_VE *= scale_factor; tmp_E *= scale_factor; tmp_P *= scale_factor; @@ -994,7 +941,7 @@ int dll_pll_veml_tracking::save_matfile() dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); try { - dump_file.open(d_dump_filename.c_str(), std::ios::binary | std::ios::ate); + dump_file.open(trk_parameters.dump_filename.c_str(), std::ios::binary | std::ios::ate); } catch (const std::ifstream::failure &e) { @@ -1093,7 +1040,7 @@ int dll_pll_veml_tracking::save_matfile() // WRITE MAT FILE mat_t *matfp; matvar_t *matvar; - std::string filename = d_dump_filename; + std::string filename = trk_parameters.dump_filename; filename.erase(filename.length() - 4, 4); filename.append(".mat"); matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73); @@ -1211,17 +1158,17 @@ void dll_pll_veml_tracking::set_channel(unsigned int channel) d_channel = channel; LOG(INFO) << "Tracking Channel set to " << d_channel; // ############# ENABLE DATA FILE LOG ################# - if (d_dump) + if (trk_parameters.dump) { if (!d_dump_file.is_open()) { try { - d_dump_filename.append(boost::lexical_cast(d_channel)); - d_dump_filename.append(".dat"); + trk_parameters.dump_filename.append(boost::lexical_cast(d_channel)); + trk_parameters.dump_filename.append(".dat"); d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); - d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary); - LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str(); + d_dump_file.open(trk_parameters.dump_filename.c_str(), std::ios::out | std::ios::binary); + LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << trk_parameters.dump_filename.c_str(); } catch (const std::ifstream::failure &e) { @@ -1367,30 +1314,30 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused) { // UPDATE INTEGRATION TIME d_extend_correlation_symbols_count = 0; - float new_correlation_time = static_cast(d_extend_correlation_symbols) * static_cast(d_code_period); + float new_correlation_time = static_cast(trk_parameters.extend_correlation_symbols) * static_cast(d_code_period); d_carrier_loop_filter.set_pdi(new_correlation_time); d_code_loop_filter.set_pdi(new_correlation_time); d_state = 3; // next state is the extended correlator integrator - LOG(INFO) << "Enabled " << d_extend_correlation_symbols << " [symbols] extended correlator for CH " + LOG(INFO) << "Enabled " << trk_parameters.extend_correlation_symbols << " [symbols] extended correlator for CH " << d_channel << " : Satellite " << Gnss_Satellite(systemName, d_acquisition_gnss_synchro->PRN); - std::cout << "Enabled " << d_extend_correlation_symbols << " [symbols] extended correlator for CH " + std::cout << "Enabled " << trk_parameters.extend_correlation_symbols << " [symbols] extended correlator for CH " << d_channel << " : Satellite " << Gnss_Satellite(systemName, d_acquisition_gnss_synchro->PRN) << std::endl; // Set narrow taps delay values [chips] - d_code_loop_filter.set_DLL_BW(d_dll_bw_narrow_hz); - d_carrier_loop_filter.set_PLL_BW(d_pll_bw_narrow_hz); + d_code_loop_filter.set_DLL_BW(trk_parameters.dll_bw_narrow_hz); + d_carrier_loop_filter.set_PLL_BW(trk_parameters.pll_bw_narrow_hz); if (d_veml) { - d_local_code_shift_chips[0] = -d_very_early_late_spc_narrow_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[1] = -d_early_late_spc_narrow_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[3] = d_early_late_spc_narrow_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[4] = d_very_early_late_spc_narrow_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[0] = -trk_parameters.very_early_late_space_narrow_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[1] = -trk_parameters.early_late_space_narrow_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[3] = trk_parameters.early_late_space_narrow_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[4] = trk_parameters.very_early_late_space_narrow_chips * static_cast(d_code_samples_per_chip); } else { - d_local_code_shift_chips[0] = -d_early_late_spc_narrow_chips * static_cast(d_code_samples_per_chip); - d_local_code_shift_chips[2] = d_early_late_spc_narrow_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[0] = -trk_parameters.early_late_space_narrow_chips * static_cast(d_code_samples_per_chip); + d_local_code_shift_chips[2] = trk_parameters.early_late_space_narrow_chips * static_cast(d_code_samples_per_chip); } } else @@ -1413,7 +1360,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused) // ########### Output the tracking results to Telemetry block ########## if (interchange_iq) { - if (d_track_pilot) + if (trk_parameters.track_pilot) { // Note that data and pilot components are in quadrature. I and Q are interchanged current_synchro_data.Prompt_I = static_cast((*d_Prompt_Data).imag()); @@ -1427,7 +1374,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused) } else { - if (d_track_pilot) + if (trk_parameters.track_pilot) { // Note that data and pilot components are in quadrature. I and Q are interchanged current_synchro_data.Prompt_I = static_cast((*d_Prompt_Data).real()); @@ -1446,7 +1393,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused) current_synchro_data.Flag_valid_symbol_output = true; current_synchro_data.correlation_length_ms = d_correlation_length_ms; d_extend_correlation_symbols_count++; - if (d_extend_correlation_symbols_count == (d_extend_correlation_symbols - 1)) + if (d_extend_correlation_symbols_count == (trk_parameters.extend_correlation_symbols - 1)) { d_extend_correlation_symbols_count = 0; d_state = 4; @@ -1477,7 +1424,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused) // ########### Output the tracking results to Telemetry block ########## if (interchange_iq) { - if (d_track_pilot) + if (trk_parameters.track_pilot) { // Note that data and pilot components are in quadrature. I and Q are interchanged current_synchro_data.Prompt_I = static_cast((*d_Prompt_Data).imag()); @@ -1491,7 +1438,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused) } else { - if (d_track_pilot) + if (trk_parameters.track_pilot) { // Note that data and pilot components are in quadrature. I and Q are interchanged current_synchro_data.Prompt_I = static_cast((*d_Prompt_Data).real()); @@ -1528,7 +1475,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused) d_sample_counter += d_current_prn_length_samples; if (current_synchro_data.Flag_valid_symbol_output) { - current_synchro_data.fs = static_cast(d_fs_in); + current_synchro_data.fs = static_cast(trk_parameters.fs_in); current_synchro_data.Tracking_sample_counter = d_sample_counter; *out[0] = current_synchro_data; return 1; diff --git a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h index 1065f44ef..e9e41ccbc 100755 --- a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h +++ b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h @@ -39,20 +39,32 @@ #include #include +typedef struct +{ + /* DLL/PLL tracking configuration */ + double fs_in; + unsigned int vector_length; + bool dump; + std::string dump_filename; + float pll_bw_hz; + float dll_bw_hz; + float pll_bw_narrow_hz; + float dll_bw_narrow_hz; + float early_late_space_chips; + float very_early_late_space_chips; + float early_late_space_narrow_chips; + float very_early_late_space_narrow_chips; + int extend_correlation_symbols; + bool track_pilot; + char system; + char signal[3]; +} dllpllconf_t; class dll_pll_veml_tracking; typedef boost::shared_ptr dll_pll_veml_tracking_sptr; -dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(double fs_in, unsigned int vector_length, - bool dump, std::string dump_filename, - float pll_bw_hz, float dll_bw_hz, - float pll_bw_narrow_hz, float dll_bw_narrow_hz, - float early_late_space_chips, float very_early_late_space_chips, - float early_late_space_narrow_chips, - float very_early_late_space_narrow_chips, - int extend_correlation_symbols, bool track_pilot, - char system, char signal[3]); +dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(dllpllconf_t conf_); /*! * \brief This class implements a code DLL + carrier PLL tracking block. @@ -72,29 +84,9 @@ public: void forecast(int noutput_items, gr_vector_int &ninput_items_required); private: - friend dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(double fs_in, unsigned int vector_length, - bool dump, std::string dump_filename, - float pll_bw_hz, float dll_bw_hz, float pll_bw_narrow_hz, - float dll_bw_narrow_hz, float early_late_space_chips, - float very_early_late_space_chips, float early_late_space_narrow_chips, - float very_early_late_space_narrow_chips, - int extend_correlation_symbols, bool track_pilot, - char system, char signal[3]); + friend dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(dllpllconf_t conf_); - dll_pll_veml_tracking(double fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float pll_bw_narrow_hz, - float dll_bw_narrow_hz, - float early_late_space_chips, - float very_early_late_space_chips, - float early_late_space_narrow_chips, - float very_early_late_space_narrow_chips, - int extend_correlation_symbols, - bool track_pilot, - char system, char signal[3]); + dll_pll_veml_tracking(dllpllconf_t conf_); bool cn0_and_tracking_lock_status(); bool acquire_secondary(); @@ -107,12 +99,10 @@ private: int save_matfile(); // tracking configuration vars - bool d_dump; + dllpllconf_t trk_parameters; bool d_veml; bool d_cloop; - unsigned int d_vector_length; unsigned int d_channel; - double d_fs_in; Gnss_Synchro *d_acquisition_gnss_synchro; //Signal parameters @@ -135,10 +125,6 @@ private: //Integration period in samples int d_correlation_length_ms; int d_n_correlator_taps; - float d_early_late_spc_chips; - float d_very_early_late_spc_chips; - float d_early_late_spc_narrow_chips; - float d_very_early_late_spc_narrow_chips; float *d_tracking_code; float *d_data_code; @@ -159,7 +145,6 @@ private: gr_complex *d_Very_Late; bool d_enable_extended_integration; - int d_extend_correlation_symbols; int d_extend_correlation_symbols_count; int d_current_symbol; @@ -170,7 +155,6 @@ private: gr_complex d_VL_accu; gr_complex d_last_prompt; - bool d_track_pilot; gr_complex *d_Prompt_Data; double d_code_phase_step_chips; @@ -187,11 +171,6 @@ private: double d_acq_code_phase_samples; double d_acq_carrier_doppler_hz; - // tracking parameters - float d_dll_bw_hz; - float d_pll_bw_hz; - float d_dll_bw_narrow_hz; - float d_pll_bw_narrow_hz; // tracking vars double d_carr_error_hz; double d_carr_error_filt_hz; @@ -223,7 +202,6 @@ private: gr_complex *d_Prompt_buffer; // file dump - std::string d_dump_filename; std::ofstream d_dump_file; }; From 5aec66f85e4b3238da9de7121997a248cccd8e9f Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Thu, 5 Apr 2018 20:31:53 +0200 Subject: [PATCH 05/21] CMake fix --- .../cmake/Modules/VolkGnsssdrConfigVersion.cmake.in | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/VolkGnsssdrConfigVersion.cmake.in b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/VolkGnsssdrConfigVersion.cmake.in index 265daeb8e..84dbe0b29 100644 --- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/VolkGnsssdrConfigVersion.cmake.in +++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/VolkGnsssdrConfigVersion.cmake.in @@ -29,6 +29,6 @@ if(${PACKAGE_FIND_VERSION_MAJOR} EQUAL ${MAJOR_VERSION}) if(NOT ${PACKAGE_FIND_VERSION_PATCH} GREATER ${MAINT_VERSION}) set(PACKAGE_VERSION_EXACT 1) # exact match for API version set(PACKAGE_VERSION_COMPATIBLE 1) # compat for minor/patch version - endif(NOT ${PACKAGE_FIND_VERSION_PATCH} GREATER ${MINOR_VERSION}) - endif(${PACKAGE_FIND_VERSION_MINOR} EQUAL ${API_COMPAT}) + endif(NOT ${PACKAGE_FIND_VERSION_PATCH} GREATER ${MAINT_VERSION}) + endif(${PACKAGE_FIND_VERSION_MINOR} EQUAL ${MINOR_VERSION}) endif(${PACKAGE_FIND_VERSION_MAJOR} EQUAL ${MAJOR_VERSION}) From b9c2614fc3ec8645387034e69fcfd5807ffa05f2 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Thu, 5 Apr 2018 20:58:48 +0200 Subject: [PATCH 06/21] Fix bug in saving data into a .mat file --- .../tracking/gnuradio_blocks/dll_pll_veml_tracking.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc index a89dfefc9..887943acc 100755 --- a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc +++ b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc @@ -1100,7 +1100,7 @@ int dll_pll_veml_tracking::save_matfile() if (reinterpret_cast(matfp) != NULL) { size_t dims[2] = {1, static_cast(num_epoch)}; - matvar = Mat_VarCreate("abs_VE", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0); + matvar = Mat_VarCreate("abs_VE", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_VE, 0); Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE Mat_VarFree(matvar); @@ -1116,7 +1116,7 @@ int dll_pll_veml_tracking::save_matfile() Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE Mat_VarFree(matvar); - matvar = Mat_VarCreate("abs_VL", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0); + matvar = Mat_VarCreate("abs_VL", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_VL, 0); Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE Mat_VarFree(matvar); From c9925e07db504af26f4a038ca54ce7014a105932 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Thu, 5 Apr 2018 21:04:01 +0200 Subject: [PATCH 07/21] Initialize missing parameter --- .../acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc index 81773e326..821d61acb 100644 --- a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc @@ -72,6 +72,7 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition( use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_; max_dwells_ = configuration_->property(role + ".max_dwells", 1); + acq_parameters.max_dwells = max_dwells_; dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename); acq_parameters.dump_filename = dump_filename_; From 8a4b51bf380ff5ee9392c7d7d0bc3ffde5788ced Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Thu, 5 Apr 2018 21:15:51 +0200 Subject: [PATCH 08/21] Use dll_pll_veml_tracking tracking block for GPS L2C --- .../adapters/gps_l2_m_dll_pll_tracking.cc | 62 +- .../adapters/gps_l2_m_dll_pll_tracking.h | 4 +- .../tracking/gnuradio_blocks/CMakeLists.txt | 1 - .../gps_l2_m_dll_pll_tracking_cc.cc | 761 ------------------ .../gps_l2_m_dll_pll_tracking_cc.h | 165 ---- 5 files changed, 22 insertions(+), 971 deletions(-) delete mode 100644 src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc delete mode 100644 src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.h diff --git a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc index 563316bf5..9bee8e419 100644 --- a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc @@ -60,7 +60,6 @@ GpsL2MDllPllTracking::GpsL2MDllPllTracking( if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast(FLAGS_pll_bw_hz); float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 0.75); if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast(FLAGS_dll_bw_hz); - unified_ = configuration->property(role + ".unified", false); float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5); std::string default_dump_filename = "./track_ch"; std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); @@ -79,26 +78,17 @@ GpsL2MDllPllTracking::GpsL2MDllPllTracking( if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); - if (unified_) - { - char sig_[3] = "2S"; - item_size_ = sizeof(gr_complex); - tracking_unified_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, pll_bw_hz, dll_bw_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_chips, - early_late_space_chips, - 1, false, 'G', sig_); - } - else - { - tracking_ = gps_l2_m_dll_pll_make_tracking_cc( - 0, fs_in, vector_length, dump, - dump_filename, pll_bw_hz, dll_bw_hz, - early_late_space_chips); - } + + char sig_[3] = "2S"; + item_size_ = sizeof(gr_complex); + tracking_ = dll_pll_veml_make_tracking( + fs_in, vector_length, dump, dump_filename, + pll_bw_hz, dll_bw_hz, pll_bw_hz, dll_bw_hz, + early_late_space_chips, + early_late_space_chips, + early_late_space_chips, + early_late_space_chips, + 1, false, 'G', sig_); } else { @@ -117,33 +107,26 @@ GpsL2MDllPllTracking::~GpsL2MDllPllTracking() void GpsL2MDllPllTracking::start_tracking() { - if (unified_) - tracking_unified_->start_tracking(); - else - tracking_->start_tracking(); + tracking_->start_tracking(); } + /* * Set tracking channel unique ID */ void GpsL2MDllPllTracking::set_channel(unsigned int channel) { channel_ = channel; - if (unified_) - tracking_unified_->set_channel(channel); - else - tracking_->set_channel(channel); + tracking_->set_channel(channel); } void GpsL2MDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) { - if (unified_) - tracking_unified_->set_gnss_synchro(p_gnss_synchro); - else - tracking_->set_gnss_synchro(p_gnss_synchro); + tracking_->set_gnss_synchro(p_gnss_synchro); } + void GpsL2MDllPllTracking::connect(gr::top_block_sptr top_block) { if (top_block) @@ -152,6 +135,7 @@ void GpsL2MDllPllTracking::connect(gr::top_block_sptr top_block) //nothing to connect, now the tracking uses gr_sync_decimator } + void GpsL2MDllPllTracking::disconnect(gr::top_block_sptr top_block) { if (top_block) @@ -160,18 +144,14 @@ void GpsL2MDllPllTracking::disconnect(gr::top_block_sptr top_block) //nothing to disconnect, now the tracking uses gr_sync_decimator } + gr::basic_block_sptr GpsL2MDllPllTracking::get_left_block() { - if (unified_) - return tracking_unified_; - else - return tracking_; + return tracking_; } + gr::basic_block_sptr GpsL2MDllPllTracking::get_right_block() { - if (unified_) - return tracking_unified_; - else - return tracking_; + return tracking_; } diff --git a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h index 77741e9b1..4717d0f5f 100644 --- a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h +++ b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h @@ -39,7 +39,6 @@ #define GNSS_SDR_gps_l2_m_dll_pll_tracking_H_ #include "tracking_interface.h" -#include "gps_l2_m_dll_pll_tracking_cc.h" #include "dll_pll_veml_tracking.h" #include @@ -93,8 +92,7 @@ public: void start_tracking() override; private: - gps_l2_m_dll_pll_tracking_cc_sptr tracking_; - dll_pll_veml_tracking_sptr tracking_unified_; + dll_pll_veml_tracking_sptr tracking_; size_t item_size_; unsigned int channel_; std::string role_; diff --git a/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt b/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt index 3c3fb03d7..c30beee68 100644 --- a/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt +++ b/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt @@ -30,7 +30,6 @@ set(TRACKING_GR_BLOCKS_SOURCES galileo_e1_tcp_connector_tracking_cc.cc gps_l1_ca_tcp_connector_tracking_cc.cc galileo_e5a_dll_pll_tracking_cc.cc - gps_l2_m_dll_pll_tracking_cc.cc gps_l5i_dll_pll_tracking_cc.cc gps_l1_ca_dll_pll_c_aid_tracking_cc.cc gps_l1_ca_dll_pll_c_aid_tracking_sc.cc 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 deleted file mode 100644 index 7d53de441..000000000 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc +++ /dev/null @@ -1,761 +0,0 @@ -/*! - * \file gps_l2_m_dll_pll_tracking_cc.cc - * \brief Implementation of a code DLL + carrier PLL tracking block for GPS L2C - * \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com - * Javier Arribas, 2011. jarribas(at)cttc.es - * - * Code DLL + carrier PLL according to the algorithms described in: - * [1] K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen, - * A Software-Defined GPS and Galileo Receiver. A Single-Frequency - * Approach, Birkhauser, 2007 - * - * ------------------------------------------------------------------------- - * - * Copyright (C) 2010-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 "gps_l2_m_dll_pll_tracking_cc.h" -#include "gps_l2c_signal.h" -#include "tracking_discriminators.h" -#include "lock_detectors.h" -#include "GPS_L2C.h" -#include "control_message_factory.h" -#include "gnss_sdr_flags.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include - -using google::LogMessage; - -gps_l2_m_dll_pll_tracking_cc_sptr -gps_l2_m_dll_pll_make_tracking_cc( - long if_freq, - long fs_in, - unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips) -{ - return gps_l2_m_dll_pll_tracking_cc_sptr(new gps_l2_m_dll_pll_tracking_cc(if_freq, - fs_in, vector_length, dump, dump_filename, pll_bw_hz, dll_bw_hz, early_late_space_chips)); -} - - -void gps_l2_m_dll_pll_tracking_cc::forecast(int noutput_items, - gr_vector_int &ninput_items_required) -{ - if (noutput_items != 0) - { - ninput_items_required[0] = static_cast(d_vector_length) * 2; //set the required available samples in each call - } -} - - -gps_l2_m_dll_pll_tracking_cc::gps_l2_m_dll_pll_tracking_cc( - long if_freq, - long fs_in, - unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips) : gr::block("gps_l2_m_dll_pll_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)), - gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) -{ - // Telemetry bit synchronization message port input - this->message_port_register_in(pmt::mp("preamble_timestamp_s")); - this->message_port_register_out(pmt::mp("events")); - // initialize internal vars - d_dump = dump; - d_if_freq = if_freq; - d_fs_in = fs_in; - d_vector_length = vector_length; - d_dump_filename = dump_filename; - - d_current_prn_length_samples = static_cast(d_vector_length); - - // DLL/PLL filter initialization - d_carrier_loop_filter = Tracking_2nd_PLL_filter(GPS_L2_M_PERIOD); - d_code_loop_filter = Tracking_2nd_DLL_filter(GPS_L2_M_PERIOD); - - // Initialize tracking ========================================== - d_code_loop_filter.set_DLL_BW(dll_bw_hz); - d_carrier_loop_filter.set_PLL_BW(pll_bw_hz); - - //--- DLL variables -------------------------------------------------------- - d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips) - - // Initialization of local code replica - // Get space for a vector with the C/A code replica sampled 1x/chip - d_ca_code = static_cast(volk_gnsssdr_malloc(static_cast(GPS_L2_M_CODE_LENGTH_CHIPS) * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - - // correlator outputs (scalar) - d_n_correlator_taps = 3; // Early, Prompt, and Late - d_correlator_outs = static_cast(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - for (int n = 0; n < d_n_correlator_taps; n++) - { - d_correlator_outs[n] = gr_complex(0, 0); - } - d_local_code_shift_chips = static_cast(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment())); - // Set TAPs delay values [chips] - d_local_code_shift_chips[0] = -d_early_late_spc_chips; - d_local_code_shift_chips[1] = 0.0; - d_local_code_shift_chips[2] = d_early_late_spc_chips; - - multicorrelator_cpu.init(2 * d_current_prn_length_samples, d_n_correlator_taps); - - //--- Perform initializations ------------------------------ - // define initial code frequency basis of NCO - d_code_freq_chips = GPS_L2_M_CODE_RATE_HZ; - // define residual code phase (in chips) - d_rem_code_phase_samples = 0.0; - // define residual carrier phase - d_rem_carr_phase_rad = 0.0; - - // sample synchronization - d_sample_counter = 0; - //d_sample_counter_seconds = 0; - d_acq_sample_stamp = 0; - - d_enable_tracking = false; - d_pull_in = false; - - // CN0 estimation and lock detector buffers - d_cn0_estimation_counter = 0; - d_Prompt_buffer = new gr_complex[FLAGS_cn0_samples]; - d_carrier_lock_test = 1; - d_CN0_SNV_dB_Hz = 0; - d_carrier_lock_fail_counter = 0; - d_carrier_lock_threshold = FLAGS_carrier_lock_th; - - systemName["G"] = std::string("GPS"); - - //set_min_output_buffer((long int)300); - - d_acquisition_gnss_synchro = 0; - d_channel = 0; - d_acq_code_phase_samples = 0.0; - d_acq_carrier_doppler_hz = 0.0; - d_carrier_doppler_hz = 0.0; - d_acc_carrier_phase_rad = 0.0; - d_code_phase_samples = 0.0; - - d_rem_code_phase_chips = 0.0; - d_code_phase_step_chips = 0.0; - d_carrier_phase_step_rad = 0.0; - - set_relative_rate(1.0 / static_cast(d_vector_length)); -} - - -void gps_l2_m_dll_pll_tracking_cc::start_tracking() -{ - /* - * correct the code phase according to the delay between acq and trk - */ - d_acq_code_phase_samples = d_acquisition_gnss_synchro->Acq_delay_samples; - d_acq_carrier_doppler_hz = d_acquisition_gnss_synchro->Acq_doppler_hz; - d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples; - - long int acq_trk_diff_samples; - double acq_trk_diff_seconds; - acq_trk_diff_samples = static_cast(d_sample_counter) - static_cast(d_acq_sample_stamp); //-d_vector_length; - DLOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples; - acq_trk_diff_seconds = static_cast(acq_trk_diff_samples) / static_cast(d_fs_in); - // Doppler effect - // Fd=(C/(C+Vr))*F - double radial_velocity = (GPS_L2_FREQ_HZ + d_acq_carrier_doppler_hz) / GPS_L2_FREQ_HZ; - // new chip and prn sequence periods based on acq Doppler - double T_chip_mod_seconds; - double T_prn_mod_seconds; - double T_prn_mod_samples; - d_code_freq_chips = radial_velocity * GPS_L2_M_CODE_RATE_HZ; - d_code_phase_step_chips = static_cast(d_code_freq_chips) / static_cast(d_fs_in); - T_chip_mod_seconds = 1 / d_code_freq_chips; - T_prn_mod_seconds = T_chip_mod_seconds * GPS_L2_M_CODE_LENGTH_CHIPS; - T_prn_mod_samples = T_prn_mod_seconds * static_cast(d_fs_in); - - d_current_prn_length_samples = round(T_prn_mod_samples); - - double T_prn_true_seconds = GPS_L2_M_CODE_LENGTH_CHIPS / GPS_L2_M_CODE_RATE_HZ; - double T_prn_true_samples = T_prn_true_seconds * static_cast(d_fs_in); - double T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds; - double N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds; - double corrected_acq_phase_samples, delay_correction_samples; - corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * static_cast(d_fs_in)), T_prn_true_samples); - if (corrected_acq_phase_samples < 0) - { - corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples; - } - delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples; - - d_acq_code_phase_samples = corrected_acq_phase_samples; - - d_carrier_doppler_hz = d_acq_carrier_doppler_hz; - d_carrier_phase_step_rad = GPS_L2_TWO_PI * d_carrier_doppler_hz / static_cast(d_fs_in); - - // DLL/PLL filter initialization - d_carrier_loop_filter.initialize(); // initialize the carrier filter - d_code_loop_filter.initialize(); // initialize the code filter - - // generate local reference ALWAYS starting at chip 1 (1 sample per chip) - gps_l2c_m_code_gen_complex(d_ca_code, d_acquisition_gnss_synchro->PRN); - - multicorrelator_cpu.set_local_code_and_taps(static_cast(GPS_L2_M_CODE_LENGTH_CHIPS), d_ca_code, d_local_code_shift_chips); - for (int n = 0; n < d_n_correlator_taps; n++) - { - d_correlator_outs[n] = gr_complex(0, 0); - } - - d_carrier_lock_fail_counter = 0; - d_rem_code_phase_samples = 0; - d_rem_carr_phase_rad = 0.0; - d_rem_code_phase_chips = 0.0; - d_acc_carrier_phase_rad = 0.0; - - d_code_phase_samples = d_acq_code_phase_samples; - - std::string sys_ = &d_acquisition_gnss_synchro->System; - sys = sys_.substr(0, 1); - - // DEBUG OUTPUT - std::cout << "Tracking of GPS L2CM signal started on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl; - LOG(INFO) << "Starting GPS L2CM 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; - - LOG(INFO) << "GPS L2CM 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; -} - - -int gps_l2_m_dll_pll_tracking_cc::save_matfile() -{ - // READ DUMP FILE - std::ifstream::pos_type size; - int number_of_double_vars = 11; - int number_of_float_vars = 5; - int epoch_size_bytes = sizeof(unsigned long int) + sizeof(double) * number_of_double_vars + - sizeof(float) * number_of_float_vars + sizeof(unsigned int); - std::ifstream dump_file; - dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); - try - { - dump_file.open(d_dump_filename.c_str(), std::ios::binary | std::ios::ate); - } - catch (const std::ifstream::failure &e) - { - std::cerr << "Problem opening dump file:" << e.what() << std::endl; - return 1; - } - // count number of epochs and rewind - long int num_epoch = 0; - if (dump_file.is_open()) - { - size = dump_file.tellg(); - num_epoch = static_cast(size) / static_cast(epoch_size_bytes); - dump_file.seekg(0, std::ios::beg); - } - else - { - return 1; - } - float *abs_E = new float[num_epoch]; - float *abs_P = new float[num_epoch]; - float *abs_L = new float[num_epoch]; - float *Prompt_I = new float[num_epoch]; - float *Prompt_Q = new float[num_epoch]; - unsigned long int *PRN_start_sample_count = new unsigned long int[num_epoch]; - double *acc_carrier_phase_rad = new double[num_epoch]; - double *carrier_doppler_hz = new double[num_epoch]; - double *code_freq_chips = new double[num_epoch]; - double *carr_error_hz = new double[num_epoch]; - double *carr_error_filt_hz = new double[num_epoch]; - double *code_error_chips = new double[num_epoch]; - double *code_error_filt_chips = new double[num_epoch]; - double *CN0_SNV_dB_Hz = new double[num_epoch]; - double *carrier_lock_test = new double[num_epoch]; - double *aux1 = new double[num_epoch]; - double *aux2 = new double[num_epoch]; - unsigned int *PRN = new unsigned int[num_epoch]; - - try - { - if (dump_file.is_open()) - { - for (long int i = 0; i < num_epoch; i++) - { - dump_file.read(reinterpret_cast(&abs_E[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&abs_P[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&abs_L[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&Prompt_I[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&Prompt_Q[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&PRN_start_sample_count[i]), sizeof(unsigned long int)); - dump_file.read(reinterpret_cast(&acc_carrier_phase_rad[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carrier_doppler_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_freq_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carr_error_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carr_error_filt_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_error_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_error_filt_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&CN0_SNV_dB_Hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carrier_lock_test[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&aux1[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&aux2[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&PRN[i]), sizeof(unsigned int)); - } - } - dump_file.close(); - } - catch (const std::ifstream::failure &e) - { - std::cerr << "Problem reading dump file:" << e.what() << std::endl; - delete[] abs_E; - delete[] abs_P; - delete[] abs_L; - delete[] Prompt_I; - delete[] Prompt_Q; - delete[] PRN_start_sample_count; - delete[] acc_carrier_phase_rad; - delete[] carrier_doppler_hz; - delete[] code_freq_chips; - delete[] carr_error_hz; - delete[] carr_error_filt_hz; - delete[] code_error_chips; - delete[] code_error_filt_chips; - delete[] CN0_SNV_dB_Hz; - delete[] carrier_lock_test; - delete[] aux1; - delete[] aux2; - delete[] PRN; - return 1; - } - - // WRITE MAT FILE - mat_t *matfp; - matvar_t *matvar; - std::string filename = d_dump_filename; - filename.erase(filename.length() - 4, 4); - filename.append(".mat"); - matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73); - if (reinterpret_cast(matfp) != NULL) - { - size_t dims[2] = {1, static_cast(num_epoch)}; - matvar = Mat_VarCreate("abs_E", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("abs_P", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_P, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("abs_L", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_L, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("Prompt_I", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_I, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("Prompt_Q", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_Q, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("PRN_start_sample_count", MAT_C_UINT64, MAT_T_UINT64, 2, dims, PRN_start_sample_count, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("acc_carrier_phase_rad", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, acc_carrier_phase_rad, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carrier_doppler_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_doppler_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_freq_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_freq_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carr_error_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carr_error_filt_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_filt_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_error_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_error_filt_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_filt_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("CN0_SNV_dB_Hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, CN0_SNV_dB_Hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carrier_lock_test", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_lock_test, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("aux1", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux1, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("aux2", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux2, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("PRN", MAT_C_UINT32, MAT_T_UINT32, 2, dims, PRN, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - } - Mat_Close(matfp); - delete[] abs_E; - delete[] abs_P; - delete[] abs_L; - delete[] Prompt_I; - delete[] Prompt_Q; - delete[] PRN_start_sample_count; - delete[] acc_carrier_phase_rad; - delete[] carrier_doppler_hz; - delete[] code_freq_chips; - delete[] carr_error_hz; - delete[] carr_error_filt_hz; - delete[] code_error_chips; - delete[] code_error_filt_chips; - delete[] CN0_SNV_dB_Hz; - delete[] carrier_lock_test; - delete[] aux1; - delete[] aux2; - delete[] PRN; - return 0; -} - - -gps_l2_m_dll_pll_tracking_cc::~gps_l2_m_dll_pll_tracking_cc() -{ - if (d_dump_file.is_open()) - { - try - { - d_dump_file.close(); - } - catch (const std::exception &ex) - { - LOG(WARNING) << "Exception in destructor " << ex.what(); - } - } - if (d_dump) - { - if (d_channel == 0) - { - std::cout << "Writing .mat files ..."; - } - gps_l2_m_dll_pll_tracking_cc::save_matfile(); - if (d_channel == 0) - { - std::cout << " done." << std::endl; - } - } - try - { - volk_gnsssdr_free(d_local_code_shift_chips); - volk_gnsssdr_free(d_correlator_outs); - volk_gnsssdr_free(d_ca_code); - delete[] d_Prompt_buffer; - multicorrelator_cpu.free(); - } - catch (const std::exception &ex) - { - LOG(WARNING) << "Exception in destructor " << ex.what(); - } -} - - -int gps_l2_m_dll_pll_tracking_cc::general_work(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items __attribute__((unused)), - gr_vector_const_void_star &input_items, gr_vector_void_star &output_items) -{ - // process vars - double carr_error_hz = 0; - double carr_error_filt_hz = 0; - double code_error_chips = 0; - double code_error_filt_chips = 0; - - // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder - Gnss_Synchro current_synchro_data = Gnss_Synchro(); - - // Block input data and block output stream pointers - const gr_complex *in = reinterpret_cast(input_items[0]); - Gnss_Synchro **out = reinterpret_cast(&output_items[0]); - - if (d_enable_tracking == true) - { - // Fill the acquisition data - current_synchro_data = *d_acquisition_gnss_synchro; - // Receiver signal alignment - if (d_pull_in == true) - { - int samples_offset; - double acq_trk_shif_correction_samples; - int acq_to_trk_delay_samples; - acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp; - acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast(acq_to_trk_delay_samples), static_cast(d_current_prn_length_samples)); - samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples); - current_synchro_data.Tracking_sample_counter = d_sample_counter + samples_offset; - 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 alignment - 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; - current_synchro_data.fs = d_fs_in; - current_synchro_data.correlation_length_ms = 20; - consume_each(samples_offset); // shift input to perform alignment with local replica - return 0; - } - - // ################# CARRIER WIPEOFF AND CORRELATORS ############################## - // perform carrier wipe-off and compute Early, Prompt and Late correlation - multicorrelator_cpu.set_input_output_vectors(d_correlator_outs, in); - multicorrelator_cpu.Carrier_wipeoff_multicorrelator_resampler(d_rem_carr_phase_rad, - d_carrier_phase_step_rad, - d_rem_code_phase_chips, - d_code_phase_step_chips, - d_current_prn_length_samples); - - // ################## PLL ########################################################## - // PLL discriminator - // Update PLL discriminator [rads/Ti -> Secs/Ti] - carr_error_hz = pll_cloop_two_quadrant_atan(d_correlator_outs[1]) / GPS_L2_TWO_PI; - // Carrier discriminator filter - 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_L2_M_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L2_M_CODE_RATE_HZ) / GPS_L2_FREQ_HZ); - - // ################## DLL ########################################################## - // DLL discriminator - code_error_chips = dll_nc_e_minus_l_normalized(d_correlator_outs[0], d_correlator_outs[2]); // [chips/Ti] - // Code discriminator filter - code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips); //[chips/second] - double T_chip_seconds = 1.0 / static_cast(d_code_freq_chips); - double T_prn_seconds = T_chip_seconds * GPS_L2_M_CODE_LENGTH_CHIPS; - double code_error_filt_secs = (T_prn_seconds * code_error_filt_chips * T_chip_seconds); //[seconds] - //double code_error_filt_secs = (GPS_L2_M_PERIOD * code_error_filt_chips) / GPS_L2_M_CODE_RATE_HZ; //[seconds] - - // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT ####################### - // keep alignment parameters for the next input buffer - // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation - double T_prn_samples = T_prn_seconds * static_cast(d_fs_in); - double K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * static_cast(d_fs_in); - d_current_prn_length_samples = round(K_blk_samples); // round to a discrete number of samples - - //################### PLL COMMANDS ################################################# - // carrier phase step (NCO phase increment per sample) [rads/sample] - d_carrier_phase_step_rad = GPS_L2_TWO_PI * d_carrier_doppler_hz / static_cast(d_fs_in); - // remnant 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_L2_TWO_PI); - // carrier phase accumulator - 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_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 < FLAGS_cn0_samples) - { - // fill buffer with prompt correlator output values - d_Prompt_buffer[d_cn0_estimation_counter] = d_correlator_outs[1]; - d_cn0_estimation_counter++; - } - else - { - d_cn0_estimation_counter = 0; - // Code lock indicator - d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, FLAGS_cn0_samples, d_fs_in, GPS_L2_M_CODE_LENGTH_CHIPS); - // Carrier lock indicator - d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, FLAGS_cn0_samples); - // Loss of lock detection - if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < FLAGS_cn0_min) - { - d_carrier_lock_fail_counter++; - } - else - { - if (d_carrier_lock_fail_counter > 0) d_carrier_lock_fail_counter--; - } - if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail) - { - std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl; - LOG(INFO) << "Loss of lock in channel " << d_channel << "!"; - this->message_port_pub(pmt::mp("events"), pmt::from_long(3)); //3 -> loss of lock - d_carrier_lock_fail_counter = 0; - d_enable_tracking = false; // TODO: check if disabling tracking is consistent with the channel state machine - } - } - // ########### Output the tracking data to navigation and PVT ########## - current_synchro_data.Prompt_I = static_cast(d_correlator_outs[1].real()); - current_synchro_data.Prompt_Q = static_cast(d_correlator_outs[1].imag()); - current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples; - current_synchro_data.Code_phase_samples = d_rem_code_phase_samples; - 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; - current_synchro_data.Flag_valid_symbol_output = true; - current_synchro_data.correlation_length_ms = 20; - } - else - { - for (int n = 0; n < d_n_correlator_taps; n++) - { - d_correlator_outs[n] = gr_complex(0, 0); - } - current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples; - current_synchro_data.correlation_length_ms = 20; - } - //assign the GNURadio block output data - current_synchro_data.fs = d_fs_in; - *out[0] = current_synchro_data; - - if (d_dump) - { - // MULTIPLEXED FILE RECORDING - Record results to file - float prompt_I; - float prompt_Q; - float tmp_E, tmp_P, tmp_L; - double tmp_double; - prompt_I = d_correlator_outs[1].real(); - prompt_Q = d_correlator_outs[1].imag(); - tmp_E = std::abs(d_correlator_outs[0]); - tmp_P = std::abs(d_correlator_outs[1]); - tmp_L = std::abs(d_correlator_outs[2]); - try - { - // EPR - d_dump_file.write(reinterpret_cast(&tmp_E), sizeof(float)); - d_dump_file.write(reinterpret_cast(&tmp_P), sizeof(float)); - d_dump_file.write(reinterpret_cast(&tmp_L), sizeof(float)); - // PROMPT I and Q (to analyze navigation symbols) - 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)); - // accumulated carrier phase - d_dump_file.write(reinterpret_cast(&d_acc_carrier_phase_rad), sizeof(double)); - - // carrier and code frequency - d_dump_file.write(reinterpret_cast(&d_carrier_doppler_hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&d_code_freq_chips), sizeof(double)); - - //PLL commands - d_dump_file.write(reinterpret_cast(&carr_error_hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&d_carrier_doppler_hz), sizeof(double)); - - //DLL commands - d_dump_file.write(reinterpret_cast(&code_error_chips), sizeof(double)); - d_dump_file.write(reinterpret_cast(&code_error_filt_chips), sizeof(double)); - - // CN0 and carrier lock test - d_dump_file.write(reinterpret_cast(&d_CN0_SNV_dB_Hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&d_carrier_lock_test), sizeof(double)); - - // 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); - d_dump_file.write(reinterpret_cast(&tmp_double), sizeof(double)); - - // PRN - unsigned int prn_ = d_acquisition_gnss_synchro->PRN; - d_dump_file.write(reinterpret_cast(&prn_), sizeof(unsigned int)); - } - catch (std::ifstream::failure &e) - { - LOG(WARNING) << "Exception writing trk dump file " << e.what(); - } - } - consume_each(d_current_prn_length_samples); - d_sample_counter += d_current_prn_length_samples; - if (current_synchro_data.Flag_valid_symbol_output) - { - return 1; - } - else - { - return 0; - } -} - - -void gps_l2_m_dll_pll_tracking_cc::set_channel(unsigned int channel) -{ - d_channel = channel; - LOG(INFO) << "Tracking Channel set to " << d_channel; - // ############# ENABLE DATA FILE LOG ################# - if (d_dump == true) - { - if (d_dump_file.is_open() == false) - { - try - { - d_dump_filename.append(boost::lexical_cast(d_channel)); - d_dump_filename.append(".dat"); - d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); - d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary); - LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str(); - } - catch (std::ifstream::failure &e) - { - LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what(); - } - } - } -} - - -void gps_l2_m_dll_pll_tracking_cc::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro) -{ - d_acquisition_gnss_synchro = p_gnss_synchro; -} diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.h b/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.h deleted file mode 100644 index 37b49c924..000000000 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.h +++ /dev/null @@ -1,165 +0,0 @@ -/*! - * \file gps_l2_m_dll_pll_tracking_cc.h - * \brief Interface of a code DLL + carrier PLL tracking block for GPS L2C - * \author Javier Arribas, 2015. jarribas(at)cttc.es - * - * Code DLL + carrier PLL according to the algorithms described in: - * K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen, - * A Software-Defined GPS and Galileo Receiver. A Single-Frequency Approach, - * Birkhauser, 2007 - * - * ------------------------------------------------------------------------- - * - * Copyright (C) 2010-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 . - * - * ------------------------------------------------------------------------- - */ - -#ifndef GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H -#define GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H - -#include "gnss_synchro.h" -#include "tracking_2nd_DLL_filter.h" -#include "tracking_2nd_PLL_filter.h" -#include "cpu_multicorrelator.h" -#include -#include -#include -#include - -class gps_l2_m_dll_pll_tracking_cc; - -typedef boost::shared_ptr - gps_l2_m_dll_pll_tracking_cc_sptr; - -gps_l2_m_dll_pll_tracking_cc_sptr -gps_l2_m_dll_pll_make_tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips); - - -/*! - * \brief This class implements a DLL + PLL tracking loop block - */ -class gps_l2_m_dll_pll_tracking_cc : public gr::block -{ -public: - ~gps_l2_m_dll_pll_tracking_cc(); - - void set_channel(unsigned int channel); - void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro); - void start_tracking(); - - int general_work(int noutput_items, gr_vector_int& ninput_items, - gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); - - void forecast(int noutput_items, gr_vector_int& ninput_items_required); - -private: - friend gps_l2_m_dll_pll_tracking_cc_sptr - gps_l2_m_dll_pll_make_tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips); - - gps_l2_m_dll_pll_tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips); - - // tracking configuration vars - unsigned int d_vector_length; - bool d_dump; - - Gnss_Synchro* d_acquisition_gnss_synchro; - unsigned int d_channel; - long d_if_freq; - long d_fs_in; - - double d_early_late_spc_chips; - - // remaining code phase and carrier phase between tracking loops - double d_rem_code_phase_samples; - double d_rem_code_phase_chips; - double d_rem_carr_phase_rad; - - // PLL and DLL filter library - Tracking_2nd_DLL_filter d_code_loop_filter; - Tracking_2nd_PLL_filter d_carrier_loop_filter; - - // acquisition - double d_acq_code_phase_samples; - double d_acq_carrier_doppler_hz; - // correlator - int d_n_correlator_taps; - gr_complex* d_ca_code; - float* d_local_code_shift_chips; - gr_complex* d_correlator_outs; - cpu_multicorrelator multicorrelator_cpu; - - // tracking vars - double d_code_freq_chips; - double d_code_phase_step_chips; - double d_carrier_doppler_hz; - double d_carrier_phase_step_rad; - double d_acc_carrier_phase_rad; - double d_code_phase_samples; - - // PRN period in samples - int d_current_prn_length_samples; - - // processing samples counters - unsigned long int d_sample_counter; - unsigned long int d_acq_sample_stamp; - - // CN0 estimation and lock detector - int d_cn0_estimation_counter; - gr_complex* d_Prompt_buffer; - double d_carrier_lock_test; - double d_CN0_SNV_dB_Hz; - double d_carrier_lock_threshold; - int d_carrier_lock_fail_counter; - - // control vars - bool d_enable_tracking; - bool d_pull_in; - - // file dump - std::string d_dump_filename; - std::ofstream d_dump_file; - - std::map systemName; - std::string sys; - - int save_matfile(); -}; - -#endif //GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H From c1eccf1a27890aa7706c30b039e8d7065032d988 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Thu, 5 Apr 2018 21:24:01 +0200 Subject: [PATCH 09/21] Delete unused member --- src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h index 4717d0f5f..a18a82c6e 100644 --- a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h +++ b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h @@ -98,7 +98,6 @@ private: std::string role_; unsigned int in_streams_; unsigned int out_streams_; - bool unified_; }; #endif // GNSS_SDR_gps_l2_m_dll_pll_tracking_H_ From 32cfe3e228d456a97e9eafc96b668ca7f9a8cf10 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Thu, 5 Apr 2018 21:35:01 +0200 Subject: [PATCH 10/21] Use dll_pll_veml_tracking tracking block for Galileo E5a --- .../adapters/galileo_e5a_dll_pll_tracking.cc | 66 +- .../adapters/galileo_e5a_dll_pll_tracking.h | 5 +- .../tracking/gnuradio_blocks/CMakeLists.txt | 1 - .../galileo_e5a_dll_pll_tracking_cc.cc | 977 ------------------ .../galileo_e5a_dll_pll_tracking_cc.h | 207 ---- 5 files changed, 23 insertions(+), 1233 deletions(-) delete mode 100644 src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc delete mode 100644 src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.h diff --git a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc index 5a61f2007..7efce405a 100644 --- a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc @@ -56,7 +56,6 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking( int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 12000000); int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); bool dump = configuration->property(role + ".dump", false); - unified_ = configuration->property(role + ".unified", false); float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 20.0); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast(FLAGS_pll_bw_hz); float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 20.0); @@ -89,29 +88,18 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking( if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); - if (unified_) - { - char sig_[3] = "5X"; - item_size_ = sizeof(gr_complex); - tracking_unified_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, - pll_bw_narrow_hz, dll_bw_narrow_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_narrow_chips, - early_late_space_narrow_chips, - extend_correlation_symbols, - track_pilot, 'E', sig_); - } - else - { - tracking_ = galileo_e5a_dll_pll_make_tracking_cc( - 0, fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, pll_bw_narrow_hz, - dll_bw_narrow_hz, ti_ms, - early_late_space_chips); - } + char sig_[3] = "5X"; + item_size_ = sizeof(gr_complex); + tracking_ = dll_pll_veml_make_tracking( + fs_in, vector_length, dump, dump_filename, + pll_bw_hz, dll_bw_hz, + pll_bw_narrow_hz, dll_bw_narrow_hz, + early_late_space_chips, + early_late_space_chips, + early_late_space_narrow_chips, + early_late_space_narrow_chips, + extend_correlation_symbols, + track_pilot, 'E', sig_); } else { @@ -130,33 +118,26 @@ GalileoE5aDllPllTracking::~GalileoE5aDllPllTracking() void GalileoE5aDllPllTracking::start_tracking() { - if (unified_) - tracking_unified_->start_tracking(); - else - tracking_->start_tracking(); + tracking_->start_tracking(); } + /* * Set tracking channel unique ID */ void GalileoE5aDllPllTracking::set_channel(unsigned int channel) { channel_ = channel; - if (unified_) - tracking_unified_->set_channel(channel); - else - tracking_->set_channel(channel); + tracking_->set_channel(channel); } void GalileoE5aDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) { - if (unified_) - tracking_unified_->set_gnss_synchro(p_gnss_synchro); - else - tracking_->set_gnss_synchro(p_gnss_synchro); + tracking_->set_gnss_synchro(p_gnss_synchro); } + void GalileoE5aDllPllTracking::connect(gr::top_block_sptr top_block) { if (top_block) @@ -165,6 +146,7 @@ void GalileoE5aDllPllTracking::connect(gr::top_block_sptr top_block) //nothing to connect, now the tracking uses gr_sync_decimator } + void GalileoE5aDllPllTracking::disconnect(gr::top_block_sptr top_block) { if (top_block) @@ -173,18 +155,14 @@ void GalileoE5aDllPllTracking::disconnect(gr::top_block_sptr top_block) //nothing to disconnect, now the tracking uses gr_sync_decimator } + gr::basic_block_sptr GalileoE5aDllPllTracking::get_left_block() { - if (unified_) - return tracking_unified_; - else - return tracking_; + return tracking_; } + gr::basic_block_sptr GalileoE5aDllPllTracking::get_right_block() { - if (unified_) - return tracking_unified_; - else - return tracking_; + return tracking_; } diff --git a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.h b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.h index 69d5600e4..7f7767784 100644 --- a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.h +++ b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.h @@ -40,7 +40,6 @@ #define GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_H_ #include "tracking_interface.h" -#include "galileo_e5a_dll_pll_tracking_cc.h" #include "dll_pll_veml_tracking.h" #include @@ -94,14 +93,12 @@ public: void start_tracking() override; private: - galileo_e5a_dll_pll_tracking_cc_sptr tracking_; - dll_pll_veml_tracking_sptr tracking_unified_; + dll_pll_veml_tracking_sptr tracking_; size_t item_size_; unsigned int channel_; std::string role_; unsigned int in_streams_; unsigned int out_streams_; - bool unified_; }; #endif /* GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_H_ */ diff --git a/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt b/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt index c30beee68..4ab29bc5d 100644 --- a/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt +++ b/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt @@ -29,7 +29,6 @@ endif(ENABLE_FPGA) set(TRACKING_GR_BLOCKS_SOURCES galileo_e1_tcp_connector_tracking_cc.cc gps_l1_ca_tcp_connector_tracking_cc.cc - galileo_e5a_dll_pll_tracking_cc.cc gps_l5i_dll_pll_tracking_cc.cc gps_l1_ca_dll_pll_c_aid_tracking_cc.cc gps_l1_ca_dll_pll_c_aid_tracking_sc.cc 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 deleted file mode 100644 index b1ab64db2..000000000 --- a/src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc +++ /dev/null @@ -1,977 +0,0 @@ -/*! - * \file galileo_e5a_dll_pll_tracking_cc.h - * \brief Implementation of a code DLL + carrier PLL - * tracking block for Galileo E5a signals - * \author Marc Sales, 2014. marcsales92(at)gmail.com - * \based on work from: - *
    - *
  • Javier Arribas, 2011. jarribas(at)cttc.es - *
  • Luis Esteve, 2012. luis(at)epsilon-formacion.com - *
- * - * ------------------------------------------------------------------------- - * - * Copyright (C) 2010-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 "galileo_e5a_dll_pll_tracking_cc.h" -#include "galileo_e5_signal_processing.h" -#include "tracking_discriminators.h" -#include "lock_detectors.h" -#include "Galileo_E5a.h" -#include "Galileo_E1.h" -#include "control_message_factory.h" -#include "gnss_sdr_flags.h" -#include -#include -#include -#include -#include -#include -#include -#include - - -using google::LogMessage; - -galileo_e5a_dll_pll_tracking_cc_sptr -galileo_e5a_dll_pll_make_tracking_cc( - long if_freq, - long fs_in, - unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float pll_bw_narrow_hz, - float dll_bw_narrow_hz, - int ti_ms, - float early_late_space_chips) -{ - return galileo_e5a_dll_pll_tracking_cc_sptr(new Galileo_E5a_Dll_Pll_Tracking_cc(if_freq, - fs_in, vector_length, dump, dump_filename, pll_bw_hz, dll_bw_hz, pll_bw_narrow_hz, dll_bw_narrow_hz, ti_ms, early_late_space_chips)); -} - - -void Galileo_E5a_Dll_Pll_Tracking_cc::forecast(int noutput_items, gr_vector_int &ninput_items_required) -{ - if (noutput_items != 0) - { - ninput_items_required[0] = static_cast(d_vector_length) * 2; //set the required available samples in each call - } -} - - -Galileo_E5a_Dll_Pll_Tracking_cc::Galileo_E5a_Dll_Pll_Tracking_cc( - long if_freq, - long fs_in, - unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float pll_bw_narrow_hz, - float dll_bw_narrow_hz, - int ti_ms, - float early_late_space_chips) : gr::block("Galileo_E5a_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)), - gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) -{ - // Telemetry bit synchronization message port input - this->message_port_register_in(pmt::mp("preamble_timestamp_s")); - this->message_port_register_out(pmt::mp("events")); - this->set_relative_rate(1.0 / vector_length); - // initialize internal vars - d_dump = dump; - d_if_freq = if_freq; - d_fs_in = fs_in; - d_vector_length = vector_length; - d_dump_filename = dump_filename; - d_code_loop_filter = Tracking_2nd_DLL_filter(GALILEO_E5a_CODE_PERIOD); - d_carrier_loop_filter = Tracking_2nd_PLL_filter(GALILEO_E5a_CODE_PERIOD); - d_current_ti_ms = 1; // initializes with 1ms of integration time until secondary code lock - d_ti_ms = ti_ms; - d_dll_bw_hz = dll_bw_hz; - d_pll_bw_hz = pll_bw_hz; - d_dll_bw_narrow_hz = dll_bw_narrow_hz; - d_pll_bw_narrow_hz = pll_bw_narrow_hz; - - // Initialize tracking ========================================== - d_code_loop_filter.set_DLL_BW(d_dll_bw_hz); - d_carrier_loop_filter.set_PLL_BW(d_pll_bw_hz); - - //--- DLL variables -------------------------------------------------------- - d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips) - - // Initialization of local code replica - // Get space for a vector with the E5a primary code replicas sampled 1x/chip - d_codeQ = static_cast(volk_gnsssdr_malloc(Galileo_E5a_CODE_LENGTH_CHIPS * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - d_codeI = static_cast(volk_gnsssdr_malloc(Galileo_E5a_CODE_LENGTH_CHIPS * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - - // correlator Q outputs (scalar) - d_n_correlator_taps = 3; // Early, Prompt, Late - d_correlator_outs = static_cast(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - for (int n = 0; n < d_n_correlator_taps; n++) - { - d_correlator_outs[n] = gr_complex(0, 0); - } - - // map memory pointers of correlator outputs - d_Single_Early = &d_correlator_outs[0]; - d_Single_Prompt = &d_correlator_outs[1]; - d_Single_Late = &d_correlator_outs[2]; - - d_local_code_shift_chips = static_cast(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment())); - // Set TAPs delay values [chips] - d_local_code_shift_chips[0] = -d_early_late_spc_chips; - d_local_code_shift_chips[1] = 0.0; - d_local_code_shift_chips[2] = d_early_late_spc_chips; - - multicorrelator_cpu_Q.init(2 * d_vector_length, d_n_correlator_taps); - - // correlator I single output for data (scalar) - d_Single_Prompt_data = static_cast(volk_gnsssdr_malloc(sizeof(gr_complex), volk_gnsssdr_get_alignment())); - *d_Single_Prompt_data = gr_complex(0, 0); - multicorrelator_cpu_I.init(2 * d_vector_length, 1); // single correlator for data channel - - //--- Perform initializations ------------------------------ - // define initial code frequency basis of NCO - d_code_freq_chips = Galileo_E5a_CODE_CHIP_RATE_HZ; - // define residual code phase (in chips) - d_rem_code_phase_samples = 0.0; - // define residual carrier phase - d_rem_carr_phase_rad = 0.0; - //Filter error vars - d_code_error_filt_secs = 0.0; - // sample synchronization - d_sample_counter = 0; - d_acq_sample_stamp = 0; - d_first_transition = false; - - d_secondary_lock = false; - d_secondary_delay = 0; - d_integration_counter = 0; - - d_current_prn_length_samples = static_cast(d_vector_length); - - // CN0 estimation and lock detector buffers - d_cn0_estimation_counter = 0; - d_Prompt_buffer = new gr_complex[static_cast(FLAGS_cn0_samples)]; - d_carrier_lock_test = 1; - d_CN0_SNV_dB_Hz = 0; - d_carrier_lock_fail_counter = 0; - d_carrier_lock_threshold = FLAGS_carrier_lock_th; - - d_acquisition_gnss_synchro = 0; - d_channel = 0; - tmp_E = 0; - tmp_P = 0; - tmp_L = 0; - d_acq_code_phase_samples = 0; - d_acq_carrier_doppler_hz = 0; - d_carrier_doppler_hz = 0; - d_acc_carrier_phase_rad = 0; - d_code_phase_samples = 0; - d_acc_code_phase_secs = 0; - d_state = 0; - - d_rem_code_phase_chips = 0.0; - d_code_phase_step_chips = 0.0; - d_carrier_phase_step_rad = 0.0; - - systemName["E"] = std::string("Galileo"); -} - - -Galileo_E5a_Dll_Pll_Tracking_cc::~Galileo_E5a_Dll_Pll_Tracking_cc() -{ - if (d_dump_file.is_open()) - { - try - { - d_dump_file.close(); - } - catch (const std::exception &ex) - { - LOG(WARNING) << "Exception in destructor " << ex.what(); - } - } - - if (d_dump) - { - if (d_channel == 0) - { - std::cout << "Writing .mat files ..."; - } - Galileo_E5a_Dll_Pll_Tracking_cc::save_matfile(); - if (d_channel == 0) - { - std::cout << " done." << std::endl; - } - } - - try - { - delete[] d_codeI; - delete[] d_codeQ; - delete[] d_Prompt_buffer; - volk_gnsssdr_free(d_local_code_shift_chips); - volk_gnsssdr_free(d_correlator_outs); - volk_gnsssdr_free(d_Single_Prompt_data); - multicorrelator_cpu_Q.free(); - multicorrelator_cpu_I.free(); - } - catch (const std::exception &ex) - { - LOG(WARNING) << "Exception in destructor " << ex.what(); - } -} - - -void Galileo_E5a_Dll_Pll_Tracking_cc::start_tracking() -{ - /* - * correct the code phase according to the delay between acq and trk - */ - d_acq_code_phase_samples = d_acquisition_gnss_synchro->Acq_delay_samples; - d_acq_carrier_doppler_hz = d_acquisition_gnss_synchro->Acq_doppler_hz; - d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples; - - long int acq_trk_diff_samples; - double acq_trk_diff_seconds; - acq_trk_diff_samples = static_cast(d_sample_counter) - static_cast(d_acq_sample_stamp); //-d_vector_length; - LOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples; - acq_trk_diff_seconds = static_cast(acq_trk_diff_samples) / static_cast(d_fs_in); - //doppler effect - // Fd=(C/(C+Vr))*F - double radial_velocity; - radial_velocity = (Galileo_E5a_FREQ_HZ + d_acq_carrier_doppler_hz) / Galileo_E5a_FREQ_HZ; - // new chip and prn sequence periods based on acq Doppler - double T_chip_mod_seconds; - double T_prn_mod_seconds; - double T_prn_mod_samples; - d_code_freq_chips = radial_velocity * Galileo_E5a_CODE_CHIP_RATE_HZ; - T_chip_mod_seconds = 1 / d_code_freq_chips; - T_prn_mod_seconds = T_chip_mod_seconds * Galileo_E5a_CODE_LENGTH_CHIPS; - T_prn_mod_samples = T_prn_mod_seconds * static_cast(d_fs_in); - - d_current_prn_length_samples = round(T_prn_mod_samples); - - double T_prn_true_seconds = Galileo_E5a_CODE_LENGTH_CHIPS / Galileo_E5a_CODE_CHIP_RATE_HZ; - double T_prn_true_samples = T_prn_true_seconds * static_cast(d_fs_in); - double T_prn_diff_seconds; - T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds; - double N_prn_diff; - N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds; - double corrected_acq_phase_samples, delay_correction_samples; - corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * static_cast(d_fs_in)), T_prn_true_samples); - if (corrected_acq_phase_samples < 0) - { - corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples; - } - delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples; - - d_acq_code_phase_samples = corrected_acq_phase_samples; - - d_carrier_doppler_hz = d_acq_carrier_doppler_hz; - - // DLL/PLL filter initialization - d_carrier_loop_filter.initialize(); // initialize the carrier filter - d_code_loop_filter.initialize(); // initialize the code filter - - // generate local reference ALWAYS starting at chip 1 (1 sample per chip) - char sig[3]; - strcpy(sig, "5Q"); - galileo_e5_a_code_gen_complex_primary(d_codeQ, d_acquisition_gnss_synchro->PRN, sig); - - strcpy(sig, "5I"); - galileo_e5_a_code_gen_complex_primary(d_codeI, d_acquisition_gnss_synchro->PRN, sig); - - d_carrier_lock_fail_counter = 0; - d_rem_code_phase_samples = 0; - d_rem_carr_phase_rad = 0; - d_acc_carrier_phase_rad = 0; - d_acc_code_phase_secs = 0; - - d_code_phase_samples = d_acq_code_phase_samples; - - std::string sys_ = &d_acquisition_gnss_synchro->System; - sys = sys_.substr(0, 1); - - // DEBUG OUTPUT - std::cout << "Tracking of Galileo E5a signal started on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl; - LOG(INFO) << "Galileo E5a starting tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel; - - // enable tracking - d_state = 1; - - 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; -} - - -void Galileo_E5a_Dll_Pll_Tracking_cc::acquire_secondary() -{ - // 1. Transform replica to 1 and -1 - int sec_code_signed[Galileo_E5a_Q_SECONDARY_CODE_LENGTH]; - for (unsigned int i = 0; i < Galileo_E5a_Q_SECONDARY_CODE_LENGTH; i++) - { - if (Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1].at(i) == '0') - { - sec_code_signed[i] = 1; - } - else - { - sec_code_signed[i] = -1; - } - } - // 2. Transform buffer to 1 and -1 - int in_corr[static_cast(FLAGS_cn0_samples)]; - for (unsigned int i = 0; i < static_cast(FLAGS_cn0_samples); i++) - { - if (d_Prompt_buffer[i].real() > 0) - { - in_corr[i] = 1; - } - else - { - in_corr[i] = -1; - } - } - // 3. Serial search - int out_corr; - int current_best_ = 0; - for (unsigned int i = 0; i < Galileo_E5a_Q_SECONDARY_CODE_LENGTH; i++) - { - out_corr = 0; - for (unsigned int j = 0; j < static_cast(FLAGS_cn0_samples); j++) - { - //reverse replica sign since i*i=-1 (conjugated complex) - out_corr += in_corr[j] * -sec_code_signed[(j + i) % Galileo_E5a_Q_SECONDARY_CODE_LENGTH]; - } - if (abs(out_corr) > current_best_) - { - current_best_ = abs(out_corr); - d_secondary_delay = i; - } - } - if (current_best_ == FLAGS_cn0_samples) // all bits correlate - { - d_secondary_lock = true; - d_secondary_delay = (d_secondary_delay + static_cast(FLAGS_cn0_samples) - 1) % Galileo_E5a_Q_SECONDARY_CODE_LENGTH; - } -} - - -int Galileo_E5a_Dll_Pll_Tracking_cc::general_work(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items __attribute__((unused)), - gr_vector_const_void_star &input_items, gr_vector_void_star &output_items) -{ - // process vars - double carr_error_hz; - double carr_error_filt_hz; - double code_error_chips; - double code_error_filt_chips; - - // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder - Gnss_Synchro **out = reinterpret_cast(&output_items[0]); //block output streams pointer - - // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder - Gnss_Synchro current_synchro_data; - // Fill the acquisition data - current_synchro_data = *d_acquisition_gnss_synchro; - - /* States: 0 Tracking not enabled - * 1 Pull-in of primary code (alignment). - * 3 Tracking algorithm. Correlates EPL each loop and accumulates the result - * until it reaches integration time. - */ - switch (d_state) - { - case 0: - { - d_Early = gr_complex(0, 0); - d_Prompt = gr_complex(0, 0); - d_Late = gr_complex(0, 0); - d_Prompt_data = gr_complex(0, 0); - current_synchro_data.Tracking_sample_counter = d_sample_counter; - break; - } - case 1: - { - int samples_offset; - double acq_trk_shif_correction_samples; - int acq_to_trk_delay_samples; - acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp; - acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast(acq_to_trk_delay_samples), static_cast(d_current_prn_length_samples)); - samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples); - d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples - DLOG(INFO) << " samples_offset=" << samples_offset; - d_state = 2; // start in Ti = 1 code, until secondary code lock. - - // make an output to not stop the rest of the processing blocks - current_synchro_data.Prompt_I = 0.0; - current_synchro_data.Prompt_Q = 0.0; - current_synchro_data.Tracking_sample_counter = d_sample_counter; - current_synchro_data.Carrier_phase_rads = 0.0; - current_synchro_data.CN0_dB_hz = 0.0; - current_synchro_data.fs = d_fs_in; - consume_each(samples_offset); //shift input to perform alignment with local replica - return 0; - break; - } - case 2: - { - // Block input data and block output stream pointers - const gr_complex *in = reinterpret_cast(input_items[0]); //PRN start block alignment - gr_complex sec_sign_Q; - gr_complex sec_sign_I; - // Secondary code Chip - if (d_secondary_lock) - { - sec_sign_Q = gr_complex((Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1].at(d_secondary_delay) == '0' ? -1 : 1), 0); - sec_sign_I = gr_complex((Galileo_E5a_I_SECONDARY_CODE.at(d_secondary_delay % Galileo_E5a_I_SECONDARY_CODE_LENGTH) == '0' ? -1 : 1), 0); - } - else - { - sec_sign_Q = gr_complex(1.0, 0.0); - sec_sign_I = gr_complex(1.0, 0.0); - } - // Reset integration counter - if (d_integration_counter == d_current_ti_ms) - { - d_integration_counter = 0; - } - //Generate local code and carrier replicas (using \hat{f}_d(k-1)) - if (d_integration_counter == 0) - { - // Reset accumulated values - d_Early = gr_complex(0, 0); - d_Prompt = gr_complex(0, 0); - d_Late = gr_complex(0, 0); - } - - // perform carrier wipe-off and compute Early, Prompt and Late - // correlation of 1 primary code - - multicorrelator_cpu_Q.set_local_code_and_taps(Galileo_E5a_CODE_LENGTH_CHIPS, d_codeQ, d_local_code_shift_chips); - multicorrelator_cpu_I.set_local_code_and_taps(Galileo_E5a_CODE_LENGTH_CHIPS, d_codeI, &d_local_code_shift_chips[1]); - - // ################# CARRIER WIPEOFF AND CORRELATORS ############################## - // perform carrier wipe-off and compute Early, Prompt and Late correlation - multicorrelator_cpu_Q.set_input_output_vectors(d_correlator_outs, in); - multicorrelator_cpu_I.set_input_output_vectors(d_Single_Prompt_data, in); - - double carr_phase_step_rad = GALILEO_TWO_PI * d_carrier_doppler_hz / static_cast(d_fs_in); - double code_phase_step_chips = d_code_freq_chips / (static_cast(d_fs_in)); - double rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / d_fs_in); - multicorrelator_cpu_Q.Carrier_wipeoff_multicorrelator_resampler( - d_rem_carr_phase_rad, - carr_phase_step_rad, - rem_code_phase_chips, - code_phase_step_chips, - d_current_prn_length_samples); - - multicorrelator_cpu_I.Carrier_wipeoff_multicorrelator_resampler( - d_rem_carr_phase_rad, - carr_phase_step_rad, - rem_code_phase_chips, - code_phase_step_chips, - d_current_prn_length_samples); - - // Accumulate results (coherent integration since there are no bit transitions in pilot signal) - d_Early += (*d_Single_Early) * sec_sign_Q; - d_Prompt += (*d_Single_Prompt) * sec_sign_Q; - d_Late += (*d_Single_Late) * sec_sign_Q; - d_Prompt_data = (*d_Single_Prompt_data); - d_Prompt_data *= sec_sign_I; - d_integration_counter++; - - // ################## PLL ########################################################## - // PLL discriminator - if (d_integration_counter == d_current_ti_ms) - { - if (d_secondary_lock == true) - { - carr_error_hz = pll_four_quadrant_atan(d_Prompt) / GALILEO_PI * 2.0; - } - else - { - carr_error_hz = pll_cloop_two_quadrant_atan(d_Prompt) / GALILEO_PI * 2.0; - } - - // Carrier discriminator filter - 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 = Galileo_E5a_CODE_CHIP_RATE_HZ + ((d_carrier_doppler_hz * Galileo_E5a_CODE_CHIP_RATE_HZ) / Galileo_E5a_FREQ_HZ); - } - // carrier phase accumulator for (K) doppler estimation - d_acc_carrier_phase_rad -= 2.0 * GALILEO_PI * d_carrier_doppler_hz * GALILEO_E5a_CODE_PERIOD; - // remnant carrier phase to prevent overflow in the code NCO - d_rem_carr_phase_rad = d_rem_carr_phase_rad + 2.0 * GALILEO_PI * d_carrier_doppler_hz * GALILEO_E5a_CODE_PERIOD; - d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, 2.0 * GALILEO_PI); - - // ################## DLL ########################################################## - if (d_integration_counter == d_current_ti_ms) - { - // DLL discriminator - code_error_chips = dll_nc_e_minus_l_normalized(d_Early, d_Late); //[chips/Ti] - // Code discriminator filter - code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips); //[chips/second] - //Code phase accumulator - d_code_error_filt_secs = (GALILEO_E5a_CODE_PERIOD * code_error_filt_chips) / Galileo_E5a_CODE_CHIP_RATE_HZ; //[seconds] - } - d_acc_code_phase_secs = d_acc_code_phase_secs + d_code_error_filt_secs; - - // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT ####################### - // keep alignment parameters for the next input buffer - double T_chip_seconds; - double T_prn_seconds; - double T_prn_samples; - double K_blk_samples; - // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation - T_chip_seconds = 1.0 / d_code_freq_chips; - T_prn_seconds = T_chip_seconds * Galileo_E5a_CODE_LENGTH_CHIPS; - T_prn_samples = T_prn_seconds * static_cast(d_fs_in); - K_blk_samples = T_prn_samples + d_rem_code_phase_samples + d_code_error_filt_secs * static_cast(d_fs_in); - d_current_prn_length_samples = round(K_blk_samples); //round to a discrete samples - d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample - - // ####### CN0 ESTIMATION AND LOCK DETECTORS ###### - if (d_cn0_estimation_counter < FLAGS_cn0_samples - 1) - { - // fill buffer with prompt correlator output values - d_Prompt_buffer[d_cn0_estimation_counter] = d_Prompt; - d_cn0_estimation_counter++; - } - else - { - d_Prompt_buffer[d_cn0_estimation_counter] = d_Prompt; - // ATTEMPT SECONDARY CODE ACQUISITION - if (d_secondary_lock == false) - { - acquire_secondary(); // changes d_secondary_lock and d_secondary_delay - if (d_secondary_lock == true) - { - std::cout << "Galileo E5a secondary code locked for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl; - d_current_ti_ms = d_ti_ms; - // Change loop parameters ========================================== - d_code_loop_filter.set_pdi(d_current_ti_ms * GALILEO_E5a_CODE_PERIOD); - d_carrier_loop_filter.set_pdi(d_current_ti_ms * GALILEO_E5a_CODE_PERIOD); - d_code_loop_filter.set_DLL_BW(d_dll_bw_narrow_hz); - d_carrier_loop_filter.set_PLL_BW(d_pll_bw_narrow_hz); - } - else - { - //std::cout << "Secondary code delay couldn't be resolved." << std::endl; - d_carrier_lock_fail_counter++; - if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail) - { - std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl; - LOG(INFO) << "Loss of lock in channel " << d_channel << "!"; - this->message_port_pub(pmt::mp("events"), pmt::from_long(3)); //3 -> loss of lock - d_carrier_lock_fail_counter = 0; - d_state = 0; // TODO: check if disabling tracking is consistent with the channel state machine - } - } - } - else // Secondary lock achieved, monitor carrier lock. - { - // Code lock indicator - d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, static_cast(FLAGS_cn0_samples), d_fs_in, d_current_ti_ms * Galileo_E5a_CODE_LENGTH_CHIPS); - // Carrier lock indicator - d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, static_cast(FLAGS_cn0_samples)); - // Loss of lock detection - if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < FLAGS_cn0_min) - { - d_carrier_lock_fail_counter++; - } - else - { - if (d_carrier_lock_fail_counter > 0) d_carrier_lock_fail_counter--; - - if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail) - { - std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl; - LOG(INFO) << "Loss of lock in channel " << d_channel << "!"; - this->message_port_pub(pmt::mp("events"), pmt::from_long(3)); //3 -> loss of lock - d_carrier_lock_fail_counter = 0; - d_state = 0; - } - } - } - d_cn0_estimation_counter = 0; - } - if (d_secondary_lock && (d_secondary_delay % Galileo_E5a_I_SECONDARY_CODE_LENGTH) == 0) - { - d_first_transition = true; - } - // ########### Output the tracking data to navigation and PVT ########## - // The first Prompt output not equal to 0 is synchronized with the transition of a navigation data bit. - if (d_secondary_lock && d_first_transition) - { - current_synchro_data.Prompt_I = static_cast(d_Prompt_data.real()); - current_synchro_data.Prompt_Q = static_cast(d_Prompt_data.imag()); - current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples; - current_synchro_data.Code_phase_samples = d_rem_code_phase_samples; - 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; - current_synchro_data.Flag_valid_symbol_output = true; - } - else - { - // make an output to not stop the rest of the processing blocks - current_synchro_data.Prompt_I = 0.0; - current_synchro_data.Prompt_Q = 0.0; - current_synchro_data.Tracking_sample_counter = d_sample_counter; - current_synchro_data.Carrier_phase_rads = 0.0; - current_synchro_data.CN0_dB_hz = 0.0; - current_synchro_data.Flag_valid_symbol_output = false; - } - - break; - } - } - - current_synchro_data.fs = d_fs_in; - current_synchro_data.correlation_length_ms = GALILEO_E5a_CODE_PERIOD_MS; - if (current_synchro_data.Flag_valid_symbol_output) - { - *out[0] = current_synchro_data; - } - - if (d_dump) - { - // MULTIPLEXED FILE RECORDING - Record results to file - float prompt_I; - float prompt_Q; - double tmp_double; - prompt_I = (d_Prompt_data).real(); - prompt_Q = (d_Prompt_data).imag(); - if (d_integration_counter == d_current_ti_ms) - { - tmp_E = std::abs(d_Early); - tmp_P = std::abs(d_Prompt); - tmp_L = std::abs(d_Late); - } - try - { - // EPR - d_dump_file.write(reinterpret_cast(&tmp_E), sizeof(float)); - d_dump_file.write(reinterpret_cast(&tmp_P), sizeof(float)); - d_dump_file.write(reinterpret_cast(&tmp_L), sizeof(float)); - // PROMPT I and Q (to analyze navigation symbols) - 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)); - // accumulated carrier phase - d_dump_file.write(reinterpret_cast(&d_acc_carrier_phase_rad), sizeof(double)); - - // carrier and code frequency - d_dump_file.write(reinterpret_cast(&d_carrier_doppler_hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&d_code_freq_chips), sizeof(double)); - - //PLL commands - d_dump_file.write(reinterpret_cast(&carr_error_hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&carr_error_filt_hz), sizeof(double)); - - //DLL commands - d_dump_file.write(reinterpret_cast(&code_error_chips), sizeof(double)); - d_dump_file.write(reinterpret_cast(&code_error_filt_chips), sizeof(double)); - - // CN0 and carrier lock test - d_dump_file.write(reinterpret_cast(&d_CN0_SNV_dB_Hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&d_carrier_lock_test), sizeof(double)); - - // 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); - d_dump_file.write(reinterpret_cast(&tmp_double), sizeof(double)); - - // PRN - unsigned int prn_ = d_acquisition_gnss_synchro->PRN; - d_dump_file.write(reinterpret_cast(&prn_), sizeof(unsigned int)); - } - catch (const std::ifstream::failure &e) - { - LOG(WARNING) << "Exception writing trk dump file " << e.what(); - } - } - - d_secondary_delay = (d_secondary_delay + 1) % Galileo_E5a_Q_SECONDARY_CODE_LENGTH; - d_sample_counter += d_current_prn_length_samples; - consume_each(d_current_prn_length_samples); - - if (current_synchro_data.Flag_valid_symbol_output) - { - return 1; - } - else - { - return 0; - } -} - - -void Galileo_E5a_Dll_Pll_Tracking_cc::set_channel(unsigned int channel) -{ - d_channel = channel; - LOG(INFO) << "Tracking Channel set to " << d_channel; - // ############# ENABLE DATA FILE LOG ################# - if (d_dump == true) - { - if (d_dump_file.is_open() == false) - { - try - { - d_dump_filename.append(boost::lexical_cast(d_channel)); - d_dump_filename.append(".dat"); - d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); - d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary); - LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str(); - } - catch (const std::ifstream::failure &e) - { - LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what(); - } - } - } -} - - -int Galileo_E5a_Dll_Pll_Tracking_cc::save_matfile() -{ - // READ DUMP FILE - std::ifstream::pos_type size; - int number_of_double_vars = 11; - int number_of_float_vars = 5; - int epoch_size_bytes = sizeof(unsigned long int) + sizeof(double) * number_of_double_vars + - sizeof(float) * number_of_float_vars + sizeof(unsigned int); - std::ifstream dump_file; - dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); - try - { - dump_file.open(d_dump_filename.c_str(), std::ios::binary | std::ios::ate); - } - catch (const std::ifstream::failure &e) - { - std::cerr << "Problem opening dump file:" << e.what() << std::endl; - return 1; - } - // count number of epochs and rewind - long int num_epoch = 0; - if (dump_file.is_open()) - { - size = dump_file.tellg(); - num_epoch = static_cast(size) / static_cast(epoch_size_bytes); - dump_file.seekg(0, std::ios::beg); - } - else - { - return 1; - } - float *abs_E = new float[num_epoch]; - float *abs_P = new float[num_epoch]; - float *abs_L = new float[num_epoch]; - float *Prompt_I = new float[num_epoch]; - float *Prompt_Q = new float[num_epoch]; - unsigned long int *PRN_start_sample_count = new unsigned long int[num_epoch]; - double *acc_carrier_phase_rad = new double[num_epoch]; - double *carrier_doppler_hz = new double[num_epoch]; - double *code_freq_chips = new double[num_epoch]; - double *carr_error_hz = new double[num_epoch]; - double *carr_error_filt_hz = new double[num_epoch]; - double *code_error_chips = new double[num_epoch]; - double *code_error_filt_chips = new double[num_epoch]; - double *CN0_SNV_dB_Hz = new double[num_epoch]; - double *carrier_lock_test = new double[num_epoch]; - double *aux1 = new double[num_epoch]; - double *aux2 = new double[num_epoch]; - unsigned int *PRN = new unsigned int[num_epoch]; - - try - { - if (dump_file.is_open()) - { - for (long int i = 0; i < num_epoch; i++) - { - dump_file.read(reinterpret_cast(&abs_E[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&abs_P[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&abs_L[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&Prompt_I[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&Prompt_Q[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&PRN_start_sample_count[i]), sizeof(unsigned long int)); - dump_file.read(reinterpret_cast(&acc_carrier_phase_rad[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carrier_doppler_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_freq_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carr_error_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carr_error_filt_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_error_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_error_filt_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&CN0_SNV_dB_Hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carrier_lock_test[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&aux1[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&aux2[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&PRN[i]), sizeof(unsigned int)); - } - } - dump_file.close(); - } - catch (const std::ifstream::failure &e) - { - std::cerr << "Problem reading dump file:" << e.what() << std::endl; - delete[] abs_E; - delete[] abs_P; - delete[] abs_L; - delete[] Prompt_I; - delete[] Prompt_Q; - delete[] PRN_start_sample_count; - delete[] acc_carrier_phase_rad; - delete[] carrier_doppler_hz; - delete[] code_freq_chips; - delete[] carr_error_hz; - delete[] carr_error_filt_hz; - delete[] code_error_chips; - delete[] code_error_filt_chips; - delete[] CN0_SNV_dB_Hz; - delete[] carrier_lock_test; - delete[] aux1; - delete[] aux2; - delete[] PRN; - return 1; - } - - // WRITE MAT FILE - mat_t *matfp; - matvar_t *matvar; - std::string filename = d_dump_filename; - filename.erase(filename.length() - 4, 4); - filename.append(".mat"); - matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73); - if (reinterpret_cast(matfp) != NULL) - { - size_t dims[2] = {1, static_cast(num_epoch)}; - matvar = Mat_VarCreate("abs_E", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("abs_P", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_P, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("abs_L", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_L, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("Prompt_I", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_I, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("Prompt_Q", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_Q, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("PRN_start_sample_count", MAT_C_UINT64, MAT_T_UINT64, 2, dims, PRN_start_sample_count, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("acc_carrier_phase_rad", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, acc_carrier_phase_rad, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carrier_doppler_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_doppler_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_freq_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_freq_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carr_error_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carr_error_filt_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_filt_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_error_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_error_filt_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_filt_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("CN0_SNV_dB_Hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, CN0_SNV_dB_Hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carrier_lock_test", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_lock_test, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("aux1", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux1, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("aux2", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux2, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("PRN", MAT_C_UINT32, MAT_T_UINT32, 2, dims, PRN, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - } - Mat_Close(matfp); - delete[] abs_E; - delete[] abs_P; - delete[] abs_L; - delete[] Prompt_I; - delete[] Prompt_Q; - delete[] PRN_start_sample_count; - delete[] acc_carrier_phase_rad; - delete[] carrier_doppler_hz; - delete[] code_freq_chips; - delete[] carr_error_hz; - delete[] carr_error_filt_hz; - delete[] code_error_chips; - delete[] code_error_filt_chips; - delete[] CN0_SNV_dB_Hz; - delete[] carrier_lock_test; - delete[] aux1; - delete[] aux2; - delete[] PRN; - return 0; -} - - -void Galileo_E5a_Dll_Pll_Tracking_cc::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro) -{ - d_acquisition_gnss_synchro = p_gnss_synchro; -} diff --git a/src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.h b/src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.h deleted file mode 100644 index af9ea31fb..000000000 --- a/src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.h +++ /dev/null @@ -1,207 +0,0 @@ -/*! - * \file galileo_e5a_dll_pll_tracking_cc.h - * \brief Implementation of a code DLL + carrier PLL - * tracking block for Galileo E5a signals - * \author Marc Sales, 2014. marcsales92(at)gmail.com - * \based on work from: - *
    - *
  • Javier Arribas, 2011. jarribas(at)cttc.es - *
  • Luis Esteve, 2012. luis(at)epsilon-formacion.com - *
- * - * ------------------------------------------------------------------------- - * - * Copyright (C) 2010-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 . - * - * ------------------------------------------------------------------------- - */ - -#ifndef GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_CC_H_ -#define GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_CC_H_ - -#include "gnss_synchro.h" -#include "tracking_2nd_DLL_filter.h" -#include "tracking_2nd_PLL_filter.h" -#include "cpu_multicorrelator.h" -#include -#include -#include -#include - -class Galileo_E5a_Dll_Pll_Tracking_cc; - -typedef boost::shared_ptr - galileo_e5a_dll_pll_tracking_cc_sptr; - -galileo_e5a_dll_pll_tracking_cc_sptr -galileo_e5a_dll_pll_make_tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float pll_bw_narrow_narrowhz, - float dll_bw_narrow_hz, - int ti_ms, - float early_late_space_chips); - - -/*! - * \brief This class implements a DLL + PLL tracking loop block - */ -class Galileo_E5a_Dll_Pll_Tracking_cc : public gr::block -{ -public: - ~Galileo_E5a_Dll_Pll_Tracking_cc(); - - void set_channel(unsigned int channel); - void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro); - void start_tracking(); - - int general_work(int noutput_items, gr_vector_int& ninput_items, - gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); - - void forecast(int noutput_items, gr_vector_int& ninput_items_required); - -private: - friend galileo_e5a_dll_pll_tracking_cc_sptr - galileo_e5a_dll_pll_make_tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float pll_bw_narrow_hz, - float dll_bw_narrow_hz, - int ti_ms, - float early_late_space_chips); - - Galileo_E5a_Dll_Pll_Tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float pll_bw_narrow_hz, - float dll_bw_narrow_hz, - int ti_ms, - float early_late_space_chips); - void acquire_secondary(); - // tracking configuration vars - unsigned int d_vector_length; - int d_current_ti_ms; - int d_ti_ms; - bool d_dump; - - - Gnss_Synchro* d_acquisition_gnss_synchro; - unsigned int d_channel; - long d_if_freq; - long d_fs_in; - - double d_early_late_spc_chips; - double d_dll_bw_hz; - double d_pll_bw_hz; - double d_dll_bw_narrow_hz; - double d_pll_bw_narrow_hz; - - gr_complex* d_codeQ; - gr_complex* d_codeI; - - gr_complex d_Early; - gr_complex d_Prompt; - gr_complex d_Late; - gr_complex d_Prompt_data; - - gr_complex* d_Single_Early; - gr_complex* d_Single_Prompt; - gr_complex* d_Single_Late; - gr_complex* d_Single_Prompt_data; - - - float tmp_E; - float tmp_P; - float tmp_L; - // remaining code phase and carrier phase between tracking loops - double d_rem_code_phase_samples; - double d_rem_code_phase_chips; - double d_rem_carr_phase_rad; - - // PLL and DLL filter library - Tracking_2nd_DLL_filter d_code_loop_filter; - Tracking_2nd_PLL_filter d_carrier_loop_filter; - - // acquisition - double d_acq_code_phase_samples; - double d_acq_carrier_doppler_hz; - // correlator - int d_n_correlator_taps; - float* d_local_code_shift_chips; - gr_complex* d_correlator_outs; - cpu_multicorrelator multicorrelator_cpu_I; - cpu_multicorrelator multicorrelator_cpu_Q; - - // tracking vars - double d_code_freq_chips; - double d_carrier_doppler_hz; - double d_acc_carrier_phase_rad; - double d_code_phase_samples; - double d_acc_code_phase_secs; - double d_code_error_filt_secs; - double d_code_phase_step_chips; - double d_carrier_phase_step_rad; - - - //PRN period in samples - int d_current_prn_length_samples; - - //processing samples counters - unsigned long int d_sample_counter; - unsigned long int d_acq_sample_stamp; - - // CN0 estimation and lock detector - int d_cn0_estimation_counter; - gr_complex* d_Prompt_buffer; - double d_carrier_lock_test; - double d_CN0_SNV_dB_Hz; - double d_carrier_lock_threshold; - int d_carrier_lock_fail_counter; - - // control vars - int d_state; - bool d_first_transition; - - // Secondary code acquisition - bool d_secondary_lock; - int d_secondary_delay; - int d_integration_counter; - - // file dump - std::string d_dump_filename; - std::ofstream d_dump_file; - - std::map systemName; - std::string sys; - - int save_matfile(); -}; - -#endif /* GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_CC_H_ */ From a31f4fc7cc9372ad4eb40aeee53d4034fadf379a Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Thu, 5 Apr 2018 21:49:32 +0200 Subject: [PATCH 11/21] Use dll_pll_veml_tracking tracking block for GPS L5 --- .../adapters/gps_l5i_dll_pll_tracking.cc | 65 +- .../adapters/gps_l5i_dll_pll_tracking.h | 5 +- .../tracking/gnuradio_blocks/CMakeLists.txt | 1 - .../gps_l5i_dll_pll_tracking_cc.cc | 762 ------------------ .../gps_l5i_dll_pll_tracking_cc.h | 165 ---- 5 files changed, 23 insertions(+), 975 deletions(-) delete mode 100644 src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.cc delete mode 100644 src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.h diff --git a/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc index d28255416..3ae4c85df 100644 --- a/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc @@ -56,7 +56,6 @@ GpsL5iDllPllTracking::GpsL5iDllPllTracking( int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); bool dump = configuration->property(role + ".dump", false); - unified_ = configuration->property(role + ".unified", false); float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast(FLAGS_pll_bw_hz); float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0); @@ -88,28 +87,18 @@ GpsL5iDllPllTracking::GpsL5iDllPllTracking( if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); - if (unified_) - { - char sig_[3] = "L5"; - item_size_ = sizeof(gr_complex); - tracking_unified_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, - pll_bw_narrow_hz, dll_bw_narrow_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_narrow_chips, - early_late_space_narrow_chips, - extend_correlation_symbols, - track_pilot, 'G', sig_); - } - else - { - tracking_ = gps_l5i_dll_pll_make_tracking_cc( - 0, fs_in, vector_length, dump, - dump_filename, pll_bw_hz, dll_bw_hz, - early_late_space_chips); - } + char sig_[3] = "L5"; + item_size_ = sizeof(gr_complex); + tracking_ = dll_pll_veml_make_tracking( + fs_in, vector_length, dump, dump_filename, + pll_bw_hz, dll_bw_hz, + pll_bw_narrow_hz, dll_bw_narrow_hz, + early_late_space_chips, + early_late_space_chips, + early_late_space_narrow_chips, + early_late_space_narrow_chips, + extend_correlation_symbols, + track_pilot, 'G', sig_); } else { @@ -128,33 +117,26 @@ GpsL5iDllPllTracking::~GpsL5iDllPllTracking() void GpsL5iDllPllTracking::start_tracking() { - if (unified_) - tracking_unified_->start_tracking(); - else - tracking_->start_tracking(); + tracking_->start_tracking(); } + /* * Set tracking channel unique ID */ void GpsL5iDllPllTracking::set_channel(unsigned int channel) { channel_ = channel; - if (unified_) - tracking_unified_->set_channel(channel); - else - tracking_->set_channel(channel); + tracking_->set_channel(channel); } void GpsL5iDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) { - if (unified_) - tracking_unified_->set_gnss_synchro(p_gnss_synchro); - else - tracking_->set_gnss_synchro(p_gnss_synchro); + tracking_->set_gnss_synchro(p_gnss_synchro); } + void GpsL5iDllPllTracking::connect(gr::top_block_sptr top_block) { if (top_block) @@ -163,6 +145,7 @@ void GpsL5iDllPllTracking::connect(gr::top_block_sptr top_block) //nothing to connect, now the tracking uses gr_sync_decimator } + void GpsL5iDllPllTracking::disconnect(gr::top_block_sptr top_block) { if (top_block) @@ -171,18 +154,14 @@ void GpsL5iDllPllTracking::disconnect(gr::top_block_sptr top_block) //nothing to disconnect, now the tracking uses gr_sync_decimator } + gr::basic_block_sptr GpsL5iDllPllTracking::get_left_block() { - if (unified_) - return tracking_unified_; - else - return tracking_; + return tracking_; } + gr::basic_block_sptr GpsL5iDllPllTracking::get_right_block() { - if (unified_) - return tracking_unified_; - else - return tracking_; + return tracking_; } diff --git a/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.h b/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.h index 472de2466..31a6d41f9 100644 --- a/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.h +++ b/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.h @@ -38,7 +38,6 @@ #define GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_H_ #include "tracking_interface.h" -#include "gps_l5i_dll_pll_tracking_cc.h" #include "dll_pll_veml_tracking.h" #include @@ -92,14 +91,12 @@ public: void start_tracking() override; private: - gps_l5i_dll_pll_tracking_cc_sptr tracking_; - dll_pll_veml_tracking_sptr tracking_unified_; + dll_pll_veml_tracking_sptr tracking_; size_t item_size_; unsigned int channel_; std::string role_; unsigned int in_streams_; unsigned int out_streams_; - bool unified_; }; #endif // GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_H_ diff --git a/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt b/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt index 4ab29bc5d..535a38663 100644 --- a/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt +++ b/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt @@ -29,7 +29,6 @@ endif(ENABLE_FPGA) set(TRACKING_GR_BLOCKS_SOURCES galileo_e1_tcp_connector_tracking_cc.cc gps_l1_ca_tcp_connector_tracking_cc.cc - gps_l5i_dll_pll_tracking_cc.cc gps_l1_ca_dll_pll_c_aid_tracking_cc.cc gps_l1_ca_dll_pll_c_aid_tracking_sc.cc glonass_l1_ca_dll_pll_tracking_cc.cc diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.cc deleted file mode 100644 index ad18db9cd..000000000 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.cc +++ /dev/null @@ -1,762 +0,0 @@ -/*! - * \file gps_l5i_dll_pll_tracking_cc.cc - * \brief Implementation of a code DLL + carrier PLL tracking block for GPS L2C - * \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com - * Javier Arribas, 2011. jarribas(at)cttc.es - * - * Code DLL + carrier PLL according to the algorithms described in: - * [1] K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen, - * A Software-Defined GPS and Galileo Receiver. A Single-Frequency - * Approach, Birkhauser, 2007 - * - * ------------------------------------------------------------------------- - * - * Copyright (C) 2010-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 "gps_l5i_dll_pll_tracking_cc.h" -#include "gps_l5_signal.h" -#include "tracking_discriminators.h" -#include "lock_detectors.h" -#include "GPS_L5.h" -#include "control_message_factory.h" -#include "gnss_sdr_flags.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -using google::LogMessage; - -gps_l5i_dll_pll_tracking_cc_sptr -gps_l5i_dll_pll_make_tracking_cc( - long if_freq, - long fs_in, - unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips) -{ - return gps_l5i_dll_pll_tracking_cc_sptr(new gps_l5i_dll_pll_tracking_cc(if_freq, - fs_in, vector_length, dump, dump_filename, pll_bw_hz, dll_bw_hz, early_late_space_chips)); -} - - -void gps_l5i_dll_pll_tracking_cc::forecast(int noutput_items, - gr_vector_int &ninput_items_required) -{ - if (noutput_items != 0) - { - ninput_items_required[0] = static_cast(d_vector_length) * 2; //set the required available samples in each call - } -} - - -gps_l5i_dll_pll_tracking_cc::gps_l5i_dll_pll_tracking_cc( - long if_freq, - long fs_in, - unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips) : gr::block("gps_l5i_dll_pll_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)), - gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) -{ - // Telemetry bit synchronization message port input - this->message_port_register_in(pmt::mp("preamble_timestamp_s")); - this->message_port_register_out(pmt::mp("events")); - // initialize internal vars - d_dump = dump; - d_if_freq = if_freq; - d_fs_in = fs_in; - d_vector_length = vector_length; - d_dump_filename = dump_filename; - - d_current_prn_length_samples = static_cast(d_vector_length); - - // DLL/PLL filter initialization - d_carrier_loop_filter = Tracking_2nd_PLL_filter(GPS_L5i_PERIOD); - d_code_loop_filter = Tracking_2nd_DLL_filter(GPS_L5i_PERIOD); - - // Initialize tracking ========================================== - d_code_loop_filter.set_DLL_BW(dll_bw_hz); - d_carrier_loop_filter.set_PLL_BW(pll_bw_hz); - - //--- DLL variables -------------------------------------------------------- - d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips) - - // Initialization of local code replica - // Get space for a vector with the C/A code replica sampled 1x/chip - d_ca_code = static_cast(volk_gnsssdr_malloc(static_cast(GPS_L5i_CODE_LENGTH_CHIPS) * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - - // correlator outputs (scalar) - d_n_correlator_taps = 3; // Early, Prompt, and Late - d_correlator_outs = static_cast(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - for (int n = 0; n < d_n_correlator_taps; n++) - { - d_correlator_outs[n] = gr_complex(0, 0); - } - d_local_code_shift_chips = static_cast(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment())); - // Set TAPs delay values [chips] - d_local_code_shift_chips[0] = -d_early_late_spc_chips; - d_local_code_shift_chips[1] = 0.0; - d_local_code_shift_chips[2] = d_early_late_spc_chips; - - multicorrelator_cpu.init(2 * d_current_prn_length_samples, d_n_correlator_taps); - - //--- Perform initializations ------------------------------ - // define initial code frequency basis of NCO - d_code_freq_chips = GPS_L5i_CODE_RATE_HZ; - // define residual code phase (in chips) - d_rem_code_phase_samples = 0.0; - // define residual carrier phase - d_rem_carr_phase_rad = 0.0; - - // sample synchronization - d_sample_counter = 0; - //d_sample_counter_seconds = 0; - d_acq_sample_stamp = 0; - - d_enable_tracking = false; - d_pull_in = false; - - // CN0 estimation and lock detector buffers - d_cn0_estimation_counter = 0; - d_Prompt_buffer = new gr_complex[FLAGS_cn0_samples]; - d_carrier_lock_test = 1; - d_CN0_SNV_dB_Hz = 0; - d_carrier_lock_fail_counter = 0; - d_carrier_lock_threshold = FLAGS_carrier_lock_th; - - systemName["G"] = std::string("GPS"); - - //set_min_output_buffer((long int)300); - - d_acquisition_gnss_synchro = 0; - d_channel = 0; - d_acq_code_phase_samples = 0.0; - d_acq_carrier_doppler_hz = 0.0; - d_carrier_doppler_hz = 0.0; - d_acc_carrier_phase_rad = 0.0; - d_code_phase_samples = 0.0; - - d_rem_code_phase_chips = 0.0; - d_code_phase_step_chips = 0.0; - d_carrier_phase_step_rad = 0.0; - - set_relative_rate(1.0 / static_cast(d_vector_length)); -} - - -void gps_l5i_dll_pll_tracking_cc::start_tracking() -{ - /* - * correct the code phase according to the delay between acq and trk - */ - d_acq_code_phase_samples = d_acquisition_gnss_synchro->Acq_delay_samples; - d_acq_carrier_doppler_hz = d_acquisition_gnss_synchro->Acq_doppler_hz; - d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples; - - long int acq_trk_diff_samples; - double acq_trk_diff_seconds; - acq_trk_diff_samples = static_cast(d_sample_counter) - static_cast(d_acq_sample_stamp); //-d_vector_length; - DLOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples; - acq_trk_diff_seconds = static_cast(acq_trk_diff_samples) / static_cast(d_fs_in); - // Doppler effect - // Fd=(C/(C+Vr))*F - double radial_velocity = (GPS_L5_FREQ_HZ + d_acq_carrier_doppler_hz) / GPS_L5_FREQ_HZ; - // new chip and prn sequence periods based on acq Doppler - double T_chip_mod_seconds; - double T_prn_mod_seconds; - double T_prn_mod_samples; - d_code_freq_chips = radial_velocity * GPS_L5i_CODE_RATE_HZ; - d_code_phase_step_chips = static_cast(d_code_freq_chips) / static_cast(d_fs_in); - T_chip_mod_seconds = 1 / d_code_freq_chips; - T_prn_mod_seconds = T_chip_mod_seconds * GPS_L5i_CODE_LENGTH_CHIPS; - T_prn_mod_samples = T_prn_mod_seconds * static_cast(d_fs_in); - - d_current_prn_length_samples = round(T_prn_mod_samples); - - double T_prn_true_seconds = GPS_L5i_CODE_LENGTH_CHIPS / GPS_L5i_CODE_RATE_HZ; - double T_prn_true_samples = T_prn_true_seconds * static_cast(d_fs_in); - double T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds; - double N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds; - double corrected_acq_phase_samples, delay_correction_samples; - corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * static_cast(d_fs_in)), T_prn_true_samples); - if (corrected_acq_phase_samples < 0) - { - corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples; - } - delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples; - - d_acq_code_phase_samples = corrected_acq_phase_samples; - - d_carrier_doppler_hz = d_acq_carrier_doppler_hz; - d_carrier_phase_step_rad = GPS_L5_TWO_PI * d_carrier_doppler_hz / static_cast(d_fs_in); - - // DLL/PLL filter initialization - d_carrier_loop_filter.initialize(); // initialize the carrier filter - d_code_loop_filter.initialize(); // initialize the code filter - - // generate local reference ALWAYS starting at chip 1 (1 sample per chip) - gps_l5i_code_gen_complex(d_ca_code, d_acquisition_gnss_synchro->PRN); - - multicorrelator_cpu.set_local_code_and_taps(static_cast(GPS_L5i_CODE_LENGTH_CHIPS), d_ca_code, d_local_code_shift_chips); - for (int n = 0; n < d_n_correlator_taps; n++) - { - d_correlator_outs[n] = gr_complex(0, 0); - } - - d_carrier_lock_fail_counter = 0; - d_rem_code_phase_samples = 0; - d_rem_carr_phase_rad = 0.0; - d_rem_code_phase_chips = 0.0; - d_acc_carrier_phase_rad = 0.0; - - d_code_phase_samples = d_acq_code_phase_samples; - - std::string sys_ = &d_acquisition_gnss_synchro->System; - sys = sys_.substr(0, 1); - - // DEBUG OUTPUT - std::cout << "Tracking of GPS L5i signal started on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl; - LOG(INFO) << "Starting GPS L5i 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; - - LOG(INFO) << "GPS L5i 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; -} - - -int gps_l5i_dll_pll_tracking_cc::save_matfile() -{ - // READ DUMP FILE - std::ifstream::pos_type size; - int number_of_double_vars = 11; - int number_of_float_vars = 5; - int epoch_size_bytes = sizeof(unsigned long int) + sizeof(double) * number_of_double_vars + - sizeof(float) * number_of_float_vars + sizeof(unsigned int); - std::ifstream dump_file; - dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); - try - { - dump_file.open(d_dump_filename.c_str(), std::ios::binary | std::ios::ate); - } - catch (const std::ifstream::failure &e) - { - std::cerr << "Problem opening dump file:" << e.what() << std::endl; - return 1; - } - // count number of epochs and rewind - long int num_epoch = 0; - if (dump_file.is_open()) - { - size = dump_file.tellg(); - num_epoch = static_cast(size) / static_cast(epoch_size_bytes); - dump_file.seekg(0, std::ios::beg); - } - else - { - return 1; - } - float *abs_E = new float[num_epoch]; - float *abs_P = new float[num_epoch]; - float *abs_L = new float[num_epoch]; - float *Prompt_I = new float[num_epoch]; - float *Prompt_Q = new float[num_epoch]; - unsigned long int *PRN_start_sample_count = new unsigned long int[num_epoch]; - double *acc_carrier_phase_rad = new double[num_epoch]; - double *carrier_doppler_hz = new double[num_epoch]; - double *code_freq_chips = new double[num_epoch]; - double *carr_error_hz = new double[num_epoch]; - double *carr_error_filt_hz = new double[num_epoch]; - double *code_error_chips = new double[num_epoch]; - double *code_error_filt_chips = new double[num_epoch]; - double *CN0_SNV_dB_Hz = new double[num_epoch]; - double *carrier_lock_test = new double[num_epoch]; - double *aux1 = new double[num_epoch]; - double *aux2 = new double[num_epoch]; - unsigned int *PRN = new unsigned int[num_epoch]; - - try - { - if (dump_file.is_open()) - { - for (long int i = 0; i < num_epoch; i++) - { - dump_file.read(reinterpret_cast(&abs_E[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&abs_P[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&abs_L[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&Prompt_I[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&Prompt_Q[i]), sizeof(float)); - dump_file.read(reinterpret_cast(&PRN_start_sample_count[i]), sizeof(unsigned long int)); - dump_file.read(reinterpret_cast(&acc_carrier_phase_rad[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carrier_doppler_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_freq_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carr_error_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carr_error_filt_hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_error_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&code_error_filt_chips[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&CN0_SNV_dB_Hz[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&carrier_lock_test[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&aux1[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&aux2[i]), sizeof(double)); - dump_file.read(reinterpret_cast(&PRN[i]), sizeof(unsigned int)); - } - } - dump_file.close(); - } - catch (const std::ifstream::failure &e) - { - std::cerr << "Problem reading dump file:" << e.what() << std::endl; - delete[] abs_E; - delete[] abs_P; - delete[] abs_L; - delete[] Prompt_I; - delete[] Prompt_Q; - delete[] PRN_start_sample_count; - delete[] acc_carrier_phase_rad; - delete[] carrier_doppler_hz; - delete[] code_freq_chips; - delete[] carr_error_hz; - delete[] carr_error_filt_hz; - delete[] code_error_chips; - delete[] code_error_filt_chips; - delete[] CN0_SNV_dB_Hz; - delete[] carrier_lock_test; - delete[] aux1; - delete[] aux2; - delete[] PRN; - return 1; - } - - // WRITE MAT FILE - mat_t *matfp; - matvar_t *matvar; - std::string filename = d_dump_filename; - filename.erase(filename.length() - 4, 4); - filename.append(".mat"); - matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73); - if (reinterpret_cast(matfp) != NULL) - { - size_t dims[2] = {1, static_cast(num_epoch)}; - matvar = Mat_VarCreate("abs_E", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("abs_P", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_P, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("abs_L", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_L, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("Prompt_I", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_I, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("Prompt_Q", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_Q, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("PRN_start_sample_count", MAT_C_UINT64, MAT_T_UINT64, 2, dims, PRN_start_sample_count, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("acc_carrier_phase_rad", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, acc_carrier_phase_rad, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carrier_doppler_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_doppler_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_freq_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_freq_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carr_error_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carr_error_filt_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_filt_hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_error_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("code_error_filt_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_filt_chips, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("CN0_SNV_dB_Hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, CN0_SNV_dB_Hz, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("carrier_lock_test", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_lock_test, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("aux1", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux1, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("aux2", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux2, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - - matvar = Mat_VarCreate("PRN", MAT_C_UINT32, MAT_T_UINT32, 2, dims, PRN, 0); - Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE - Mat_VarFree(matvar); - } - Mat_Close(matfp); - delete[] abs_E; - delete[] abs_P; - delete[] abs_L; - delete[] Prompt_I; - delete[] Prompt_Q; - delete[] PRN_start_sample_count; - delete[] acc_carrier_phase_rad; - delete[] carrier_doppler_hz; - delete[] code_freq_chips; - delete[] carr_error_hz; - delete[] carr_error_filt_hz; - delete[] code_error_chips; - delete[] code_error_filt_chips; - delete[] CN0_SNV_dB_Hz; - delete[] carrier_lock_test; - delete[] aux1; - delete[] aux2; - delete[] PRN; - return 0; -} - - -gps_l5i_dll_pll_tracking_cc::~gps_l5i_dll_pll_tracking_cc() -{ - if (d_dump_file.is_open()) - { - try - { - d_dump_file.close(); - } - catch (const std::exception &ex) - { - LOG(WARNING) << "Exception in destructor " << ex.what(); - } - } - if (d_dump) - { - if (d_channel == 0) - { - std::cout << "Writing .mat files ..."; - } - gps_l5i_dll_pll_tracking_cc::save_matfile(); - if (d_channel == 0) - { - std::cout << " done." << std::endl; - } - } - try - { - volk_gnsssdr_free(d_local_code_shift_chips); - volk_gnsssdr_free(d_correlator_outs); - volk_gnsssdr_free(d_ca_code); - delete[] d_Prompt_buffer; - multicorrelator_cpu.free(); - } - catch (const std::exception &ex) - { - LOG(WARNING) << "Exception in destructor " << ex.what(); - } -} - - -int gps_l5i_dll_pll_tracking_cc::general_work(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items __attribute__((unused)), - gr_vector_const_void_star &input_items, gr_vector_void_star &output_items) -{ - // process vars - double carr_error_hz = 0; - double carr_error_filt_hz = 0; - double code_error_chips = 0; - double code_error_filt_chips = 0; - - // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder - Gnss_Synchro current_synchro_data = Gnss_Synchro(); - - // Block input data and block output stream pointers - const gr_complex *in = reinterpret_cast(input_items[0]); - Gnss_Synchro **out = reinterpret_cast(&output_items[0]); - - if (d_enable_tracking == true) - { - // Fill the acquisition data - current_synchro_data = *d_acquisition_gnss_synchro; - // Receiver signal alignment - if (d_pull_in == true) - { - int samples_offset; - double acq_trk_shif_correction_samples; - int acq_to_trk_delay_samples; - acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp; - acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast(acq_to_trk_delay_samples), static_cast(d_current_prn_length_samples)); - samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples); - current_synchro_data.Tracking_sample_counter = d_sample_counter + samples_offset; - 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 alignment - 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; - current_synchro_data.fs = d_fs_in; - current_synchro_data.correlation_length_ms = 1; - consume_each(samples_offset); // shift input to perform alignment with local replica - return 0; - } - - // ################# CARRIER WIPEOFF AND CORRELATORS ############################## - // perform carrier wipe-off and compute Early, Prompt and Late correlation - multicorrelator_cpu.set_input_output_vectors(d_correlator_outs, in); - multicorrelator_cpu.Carrier_wipeoff_multicorrelator_resampler(d_rem_carr_phase_rad, - d_carrier_phase_step_rad, - d_rem_code_phase_chips, - d_code_phase_step_chips, - d_current_prn_length_samples); - - // ################## PLL ########################################################## - // PLL discriminator - // Update PLL discriminator [rads/Ti -> Secs/Ti] - carr_error_hz = pll_cloop_two_quadrant_atan(d_correlator_outs[1]) / GPS_L5_TWO_PI; - // Carrier discriminator filter - 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_L5i_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L5i_CODE_RATE_HZ) / GPS_L5_FREQ_HZ); - - // ################## DLL ########################################################## - // DLL discriminator - code_error_chips = dll_nc_e_minus_l_normalized(d_correlator_outs[0], d_correlator_outs[2]); // [chips/Ti] - // Code discriminator filter - code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips); //[chips/second] - double T_chip_seconds = 1.0 / static_cast(d_code_freq_chips); - double T_prn_seconds = T_chip_seconds * GPS_L5i_CODE_LENGTH_CHIPS; - double code_error_filt_secs = (T_prn_seconds * code_error_filt_chips * T_chip_seconds); //[seconds] - //double code_error_filt_secs = (GPS_L5i_PERIOD * code_error_filt_chips) / GPS_L5i_CODE_RATE_HZ; //[seconds] - - // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT ####################### - // keep alignment parameters for the next input buffer - // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation - double T_prn_samples = T_prn_seconds * static_cast(d_fs_in); - double K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * static_cast(d_fs_in); - d_current_prn_length_samples = round(K_blk_samples); // round to a discrete number of samples - - //################### PLL COMMANDS ################################################# - // carrier phase step (NCO phase increment per sample) [rads/sample] - d_carrier_phase_step_rad = GPS_L5_TWO_PI * d_carrier_doppler_hz / static_cast(d_fs_in); - // remnant 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_L5_TWO_PI); - // carrier phase accumulator - 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_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 < FLAGS_cn0_samples) - { - // fill buffer with prompt correlator output values - d_Prompt_buffer[d_cn0_estimation_counter] = d_correlator_outs[1]; - d_cn0_estimation_counter++; - } - else - { - d_cn0_estimation_counter = 0; - // Code lock indicator - d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, FLAGS_cn0_samples, d_fs_in, GPS_L5i_CODE_LENGTH_CHIPS); - // Carrier lock indicator - d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, FLAGS_cn0_samples); - // Loss of lock detection - if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < FLAGS_cn0_min) - { - d_carrier_lock_fail_counter++; - } - else - { - if (d_carrier_lock_fail_counter > 0) d_carrier_lock_fail_counter--; - } - if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail) - { - std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl; - LOG(INFO) << "Loss of lock in channel " << d_channel << "!"; - this->message_port_pub(pmt::mp("events"), pmt::from_long(3)); //3 -> loss of lock - d_carrier_lock_fail_counter = 0; - d_enable_tracking = false; // TODO: check if disabling tracking is consistent with the channel state machine - } - } - // ########### Output the tracking data to navigation and PVT ########## - current_synchro_data.Prompt_I = static_cast(d_correlator_outs[1].real()); - current_synchro_data.Prompt_Q = static_cast(d_correlator_outs[1].imag()); - current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples; - current_synchro_data.Code_phase_samples = d_rem_code_phase_samples; - 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; - current_synchro_data.Flag_valid_symbol_output = true; - current_synchro_data.correlation_length_ms = 1; - } - else - { - for (int n = 0; n < d_n_correlator_taps; n++) - { - d_correlator_outs[n] = gr_complex(0, 0); - } - current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples; - current_synchro_data.correlation_length_ms = 1; - } - //assign the GNURadio block output data - current_synchro_data.fs = d_fs_in; - *out[0] = current_synchro_data; - - if (d_dump) - { - // MULTIPLEXED FILE RECORDING - Record results to file - float prompt_I; - float prompt_Q; - float tmp_E, tmp_P, tmp_L; - double tmp_double; - prompt_I = d_correlator_outs[1].real(); - prompt_Q = d_correlator_outs[1].imag(); - tmp_E = std::abs(d_correlator_outs[0]); - tmp_P = std::abs(d_correlator_outs[1]); - tmp_L = std::abs(d_correlator_outs[2]); - try - { - // EPR - d_dump_file.write(reinterpret_cast(&tmp_E), sizeof(float)); - d_dump_file.write(reinterpret_cast(&tmp_P), sizeof(float)); - d_dump_file.write(reinterpret_cast(&tmp_L), sizeof(float)); - // PROMPT I and Q (to analyze navigation symbols) - 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)); - // accumulated carrier phase - d_dump_file.write(reinterpret_cast(&d_acc_carrier_phase_rad), sizeof(double)); - - // carrier and code frequency - d_dump_file.write(reinterpret_cast(&d_carrier_doppler_hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&d_code_freq_chips), sizeof(double)); - - //PLL commands - d_dump_file.write(reinterpret_cast(&carr_error_hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&d_carrier_doppler_hz), sizeof(double)); - - //DLL commands - d_dump_file.write(reinterpret_cast(&code_error_chips), sizeof(double)); - d_dump_file.write(reinterpret_cast(&code_error_filt_chips), sizeof(double)); - - // CN0 and carrier lock test - d_dump_file.write(reinterpret_cast(&d_CN0_SNV_dB_Hz), sizeof(double)); - d_dump_file.write(reinterpret_cast(&d_carrier_lock_test), sizeof(double)); - - // 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); - d_dump_file.write(reinterpret_cast(&tmp_double), sizeof(double)); - - // PRN - unsigned int prn_ = d_acquisition_gnss_synchro->PRN; - d_dump_file.write(reinterpret_cast(&prn_), sizeof(unsigned int)); - } - catch (std::ifstream::failure &e) - { - LOG(WARNING) << "Exception writing trk dump file " << e.what(); - } - } - consume_each(d_current_prn_length_samples); // this is necessary in gr::block derivates - d_sample_counter += d_current_prn_length_samples; // count for the processed samples - if (current_synchro_data.Flag_valid_symbol_output) - { - return 1; - } - else - { - return 0; - } -} - - -void gps_l5i_dll_pll_tracking_cc::set_channel(unsigned int channel) -{ - d_channel = channel; - LOG(INFO) << "Tracking Channel set to " << d_channel; - // ############# ENABLE DATA FILE LOG ################# - if (d_dump == true) - { - if (d_dump_file.is_open() == false) - { - try - { - d_dump_filename.append(boost::lexical_cast(d_channel)); - d_dump_filename.append(".dat"); - d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); - d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary); - LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str(); - } - catch (std::ifstream::failure &e) - { - LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what(); - } - } - } -} - - -void gps_l5i_dll_pll_tracking_cc::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro) -{ - d_acquisition_gnss_synchro = p_gnss_synchro; -} diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.h b/src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.h deleted file mode 100644 index cfe4b06f3..000000000 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.h +++ /dev/null @@ -1,165 +0,0 @@ -/*! - * \file gps_l5i_dll_pll_tracking_cc.h - * \brief Interface of a code DLL + carrier PLL tracking block for GPS L2C - * \author Javier Arribas, 2015. jarribas(at)cttc.es - * - * Code DLL + carrier PLL according to the algorithms described in: - * K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen, - * A Software-Defined GPS and Galileo Receiver. A Single-Frequency Approach, - * Birkhauser, 2007 - * - * ------------------------------------------------------------------------- - * - * Copyright (C) 2010-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 . - * - * ------------------------------------------------------------------------- - */ - -#ifndef GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_CC_H -#define GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_CC_H - -#include "gnss_synchro.h" -#include "tracking_2nd_DLL_filter.h" -#include "tracking_2nd_PLL_filter.h" -#include "cpu_multicorrelator.h" -#include -#include -#include -#include - -class gps_l5i_dll_pll_tracking_cc; - -typedef boost::shared_ptr - gps_l5i_dll_pll_tracking_cc_sptr; - -gps_l5i_dll_pll_tracking_cc_sptr -gps_l5i_dll_pll_make_tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips); - - -/*! - * \brief This class implements a DLL + PLL tracking loop block - */ -class gps_l5i_dll_pll_tracking_cc : public gr::block -{ -public: - ~gps_l5i_dll_pll_tracking_cc(); - - void set_channel(unsigned int channel); - void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro); - void start_tracking(); - - int general_work(int noutput_items, gr_vector_int& ninput_items, - gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); - - void forecast(int noutput_items, gr_vector_int& ninput_items_required); - -private: - friend gps_l5i_dll_pll_tracking_cc_sptr - gps_l5i_dll_pll_make_tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips); - - gps_l5i_dll_pll_tracking_cc(long if_freq, - long fs_in, unsigned int vector_length, - bool dump, - std::string dump_filename, - float pll_bw_hz, - float dll_bw_hz, - float early_late_space_chips); - - // tracking configuration vars - unsigned int d_vector_length; - bool d_dump; - - Gnss_Synchro* d_acquisition_gnss_synchro; - unsigned int d_channel; - long d_if_freq; - long d_fs_in; - - double d_early_late_spc_chips; - - // remaining code phase and carrier phase between tracking loops - double d_rem_code_phase_samples; - double d_rem_code_phase_chips; - double d_rem_carr_phase_rad; - - // PLL and DLL filter library - Tracking_2nd_DLL_filter d_code_loop_filter; - Tracking_2nd_PLL_filter d_carrier_loop_filter; - - // acquisition - double d_acq_code_phase_samples; - double d_acq_carrier_doppler_hz; - // correlator - int d_n_correlator_taps; - gr_complex* d_ca_code; - float* d_local_code_shift_chips; - gr_complex* d_correlator_outs; - cpu_multicorrelator multicorrelator_cpu; - - // tracking vars - double d_code_freq_chips; - double d_code_phase_step_chips; - double d_carrier_doppler_hz; - double d_carrier_phase_step_rad; - double d_acc_carrier_phase_rad; - double d_code_phase_samples; - - // PRN period in samples - int d_current_prn_length_samples; - - // processing samples counters - unsigned long int d_sample_counter; - unsigned long int d_acq_sample_stamp; - - // CN0 estimation and lock detector - int d_cn0_estimation_counter; - gr_complex* d_Prompt_buffer; - double d_carrier_lock_test; - double d_CN0_SNV_dB_Hz; - double d_carrier_lock_threshold; - int d_carrier_lock_fail_counter; - - // control vars - bool d_enable_tracking; - bool d_pull_in; - - // file dump - std::string d_dump_filename; - std::ofstream d_dump_file; - - std::map systemName; - std::string sys; - - int save_matfile(); -}; - -#endif //GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_CC_H From ac168cf27461eae06de8ce2be73b1ba4da63aaee Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Fri, 6 Apr 2018 09:39:11 +0200 Subject: [PATCH 12/21] Avoid warning --- src/algorithms/signal_source/libs/ad9361_manager.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/algorithms/signal_source/libs/ad9361_manager.cc b/src/algorithms/signal_source/libs/ad9361_manager.cc index b0a41bd55..34f6f5389 100644 --- a/src/algorithms/signal_source/libs/ad9361_manager.cc +++ b/src/algorithms/signal_source/libs/ad9361_manager.cc @@ -86,7 +86,7 @@ bool get_ad9361_stream_dev(struct iio_context *ctx, enum iodev d, struct iio_dev /* finds AD9361 streaming IIO channels */ -bool get_ad9361_stream_ch(struct iio_context *ctx, enum iodev d, struct iio_device *dev, int chid, struct iio_channel **chn) +bool get_ad9361_stream_ch(struct iio_context *ctx __attribute__((unused)), enum iodev d, struct iio_device *dev, int chid, struct iio_channel **chn) { std::stringstream name; name.str(""); From e01a6ce7403e10434aedb5cb920e7a58dd33d703 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Fri, 6 Apr 2018 09:44:55 +0200 Subject: [PATCH 13/21] Remove unused variable --- src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc index 7efce405a..aaa6147e6 100644 --- a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc @@ -62,7 +62,6 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking( if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast(FLAGS_dll_bw_hz); float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 5.0); float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 2.0); - int ti_ms = configuration->property(role + ".ti_ms", 3); float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5); std::string default_dump_filename = "./track_ch"; std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); From 5d9fb5af38a4e6ed56cc99b3cb5848247e3ddc8c Mon Sep 17 00:00:00 2001 From: Antonio Ramos Date: Fri, 6 Apr 2018 10:10:32 +0200 Subject: [PATCH 14/21] Migrate tracking adapters to new conf structure --- .../adapters/galileo_e5a_dll_pll_tracking.cc | 32 +++++++++++-------- .../adapters/gps_l2_m_dll_pll_tracking.cc | 9 +----- .../adapters/gps_l5i_dll_pll_tracking.cc | 11 +------ 3 files changed, 21 insertions(+), 31 deletions(-) diff --git a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc index 7efce405a..e4de78c22 100644 --- a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc @@ -49,26 +49,36 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking( ConfigurationInterface* configuration, std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams) { + dllpllconf_t trk_param; DLOG(INFO) << "role " << role; //################# CONFIGURATION PARAMETERS ######################## std::string default_item_type = "gr_complex"; std::string item_type = configuration->property(role + ".item_type", default_item_type); int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 12000000); int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); + trk_param.fs_in = fs_in; bool dump = configuration->property(role + ".dump", false); + trk_param.dump = dump; float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 20.0); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast(FLAGS_pll_bw_hz); + trk_param.pll_bw_hz = pll_bw_hz; float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 20.0); if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast(FLAGS_dll_bw_hz); + trk_param.dll_bw_hz = dll_bw_hz; float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 5.0); + trk_param.pll_bw_narrow_hz = pll_bw_narrow_hz; float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 2.0); - int ti_ms = configuration->property(role + ".ti_ms", 3); + trk_param.dll_bw_narrow_hz = dll_bw_narrow_hz; float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5); + trk_param.early_late_space_chips = early_late_space_chips; std::string default_dump_filename = "./track_ch"; std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); + trk_param.dump_filename = dump_filename; int vector_length = std::round(fs_in / (Galileo_E5a_CODE_CHIP_RATE_HZ / Galileo_E5a_CODE_LENGTH_CHIPS)); + trk_param.vector_length = vector_length; int extend_correlation_symbols = configuration->property(role + ".extend_correlation_symbols", 1); float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.15); + trk_param.early_late_space_narrow_chips = early_late_space_narrow_chips; bool track_pilot = configuration->property(role + ".track_pilot", false); if (extend_correlation_symbols < 1) { @@ -84,22 +94,18 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking( { std::cout << TEXT_RED << "WARNING: Galileo E5a. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << std::endl; } + trk_param.extend_correlation_symbols = extend_correlation_symbols; + trk_param.track_pilot = track_pilot; + trk_param.very_early_late_space_chips = 0.0; + trk_param.very_early_late_space_narrow_chips = 0.0; + trk_param.system = 'E'; + char sig_[3] = "5X"; + std::memcpy(trk_param.signal, sig_, 3); //################# MAKE TRACKING GNURadio object ################### if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); - char sig_[3] = "5X"; - item_size_ = sizeof(gr_complex); - tracking_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, - pll_bw_narrow_hz, dll_bw_narrow_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_narrow_chips, - early_late_space_narrow_chips, - extend_correlation_symbols, - track_pilot, 'E', sig_); + tracking_ = dll_pll_veml_make_tracking(trk_param); } else { diff --git a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc index bcb9fe3fc..7ed9444a6 100644 --- a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc @@ -96,14 +96,7 @@ GpsL2MDllPllTracking::GpsL2MDllPllTracking( if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); - tracking_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, pll_bw_hz, dll_bw_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_chips, - early_late_space_chips, - 1, false, 'G', sig_); + tracking_ = dll_pll_veml_make_tracking(trk_param); } else { diff --git a/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc index 987a4fa84..38ab6f55e 100644 --- a/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc +++ b/src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc @@ -105,16 +105,7 @@ GpsL5iDllPllTracking::GpsL5iDllPllTracking( if (item_type.compare("gr_complex") == 0) { item_size_ = sizeof(gr_complex); - tracking_ = dll_pll_veml_make_tracking( - fs_in, vector_length, dump, dump_filename, - pll_bw_hz, dll_bw_hz, - pll_bw_narrow_hz, dll_bw_narrow_hz, - early_late_space_chips, - early_late_space_chips, - early_late_space_narrow_chips, - early_late_space_narrow_chips, - extend_correlation_symbols, - track_pilot, 'G', sig_); + tracking_ = dll_pll_veml_make_tracking(trk_param); } else { From 77e0ec1072f0d1ce4a90aed8862f7d9f613c7007 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Fri, 6 Apr 2018 10:26:09 +0200 Subject: [PATCH 15/21] Update reference --- src/utils/reproducibility/ieee-access18/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/utils/reproducibility/ieee-access18/README.md b/src/utils/reproducibility/ieee-access18/README.md index d4238946e..62098afaa 100644 --- a/src/utils/reproducibility/ieee-access18/README.md +++ b/src/utils/reproducibility/ieee-access18/README.md @@ -4,11 +4,11 @@ Continuous Reproducibility in GNSS Signal Processing This folder contains files required for the reproduction of the experiment proposed in: -C. Fernández-Prades, J. Vilà-Valls, J. Arribas and A. Ramos, *Continuous Reproducibility in GNSS Signal Processing*, submitted to IEEE Access, Feb. 2018. +C. Fernández-Prades, J. Vilà-Valls, J. Arribas and A. Ramos, [*Continuous Reproducibility in GNSS Signal Processing*](http://ieeexplore.ieee.org/document/8331069/), IEEE Access, accepted for publication, April 2018. DOI: 10.1109/ACCESS.2018.2822835 -The dataset used in this paper is available at +The data set used in this paper is available at https://zenodo.org/record/1184601 -The sample format is `ibyte`: Interleaved (I&Q) stream of samples of type signed integer, 8-bit two’s complement number ranging from -128 to 127.  +The sample format is `ibyte`: Interleaved (I&Q) stream of samples of type signed integer, 8-bit two’s complement number ranging from -128 to 127. The sampling rate is 3 MSps. The figure appearing in that paper can be automatically generated with the pipeline available at https://gitlab.com/gnss-sdr/gnss-sdr/pipelines From b1a295d9822b3c208a08befa1042a5da33e96200 Mon Sep 17 00:00:00 2001 From: Antonio Ramos Date: Fri, 6 Apr 2018 10:48:10 +0200 Subject: [PATCH 16/21] Fix bug --- .../tracking/gnuradio_blocks/dll_pll_veml_tracking.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc index 97662aef5..4ae6f8195 100755 --- a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc +++ b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc @@ -80,13 +80,13 @@ void dll_pll_veml_tracking::forecast(int noutput_items, dll_pll_veml_tracking::dll_pll_veml_tracking(dllpllconf_t conf_) : gr::block("dll_pll_veml_tracking", gr::io_signature::make(1, 1, sizeof(gr_complex)), gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) { + trk_parameters = conf_; // Telemetry bit synchronization message port input this->message_port_register_in(pmt::mp("preamble_timestamp_s")); this->message_port_register_out(pmt::mp("events")); this->set_relative_rate(1.0 / static_cast(trk_parameters.vector_length)); // initialize internal vars - trk_parameters = conf_; d_veml = false; d_cloop = true; d_synchonizing = false; From fc34bb4d98dd49df3f5861ff239b4ff3c0d8a52a Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Sat, 7 Apr 2018 14:15:48 +0200 Subject: [PATCH 17/21] Get rid of gr::random so it can be compiled with c++17 The error was: In file included from /Users/carlesfernandez/git/cttc/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc:31: In file included from /Users/carlesfernandez/git/cttc/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h:36: In file included from /opt/local/include/gnuradio/random.h:30: In file included from /opt/local/include/boost/random.hpp:83: /opt/local/include/boost/random/uniform_on_sphere.hpp:229:37: error: no member named 'bind2nd' in namespace 'std' std::bind2nd(std::multiplies(), 1/sqrt(sqsum))); ~~~~~^ 1 error generated. --- .../signal_generator/gnuradio_blocks/signal_generator_c.cc | 5 ++--- .../signal_generator/gnuradio_blocks/signal_generator_c.h | 6 ++++-- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc b/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc index 3cd4c92d9..bfb1eb48a 100644 --- a/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc +++ b/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc @@ -133,8 +133,8 @@ void signal_generator_c::init() } } } - random_ = new gr::random(); std::default_random_engine e1(r()); + std::default_random_engine e2(r()); std::uniform_int_distribution uniform_dist(0, RAND_MAX); } @@ -271,7 +271,6 @@ signal_generator_c::~signal_generator_c() } } */ volk_gnsssdr_free(complex_phase_); - delete random_; } @@ -433,7 +432,7 @@ int signal_generator_c::general_work(int noutput_items __attribute__((unused)), { for (out_idx = 0; out_idx < vector_length_; out_idx++) { - out[out_idx] += gr_complex(random_->gasdev(), random_->gasdev()); + out[out_idx] += gr_complex(normal_dist(e1), normal_dist(e2)); } } diff --git a/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h b/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h index c01b6c8e0..1dce88924 100644 --- a/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h +++ b/src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h @@ -33,7 +33,7 @@ #include "gnss_signal.h" #include -#include +//#include #include #include #include @@ -120,13 +120,15 @@ private: boost::scoped_array sampled_code_data_; boost::scoped_array sampled_code_pilot_; - gr::random *random_; + //gr::random *random_; gr_complex *complex_phase_; unsigned int work_counter_; std::random_device r; std::default_random_engine e1; + std::default_random_engine e2; std::uniform_int_distribution uniform_dist; + std::normal_distribution normal_dist; public: ~signal_generator_c(); // public destructor From 795ac97e12704ca360f752ae72de4a6d652dfa59 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Sat, 7 Apr 2018 17:03:25 +0200 Subject: [PATCH 18/21] Set -std=c++11, -std=c++14 or -std=c++17 where appropriate --- CMakeLists.txt | 42 +++++---- .../volk_gnsssdr/CMakeLists.txt | 86 ++++++++++++++++++- 2 files changed, 111 insertions(+), 17 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 563adfc03..b74802213 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -360,7 +360,7 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${GNSSSDR_GCC_MIN_VERSION}) endif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") -if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") +if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") execute_process(COMMAND ${CMAKE_CXX_COMPILER} -v RESULT_VARIABLE _res ERROR_VARIABLE _err @@ -387,7 +387,7 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") else(${_res} STREQUAL "0") message(WARNING "\nCannot determine the version of the compiler selected to build GNSS-SDR (${APPLE_STR}Clang : ${CMAKE_CXX_COMPILER}). This build may or not work. We highly recommend using Apple Clang version ${APPLECLANG_MIN_VERSION} or more recent, or Clang version ${CLANG_MIN_VERSION} or more recent.") endif(${_res} STREQUAL "0") -endif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") +endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") @@ -783,7 +783,7 @@ if (NOT GLOG_FOUND OR ${LOCAL_GFLAGS}) set(GFLAGS_LIBRARY_DIR_TO_LINK ${GFlags_LIBRARY_DIRS}) endif(${LOCAL_GFLAGS}) - if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags "#!/bin/sh export CPPFLAGS=-I${GFlags_INCLUDE_DIRS} @@ -799,7 +799,7 @@ autoreconf -vfi cd ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION} ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configure") - else("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + else(CMAKE_CXX_COMPILER_ID MATCHES "Clang") file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags "#!/bin/sh export CPPFLAGS=-I${GFlags_INCLUDE_DIRS} @@ -812,7 +812,7 @@ autoreconf -vfi cd ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION} ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configure") - endif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") file(COPY ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION} @@ -1458,39 +1458,51 @@ endif(ENABLE_GPROF) ######################################################################## # Set compiler flags ######################################################################## -# Enable C++14 support in GCC / Fallback to C++11 when using GCC < 6.1.1 +# Enable C++17 support in GCC >= 8.0.0 +# Enable C++14 support in 8.0.0 > GCC >= 6.1.1 +# Fallback to C++11 when using GCC < 6.1.1 if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wall -Wextra") #Add warning flags: For "-Wall" see http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html endif(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) -# Enable C++14 support in Clang from 3.5 / Fallback to C++11 if older version and use lib++ if working in macOS +# Enable C++17 support in Clang >= 6.0.0 or AppleClang >= 900 +# Enable C++14 support in 6.0.0 > Clang >= 3.5.0 or 900 > AppleClang >= 600 +# Fallback to C++11 if older version if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") if(OS_IS_MACOSX) # See https://trac.macports.org/wiki/XcodeVersionInfo for Apple Clang version equivalences if(CLANG_VERSION VERSION_LESS "600") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") else(CLANG_VERSION VERSION_LESS "600") - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + if(CLANG_VERSION VERSION_LESS "900") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + else(CLANG_VERSION VERSION_LESS "900") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + endif(CLANG_VERSION VERSION_LESS "900") endif(CLANG_VERSION VERSION_LESS "600") - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wno-deprecated-declarations") else(OS_IS_MACOSX) if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") endif(OS_IS_MACOSX) - if(CMAKE_BUILD_TYPE MATCHES "Release") - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wno-unused-private-field") - endif(CMAKE_BUILD_TYPE MATCHES "Release") if(OS_IS_MACOSX) - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -stdlib=libc++") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -stdlib=libc++") endif(OS_IS_MACOSX) endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") diff --git a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/CMakeLists.txt b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/CMakeLists.txt index 0534fa62b..d4ea0c46f 100644 --- a/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/CMakeLists.txt +++ b/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/CMakeLists.txt @@ -27,9 +27,91 @@ enable_language(CXX) enable_language(C) enable_testing() -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall") +# Set compiler flags +set(GNSSSDR_CLANG_MIN_VERSION "3.4.0") +set(GNSSSDR_APPLECLANG_MIN_VERSION "500") +if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + execute_process(COMMAND + ${CMAKE_CXX_COMPILER} -v + RESULT_VARIABLE _res ERROR_VARIABLE _err + ERROR_STRIP_TRAILING_WHITESPACE) + if(${_res} STREQUAL "0") + # output is in error stream + string(REGEX MATCH "^Apple.*" IS_APPLE ${_err}) + if("${IS_APPLE}" STREQUAL "") + set(MIN_VERSION ${GNSSSDR_CLANG_MIN_VERSION}) + set(APPLE_STR "") + # retrieve the compiler's version from it + string(REGEX MATCH "clang version [0-9.]+" CLANG_OTHER_VERSION ${_err}) + string(REGEX MATCH "[0-9.]+" CLANG_VERSION ${CLANG_OTHER_VERSION}) + else("${IS_APPLE}" STREQUAL "") + set(MIN_VERSION ${GNSSSDR_APPLECLANG_MIN_VERSION}) + set(APPLE_STR "Apple ") + # retrieve the compiler's version from it + string(REGEX MATCH "(clang-[0-9.]+)" CLANG_APPLE_VERSION ${_err}) + string(REGEX MATCH "[0-9.]+" CLANG_VERSION ${CLANG_APPLE_VERSION}) + endif("${IS_APPLE}" STREQUAL "") + if(${CLANG_VERSION} VERSION_LESS "${MIN_VERSION}") + message(WARNING "\nThe compiler selected to build VOLK-GNSSSDR (${APPLE_STR}Clang version ${CLANG_VERSION} : ${CMAKE_CXX_COMPILER}) is older than that officially supported (${MIN_VERSION} minimum). This build may or not work. We highly recommend using Apple Clang version ${APPLECLANG_MIN_VERSION} or more recent, or Clang version ${CLANG_MIN_VERSION} or more recent.") + endif(${CLANG_VERSION} VERSION_LESS "${MIN_VERSION}") + else(${_res} STREQUAL "0") + message(WARNING "\nCannot determine the version of the compiler selected to build VOLK-GNSSSDR (${APPLE_STR}Clang : ${CMAKE_CXX_COMPILER}). This build may or not work. We highly recommend using Apple Clang version ${APPLECLANG_MIN_VERSION} or more recent, or Clang version ${CLANG_MIN_VERSION} or more recent.") + endif(${_res} STREQUAL "0") +endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + +# Enable C++17 support in GCC >= 8.0.0 +# Enable C++14 support in 8.0.0 > GCC >= 6.1.1 +# Fallback to C++11 when using GCC < 6.1.1 +if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") + else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") + endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wall -Wextra") #Add warning flags: For "-Wall" see http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html +endif(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) + +# Enable C++17 support in Clang >= 6.0.0 or AppleClang >= 900 +# Enable C++14 support in 6.0.0 > Clang >= 3.5.0 or 900 > AppleClang >= 600 +# Fallback to C++11 if older version +if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + if(CMAKE_SYSTEM_NAME MATCHES "Darwin") + # See https://trac.macports.org/wiki/XcodeVersionInfo for Apple Clang version equivalences + if(CLANG_VERSION VERSION_LESS "600") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") + else(CLANG_VERSION VERSION_LESS "600") + if(CLANG_VERSION VERSION_LESS "900") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + else(CLANG_VERSION VERSION_LESS "900") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + endif(CLANG_VERSION VERSION_LESS "900") + endif(CLANG_VERSION VERSION_LESS "600") + else(CMAKE_SYSTEM_NAME MATCHES "Darwin") + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") + else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") + if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") + else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") + set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") + endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") + endif(CMAKE_SYSTEM_NAME MATCHES "Darwin") +endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + +if(NOT (CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang")) + if(NOT (CMAKE_VERSION VERSION_LESS "3.1")) + set(CMAKE_C_STANDARD 11) + set(CMAKE_CXX_STANDARD 11) + endif(NOT (CMAKE_VERSION VERSION_LESS "3.1")) +endif(NOT (CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang")) + +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MY_CXX_FLAGS} -Wall") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall") -add_definitions(-D_GLIBCXX_USE_CXX11_ABI=1) if(CMAKE_VERSION VERSION_GREATER "3.0") cmake_policy(SET CMP0042 NEW) From 204aef99d0c674fbaa0f131d4df2053d697324dc Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Sun, 8 Apr 2018 23:48:35 +0200 Subject: [PATCH 19/21] Hold back c++17 until GNU Radio allows for it (already in next, so 3.8 will do) --- CMakeLists.txt | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b74802213..789a19974 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1458,24 +1458,24 @@ endif(ENABLE_GPROF) ######################################################################## # Set compiler flags ######################################################################## -# Enable C++17 support in GCC >= 8.0.0 -# Enable C++14 support in 8.0.0 > GCC >= 6.1.1 +# Support of C++17 is still not possible due to pm_remez.h (solved in GNU Radio 3.8) +# Enable C++14 support in GCC >= 6.1.1 # Fallback to C++11 when using GCC < 6.1.1 if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") - if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") + # if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") - else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") - endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") + # else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") + # set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + # endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0") endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wall -Wextra") #Add warning flags: For "-Wall" see http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html endif(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) -# Enable C++17 support in Clang >= 6.0.0 or AppleClang >= 900 -# Enable C++14 support in 6.0.0 > Clang >= 3.5.0 or 900 > AppleClang >= 600 +# Support of C++17 is still not possible due to pm_remez.h (solved in GNU Radio 3.8) +# Enable C++14 support in Clang >= 3.5.0 or AppleClang >= 600 # Fallback to C++11 if older version if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") if(OS_IS_MACOSX) @@ -1483,21 +1483,21 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") if(CLANG_VERSION VERSION_LESS "600") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") else(CLANG_VERSION VERSION_LESS "600") - if(CLANG_VERSION VERSION_LESS "900") + # if(CLANG_VERSION VERSION_LESS "900") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") - else(CLANG_VERSION VERSION_LESS "900") - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") - endif(CLANG_VERSION VERSION_LESS "900") + # else(CLANG_VERSION VERSION_LESS "900") + # set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + # endif(CLANG_VERSION VERSION_LESS "900") endif(CLANG_VERSION VERSION_LESS "600") else(OS_IS_MACOSX) if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11") else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") - if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") + # if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14") - else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") - set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") - endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") + # else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") + # set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17") + # endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0") endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0") endif(OS_IS_MACOSX) From d42d6b2ed4e4f4975f9172f32b4ce2b8468fc76e Mon Sep 17 00:00:00 2001 From: Antonio Ramos Date: Mon, 9 Apr 2018 16:16:50 +0200 Subject: [PATCH 20/21] Change std::vector> by gnss_circular_deque --- src/algorithms/libs/gnss_circular_deque.h | 213 ++++++++++++++++++ .../observables/adapters/CMakeLists.txt | 1 + .../gnuradio_blocks/CMakeLists.txt | 6 +- .../gnuradio_blocks/hybrid_observables_cc.cc | 122 +++++++--- .../gnuradio_blocks/hybrid_observables_cc.h | 11 +- 5 files changed, 312 insertions(+), 41 deletions(-) create mode 100644 src/algorithms/libs/gnss_circular_deque.h diff --git a/src/algorithms/libs/gnss_circular_deque.h b/src/algorithms/libs/gnss_circular_deque.h new file mode 100644 index 000000000..f453be3d2 --- /dev/null +++ b/src/algorithms/libs/gnss_circular_deque.h @@ -0,0 +1,213 @@ +/*! + * \file gnss_circular_deque.h + * \brief This class implements a circular deque for Gnss_Synchro + * + * \author Luis Esteve, 2018. antonio.ramos(at)cttc.es + * + * Detailed description of the file here if needed. + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2018 (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 . + * + * ------------------------------------------------------------------------- + */ + +#ifndef GNSS_SDR_CIRCULAR_DEQUE_H_ +#define GNSS_SDR_CIRCULAR_DEQUE_H_ + +template +class Gnss_circular_deque +{ +public: + Gnss_circular_deque(); + Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann); + ~Gnss_circular_deque(); + unsigned int size(const unsigned int ch); + T& at(const unsigned int ch, const unsigned int pos); + T& front(const unsigned int ch); + T& back(const unsigned int ch); + void push_back(const unsigned int ch, const T& new_data); + T pop_front(const unsigned int ch); + void clear(const unsigned int ch); + T* get_vector(const unsigned int ch); + +private: + T** d_history; + T d_return_void; // Void object for avoid compiler errors + unsigned int* d_index_pop; + unsigned int* d_index_push; + unsigned int* d_size; + unsigned int d_max_size; + unsigned int d_nchannels; +}; + + +template +Gnss_circular_deque::Gnss_circular_deque() +{ + d_max_size = 0; + d_nchannels = 0; + d_size = nullptr; + d_index_pop = nullptr; + d_index_push = nullptr; + d_history = nullptr; +} + +template +Gnss_circular_deque::Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann) +{ + d_max_size = max_size; + d_nchannels = nchann; + if (d_max_size > 0 and d_nchannels > 0) + { + d_size = new unsigned int[d_nchannels]; + d_index_pop = new unsigned int[d_nchannels]; + d_index_push = new unsigned int[d_nchannels]; + d_history = new T*[d_nchannels]; + for (unsigned int i = 0; i < d_nchannels; i++) + { + d_size[i] = 0; + d_index_pop[i] = 0; + d_index_push[i] = 0; + d_history[i] = new T[d_max_size]; + } + } +} + +template +Gnss_circular_deque::~Gnss_circular_deque() +{ + if (d_max_size > 0 and d_nchannels > 0) + { + delete[] d_size; + delete[] d_index_pop; + delete[] d_index_push; + for (unsigned int i = 0; i < d_nchannels; i++) + { + delete[] d_history[i]; + } + delete[] d_history; + } +} + +template +unsigned int Gnss_circular_deque::size(const unsigned int ch) +{ + return d_size[ch]; +} + +template +T& Gnss_circular_deque::back(const unsigned int ch) +{ + if (d_size[ch] > 0) + { + unsigned int index = 0; + if (d_index_push[ch] > 0) + { + index = d_index_push[ch] - 1; + } + else + { + index = d_max_size; + } + return d_history[ch][index]; + } + else + { + return d_return_void; + } +} + +template +T& Gnss_circular_deque::front(const unsigned int ch) +{ + if (d_size[ch] > 0) + { + return d_history[ch][d_index_pop[ch]]; + } + else + { + return d_return_void; + } +} + +template +T& Gnss_circular_deque::at(const unsigned int ch, const unsigned int pos) +{ + if (d_size[ch] > 0 and pos < d_size[ch]) + { + unsigned int index = (d_index_pop[ch] + pos) % d_max_size; + return d_history[ch][index]; + } + else + { + return d_return_void; + } +} + +template +void Gnss_circular_deque::clear(const unsigned int ch) +{ + d_size[ch] = 0; + d_index_pop[ch] = 0; + d_index_push[ch] = 0; +} + +template +T Gnss_circular_deque::pop_front(const unsigned int ch) +{ + T result; + if (d_size[ch] > 0) + { + d_size[ch]--; + result = d_history[ch][d_index_pop[ch]]; + d_index_pop[ch]++; + d_index_pop[ch] %= d_max_size; + } + return result; +} + +template +void Gnss_circular_deque::push_back(const unsigned int ch, const T& new_data) +{ + d_history[ch][d_index_push[ch]] = new_data; + d_index_push[ch]++; + d_index_push[ch] %= d_max_size; + if (d_size[ch] < d_max_size) + { + d_size[ch]++; + } + else + { + d_index_pop[ch]++; + d_index_pop[ch] %= d_max_size; + } +} + +template +T* Gnss_circular_deque::get_vector(const unsigned int ch) +{ + return d_history[ch]; +} + + +#endif /* GNSS_SDR_CIRCULAR_DEQUE_H_ */ diff --git a/src/algorithms/observables/adapters/CMakeLists.txt b/src/algorithms/observables/adapters/CMakeLists.txt index 5129e4157..882b22d83 100644 --- a/src/algorithms/observables/adapters/CMakeLists.txt +++ b/src/algorithms/observables/adapters/CMakeLists.txt @@ -26,6 +26,7 @@ include_directories( ${CMAKE_SOURCE_DIR}/src/core/interfaces ${CMAKE_SOURCE_DIR}/src/core/receiver ${CMAKE_SOURCE_DIR}/src/algorithms/observables/gnuradio_blocks + ${CMAKE_SOURCE_DIR}/src/algorithms/libs ${CMAKE_SOURCE_DIR}/src/algorithms/PVT/libs ${GLOG_INCLUDE_DIRS} ${GFlags_INCLUDE_DIRS} diff --git a/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt b/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt index 98b8213d8..e3db8ebcf 100644 --- a/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt +++ b/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt @@ -39,8 +39,8 @@ list(SORT OBS_GR_BLOCKS_HEADERS) add_library(obs_gr_blocks ${OBS_GR_BLOCKS_SOURCES} ${OBS_GR_BLOCKS_HEADERS}) source_group(Headers FILES ${OBS_GR_BLOCKS_HEADERS}) if(MATIO_FOUND) - add_dependencies(obs_gr_blocks glog-${glog_RELEASE} armadillo-${armadillo_RELEASE}) + add_dependencies(obs_gr_blocks gnss_sp_libs glog-${glog_RELEASE} armadillo-${armadillo_RELEASE}) else(MATIO_FOUND) - add_dependencies(obs_gr_blocks glog-${glog_RELEASE} armadillo-${armadillo_RELEASE} matio-${GNSSSDR_MATIO_LOCAL_VERSION}) + add_dependencies(obs_gr_blocks gnss_sp_libs glog-${glog_RELEASE} armadillo-${armadillo_RELEASE} matio-${GNSSSDR_MATIO_LOCAL_VERSION}) endif(MATIO_FOUND) -target_link_libraries(obs_gr_blocks ${GNURADIO_RUNTIME_LIBRARIES} ${ARMADILLO_LIBRARIES} ${MATIO_LIBRARIES}) +target_link_libraries(obs_gr_blocks gnss_sp_libs ${GNURADIO_RUNTIME_LIBRARIES} ${ARMADILLO_LIBRARIES} ${MATIO_LIBRARIES}) diff --git a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc index 6e95da824..4b03988aa 100644 --- a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc +++ b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc @@ -66,11 +66,7 @@ hybrid_observables_cc::hybrid_observables_cc(unsigned int nchannels_in, max_delta = 0.15; // 150 ms valid_channels.resize(d_nchannels, false); d_num_valid_channels = 0; - - for (unsigned int i = 0; i < d_nchannels; i++) - { - d_gnss_synchro_history.push_back(std::deque()); - } + d_gnss_synchro_history = Gnss_circular_deque(200, d_nchannels); // ############# ENABLE DATA FILE LOG ################# if (d_dump) @@ -302,15 +298,37 @@ int hybrid_observables_cc::save_matfile() } -bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, std::deque &data, const double &ti) +bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, const unsigned int &ch, const double &ti) { - if ((ti < data.front().RX_time) or (ti > data.back().RX_time)) + if ((ti < d_gnss_synchro_history.front(ch).RX_time) or (ti > d_gnss_synchro_history.back(ch).RX_time)) { return false; } - std::deque::iterator it; + std::pair ind = find_interp_elements(ch, ti); - arma::vec t = arma::vec(data.size()); + double m = 0.0; + double c = 0.0; + + // CARRIER PHASE INTERPOLATION + + m = (d_gnss_synchro_history.at(ch, ind.first).Carrier_phase_rads - d_gnss_synchro_history.at(ch, ind.second).Carrier_phase_rads) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time); + c = d_gnss_synchro_history.at(ch, ind.first).Carrier_phase_rads - m * d_gnss_synchro_history.at(ch, ind.first).RX_time; + out.Carrier_phase_rads = m * ti + c; + + // CARRIER DOPPLER INTERPOLATION + m = (d_gnss_synchro_history.at(ch, ind.first).Carrier_Doppler_hz - d_gnss_synchro_history.at(ch, ind.second).Carrier_Doppler_hz) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time); + c = d_gnss_synchro_history.at(ch, ind.first).Carrier_Doppler_hz - m * d_gnss_synchro_history.at(ch, ind.first).RX_time; + out.Carrier_Doppler_hz = m * ti + c; + + // TOW INTERPOLATION + m = (d_gnss_synchro_history.at(ch, ind.first).TOW_at_current_symbol_s - d_gnss_synchro_history.at(ch, ind.second).TOW_at_current_symbol_s) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time); + c = d_gnss_synchro_history.at(ch, ind.first).TOW_at_current_symbol_s - m * d_gnss_synchro_history.at(ch, ind.first).RX_time; + out.TOW_at_current_symbol_s = m * ti + c; + + return true; + + /* + arma::vec t = arma::vec(d_gnss_synchro_history.size(ch)); arma::vec dop = t; arma::vec cph = t; arma::vec tow = t; @@ -336,6 +354,7 @@ bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, std::deque hybrid_observables_cc::find_interp_elements(const unsigned int &ch, const double &ti) +{ + unsigned int closest = 0; + double dif = std::numeric_limits::max(); + double dt = 0.0; + for (unsigned int i = 0; i < d_gnss_synchro_history.size(ch); i++) + { + dt = std::fabs(ti - d_gnss_synchro_history.at(ch, i).RX_time); + if (dt < dif) + { + dif = dt; + closest = i; + } + } + unsigned int index1; + unsigned int index2; + if (closest == 0) + { + index1 = 0; + index2 = 1; + } + else if (closest == (d_gnss_synchro_history.size(ch) - 1)) + { + index1 = d_gnss_synchro_history.size(ch) - 2; + index2 = d_gnss_synchro_history.size(ch) - 1; + } + else + { + if (d_gnss_synchro_history.at(ch, closest).RX_time < ti) + { + index1 = closest; + index2 = closest + 1; + } + else + { + index1 = closest - 1; + index2 = closest; + } + } + return std::pair(index1, index2); +} + void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items_required) @@ -363,13 +424,13 @@ void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)), } -void hybrid_observables_cc::clean_history(std::deque &data) +void hybrid_observables_cc::clean_history(Gnss_circular_deque &data, unsigned int pos) { - while (data.size() > 0) + while (data.size(pos) > 0) { - if ((T_rx_s - data.front().RX_time) > max_delta) + if ((T_rx_s - data.front(pos).RX_time) > max_delta) { - data.pop_front(); + data.pop_front(pos); } else { @@ -454,11 +515,9 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) } ////////////////////////////////////////////////////////////////////////// - std::vector>::iterator it; if (total_input_items > 0) { - i = 0; - for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++) + for (unsigned int i = 0; i < d_nchannels; i++) { if (ninput_items[i] > 0) { @@ -467,26 +526,25 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) { if (in[i][aux].Flag_valid_word) { - it->push_back(in[i][aux]); - it->back().RX_time = compute_T_rx_s(in[i][aux]); + d_gnss_synchro_history.push_back(i, in[i][aux]); + d_gnss_synchro_history.back(i).RX_time = compute_T_rx_s(in[i][aux]); // Check if the last Gnss_Synchro comes from the same satellite as the previous ones - if (it->size() > 1) + if (d_gnss_synchro_history.size(i) > 1) { - if (it->front().PRN != it->back().PRN) + if (d_gnss_synchro_history.front(i).PRN != d_gnss_synchro_history.back(i).PRN) { - it->clear(); + d_gnss_synchro_history.clear(i); } } } } consume(i, ninput_items[i]); } - i++; } } for (i = 0; i < d_nchannels; i++) { - if (d_gnss_synchro_history.at(i).size() > 2) + if (d_gnss_synchro_history.size(i) > 2) { valid_channels[i] = true; } @@ -506,8 +564,8 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) { if (valid_channels[i]) { - clean_history(d_gnss_synchro_history.at(i)); - if (d_gnss_synchro_history.at(i).size() < 2) + clean_history(d_gnss_synchro_history, i); + if (d_gnss_synchro_history.size(i) < 2) { valid_channels[i] = false; } @@ -523,13 +581,12 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) } std::vector epoch_data; - i = 0; - for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++) + for (unsigned int i = 0; i < d_nchannels; i++) { if (valid_channels[i]) { - Gnss_Synchro interpolated_gnss_synchro = it->back(); - if (interpolate_data(interpolated_gnss_synchro, *it, T_rx_s_out)) + Gnss_Synchro interpolated_gnss_synchro = d_gnss_synchro_history.back(i); + if (interpolate_data(interpolated_gnss_synchro, i, T_rx_s_out)) { epoch_data.push_back(interpolated_gnss_synchro); } @@ -538,7 +595,6 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) valid_channels[i] = false; } } - i++; } d_num_valid_channels = valid_channels.count(); if (d_num_valid_channels == 0) @@ -546,14 +602,14 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) return 0; } correct_TOW_and_compute_prange(epoch_data); - std::vector::iterator it2 = epoch_data.begin(); + std::vector::iterator it = epoch_data.begin(); for (i = 0; i < d_nchannels; i++) { if (valid_channels[i]) { - out[i][0] = (*it2); + out[i][0] = (*it); out[i][0].Flag_valid_pseudorange = true; - it2++; + it++; } else { diff --git a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h index aedba43ab..298a9a0bb 100644 --- a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h +++ b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h @@ -35,12 +35,12 @@ #define GNSS_SDR_HYBRID_OBSERVABLES_CC_H #include "gnss_synchro.h" +#include "gnss_circular_deque.h" #include #include #include #include -#include -#include +#include class hybrid_observables_cc; @@ -65,14 +65,15 @@ private: friend hybrid_observables_cc_sptr hybrid_make_observables_cc(unsigned int nchannels_in, unsigned int nchannels_out, bool dump, std::string dump_filename); hybrid_observables_cc(unsigned int nchannels_in, unsigned int nchannels_out, bool dump, std::string dump_filename); - void clean_history(std::deque& data); + void clean_history(Gnss_circular_deque& data, unsigned int pos); double compute_T_rx_s(const Gnss_Synchro& a); - bool interpolate_data(Gnss_Synchro& out, std::deque& data, const double& ti); + bool interpolate_data(Gnss_Synchro& out, const unsigned int& ch, const double& ti); + std::pair find_interp_elements(const unsigned int& ch, const double& ti); void correct_TOW_and_compute_prange(std::vector& data); int save_matfile(); //Tracking observable history - std::vector> d_gnss_synchro_history; + Gnss_circular_deque d_gnss_synchro_history; boost::dynamic_bitset<> valid_channels; double T_rx_s; double T_rx_step_s; From f022d49709930ff9913f1cee95f1b4d5efabff07 Mon Sep 17 00:00:00 2001 From: Javier Arribas Date: Mon, 9 Apr 2018 16:45:05 +0200 Subject: [PATCH 21/21] Revert "Modify observables history" --- src/algorithms/libs/gnss_circular_deque.h | 213 ------------------ .../observables/adapters/CMakeLists.txt | 1 - .../gnuradio_blocks/CMakeLists.txt | 6 +- .../gnuradio_blocks/hybrid_observables_cc.cc | 122 +++------- .../gnuradio_blocks/hybrid_observables_cc.h | 11 +- 5 files changed, 41 insertions(+), 312 deletions(-) delete mode 100644 src/algorithms/libs/gnss_circular_deque.h diff --git a/src/algorithms/libs/gnss_circular_deque.h b/src/algorithms/libs/gnss_circular_deque.h deleted file mode 100644 index f453be3d2..000000000 --- a/src/algorithms/libs/gnss_circular_deque.h +++ /dev/null @@ -1,213 +0,0 @@ -/*! - * \file gnss_circular_deque.h - * \brief This class implements a circular deque for Gnss_Synchro - * - * \author Luis Esteve, 2018. antonio.ramos(at)cttc.es - * - * Detailed description of the file here if needed. - * - * ------------------------------------------------------------------------- - * - * Copyright (C) 2010-2018 (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 . - * - * ------------------------------------------------------------------------- - */ - -#ifndef GNSS_SDR_CIRCULAR_DEQUE_H_ -#define GNSS_SDR_CIRCULAR_DEQUE_H_ - -template -class Gnss_circular_deque -{ -public: - Gnss_circular_deque(); - Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann); - ~Gnss_circular_deque(); - unsigned int size(const unsigned int ch); - T& at(const unsigned int ch, const unsigned int pos); - T& front(const unsigned int ch); - T& back(const unsigned int ch); - void push_back(const unsigned int ch, const T& new_data); - T pop_front(const unsigned int ch); - void clear(const unsigned int ch); - T* get_vector(const unsigned int ch); - -private: - T** d_history; - T d_return_void; // Void object for avoid compiler errors - unsigned int* d_index_pop; - unsigned int* d_index_push; - unsigned int* d_size; - unsigned int d_max_size; - unsigned int d_nchannels; -}; - - -template -Gnss_circular_deque::Gnss_circular_deque() -{ - d_max_size = 0; - d_nchannels = 0; - d_size = nullptr; - d_index_pop = nullptr; - d_index_push = nullptr; - d_history = nullptr; -} - -template -Gnss_circular_deque::Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann) -{ - d_max_size = max_size; - d_nchannels = nchann; - if (d_max_size > 0 and d_nchannels > 0) - { - d_size = new unsigned int[d_nchannels]; - d_index_pop = new unsigned int[d_nchannels]; - d_index_push = new unsigned int[d_nchannels]; - d_history = new T*[d_nchannels]; - for (unsigned int i = 0; i < d_nchannels; i++) - { - d_size[i] = 0; - d_index_pop[i] = 0; - d_index_push[i] = 0; - d_history[i] = new T[d_max_size]; - } - } -} - -template -Gnss_circular_deque::~Gnss_circular_deque() -{ - if (d_max_size > 0 and d_nchannels > 0) - { - delete[] d_size; - delete[] d_index_pop; - delete[] d_index_push; - for (unsigned int i = 0; i < d_nchannels; i++) - { - delete[] d_history[i]; - } - delete[] d_history; - } -} - -template -unsigned int Gnss_circular_deque::size(const unsigned int ch) -{ - return d_size[ch]; -} - -template -T& Gnss_circular_deque::back(const unsigned int ch) -{ - if (d_size[ch] > 0) - { - unsigned int index = 0; - if (d_index_push[ch] > 0) - { - index = d_index_push[ch] - 1; - } - else - { - index = d_max_size; - } - return d_history[ch][index]; - } - else - { - return d_return_void; - } -} - -template -T& Gnss_circular_deque::front(const unsigned int ch) -{ - if (d_size[ch] > 0) - { - return d_history[ch][d_index_pop[ch]]; - } - else - { - return d_return_void; - } -} - -template -T& Gnss_circular_deque::at(const unsigned int ch, const unsigned int pos) -{ - if (d_size[ch] > 0 and pos < d_size[ch]) - { - unsigned int index = (d_index_pop[ch] + pos) % d_max_size; - return d_history[ch][index]; - } - else - { - return d_return_void; - } -} - -template -void Gnss_circular_deque::clear(const unsigned int ch) -{ - d_size[ch] = 0; - d_index_pop[ch] = 0; - d_index_push[ch] = 0; -} - -template -T Gnss_circular_deque::pop_front(const unsigned int ch) -{ - T result; - if (d_size[ch] > 0) - { - d_size[ch]--; - result = d_history[ch][d_index_pop[ch]]; - d_index_pop[ch]++; - d_index_pop[ch] %= d_max_size; - } - return result; -} - -template -void Gnss_circular_deque::push_back(const unsigned int ch, const T& new_data) -{ - d_history[ch][d_index_push[ch]] = new_data; - d_index_push[ch]++; - d_index_push[ch] %= d_max_size; - if (d_size[ch] < d_max_size) - { - d_size[ch]++; - } - else - { - d_index_pop[ch]++; - d_index_pop[ch] %= d_max_size; - } -} - -template -T* Gnss_circular_deque::get_vector(const unsigned int ch) -{ - return d_history[ch]; -} - - -#endif /* GNSS_SDR_CIRCULAR_DEQUE_H_ */ diff --git a/src/algorithms/observables/adapters/CMakeLists.txt b/src/algorithms/observables/adapters/CMakeLists.txt index 882b22d83..5129e4157 100644 --- a/src/algorithms/observables/adapters/CMakeLists.txt +++ b/src/algorithms/observables/adapters/CMakeLists.txt @@ -26,7 +26,6 @@ include_directories( ${CMAKE_SOURCE_DIR}/src/core/interfaces ${CMAKE_SOURCE_DIR}/src/core/receiver ${CMAKE_SOURCE_DIR}/src/algorithms/observables/gnuradio_blocks - ${CMAKE_SOURCE_DIR}/src/algorithms/libs ${CMAKE_SOURCE_DIR}/src/algorithms/PVT/libs ${GLOG_INCLUDE_DIRS} ${GFlags_INCLUDE_DIRS} diff --git a/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt b/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt index e3db8ebcf..98b8213d8 100644 --- a/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt +++ b/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt @@ -39,8 +39,8 @@ list(SORT OBS_GR_BLOCKS_HEADERS) add_library(obs_gr_blocks ${OBS_GR_BLOCKS_SOURCES} ${OBS_GR_BLOCKS_HEADERS}) source_group(Headers FILES ${OBS_GR_BLOCKS_HEADERS}) if(MATIO_FOUND) - add_dependencies(obs_gr_blocks gnss_sp_libs glog-${glog_RELEASE} armadillo-${armadillo_RELEASE}) + add_dependencies(obs_gr_blocks glog-${glog_RELEASE} armadillo-${armadillo_RELEASE}) else(MATIO_FOUND) - add_dependencies(obs_gr_blocks gnss_sp_libs glog-${glog_RELEASE} armadillo-${armadillo_RELEASE} matio-${GNSSSDR_MATIO_LOCAL_VERSION}) + add_dependencies(obs_gr_blocks glog-${glog_RELEASE} armadillo-${armadillo_RELEASE} matio-${GNSSSDR_MATIO_LOCAL_VERSION}) endif(MATIO_FOUND) -target_link_libraries(obs_gr_blocks gnss_sp_libs ${GNURADIO_RUNTIME_LIBRARIES} ${ARMADILLO_LIBRARIES} ${MATIO_LIBRARIES}) +target_link_libraries(obs_gr_blocks ${GNURADIO_RUNTIME_LIBRARIES} ${ARMADILLO_LIBRARIES} ${MATIO_LIBRARIES}) diff --git a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc index 4b03988aa..6e95da824 100644 --- a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc +++ b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc @@ -66,7 +66,11 @@ hybrid_observables_cc::hybrid_observables_cc(unsigned int nchannels_in, max_delta = 0.15; // 150 ms valid_channels.resize(d_nchannels, false); d_num_valid_channels = 0; - d_gnss_synchro_history = Gnss_circular_deque(200, d_nchannels); + + for (unsigned int i = 0; i < d_nchannels; i++) + { + d_gnss_synchro_history.push_back(std::deque()); + } // ############# ENABLE DATA FILE LOG ################# if (d_dump) @@ -298,37 +302,15 @@ int hybrid_observables_cc::save_matfile() } -bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, const unsigned int &ch, const double &ti) +bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, std::deque &data, const double &ti) { - if ((ti < d_gnss_synchro_history.front(ch).RX_time) or (ti > d_gnss_synchro_history.back(ch).RX_time)) + if ((ti < data.front().RX_time) or (ti > data.back().RX_time)) { return false; } - std::pair ind = find_interp_elements(ch, ti); + std::deque::iterator it; - double m = 0.0; - double c = 0.0; - - // CARRIER PHASE INTERPOLATION - - m = (d_gnss_synchro_history.at(ch, ind.first).Carrier_phase_rads - d_gnss_synchro_history.at(ch, ind.second).Carrier_phase_rads) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time); - c = d_gnss_synchro_history.at(ch, ind.first).Carrier_phase_rads - m * d_gnss_synchro_history.at(ch, ind.first).RX_time; - out.Carrier_phase_rads = m * ti + c; - - // CARRIER DOPPLER INTERPOLATION - m = (d_gnss_synchro_history.at(ch, ind.first).Carrier_Doppler_hz - d_gnss_synchro_history.at(ch, ind.second).Carrier_Doppler_hz) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time); - c = d_gnss_synchro_history.at(ch, ind.first).Carrier_Doppler_hz - m * d_gnss_synchro_history.at(ch, ind.first).RX_time; - out.Carrier_Doppler_hz = m * ti + c; - - // TOW INTERPOLATION - m = (d_gnss_synchro_history.at(ch, ind.first).TOW_at_current_symbol_s - d_gnss_synchro_history.at(ch, ind.second).TOW_at_current_symbol_s) / (d_gnss_synchro_history.at(ch, ind.first).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time); - c = d_gnss_synchro_history.at(ch, ind.first).TOW_at_current_symbol_s - m * d_gnss_synchro_history.at(ch, ind.first).RX_time; - out.TOW_at_current_symbol_s = m * ti + c; - - return true; - - /* - arma::vec t = arma::vec(d_gnss_synchro_history.size(ch)); + arma::vec t = arma::vec(data.size()); arma::vec dop = t; arma::vec cph = t; arma::vec tow = t; @@ -354,7 +336,6 @@ bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, const unsigned i out.TOW_at_current_symbol_s = result(0); return result.is_finite(); - */ } @@ -370,48 +351,6 @@ double hybrid_observables_cc::compute_T_rx_s(const Gnss_Synchro &a) } } -std::pair hybrid_observables_cc::find_interp_elements(const unsigned int &ch, const double &ti) -{ - unsigned int closest = 0; - double dif = std::numeric_limits::max(); - double dt = 0.0; - for (unsigned int i = 0; i < d_gnss_synchro_history.size(ch); i++) - { - dt = std::fabs(ti - d_gnss_synchro_history.at(ch, i).RX_time); - if (dt < dif) - { - dif = dt; - closest = i; - } - } - unsigned int index1; - unsigned int index2; - if (closest == 0) - { - index1 = 0; - index2 = 1; - } - else if (closest == (d_gnss_synchro_history.size(ch) - 1)) - { - index1 = d_gnss_synchro_history.size(ch) - 2; - index2 = d_gnss_synchro_history.size(ch) - 1; - } - else - { - if (d_gnss_synchro_history.at(ch, closest).RX_time < ti) - { - index1 = closest; - index2 = closest + 1; - } - else - { - index1 = closest - 1; - index2 = closest; - } - } - return std::pair(index1, index2); -} - void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items_required) @@ -424,13 +363,13 @@ void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)), } -void hybrid_observables_cc::clean_history(Gnss_circular_deque &data, unsigned int pos) +void hybrid_observables_cc::clean_history(std::deque &data) { - while (data.size(pos) > 0) + while (data.size() > 0) { - if ((T_rx_s - data.front(pos).RX_time) > max_delta) + if ((T_rx_s - data.front().RX_time) > max_delta) { - data.pop_front(pos); + data.pop_front(); } else { @@ -515,9 +454,11 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) } ////////////////////////////////////////////////////////////////////////// + std::vector>::iterator it; if (total_input_items > 0) { - for (unsigned int i = 0; i < d_nchannels; i++) + i = 0; + for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++) { if (ninput_items[i] > 0) { @@ -526,25 +467,26 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) { if (in[i][aux].Flag_valid_word) { - d_gnss_synchro_history.push_back(i, in[i][aux]); - d_gnss_synchro_history.back(i).RX_time = compute_T_rx_s(in[i][aux]); + it->push_back(in[i][aux]); + it->back().RX_time = compute_T_rx_s(in[i][aux]); // Check if the last Gnss_Synchro comes from the same satellite as the previous ones - if (d_gnss_synchro_history.size(i) > 1) + if (it->size() > 1) { - if (d_gnss_synchro_history.front(i).PRN != d_gnss_synchro_history.back(i).PRN) + if (it->front().PRN != it->back().PRN) { - d_gnss_synchro_history.clear(i); + it->clear(); } } } } consume(i, ninput_items[i]); } + i++; } } for (i = 0; i < d_nchannels; i++) { - if (d_gnss_synchro_history.size(i) > 2) + if (d_gnss_synchro_history.at(i).size() > 2) { valid_channels[i] = true; } @@ -564,8 +506,8 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) { if (valid_channels[i]) { - clean_history(d_gnss_synchro_history, i); - if (d_gnss_synchro_history.size(i) < 2) + clean_history(d_gnss_synchro_history.at(i)); + if (d_gnss_synchro_history.at(i).size() < 2) { valid_channels[i] = false; } @@ -581,12 +523,13 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) } std::vector epoch_data; - for (unsigned int i = 0; i < d_nchannels; i++) + i = 0; + for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++) { if (valid_channels[i]) { - Gnss_Synchro interpolated_gnss_synchro = d_gnss_synchro_history.back(i); - if (interpolate_data(interpolated_gnss_synchro, i, T_rx_s_out)) + Gnss_Synchro interpolated_gnss_synchro = it->back(); + if (interpolate_data(interpolated_gnss_synchro, *it, T_rx_s_out)) { epoch_data.push_back(interpolated_gnss_synchro); } @@ -595,6 +538,7 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) valid_channels[i] = false; } } + i++; } d_num_valid_channels = valid_channels.count(); if (d_num_valid_channels == 0) @@ -602,14 +546,14 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused) return 0; } correct_TOW_and_compute_prange(epoch_data); - std::vector::iterator it = epoch_data.begin(); + std::vector::iterator it2 = epoch_data.begin(); for (i = 0; i < d_nchannels; i++) { if (valid_channels[i]) { - out[i][0] = (*it); + out[i][0] = (*it2); out[i][0].Flag_valid_pseudorange = true; - it++; + it2++; } else { diff --git a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h index 298a9a0bb..aedba43ab 100644 --- a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h +++ b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h @@ -35,12 +35,12 @@ #define GNSS_SDR_HYBRID_OBSERVABLES_CC_H #include "gnss_synchro.h" -#include "gnss_circular_deque.h" #include #include #include #include -#include +#include +#include class hybrid_observables_cc; @@ -65,15 +65,14 @@ private: friend hybrid_observables_cc_sptr hybrid_make_observables_cc(unsigned int nchannels_in, unsigned int nchannels_out, bool dump, std::string dump_filename); hybrid_observables_cc(unsigned int nchannels_in, unsigned int nchannels_out, bool dump, std::string dump_filename); - void clean_history(Gnss_circular_deque& data, unsigned int pos); + void clean_history(std::deque& data); double compute_T_rx_s(const Gnss_Synchro& a); - bool interpolate_data(Gnss_Synchro& out, const unsigned int& ch, const double& ti); - std::pair find_interp_elements(const unsigned int& ch, const double& ti); + bool interpolate_data(Gnss_Synchro& out, std::deque& data, const double& ti); void correct_TOW_and_compute_prange(std::vector& data); int save_matfile(); //Tracking observable history - Gnss_circular_deque d_gnss_synchro_history; + std::vector> d_gnss_synchro_history; boost::dynamic_bitset<> valid_channels; double T_rx_s; double T_rx_step_s;