From 648956ea659dc45809ebe7456d46598b6cfa5917 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 25 Jul 2017 16:26:23 +0200 Subject: [PATCH] Make code more readable --- ...ps_l1_ca_dll_pll_c_aid_tracking_fpga_sc.cc | 502 ++++++------------ 1 file changed, 172 insertions(+), 330 deletions(-) diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc.cc index e466898a6..2cd520341 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc.cc @@ -76,8 +76,8 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::msg_handler_preamble_index( pmt::pmt_t msg) { DLOG(INFO) << "Extended correlation enabled for Tracking CH " - << d_channel << ": Satellite " - << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN); + << d_channel << ": Satellite " + << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN); if (d_enable_extended_integration == false) //avoid re-setting preamble indicator { d_preamble_timestamp_s = pmt::to_double(msg); @@ -127,34 +127,29 @@ gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::gps_l1_ca_dll_pll_c_aid_tracking_fpga_ // 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_L1_CA_CODE_LENGTH_CHIPS) * sizeof(gr_complex), - volk_gnsssdr_get_alignment())); - d_ca_code_16sc = static_cast(volk_gnsssdr_malloc( - static_cast(GPS_L1_CA_CODE_LENGTH_CHIPS) * sizeof(lv_16sc_t), - volk_gnsssdr_get_alignment())); + d_ca_code = static_cast(volk_gnsssdr_malloc(static_cast(GPS_L1_CA_CODE_LENGTH_CHIPS) * sizeof(gr_complex), volk_gnsssdr_get_alignment())); + d_ca_code_16sc = static_cast(volk_gnsssdr_malloc(static_cast(GPS_L1_CA_CODE_LENGTH_CHIPS) * sizeof(lv_16sc_t), volk_gnsssdr_get_alignment())); // correlator outputs (scalar) d_n_correlator_taps = 3; // Early, Prompt, and Late - d_correlator_outs_16sc = static_cast(volk_gnsssdr_malloc( - d_n_correlator_taps * sizeof(lv_16sc_t), + d_correlator_outs_16sc = static_cast(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(lv_16sc_t), volk_gnsssdr_get_alignment())); + for (int n = 0; n < d_n_correlator_taps; n++) { d_correlator_outs_16sc[n] = lv_cmake(0, 0); } - d_local_code_shift_chips = static_cast(volk_gnsssdr_malloc( - d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment())); + 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; // create multicorrelator class - multicorrelator_fpga_8sc = std::make_shared < fpga_multicorrelator_8sc - > (d_n_correlator_taps, device_name, device_base); + multicorrelator_fpga_8sc = std::make_shared (d_n_correlator_taps, device_name, device_base); //--- Perform initializations ------------------------------ // define initial code frequency basis of NCO @@ -217,55 +212,41 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::start_tracking() 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); + acq_trk_diff_samples = static_cast(d_sample_counter) - static_cast(d_acq_sample_stamp); + 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_L1_FREQ_HZ + d_acq_carrier_doppler_hz) - / GPS_L1_FREQ_HZ; + double radial_velocity = (GPS_L1_FREQ_HZ + d_acq_carrier_doppler_hz) / GPS_L1_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_L1_CA_CODE_RATE_HZ; - d_code_phase_step_chips = static_cast(d_code_freq_chips) - / static_cast(d_fs_in); + d_code_phase_step_chips = static_cast(d_code_freq_chips) / static_cast(d_fs_in); T_chip_mod_seconds = 1.0 / d_code_freq_chips; T_prn_mod_seconds = T_chip_mod_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS; T_prn_mod_samples = T_prn_mod_seconds * static_cast(d_fs_in); d_correlation_length_samples = round(T_prn_mod_samples); - double T_prn_true_seconds = GPS_L1_CA_CODE_LENGTH_CHIPS - / GPS_L1_CA_CODE_RATE_HZ; - double T_prn_true_samples = T_prn_true_seconds - * static_cast(d_fs_in); + double T_prn_true_seconds = GPS_L1_CA_CODE_LENGTH_CHIPS / GPS_L1_CA_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); + 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; + corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples; } - delay_correction_samples = d_acq_code_phase_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_TWO_PI * d_carrier_doppler_hz - / static_cast(d_fs_in); + d_carrier_phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz / static_cast(d_fs_in); // DLL/PLL filter initialization d_carrier_loop_filter.initialize(d_acq_carrier_doppler_hz); // The carrier loop filter implements the Doppler accumulator @@ -273,12 +254,9 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::start_tracking() // generate local reference ALWAYS starting at chip 1 (1 sample per chip) gps_l1_ca_code_gen_complex(d_ca_code, d_acquisition_gnss_synchro->PRN, 0); - volk_gnsssdr_32fc_convert_16ic(d_ca_code_16sc, d_ca_code, - static_cast(GPS_L1_CA_CODE_LENGTH_CHIPS)); + volk_gnsssdr_32fc_convert_16ic(d_ca_code_16sc, d_ca_code, static_cast(GPS_L1_CA_CODE_LENGTH_CHIPS)); - multicorrelator_fpga_8sc->set_local_code_and_taps( - static_cast(GPS_L1_CA_CODE_LENGTH_CHIPS), d_ca_code_16sc, - d_local_code_shift_chips); + multicorrelator_fpga_8sc->set_local_code_and_taps(static_cast(GPS_L1_CA_CODE_LENGTH_CHIPS), d_ca_code_16sc, d_local_code_shift_chips); for (int n = 0; n < d_n_correlator_taps; n++) { d_correlator_outs_16sc[n] = lv_16sc_t(0, 0); @@ -297,11 +275,11 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::start_tracking() // DEBUG OUTPUT std::cout << "Tracking start on channel " << d_channel << " for satellite " - << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) - << std::endl; + << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) + << std::endl; LOG(INFO) << "Starting tracking of satellite " - << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) - << " on channel " << d_channel; + << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) + << " on channel " << d_channel; // enable tracking d_pull_in = true; @@ -313,22 +291,37 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::start_tracking() multicorrelator_fpga_8sc->lock_channel(); 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; + << " Code Phase correction [samples]=" << delay_correction_samples + << " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples; } gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::~gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc() { - d_dump_file.close(); - - volk_gnsssdr_free(d_local_code_shift_chips); - volk_gnsssdr_free(d_ca_code); - volk_gnsssdr_free(d_ca_code_16sc); - volk_gnsssdr_free(d_correlator_outs_16sc); - - delete[] d_Prompt_buffer; - multicorrelator_fpga_8sc->free(); + if (d_dump_file.is_open()) + { + try + { + d_dump_file.close(); + } + catch(const std::exception & ex) + { + LOG(WARNING)<< "Exception in destructor " << ex.what(); + } + } + try + { + volk_gnsssdr_free(d_local_code_shift_chips); + volk_gnsssdr_free(d_ca_code); + volk_gnsssdr_free(d_ca_code_16sc); + volk_gnsssdr_free(d_correlator_outs_16sc); + delete[] d_Prompt_buffer; + multicorrelator_fpga_8sc->free(); + } + catch(const std::exception & ex) + { + LOG(WARNING) << "Exception in destructor " << ex.what(); + } } @@ -360,39 +353,27 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( { 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_correlation_length_samples - - fmod( - static_cast(acq_to_trk_delay_samples), - static_cast(d_correlation_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; + acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp; + acq_trk_shif_correction_samples = d_correlation_length_samples - fmod( static_cast(acq_to_trk_delay_samples), static_cast(d_correlation_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 += samples_offset; // count for the processed samples d_pull_in = false; - d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad - * samples_offset / GPS_TWO_PI; - current_synchro_data.Carrier_phase_rads = - d_acc_carrier_phase_cycles * GPS_TWO_PI; - current_synchro_data.Carrier_Doppler_hz = - d_carrier_doppler_hz; + d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * samples_offset / GPS_TWO_PI; + current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_cycles * GPS_TWO_PI; + current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; current_synchro_data.fs = d_fs_in; *out[0] = current_synchro_data; //consume_each(samples_offset); // shift input to perform alignment with local replica - multicorrelator_fpga_8sc->set_initial_sample( - samples_offset); + multicorrelator_fpga_8sc->set_initial_sample(samples_offset); return 1; } // ################# CARRIER WIPEOFF AND CORRELATORS ############################## // perform carrier wipe-off and compute Early, Prompt and Late correlation - multicorrelator_fpga_8sc->set_output_vectors( - d_correlator_outs_16sc); + multicorrelator_fpga_8sc->set_output_vectors(d_correlator_outs_16sc); + multicorrelator_fpga_8sc->Carrier_wipeoff_multicorrelator_resampler( d_rem_carrier_phase_rad, d_carrier_phase_step_rad, d_rem_code_phase_chips, d_code_phase_step_chips, @@ -414,14 +395,8 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( bool enable_dll_pll; if (d_enable_extended_integration == true) { - long int symbol_diff = round( - 1000.0 - * ((static_cast(d_sample_counter) - + d_rem_code_phase_samples) - / static_cast(d_fs_in) - - d_preamble_timestamp_s)); - if (symbol_diff > 0 - and symbol_diff % d_extend_correlation_ms == 0) + long int symbol_diff = round(1000.0 * ((static_cast(d_sample_counter) + d_rem_code_phase_samples) / static_cast(d_fs_in) - d_preamble_timestamp_s)); + if (symbol_diff > 0 and symbol_diff % d_extend_correlation_ms == 0) { // compute coherent integration and enable tracking loop // perform coherent integration using correlator output history @@ -431,40 +406,32 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( d_correlator_outs_16sc[2] = lv_cmake(0, 0); for (int n = 0; n < d_extend_correlation_ms; n++) { - d_correlator_outs_16sc[0] += d_E_history.at( - n); - d_correlator_outs_16sc[1] += d_P_history.at( - n); - d_correlator_outs_16sc[2] += d_L_history.at( - n); + d_correlator_outs_16sc[0] += d_E_history.at(n); + d_correlator_outs_16sc[1] += d_P_history.at(n); + d_correlator_outs_16sc[2] += d_L_history.at(n); } if (d_preamble_synchronized == false) { - d_code_loop_filter.set_DLL_BW( - d_dll_bw_narrow_hz); - d_carrier_loop_filter.set_params(10.0, - d_pll_bw_narrow_hz, 2); + d_code_loop_filter.set_DLL_BW(d_dll_bw_narrow_hz); + d_carrier_loop_filter.set_params(10.0, d_pll_bw_narrow_hz, 2); d_preamble_synchronized = true; std::cout << "Enabled " - << d_extend_correlation_ms - << " [ms] extended correlator for CH " - << d_channel << " : Satellite " - << Gnss_Satellite(systemName[sys], - d_acquisition_gnss_synchro->PRN) - << " pll_bw = " << d_pll_bw_hz - << " [Hz], pll_narrow_bw = " - << d_pll_bw_narrow_hz << " [Hz]" - << std::endl << " dll_bw = " - << d_dll_bw_hz - << " [Hz], dll_narrow_bw = " - << d_dll_bw_narrow_hz << " [Hz]" - << std::endl; + << d_extend_correlation_ms + << " [ms] extended correlator for CH " + << d_channel << " : Satellite " + << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) + << " pll_bw = " << d_pll_bw_hz + << " [Hz], pll_narrow_bw = " + << d_pll_bw_narrow_hz << " [Hz]" + << std::endl << " dll_bw = " + << d_dll_bw_hz + << " [Hz], dll_narrow_bw = " + << d_dll_bw_narrow_hz << " [Hz]" + << std::endl; } // UPDATE INTEGRATION TIME - CURRENT_INTEGRATION_TIME_S = - static_cast(d_extend_correlation_ms) - * GPS_L1_CA_CODE_PERIOD; + CURRENT_INTEGRATION_TIME_S = static_cast(d_extend_correlation_ms) * GPS_L1_CA_CODE_PERIOD; enable_dll_pll = true; } else @@ -473,49 +440,25 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( { // continue extended coherent correlation // Compute the next buffer length based on the period of the PRN sequence and the code phase error estimation - double T_chip_seconds = 1.0 - / d_code_freq_chips; - double T_prn_seconds = T_chip_seconds - * GPS_L1_CA_CODE_LENGTH_CHIPS; - double T_prn_samples = T_prn_seconds - * static_cast(d_fs_in); + double T_chip_seconds = 1.0 / d_code_freq_chips; + double T_prn_seconds = T_chip_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS; + double T_prn_samples = T_prn_seconds * static_cast(d_fs_in); int K_prn_samples = round(T_prn_samples); - double K_T_prn_error_samples = K_prn_samples - - T_prn_samples; + double K_T_prn_error_samples = K_prn_samples - T_prn_samples; - d_rem_code_phase_samples = - d_rem_code_phase_samples - - K_T_prn_error_samples; - d_rem_code_phase_integer_samples = round( - d_rem_code_phase_samples); // round to a discrete number of samples - d_correlation_length_samples = K_prn_samples - + d_rem_code_phase_integer_samples; - d_rem_code_phase_samples = - d_rem_code_phase_samples - - d_rem_code_phase_integer_samples; + d_rem_code_phase_samples = d_rem_code_phase_samples - K_T_prn_error_samples; + d_rem_code_phase_integer_samples = round(d_rem_code_phase_samples); // round to a discrete number of samples + d_correlation_length_samples = K_prn_samples + d_rem_code_phase_integer_samples; + d_rem_code_phase_samples = d_rem_code_phase_samples - d_rem_code_phase_integer_samples; // 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); + d_code_phase_step_chips = d_code_freq_chips / static_cast(d_fs_in); // remnant code phase [chips] - d_rem_code_phase_chips = - d_rem_code_phase_samples - * (d_code_freq_chips - / static_cast(d_fs_in)); - d_rem_carrier_phase_rad = - fmod( - d_rem_carrier_phase_rad - + d_carrier_phase_step_rad - * static_cast(d_correlation_length_samples), - GPS_TWO_PI); + d_rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / static_cast(d_fs_in)); + d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast(d_correlation_length_samples), GPS_TWO_PI); // UPDATE ACCUMULATED CARRIER PHASE - CORRECTED_INTEGRATION_TIME_S = - (static_cast(d_correlation_length_samples) - / static_cast(d_fs_in)); - d_acc_carrier_phase_cycles -= - d_carrier_phase_step_rad - * d_correlation_length_samples - / GPS_TWO_PI; + CORRECTED_INTEGRATION_TIME_S = (static_cast(d_correlation_length_samples) / static_cast(d_fs_in)); + d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GPS_TWO_PI; // disable tracking loop and inform telemetry decoder enable_dll_pll = false; @@ -524,9 +467,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( { // perform basic (1ms) correlation // UPDATE INTEGRATION TIME - CURRENT_INTEGRATION_TIME_S = - static_cast(d_correlation_length_samples) - / static_cast(d_fs_in); + CURRENT_INTEGRATION_TIME_S = static_cast(d_correlation_length_samples) / static_cast(d_fs_in); enable_dll_pll = true; } } @@ -534,9 +475,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( else { // UPDATE INTEGRATION TIME - CURRENT_INTEGRATION_TIME_S = - static_cast(d_correlation_length_samples) - / static_cast(d_fs_in); + CURRENT_INTEGRATION_TIME_S = static_cast(d_correlation_length_samples) / static_cast(d_fs_in); enable_dll_pll = true; } @@ -544,26 +483,16 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( { // ################## PLL ########################################################## // Update PLL discriminator [rads/Ti -> Secs/Ti] - d_carr_phase_error_secs_Ti = pll_cloop_two_quadrant_atan( - std::complex( - d_correlator_outs_16sc[1].real(), - d_correlator_outs_16sc[1].imag())) - / GPS_TWO_PI; //prompt output + d_carr_phase_error_secs_Ti = pll_cloop_two_quadrant_atan(std::complex(d_correlator_outs_16sc[1].real(), d_correlator_outs_16sc[1].imag())) / GPS_TWO_PI; //prompt output // Carrier discriminator filter // NOTICE: The carrier loop filter includes the Carrier Doppler accumulator, as described in Kaplan // Input [s/Ti] -> output [Hz] - d_carrier_doppler_hz = - d_carrier_loop_filter.get_carrier_error(0.0, - d_carr_phase_error_secs_Ti, - CURRENT_INTEGRATION_TIME_S); + d_carrier_doppler_hz = d_carrier_loop_filter.get_carrier_error(0.0, d_carr_phase_error_secs_Ti, CURRENT_INTEGRATION_TIME_S); // PLL to DLL assistance [Secs/Ti] - d_pll_to_dll_assist_secs_Ti = (d_carrier_doppler_hz - * CURRENT_INTEGRATION_TIME_S) / GPS_L1_FREQ_HZ; + d_pll_to_dll_assist_secs_Ti = (d_carrier_doppler_hz * CURRENT_INTEGRATION_TIME_S) / GPS_L1_FREQ_HZ; // code Doppler frequency update - d_code_freq_chips = GPS_L1_CA_CODE_RATE_HZ - + ((d_carrier_doppler_hz * GPS_L1_CA_CODE_RATE_HZ) - / GPS_L1_FREQ_HZ); + d_code_freq_chips = GPS_L1_CA_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L1_CA_CODE_RATE_HZ) / GPS_L1_FREQ_HZ); // ################## DLL ########################################################## // DLL discriminator @@ -575,70 +504,44 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( d_correlator_outs_16sc[2].real(), d_correlator_outs_16sc[2].imag())); // [chips/Ti] //early and late // Code discriminator filter - d_code_error_filt_chips_s = d_code_loop_filter.get_code_nco( - d_code_error_chips_Ti); // input [chips/Ti] -> output [chips/second] - d_code_error_filt_chips_Ti = d_code_error_filt_chips_s - * CURRENT_INTEGRATION_TIME_S; - code_error_filt_secs_Ti = d_code_error_filt_chips_Ti - / d_code_freq_chips; // [s/Ti] + d_code_error_filt_chips_s = d_code_loop_filter.get_code_nco(d_code_error_chips_Ti); // input [chips/Ti] -> output [chips/second] + d_code_error_filt_chips_Ti = d_code_error_filt_chips_s * CURRENT_INTEGRATION_TIME_S; + code_error_filt_secs_Ti = d_code_error_filt_chips_Ti / d_code_freq_chips; // [s/Ti] // ################## CARRIER AND CODE NCO BUFFER ALIGNEMENT ####################### // 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_chip_seconds = 1.0 / d_code_freq_chips; - double T_prn_seconds = T_chip_seconds - * GPS_L1_CA_CODE_LENGTH_CHIPS; - double T_prn_samples = T_prn_seconds - * static_cast(d_fs_in); + double T_prn_seconds = T_chip_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS; + double T_prn_samples = T_prn_seconds * static_cast(d_fs_in); double K_prn_samples = round(T_prn_samples); - double K_T_prn_error_samples = K_prn_samples - - T_prn_samples; + double K_T_prn_error_samples = K_prn_samples - T_prn_samples; - d_rem_code_phase_samples = d_rem_code_phase_samples - - K_T_prn_error_samples - + code_error_filt_secs_Ti - * static_cast(d_fs_in); //(code_error_filt_secs_Ti + d_pll_to_dll_assist_secs_Ti) * static_cast(d_fs_in); - d_rem_code_phase_integer_samples = round( - d_rem_code_phase_samples); // round to a discrete number of samples - d_correlation_length_samples = K_prn_samples - + d_rem_code_phase_integer_samples; - d_rem_code_phase_samples = d_rem_code_phase_samples - - d_rem_code_phase_integer_samples; + d_rem_code_phase_samples = d_rem_code_phase_samples - K_T_prn_error_samples + code_error_filt_secs_Ti * static_cast(d_fs_in); //(code_error_filt_secs_Ti + d_pll_to_dll_assist_secs_Ti) * static_cast(d_fs_in); + d_rem_code_phase_integer_samples = round(d_rem_code_phase_samples); // round to a discrete number of samples + d_correlation_length_samples = K_prn_samples+ d_rem_code_phase_integer_samples; + d_rem_code_phase_samples = d_rem_code_phase_samples - d_rem_code_phase_integer_samples; //################### PLL COMMANDS ################################################# //carrier phase step (NCO phase increment per sample) [rads/sample] - d_carrier_phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz - / static_cast(d_fs_in); - d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad - * d_correlation_length_samples / GPS_TWO_PI; + d_carrier_phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz / static_cast(d_fs_in); + d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GPS_TWO_PI; // UPDATE ACCUMULATED CARRIER PHASE - CORRECTED_INTEGRATION_TIME_S = - (static_cast(d_correlation_length_samples) - / static_cast(d_fs_in)); + CORRECTED_INTEGRATION_TIME_S = (static_cast(d_correlation_length_samples) / static_cast(d_fs_in)); //remnant carrier phase [rad] - d_rem_carrier_phase_rad = fmod( - d_rem_carrier_phase_rad - + GPS_TWO_PI * d_carrier_doppler_hz - * CORRECTED_INTEGRATION_TIME_S, - GPS_TWO_PI); + d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + GPS_TWO_PI * d_carrier_doppler_hz * CORRECTED_INTEGRATION_TIME_S, GPS_TWO_PI); //################### 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); + d_code_phase_step_chips = d_code_freq_chips / static_cast(d_fs_in); //remnant code phase [chips] - d_rem_code_phase_chips = - d_rem_code_phase_samples - * (d_code_freq_chips - / static_cast(d_fs_in)); + d_rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / static_cast(d_fs_in)); // ####### CN0 ESTIMATION AND LOCK DETECTORS ####################################### if (d_cn0_estimation_counter < CN0_ESTIMATION_SAMPLES) { // fill buffer with prompt correlator output values - d_Prompt_buffer[d_cn0_estimation_counter] = - lv_cmake( - static_cast(d_correlator_outs_16sc[1].real()), + d_Prompt_buffer[d_cn0_estimation_counter] = lv_cmake(static_cast(d_correlator_outs_16sc[1].real()), static_cast(d_correlator_outs_16sc[1].imag())); // prompt d_cn0_estimation_counter++; } @@ -646,15 +549,11 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( { d_cn0_estimation_counter = 0; // Code lock indicator - d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, - CN0_ESTIMATION_SAMPLES, d_fs_in, - GPS_L1_CA_CODE_LENGTH_CHIPS); + d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES, d_fs_in, GPS_L1_CA_CODE_LENGTH_CHIPS); // Carrier lock indicator - d_carrier_lock_test = carrier_lock_detector( - d_Prompt_buffer, CN0_ESTIMATION_SAMPLES); + d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES); // Loss of lock detection - if (d_carrier_lock_test - < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < MINIMUM_VALID_CN0) + if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < MINIMUM_VALID_CN0) { d_carrier_lock_fail_counter++; } @@ -665,39 +564,28 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( d_carrier_lock_fail_counter--; } } - if (d_carrier_lock_fail_counter - > MAXIMUM_LOCK_FAIL_COUNTER) + if (d_carrier_lock_fail_counter > MAXIMUM_LOCK_FAIL_COUNTER) { - 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 + 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 multicorrelator_fpga_8sc->unlock_channel(); } } // ########### Output the tracking data to navigation and PVT ########## - current_synchro_data.Prompt_I = - static_cast((d_correlator_outs_16sc[1]).real()); - current_synchro_data.Prompt_Q = - static_cast((d_correlator_outs_16sc[1]).imag()); - current_synchro_data.Tracking_sample_counter = - d_sample_counter + d_correlation_length_samples; - current_synchro_data.Code_phase_samples = - d_rem_code_phase_samples; - current_synchro_data.Carrier_phase_rads = GPS_TWO_PI - * d_acc_carrier_phase_cycles; - current_synchro_data.Carrier_Doppler_hz = - d_carrier_doppler_hz; + current_synchro_data.Prompt_I = static_cast((d_correlator_outs_16sc[1]).real()); + current_synchro_data.Prompt_Q = static_cast((d_correlator_outs_16sc[1]).imag()); + current_synchro_data.Tracking_sample_counter = d_sample_counter + d_correlation_length_samples; + current_synchro_data.Code_phase_samples = d_rem_code_phase_samples; + current_synchro_data.Carrier_phase_rads = GPS_TWO_PI * d_acc_carrier_phase_cycles; + current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; current_synchro_data.Flag_valid_symbol_output = true; if (d_preamble_synchronized == true) { - current_synchro_data.correlation_length_ms = - d_extend_correlation_ms; + current_synchro_data.correlation_length_ms = d_extend_correlation_ms; } else { @@ -706,18 +594,12 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( } else { - current_synchro_data.Prompt_I = - static_cast((d_correlator_outs_16sc[1]).real()); - current_synchro_data.Prompt_Q = - static_cast((d_correlator_outs_16sc[1]).imag()); - current_synchro_data.Tracking_sample_counter = - d_sample_counter + d_correlation_length_samples; - current_synchro_data.Code_phase_samples = - d_rem_code_phase_samples; - current_synchro_data.Carrier_phase_rads = GPS_TWO_PI - * d_acc_carrier_phase_cycles; - current_synchro_data.Carrier_Doppler_hz = - d_carrier_doppler_hz; // todo: project the carrier doppler + current_synchro_data.Prompt_I = static_cast((d_correlator_outs_16sc[1]).real()); + current_synchro_data.Prompt_Q = static_cast((d_correlator_outs_16sc[1]).imag()); + current_synchro_data.Tracking_sample_counter = d_sample_counter + d_correlation_length_samples; + current_synchro_data.Code_phase_samples = d_rem_code_phase_samples; + current_synchro_data.Carrier_phase_rads = GPS_TWO_PI * d_acc_carrier_phase_cycles; + current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; // todo: project the carrier doppler current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz; } } @@ -728,13 +610,13 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( d_correlator_outs_16sc[n] = lv_cmake(0, 0); } - current_synchro_data.System = - { 'G'}; - current_synchro_data.Tracking_sample_counter = d_sample_counter - + d_correlation_length_samples; + current_synchro_data.System = {'G'}; + current_synchro_data.Tracking_sample_counter = d_sample_counter + d_correlation_length_samples; } + current_synchro_data.fs = d_fs_in; *out[0] = current_synchro_data; + if (d_dump) { // MULTIPLEXED FILE RECORDING - Record results to file @@ -744,84 +626,49 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work( double tmp_double; prompt_I = d_correlator_outs_16sc[1].real(); prompt_Q = d_correlator_outs_16sc[1].imag(); - tmp_E = std::abs( - std::complex(d_correlator_outs_16sc[0].real(), - d_correlator_outs_16sc[0].imag())); - tmp_P = std::abs( - std::complex(d_correlator_outs_16sc[1].real(), - d_correlator_outs_16sc[1].imag())); - tmp_L = std::abs( - std::complex(d_correlator_outs_16sc[2].real(), - d_correlator_outs_16sc[2].imag())); + tmp_E = std::abs(std::complex(d_correlator_outs_16sc[0].real(), d_correlator_outs_16sc[0].imag())); + tmp_P = std::abs(std::complex(d_correlator_outs_16sc[1].real(), d_correlator_outs_16sc[1].imag())); + tmp_L = std::abs(std::complex(d_correlator_outs_16sc[2].real(), d_correlator_outs_16sc[2].imag())); 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)); + 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)); + 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)); + 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_cycles), - sizeof(double)); + d_dump_file.write(reinterpret_cast(&d_acc_carrier_phase_cycles), 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)); + 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(&d_carr_phase_error_secs_Ti), - sizeof(double)); - d_dump_file.write( - reinterpret_cast(&d_carrier_doppler_hz), - sizeof(double)); + d_dump_file.write(reinterpret_cast(&d_carr_phase_error_secs_Ti), sizeof(double)); + d_dump_file.write(reinterpret_cast(&d_carrier_doppler_hz), sizeof(double)); //DLL commands - d_dump_file.write( - reinterpret_cast(&d_code_error_chips_Ti), - sizeof(double)); - d_dump_file.write( - reinterpret_cast(&d_code_error_filt_chips_Ti), - sizeof(double)); + d_dump_file.write(reinterpret_cast(&d_code_error_chips_Ti), sizeof(double)); + d_dump_file.write(reinterpret_cast(&d_code_error_filt_chips_Ti), 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)); + 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_code_error_chips_Ti - * CURRENT_INTEGRATION_TIME_S; - d_dump_file.write(reinterpret_cast(&tmp_double), - sizeof(double)); - tmp_double = static_cast(d_sample_counter - + d_correlation_length_samples); - d_dump_file.write(reinterpret_cast(&tmp_double), - sizeof(double)); + tmp_double = d_code_error_chips_Ti * CURRENT_INTEGRATION_TIME_S; + d_dump_file.write(reinterpret_cast(&tmp_double), sizeof(double)); + tmp_double = static_cast(d_sample_counter + d_correlation_length_samples); + d_dump_file.write(reinterpret_cast(&tmp_double), sizeof(double)); } catch (const std::ifstream::failure* e) { - LOG(WARNING) << "Exception writing trk dump file " - << e->what(); + LOG(WARNING) << "Exception writing trk dump file " << e->what(); } } @@ -844,24 +691,19 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::set_channel(unsigned int channel) { try { - d_dump_filename.append( - boost::lexical_cast( - d_channel)); + 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); + 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_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(); + << " Exception opening trk dump file " + << e->what(); } } }