From 411c8cedb0abaac43be82fd96aefb3ccf24e2de8 Mon Sep 17 00:00:00 2001 From: Javier Arribas Date: Mon, 23 Nov 2015 23:05:52 +0100 Subject: [PATCH] experimental interpolator in observables --- conf/gnss-sdr_Hybrid_byte_sim.conf | 14 +-- .../gps_l1_ca_observables_cc.cc | 72 +++++++++++++++- .../gps_l1_ca_observables_cc.h | 10 +++ .../gps_l1_ca_telemetry_decoder_cc.cc | 3 +- .../gps_l1_ca_telemetry_decoder_cc.h | 6 ++ .../gps_l1_ca_dll_pll_artemisa_tracking_cc.cc | 86 +++++++++---------- .../gps_l1_ca_dll_pll_artemisa_tracking_cc.h | 26 +++--- src/core/system_parameters/GPS_L1_CA.h | 3 + src/core/system_parameters/gnss_synchro.h | 1 + 9 files changed, 152 insertions(+), 69 deletions(-) diff --git a/conf/gnss-sdr_Hybrid_byte_sim.conf b/conf/gnss-sdr_Hybrid_byte_sim.conf index 6c0c8e334..186d73aff 100644 --- a/conf/gnss-sdr_Hybrid_byte_sim.conf +++ b/conf/gnss-sdr_Hybrid_byte_sim.conf @@ -158,7 +158,7 @@ Resampler.sample_freq_out=2600000 ;######### CHANNELS GLOBAL CONFIG ############ ;#count: Number of available GPS satellite channels. -Channels_1C.count=8 +Channels_1C.count=6 ;#count: Number of available Galileo satellite channels. Channels_1B.count=0 ;#in_acquisition: Number of channels simultaneously acquiring for the whole receiver @@ -173,11 +173,11 @@ Channel4.signal=1C Channel5.signal=1C Channel6.signal=1C Channel7.signal=1C -Channel8.signal=1B -Channel9.signal=1B -Channel10.signal=1B -Channel11.signal=1B -Channel12.signal=1B +Channel8.signal=1C +Channel9.signal=1C +Channel10.signal=1C +Channel11.signal=1C +Channel12.signal=1C Channel13.signal=1B Channel14.signal=1B Channel15.signal=1B @@ -247,7 +247,7 @@ Tracking_1C.dump=true Tracking_1C.dump_filename=../data/epl_tracking_ch_ ;#pll_bw_hz: PLL loop filter bandwidth [Hz] -Tracking_1C.pll_bw_hz=45.0; +Tracking_1C.pll_bw_hz=20.0; ;#dll_bw_hz: DLL loop filter bandwidth [Hz] Tracking_1C.dll_bw_hz=2.0; diff --git a/src/algorithms/observables/gnuradio_blocks/gps_l1_ca_observables_cc.cc b/src/algorithms/observables/gnuradio_blocks/gps_l1_ca_observables_cc.cc index a02b9fc59..d11b06c92 100644 --- a/src/algorithms/observables/gnuradio_blocks/gps_l1_ca_observables_cc.cc +++ b/src/algorithms/observables/gnuradio_blocks/gps_l1_ca_observables_cc.cc @@ -63,6 +63,13 @@ gps_l1_ca_observables_cc::gps_l1_ca_observables_cc(unsigned int nchannels, boost d_dump_filename = dump_filename; d_flag_averaging = flag_averaging; + for (int i=0;i(d_nchannels)); + d_carrier_doppler_queue_hz.push_back(std::deque(d_nchannels)); + d_symbol_TOW_queue_s.push_back(std::deque(d_nchannels)); + } + // ############# ENABLE DATA FILE LOG ################# if (d_dump == true) { @@ -128,6 +135,33 @@ int gps_l1_ca_observables_cc::general_work (int noutput_items, gr_vector_int &ni { //record the word structure in a map for pseudorange computation current_gnss_synchro_map.insert(std::pair(current_gnss_synchro[i].Channel_ID, current_gnss_synchro[i])); + + //################### SAVE DOPPLER AND ACC CARRIER PHASE HISTORIC DATA FOR INTERPOLATION IN OBSERVABLE MODULE ####### + d_carrier_doppler_queue_hz[i].push_back(current_gnss_synchro[i].Carrier_Doppler_hz); + d_acc_carrier_phase_queue_rads[i].push_back(current_gnss_synchro[i].Carrier_phase_rads); + // save TOW history + d_symbol_TOW_queue_s[i].push_back(current_gnss_synchro[i].d_TOW_at_current_symbol); + + if (d_carrier_doppler_queue_hz[i].size()>GPS_L1_CA_HISTORY_DEEP) + { + d_carrier_doppler_queue_hz[i].pop_front(); + } + if (d_acc_carrier_phase_queue_rads[i].size()>GPS_L1_CA_HISTORY_DEEP) + { + d_acc_carrier_phase_queue_rads[i].pop_front(); + } + if (d_symbol_TOW_queue_s[i].size()>GPS_L1_CA_HISTORY_DEEP) + { + d_symbol_TOW_queue_s[i].pop_front(); + } + }else{ + // Clear the observables history for this channel + if (d_symbol_TOW_queue_s[i].size()>0) + { + d_symbol_TOW_queue_s[i].clear(); + d_carrier_doppler_queue_hz[i].clear(); + d_acc_carrier_phase_queue_rads[i].clear(); + } } } @@ -150,6 +184,12 @@ int gps_l1_ca_observables_cc::general_work (int noutput_items, gr_vector_int &ni double traveltime_ms; double pseudorange_m; double delta_rx_time_ms; + arma::vec symbol_TOW_vec_s; + arma::vec dopper_vec_hz; + arma::vec dopper_vec_interp_hz; + arma::vec acc_phase_vec_rads; + arma::vec acc_phase_vec_interp_rads; + arma::vec desired_symbol_TOW(1); for(gnss_synchro_iter = current_gnss_synchro_map.begin(); gnss_synchro_iter != current_gnss_synchro_map.end(); gnss_synchro_iter++) { // compute the required symbol history shift in order to match the reference symbol @@ -160,10 +200,36 @@ int gps_l1_ca_observables_cc::general_work (int noutput_items, gr_vector_int &ni // update the pseudorange object current_gnss_synchro[gnss_synchro_iter->second.Channel_ID] = gnss_synchro_iter->second; current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].debug_var1=delta_rx_time_ms; - //current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Carrier_phase_rads = current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Carrier_phase_rads+ GPS_TWO_PI*0.001*delta_rx_time_ms*current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Carrier_Doppler_hz; current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Pseudorange_m = pseudorange_m; - current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Flag_valid_pseudorange = true; - current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].d_TOW_at_current_symbol = round(d_TOW_reference*1000)/1000 + GPS_STARTOFFSET_ms/1000.0; + current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Flag_valid_pseudorange = true; + current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].d_TOW_at_current_symbol = round(d_TOW_reference*1000.0)/1000.0 + GPS_STARTOFFSET_ms/1000.0; + + if (d_symbol_TOW_queue_s[gnss_synchro_iter->second.Channel_ID].size()>=GPS_L1_CA_HISTORY_DEEP) + { + // compute interpolated observation values for Doppler and Accumulate carrier phase + symbol_TOW_vec_s=arma::vec(std::vector(d_symbol_TOW_queue_s[gnss_synchro_iter->second.Channel_ID].begin(), d_symbol_TOW_queue_s[gnss_synchro_iter->second.Channel_ID].end())); + acc_phase_vec_rads=arma::vec(std::vector(d_acc_carrier_phase_queue_rads[gnss_synchro_iter->second.Channel_ID].begin(), d_acc_carrier_phase_queue_rads[gnss_synchro_iter->second.Channel_ID].end())); + dopper_vec_hz=arma::vec(std::vector(d_carrier_doppler_queue_hz[gnss_synchro_iter->second.Channel_ID].begin(), d_carrier_doppler_queue_hz[gnss_synchro_iter->second.Channel_ID].end())); + + + //std::cout<<"symbol_TOW_vec_s[0]="< queue, bool dump, std::string dump_filename, int output_rate_ms, bool flag_averaging); gps_l1_ca_observables_cc(unsigned int nchannels, boost::shared_ptr queue, bool dump, std::string dump_filename, int output_rate_ms, bool flag_averaging); + + //Tracking observable history + std::vector> d_acc_carrier_phase_queue_rads; + std::vector> d_carrier_doppler_queue_hz; + std::vector> d_symbol_TOW_queue_s; + // class private vars boost::shared_ptr d_queue; bool d_dump; diff --git a/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc b/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc index 260f6ded8..09c34a95b 100644 --- a/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc +++ b/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc @@ -327,13 +327,12 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i current_synchro_data.d_TOW = d_TOW_at_Preamble; current_synchro_data.d_TOW_at_current_symbol = d_TOW_at_current_symbol; - current_synchro_data.d_TOW_hybrid_at_current_symbol = current_synchro_data.d_TOW_at_current_symbol; // to be used in the hybrid configuration current_synchro_data.Flag_valid_word = (d_flag_frame_sync == true and d_flag_parity == true and flag_TOW_set == true); current_synchro_data.Flag_preamble = d_flag_preamble; current_synchro_data.Prn_timestamp_ms = in[0][0].Tracking_timestamp_secs * 1000.0; - current_synchro_data.Prn_timestamp_at_preamble_ms = Prn_timestamp_at_preamble_ms; + current_synchro_data.Prn_timestamp_at_preamble_ms = Prn_timestamp_at_preamble_ms; if(d_dump == true) { // MULTIPLEXED FILE RECORDING - Record results to file diff --git a/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.h b/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.h index f9c595711..beae77847 100644 --- a/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.h +++ b/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.h @@ -35,6 +35,7 @@ #include #include #include +#include #include "GPS_L1_CA.h" #include "gps_l1_ca_subframe_fsm.h" #include "concurrent_queue.h" @@ -142,6 +143,11 @@ private: double d_TOW_at_Preamble; double d_TOW_at_current_symbol; + std::deque d_symbol_TOW_queue_s; + // Doppler and Phase accumulator queue for interpolation in Observables + std::deque d_carrier_doppler_queue_hz; + std::deque d_acc_carrier_phase_queue_rads; + double Prn_timestamp_at_preamble_ms; bool flag_TOW_set; diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_artemisa_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_artemisa_tracking_cc.cc index f84c3448d..282ba2116 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_artemisa_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_artemisa_tracking_cc.cc @@ -167,7 +167,7 @@ gps_l1_ca_dll_pll_artemisa_tracking_cc::gps_l1_ca_dll_pll_artemisa_tracking_cc( 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_acc_carrier_phase_cycles = 0.0; d_code_phase_samples = 0.0; d_pll_to_dll_assist_secs_Ti=0.0; @@ -177,7 +177,6 @@ gps_l1_ca_dll_pll_artemisa_tracking_cc::gps_l1_ca_dll_pll_artemisa_tracking_cc( void gps_l1_ca_dll_pll_artemisa_tracking_cc::start_tracking() { - /* * correct the code phase according to the delay between acq and trk */ @@ -186,31 +185,31 @@ void gps_l1_ca_dll_pll_artemisa_tracking_cc::start_tracking() d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples; long int acq_trk_diff_samples; - float acq_trk_diff_seconds; + 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_seconds = static_cast(acq_trk_diff_samples) / static_cast(d_fs_in); //doppler effect // Fd=(C/(C+Vr))*F - float 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 - float T_chip_mod_seconds; - float T_prn_mod_seconds; - float T_prn_mod_samples; + 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); T_chip_mod_seconds = 1/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); + T_prn_mod_samples = T_prn_mod_seconds * static_cast(d_fs_in); d_current_prn_length_samples = round(T_prn_mod_samples); - float T_prn_true_seconds = GPS_L1_CA_CODE_LENGTH_CHIPS / GPS_L1_CA_CODE_RATE_HZ; - float T_prn_true_samples = T_prn_true_seconds * static_cast(d_fs_in); - float T_prn_diff_seconds= T_prn_true_seconds - T_prn_mod_seconds; - float N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds; - float 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); + 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); if (corrected_acq_phase_samples < 0) { corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples; @@ -220,7 +219,7 @@ void gps_l1_ca_dll_pll_artemisa_tracking_cc::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=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 @@ -240,7 +239,7 @@ void gps_l1_ca_dll_pll_artemisa_tracking_cc::start_tracking() d_rem_code_phase_samples = 0.0; d_rem_carrier_phase_rad = 0.0; d_rem_code_phase_chips =0.0; - d_acc_carrier_phase_rad = 0.0; + d_acc_carrier_phase_cycles = 0.0; d_pll_to_dll_assist_secs_Ti=0.0; d_code_phase_samples = d_acq_code_phase_samples; @@ -288,26 +287,26 @@ int gps_l1_ca_dll_pll_artemisa_tracking_cc::general_work (int noutput_items, gr_ Gnss_Synchro current_synchro_data = Gnss_Synchro(); // process vars - float code_error_chips_Ti=0.0; - float code_error_filt_chips=0.0; - float code_error_filt_secs_Ti=0.0; - float INTEGRATION_TIME=0.0; + double code_error_chips_Ti=0.0; + double code_error_filt_chips=0.0; + double code_error_filt_secs_Ti=0.0; + double INTEGRATION_TIME; INTEGRATION_TIME=GPS_L1_CA_CODE_PERIOD; // [Ti] - float dll_code_error_secs_Ti=0.0; - float carr_phase_error_secs_Ti=0.0; - float carr_phase_error_filt_secs_ti=0.0; + double dll_code_error_secs_Ti=0.0; + double carr_phase_error_secs_Ti=0.0; + double carr_phase_error_filt_secs_ti=0.0; double old_d_rem_code_phase_samples; - double old_d_acc_carrier_phase_rad; + double old_d_acc_carrier_phase_cycles; if (d_enable_tracking == true) { // Receiver signal alignment if (d_pull_in == true) { int samples_offset; - float acq_trk_shif_correction_samples; + 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)); + 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 d_pull_in = false; @@ -344,9 +343,9 @@ int gps_l1_ca_dll_pll_artemisa_tracking_cc::general_work (int noutput_items, gr_ // Input [s/Ti] -> output [Hz] d_carrier_doppler_hz = d_carrier_loop_filter.get_carrier_error(0.0, carr_phase_error_secs_Ti, INTEGRATION_TIME); //carrier phase accumulator for (K) doppler estimation - //d_acc_carrier_phase_rad -= (GPS_TWO_PI*d_carrier_doppler_hz*INTEGRATION_TIME); - old_d_acc_carrier_phase_rad=d_acc_carrier_phase_rad; - d_acc_carrier_phase_rad -= (GPS_TWO_PI*static_cast(d_carrier_doppler_hz)*static_cast(INTEGRATION_TIME)); + //d_acc_carrier_phase_cycles -= (d_carrier_doppler_hz*INTEGRATION_TIME); + old_d_acc_carrier_phase_cycles=d_acc_carrier_phase_cycles; + d_acc_carrier_phase_cycles -= static_cast(d_carrier_doppler_hz)*INTEGRATION_TIME; // PLL to DLL assistance [Secs/Ti] d_pll_to_dll_assist_secs_Ti = (d_carrier_doppler_hz*GPS_L1_CA_CODE_PERIOD)/GPS_L1_FREQ_HZ; // code frequency (include code Doppler estimation here) @@ -365,7 +364,7 @@ int gps_l1_ca_dll_pll_artemisa_tracking_cc::general_work (int noutput_items, gr_ //################### 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_carrier_phase_step_rad=GPS_TWO_PI*d_carrier_doppler_hz/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 * GPS_L1_CA_CODE_PERIOD,GPS_TWO_PI);//GPS_TWO_PI*carr_phase_error_filt_secs_ti; @@ -422,7 +421,7 @@ int gps_l1_ca_dll_pll_artemisa_tracking_cc::general_work (int noutput_items, gr_ // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0 current_synchro_data.Code_phase_secs = 0; - current_synchro_data.Carrier_phase_rads = static_cast(d_acc_carrier_phase_rad); + current_synchro_data.Carrier_phase_rads = GPS_TWO_PI*static_cast(d_acc_carrier_phase_cycles); current_synchro_data.Carrier_Doppler_hz = static_cast(d_carrier_doppler_hz); current_synchro_data.CN0_dB_hz = static_cast(d_CN0_SNV_dB_Hz); current_synchro_data.Flag_valid_pseudorange = false; @@ -509,28 +508,27 @@ int gps_l1_ca_dll_pll_artemisa_tracking_cc::general_work (int noutput_items, gr_ //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(float)); + 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(float)); - tmp_float=d_code_freq_chips; - d_dump_file.write(reinterpret_cast(&tmp_float), sizeof(float)); + 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_phase_error_secs_Ti), sizeof(float)); - d_dump_file.write(reinterpret_cast(&d_carrier_doppler_hz), sizeof(float)); + d_dump_file.write(reinterpret_cast(&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(&code_error_chips_Ti), sizeof(float)); - d_dump_file.write(reinterpret_cast(&code_error_filt_chips), sizeof(float)); + d_dump_file.write(reinterpret_cast(&code_error_chips_Ti), 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(float)); - d_dump_file.write(reinterpret_cast(&d_carrier_lock_test), sizeof(float)); + 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_float = d_rem_code_phase_samples; - d_dump_file.write(reinterpret_cast(&tmp_float), sizeof(float)); + 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)); } diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_artemisa_tracking_cc.h b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_artemisa_tracking_cc.h index 26ed6a070..47ad8bb65 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_artemisa_tracking_cc.h +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_artemisa_tracking_cc.h @@ -132,25 +132,25 @@ private: // remaining code phase and carrier phase between tracking loops double d_rem_code_phase_samples; - float d_rem_code_phase_chips; - float d_rem_carrier_phase_rad; + double d_rem_code_phase_chips; + double d_rem_carrier_phase_rad; // PLL and DLL filter library Tracking_2nd_DLL_filter d_code_loop_filter; Tracking_FLL_PLL_filter d_carrier_loop_filter; // acquisition - float d_acq_code_phase_samples; - float d_acq_carrier_doppler_hz; + double d_acq_code_phase_samples; + double d_acq_carrier_doppler_hz; // tracking vars double d_code_freq_chips; - float d_code_phase_step_chips; - float d_carrier_doppler_hz; - float d_carrier_phase_step_rad; - double d_acc_carrier_phase_rad; - float d_code_phase_samples; - float d_pll_to_dll_assist_secs_Ti; + double d_code_phase_step_chips; + double d_carrier_doppler_hz; + double d_carrier_phase_step_rad; + double d_acc_carrier_phase_cycles; + double d_code_phase_samples; + double d_pll_to_dll_assist_secs_Ti; //PRN period in samples int d_current_prn_length_samples; @@ -162,9 +162,9 @@ private: // CN0 estimation and lock detector int d_cn0_estimation_counter; gr_complex* d_Prompt_buffer; - float d_carrier_lock_test; - float d_CN0_SNV_dB_Hz; - float d_carrier_lock_threshold; + double d_carrier_lock_test; + double d_CN0_SNV_dB_Hz; + double d_carrier_lock_threshold; int d_carrier_lock_fail_counter; // control vars diff --git a/src/core/system_parameters/GPS_L1_CA.h b/src/core/system_parameters/GPS_L1_CA.h index 000800045..3c4a3bd0d 100644 --- a/src/core/system_parameters/GPS_L1_CA.h +++ b/src/core/system_parameters/GPS_L1_CA.h @@ -68,6 +68,9 @@ const double MAX_TOA_DELAY_MS = 20; //#define NAVIGATION_SOLUTION_RATE_MS 1000 // this cannot go here const double GPS_STARTOFFSET_ms = 68.802; //[ms] Initial sign. travel time (this cannot go here) + +// OBSERVABLE HISTORY DEEP FOR INTERPOLATION +const int GPS_L1_CA_HISTORY_DEEP=200; // NAVIGATION MESSAGE DEMODULATION AND DECODING #define GPS_PREAMBLE {1, 0, 0, 0, 1, 0, 1, 1} diff --git a/src/core/system_parameters/gnss_synchro.h b/src/core/system_parameters/gnss_synchro.h index 600f12285..9c603f90e 100644 --- a/src/core/system_parameters/gnss_synchro.h +++ b/src/core/system_parameters/gnss_synchro.h @@ -32,6 +32,7 @@ #define GNSS_SDR_GNSS_SYNCHRO_H_ #include "gnss_signal.h" +#include /*! * \brief This is the class that contains the information that is shared