[hamradio-commits] [gnss-sdr] 46/126: experimental interpolator in observables
Carles Fernandez
carles_fernandez-guest at moszumanska.debian.org
Sat Dec 26 18:38:00 UTC 2015
This is an automated email from the git hooks/post-receive script.
carles_fernandez-guest pushed a commit to branch next
in repository gnss-sdr.
commit 411c8cedb0abaac43be82fd96aefb3ccf24e2de8
Author: Javier Arribas <javiarribas at gmail.com>
Date: Mon Nov 23 23:05:52 2015 +0100
experimental interpolator in observables
---
conf/gnss-sdr_Hybrid_byte_sim.conf | 14 ++--
.../gnuradio_blocks/gps_l1_ca_observables_cc.cc | 72 +++++++++++++++++-
.../gnuradio_blocks/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 6c0c8e3..186d73a 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 a02b9fc..d11b06c 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;i++)
+ {
+ d_acc_carrier_phase_queue_rads.push_back(std::deque<double>(d_nchannels));
+ d_carrier_doppler_queue_hz.push_back(std::deque<double>(d_nchannels));
+ d_symbol_TOW_queue_s.push_back(std::deque<double>(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<int, Gnss_Synchro>(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<double>(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<double>(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<double>(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]="<<symbol_TOW_vec_s[0]<<std::endl;
+ //std::cout<<"symbol_TOW_vec_s[GPS_L1_CA_HISTORY_DEEP-1]="<<symbol_TOW_vec_s[GPS_L1_CA_HISTORY_DEEP-1]<<std::endl;
+ //std::cout<<"acc_phase_vec_rads="<<acc_phase_vec_rads<<std::endl;
+ //std::cout<<"dopper_vec_hz="<<dopper_vec_hz<<std::endl;
+
+ desired_symbol_TOW[0]=symbol_TOW_vec_s[GPS_L1_CA_HISTORY_DEEP-1]+delta_rx_time_ms/1000.0;
+ //std::cout<<"desired_symbol_TOW="<<desired_symbol_TOW[0]<<std::endl;
+
+ arma::interp1(symbol_TOW_vec_s,dopper_vec_hz,desired_symbol_TOW,dopper_vec_interp_hz);
+ arma::interp1(symbol_TOW_vec_s,acc_phase_vec_rads,desired_symbol_TOW,acc_phase_vec_interp_rads);
+
+ //std::cout<<"acc_phase_vec_interp_rads="<<acc_phase_vec_interp_rads[0]<<std::endl;
+ //std::cout<<"dopper_vec_interp_hz="<<dopper_vec_interp_hz[0]<<std::endl;
+
+ current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Carrier_phase_rads =acc_phase_vec_interp_rads[0];
+ current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Carrier_Doppler_hz =dopper_vec_interp_hz[0];
+ }
+
}
}
diff --git a/src/algorithms/observables/gnuradio_blocks/gps_l1_ca_observables_cc.h b/src/algorithms/observables/gnuradio_blocks/gps_l1_ca_observables_cc.h
index 7f7dacb..56cfd6d 100644
--- a/src/algorithms/observables/gnuradio_blocks/gps_l1_ca_observables_cc.h
+++ b/src/algorithms/observables/gnuradio_blocks/gps_l1_ca_observables_cc.h
@@ -33,12 +33,16 @@
#include <fstream>
#include <queue>
+#include <deque>
+#include <vector>
#include <string>
#include <utility>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
+#include <boost/shared_ptr.hpp>
#include <gnuradio/block.h>
#include <gnuradio/msg_queue.h>
+#include <armadillo>
#include "concurrent_queue.h"
#include "gps_navigation_message.h"
#include "rinex_printer.h"
@@ -68,6 +72,12 @@ private:
gps_l1_ca_make_observables_cc(unsigned int nchannels, boost::shared_ptr<gr::msg_queue> 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<gr::msg_queue> queue, bool dump, std::string dump_filename, int output_rate_ms, bool flag_averaging);
+
+ //Tracking observable history
+ std::vector<std::deque<double>> d_acc_carrier_phase_queue_rads;
+ std::vector<std::deque<double>> d_carrier_doppler_queue_hz;
+ std::vector<std::deque<double>> d_symbol_TOW_queue_s;
+
// class private vars
boost::shared_ptr<gr::msg_queue> 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 260f6de..09c34a9 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 f9c5957..beae778 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 <string>
#include <gnuradio/block.h>
#include <gnuradio/msg_queue.h>
+#include <deque>
#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<double> d_symbol_TOW_queue_s;
+ // Doppler and Phase accumulator queue for interpolation in Observables
+ std::deque<double> d_carrier_doppler_queue_hz;
+ std::deque<double> 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 f84c344..282ba21 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<long int>(d_sample_counter) - static_cast<long int>(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<float>(acq_trk_diff_samples) / static_cast<float>(d_fs_in);
+ acq_trk_diff_seconds = static_cast<double>(acq_trk_diff_samples) / static_cast<double>(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<double>(d_code_freq_chips) / static_cast<double>(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<float>(d_fs_in);
+ T_prn_mod_samples = T_prn_mod_seconds * static_cast<double>(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<float>(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<float>(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<double>(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<double>(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<float>(d_fs_in);
+ d_carrier_phase_step_rad=GPS_TWO_PI*d_carrier_doppler_hz/static_cast<double>(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<float>(acq_to_trk_delay_samples), static_cast<float>(d_current_prn_length_samples));
+ acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast<double>(acq_to_trk_delay_samples), static_cast<double>(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<double>(d_carrier_doppler_hz)*static_cast<double>(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<double>(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<float>(d_fs_in);
+ d_carrier_phase_step_rad=GPS_TWO_PI*d_carrier_doppler_hz/static_cast<double>(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<double>(d_acc_carrier_phase_rad);
+ current_synchro_data.Carrier_phase_rads = GPS_TWO_PI*static_cast<double>(d_acc_carrier_phase_cycles);
current_synchro_data.Carrier_Doppler_hz = static_cast<double>(d_carrier_doppler_hz);
current_synchro_data.CN0_dB_hz = static_cast<double>(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<char*>(&d_sample_counter), sizeof(unsigned long int));
// accumulated carrier phase
- d_dump_file.write(reinterpret_cast<char*>(&d_acc_carrier_phase_rad), sizeof(float));
+ d_dump_file.write(reinterpret_cast<char*>(&d_acc_carrier_phase_cycles), sizeof(double));
// carrier and code frequency
- d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(float));
- tmp_float=d_code_freq_chips;
- d_dump_file.write(reinterpret_cast<char*>(&tmp_float), sizeof(float));
+ d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(double));
+ d_dump_file.write(reinterpret_cast<char*>(&d_code_freq_chips), sizeof(double));
//PLL commands
- d_dump_file.write(reinterpret_cast<char*>(&carr_phase_error_secs_Ti), sizeof(float));
- d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(float));
+ d_dump_file.write(reinterpret_cast<char*>(&carr_phase_error_secs_Ti), sizeof(double));
+ d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(double));
//DLL commands
- d_dump_file.write(reinterpret_cast<char*>(&code_error_chips_Ti), sizeof(float));
- d_dump_file.write(reinterpret_cast<char*>(&code_error_filt_chips), sizeof(float));
+ d_dump_file.write(reinterpret_cast<char*>(&code_error_chips_Ti), sizeof(double));
+ d_dump_file.write(reinterpret_cast<char*>(&code_error_filt_chips), sizeof(double));
// CN0 and carrier lock test
- d_dump_file.write(reinterpret_cast<char*>(&d_CN0_SNV_dB_Hz), sizeof(float));
- d_dump_file.write(reinterpret_cast<char*>(&d_carrier_lock_test), sizeof(float));
+ d_dump_file.write(reinterpret_cast<char*>(&d_CN0_SNV_dB_Hz), sizeof(double));
+ d_dump_file.write(reinterpret_cast<char*>(&d_carrier_lock_test), sizeof(double));
// AUX vars (for debug purposes)
- tmp_float = d_rem_code_phase_samples;
- d_dump_file.write(reinterpret_cast<char*>(&tmp_float), sizeof(float));
+ tmp_double = d_rem_code_phase_samples;
+ d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
tmp_double = static_cast<double>(d_sample_counter + d_current_prn_length_samples);
d_dump_file.write(reinterpret_cast<char*>(&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 26ed6a0..47ad8bb 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 0008000..3c4a3bd 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 600f122..9c603f9 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 <deque>
/*!
* \brief This is the class that contains the information that is shared
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-hamradio/gnss-sdr.git
More information about the pkg-hamradio-commits
mailing list