Refactoring the gnss_synchro member initializations and minor bug fixes.

src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc

@@ -272,6 +272,12 @@ void galileo_e5a_noncoherentIQ_acquisition_caf_cc::set_local_code(std::complex<f
 
 void galileo_e5a_noncoherentIQ_acquisition_caf_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.cc

@@ -152,6 +152,12 @@ void galileo_pcps_8ms_acquisition_cc::set_local_code(std::complex<float> * code)
 
 void galileo_pcps_8ms_acquisition_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc

@@ -182,6 +182,12 @@ void pcps_acquisition_cc::update_local_carrier(gr_complex* carrier_vector, int c
 
 void pcps_acquisition_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc

@@ -163,6 +163,12 @@ void pcps_acquisition_fine_doppler_cc::set_local_code(std::complex<float> * code
 
 void pcps_acquisition_fine_doppler_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_sc.cc

@@ -184,6 +184,12 @@ void pcps_acquisition_sc::update_local_carrier(gr_complex* carrier_vector, int c
 
 void pcps_acquisition_sc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc

@@ -157,6 +157,12 @@ void pcps_assisted_acquisition_cc::set_local_code(std::complex<float> * code)
 
 void pcps_assisted_acquisition_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.cc

@@ -167,6 +167,12 @@ void pcps_cccwsr_acquisition_cc::set_local_code(std::complex<float>* code_data,
 
 void pcps_cccwsr_acquisition_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/pcps_multithread_acquisition_cc.cc

@@ -153,6 +153,12 @@ pcps_multithread_acquisition_cc::~pcps_multithread_acquisition_cc()
 
 void pcps_multithread_acquisition_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.cc

@@ -289,6 +289,12 @@ int pcps_opencl_acquisition_cc::init_opencl_environment(std::string kernel_filen
 
 void pcps_opencl_acquisition_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.cc

@@ -196,6 +196,12 @@ void pcps_quicksync_acquisition_cc::set_local_code(std::complex<float>* code)
 
 void pcps_quicksync_acquisition_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     //DLOG(INFO) << "START init";
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;

src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.cc

@@ -163,6 +163,12 @@ void pcps_tong_acquisition_cc::set_local_code(std::complex<float> * code)
 
 void pcps_tong_acquisition_cc::init()
 {
+	d_gnss_synchro->Flag_valid_acquisition=false;
+	d_gnss_synchro->Flag_valid_symbol_output=false;
+	d_gnss_synchro->Flag_valid_pseudorange=false;
+	d_gnss_synchro->Flag_valid_word=false;
+	d_gnss_synchro->Flag_preamble=false;
+
     d_gnss_synchro->Acq_delay_samples = 0.0;
     d_gnss_synchro->Acq_doppler_hz = 0.0;
     d_gnss_synchro->Acq_samplestamp_samples = 0;

src/algorithms/observables/gnuradio_blocks/mixed_observables_cc.cc

@@ -194,7 +194,7 @@ int mixed_observables_cc::general_work (int noutput_items, gr_vector_int &ninput
                             d_dump_file.write((char*)&tmp_double, sizeof(double));
                             tmp_double = current_gnss_synchro[i].PRN;
                             d_dump_file.write((char*)&tmp_double, sizeof(double));
-                            tmp_double = (double)(current_gnss_synchro[i].Flag_valid_tracking==true);
+                            tmp_double = (double)(current_gnss_synchro[i].Flag_valid_symbol_output==true);
                             d_dump_file.write((char*)&tmp_double, sizeof(double));
                             tmp_double = current_gnss_synchro[i].Prompt_I;
                             d_dump_file.write((char*)&tmp_double, sizeof(double));

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2_m_telemetry_decoder_cc.cc

@@ -130,7 +130,7 @@ int gps_l2_m_telemetry_decoder_cc::general_work (int noutput_items __attribute__
     // decode only if enough samples in buffer
     if(d_sample_buf.size() >= d_block_size)
         {
-            if (in[0].Flag_valid_tracking == false) // check if the tracking is locked
+            if (in[0].Flag_valid_symbol_output == false) // check if the tracking is locked
                 {
                     //LOG(INFO)<< "Discarting channel "<<d_channel<<" tracking not ready!"<<std::endl;
                     d_flag_valid_word = false;

src/algorithms/tracking/gnuradio_blocks/galileo_e1_dll_pll_veml_tracking_cc.cc

@@ -270,8 +270,17 @@ int galileo_e1_dll_pll_veml_tracking_cc::general_work (int noutput_items __attri
     double code_error_chips = 0.0;
     double code_error_filt_chips = 0.0;
 
+
+    // Block input data and block output stream pointers
+    const gr_complex* in = (gr_complex*) input_items[0];
+    Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0];
+    // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
+    Gnss_Synchro current_synchro_data;
+
     if (d_enable_tracking == true)
         {
+			// Fill the acquisition data
+			current_synchro_data = *d_acquisition_gnss_synchro;
             if (d_pull_in == true)
                 {
                     /*
@@ -283,21 +292,14 @@ int galileo_e1_dll_pll_veml_tracking_cc::general_work (int noutput_items __attri
                     acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
                     acq_trk_shif_correction_samples = d_current_prn_length_samples - std::fmod(static_cast<double>(acq_to_trk_delay_samples), static_cast<double>(d_current_prn_length_samples));
                     samples_offset = std::round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
+                    *out[0] = current_synchro_data;
                     d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples
                     d_pull_in = false;
                     consume_each(samples_offset); //shift input to perform alignment with local replica
                     return 1;
                 }
 
-            // 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;
-
-            // Block input data and block output stream pointers
-            const gr_complex* in = (gr_complex*) input_items[0];
-            Gnss_Synchro **out = (Gnss_Synchro **) &output_items[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);
@@ -396,36 +398,29 @@ int galileo_e1_dll_pll_veml_tracking_cc::general_work (int noutput_items __attri
 
             current_synchro_data.Prompt_I = static_cast<double>((*d_Prompt).real());
             current_synchro_data.Prompt_Q = static_cast<double>((*d_Prompt).imag());
-
+            // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!)
-            // Tracking_timestamp_secs is aligned with the NEXT PRN start sample (Hybridization problem!)
-            //compute remnant code phase samples BEFORE the Tracking timestamp
-            //d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample
-            //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter +
-            //        (double)d_current_prn_length_samples + (double)d_rem_code_phase_samples) / static_cast<double>(d_fs_in);
-
-            // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!, but some glitches??)
             current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
             //compute remnant code phase samples AFTER the Tracking timestamp
             d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample
-
             // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0
             current_synchro_data.Code_phase_secs = 0;
             current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad;
             current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
             current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
-            current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = true;
-            *out[0] = current_synchro_data;
+            current_synchro_data.correlation_length_ms=4;
+
         }
     else
     {
     	*d_Early = gr_complex(0,0);
     	*d_Prompt = gr_complex(0,0);
     	*d_Late = gr_complex(0,0);
-    	Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; //block output stream pointer
     	// GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
-        d_acquisition_gnss_synchro->Flag_valid_pseudorange = false;
+    	current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
-    	*out[0] = *d_acquisition_gnss_synchro;
     }
+    //assign the GNURadio block output data
+    *out[0] = current_synchro_data;
 
     if(d_dump)
         {
@@ -535,8 +530,4 @@ void galileo_e1_dll_pll_veml_tracking_cc::set_channel_queue(concurrent_queue<int
 void galileo_e1_dll_pll_veml_tracking_cc::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
 {
     d_acquisition_gnss_synchro = p_gnss_synchro;
-    //  Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
-    //DLOG(INFO) << "Tracking code phase set to " << d_acq_code_phase_samples;
-    //DLOG(INFO) << "Tracking carrier doppler set to " << d_acq_carrier_doppler_hz;
-    //DLOG(INFO) << "Tracking Satellite set to " << d_satellite;
 }

src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc

@@ -268,9 +268,15 @@ int Galileo_E1_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attr
     float code_error_filt_chips;
 
     tcp_packet_data tcp_data;
-
+	// GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
+	Gnss_Synchro current_synchro_data;
+	// Block input data and block output stream pointers
+	const gr_complex* in = (gr_complex*) input_items[0];
+	Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0];
     if (d_enable_tracking == true)
         {
+			// Fill the acquisition data
+			current_synchro_data = *d_acquisition_gnss_synchro;
             if (d_pull_in == true)
                 {
                     /*
@@ -282,19 +288,13 @@ int Galileo_E1_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attr
                     acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
                     acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod((float)acq_to_trk_delay_samples, (float)d_current_prn_length_samples);
                     samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
+                    *out[0] = current_synchro_data;
                     d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples
                     d_pull_in = false;
                     consume_each(samples_offset); //shift input to perform alignment with local replica
                     return 1;
                 }
-            // 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;
-
-            // Block input data and block output stream pointers
-            const gr_complex* in = (gr_complex*) input_items[0];
-            Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0];
 
             // ################# CARRIER WIPEOFF AND CORRELATORS ##############################
             // perform carrier wipe-off and compute Early, Prompt and Late correlation
@@ -417,24 +417,23 @@ int Galileo_E1_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attr
             current_synchro_data.Carrier_phase_rads = (double)d_acc_carrier_phase_rad;
             current_synchro_data.Carrier_Doppler_hz = (double)d_carrier_doppler_hz;
             current_synchro_data.CN0_dB_hz = (double)d_CN0_SNV_dB_Hz;
-            current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = true;
-            *out[0] = current_synchro_data;
+            current_synchro_data.correlation_length_ms=4;
+
         }
     else
         {
             *d_Early = gr_complex(0,0);
             *d_Prompt = gr_complex(0,0);
             *d_Late = gr_complex(0,0);
-            Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; //block output streams pointer
-            // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
-            d_acquisition_gnss_synchro->Flag_valid_pseudorange = false;
-            *out[0] = *d_acquisition_gnss_synchro;
 
+            current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
             //! When tracking is disabled an array of 1's is sent to maintain the TCP connection
             boost::array<float, NUM_TX_VARIABLES_GALILEO_E1> tx_variables_array = {{1,1,1,1,1,1,1,1,1,1,1,1,0}};
             d_tcp_com.send_receive_tcp_packet_galileo_e1(tx_variables_array, &tcp_data);
         }
-
+    //assign the GNURadio block output data
+    *out[0] = current_synchro_data;
     if(d_dump)
         {
             // MULTIPLEXED FILE RECORDING - Record results to file
@@ -546,8 +545,4 @@ void Galileo_E1_Tcp_Connector_Tracking_cc::set_channel_queue(concurrent_queue<in
 void Galileo_E1_Tcp_Connector_Tracking_cc::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
 {
     d_acquisition_gnss_synchro = p_gnss_synchro;
-    //  Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
-    //DLOG(INFO) << "Tracking code phase set to " << d_acq_code_phase_samples;
-    //DLOG(INFO) << "Tracking carrier doppler set to " << d_acq_carrier_doppler_hz;
-    //DLOG(INFO) << "Tracking Satellite set to " << d_satellite;
 }

src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc

@@ -400,8 +400,7 @@ int Galileo_E5a_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute
             d_Prompt = gr_complex(0,0);
             d_Late = gr_complex(0,0);
             d_Prompt_data = gr_complex(0,0);
-            d_acquisition_gnss_synchro->Flag_valid_pseudorange = false;
+        	current_synchro_data.Tracking_timestamp_secs = static_cast<double>(d_sample_counter) / static_cast<double>(d_fs_in);
-
             *out[0] = *d_acquisition_gnss_synchro;
 
             break;
@@ -425,9 +424,6 @@ int Galileo_E5a_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute
             current_synchro_data.Carrier_phase_rads = 0.0;
             current_synchro_data.Code_phase_secs = 0.0;
             current_synchro_data.CN0_dB_hz = 0.0;
-            current_synchro_data.Flag_valid_tracking = false;
-            current_synchro_data.Flag_valid_pseudorange = false;
-
             *out[0] = current_synchro_data;
             consume_each(samples_offset); //shift input to perform alignment with local replica
             return 1;
@@ -646,7 +642,6 @@ int Galileo_E5a_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute
                     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_tracking = false;
 
                 }
             else
@@ -658,7 +653,6 @@ int Galileo_E5a_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute
                     current_synchro_data.Carrier_phase_rads = 0.0;
                     current_synchro_data.Code_phase_secs = 0.0;
                     current_synchro_data.CN0_dB_hz = 0.0;
-                    current_synchro_data.Flag_valid_tracking = false;
 
                 }
             *out[0] = current_synchro_data;

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_cc.cc

@@ -337,6 +337,8 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items __attri
     double old_d_rem_code_phase_samples;
     if (d_enable_tracking == true)
         {
+			// Fill the acquisition data
+			current_synchro_data = *d_acquisition_gnss_synchro;
             // Receiver signal alignment
             if (d_pull_in == true)
                 {
@@ -346,20 +348,15 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items __attri
                     acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
                     acq_trk_shif_correction_samples = d_correlation_length_samples - fmod(static_cast<double>(acq_to_trk_delay_samples), static_cast<double>(d_correlation_length_samples));
                     samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
+
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
+                    *out[0] = current_synchro_data;
                     d_sample_counter += samples_offset; //count for the processed samples
                     d_pull_in = false;
-                    // Fill the acquisition data
-                    current_synchro_data = *d_acquisition_gnss_synchro;
-                    current_synchro_data.correlation_length_ms = 1;
-                    current_synchro_data.Flag_valid_symbol_output = false;
-                    *out[0] = current_synchro_data;
                     consume_each(samples_offset); //shift input to perform alignment with local replica
                     return 1;
                 }
 
-            // Fill the acquisition data
-            current_synchro_data = *d_acquisition_gnss_synchro;
-
             // ################# 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);
@@ -568,7 +565,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items __attri
                     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_pseudorange = false;
                     current_synchro_data.Flag_valid_symbol_output = true;
                     if (d_preamble_synchronized == true)
                         {
@@ -578,7 +574,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items __attri
                         {
                             current_synchro_data.correlation_length_ms = 1;
                         }
-                    *out[0] = current_synchro_data;
                 }
             else
                 {
@@ -591,10 +586,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items __attri
                     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;
-                    current_synchro_data.Flag_valid_pseudorange = false;
-                    current_synchro_data.Flag_valid_symbol_output = false;
-                    current_synchro_data.correlation_length_ms = 1;
-                    *out[0] = current_synchro_data;
                 }
         }
     else
@@ -605,11 +596,10 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items __attri
                 }
 
             current_synchro_data.System = {'G'};
-            current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
-            current_synchro_data.correlation_length_ms = 1;
-            *out[0] = current_synchro_data;
         }
-
+    //assign the GNURadio block output data
+    *out[0] = current_synchro_data;
     if(d_dump)
         {
             // MULTIPLEXED FILE RECORDING - Record results to file

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_sc.cc

@@ -314,6 +314,8 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items __attri
     double old_d_rem_code_phase_samples;
     if (d_enable_tracking == true)
         {
+    		// Fill the acquisition data
+            current_synchro_data = *d_acquisition_gnss_synchro;
             // Receiver signal alignment
             if (d_pull_in == true)
                 {
@@ -323,17 +325,14 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items __attri
                     acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
                     acq_trk_shif_correction_samples = d_correlation_length_samples - fmod(static_cast<double>(acq_to_trk_delay_samples), static_cast<double>(d_correlation_length_samples));
                     samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
+                    *out[0] = current_synchro_data;
                     d_sample_counter += samples_offset; //count for the processed samples
                     d_pull_in = false;
-                    // Fill the acquisition data
-                    current_synchro_data = *d_acquisition_gnss_synchro;
-                    *out[0] = current_synchro_data;
                     consume_each(samples_offset); //shift input to perform alignment with local replica
                     return 1;
                 }
 
-            // Fill the acquisition data
-            current_synchro_data = *d_acquisition_gnss_synchro;
 
             // ################# CARRIER WIPEOFF AND CORRELATORS ##############################
             // perform carrier wipe-off and compute Early, Prompt and Late correlation
@@ -447,7 +446,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items __attri
             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_pseudorange = false;
             current_synchro_data.Flag_valid_symbol_output = true;
             current_synchro_data.correlation_length_ms = 1;
             *out[0] = current_synchro_data;
@@ -462,8 +460,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items __attri
                 }
 
             current_synchro_data.System = {'G'};
-            current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Tracking_timestamp_secs = static_cast<double>(d_sample_counter) / static_cast<double>(d_fs_in);
-            current_synchro_data.Flag_valid_symbol_output = false;
             *out[0] = current_synchro_data;
         }
 

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc

@@ -309,10 +309,9 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__
                     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));
                     samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
                     d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples
                     d_pull_in = false;
-                    current_synchro_data.correlation_length_ms = 1;
-                    current_synchro_data.Flag_valid_symbol_output = false;
                     *out[0] = current_synchro_data;
                     consume_each(samples_offset); //shift input to perform alignment with local replica
                     return 1;
@@ -428,10 +427,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__
             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_pseudorange = false;
             current_synchro_data.Flag_valid_symbol_output = true;
             current_synchro_data.correlation_length_ms=1;
-            *out[0] = current_synchro_data;
 
         }
     else
@@ -441,13 +438,12 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items __attribute__
                     d_correlator_outs[n] = gr_complex(0,0);
                 }
 
+            current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
             current_synchro_data.System = {'G'};
-            current_synchro_data.Flag_valid_pseudorange = false;
-            current_synchro_data.Flag_valid_symbol_output = false;
-            current_synchro_data.correlation_length_ms=1;
-            *out[0] = current_synchro_data;
         }
 
+    //assign the GNURadio block output data
+    *out[0] = current_synchro_data;
     if(d_dump)
         {
 			// MULTIPLEXED FILE RECORDING - Record results to file

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_gpu_cc.cc

@@ -310,6 +310,9 @@ int Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::general_work (int noutput_items __attribu
     double old_d_rem_code_phase_samples;
     if (d_enable_tracking == true)
         {
+
+    		// Fill the acquisition data
+            current_synchro_data = *d_acquisition_gnss_synchro;
             // Receiver signal alignment
             if (d_pull_in == true)
                 {
@@ -319,18 +322,16 @@ int Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::general_work (int noutput_items __attribu
                     acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
                     acq_trk_shif_correction_samples = d_correlation_length_samples - fmod(static_cast<double>(acq_to_trk_delay_samples), static_cast<double>(d_correlation_length_samples));
                     samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
+
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
+                    *out[0] = current_synchro_data;
+
                     d_sample_counter += samples_offset; //count for the processed samples
                     d_pull_in = false;
-                    // Fill the acquisition data
-                    current_synchro_data = *d_acquisition_gnss_synchro;
-                    *out[0] = current_synchro_data;
                     consume_each(samples_offset); //shift input to perform alignment with local replica
                     return 1;
                 }
 
-            // Fill the acquisition data
-            current_synchro_data = *d_acquisition_gnss_synchro;
-
             // ################# CARRIER WIPEOFF AND CORRELATORS ##############################
             // perform carrier wipe-off and compute Early, Prompt and Late correlation
 
@@ -451,10 +452,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::general_work (int noutput_items __attribu
             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_pseudorange = false;
             current_synchro_data.Flag_valid_symbol_output = true;
             current_synchro_data.correlation_length_ms=1;
-            *out[0] = current_synchro_data;
 
         }
     else
@@ -466,11 +465,12 @@ int Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::general_work (int noutput_items __attribu
                 }
 
             current_synchro_data.System = {'G'};
-            current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
-            current_synchro_data.Flag_valid_symbol_output = false;
-            *out[0] = current_synchro_data;
         }
 
+    //assign the GNURadio block output data
+    *out[0] = current_synchro_data;
+
     if(d_dump)
         {
             // MULTIPLEXED FILE RECORDING - Record results to file

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc

@@ -308,9 +308,17 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attri
     float code_nco;
 
     tcp_packet_data tcp_data;
+	// GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
+	Gnss_Synchro current_synchro_data;
+	// Block input data and block output stream pointers
+	const gr_complex* in = (gr_complex*) input_items[0];
+	Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0];
 
     if (d_enable_tracking == true)
         {
+
+    		// Fill the acquisition data
+            current_synchro_data = *d_acquisition_gnss_synchro;
             /*
              * Receiver signal alignment
              */
@@ -325,6 +333,9 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attri
                     acq_trk_shif_correction_samples = d_next_prn_length_samples - fmod((float)acq_to_trk_delay_samples, (float)d_next_prn_length_samples);
                     samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
                     // /todo: Check if the sample counter sent to the next block as a time reference should be incremented AFTER sended or BEFORE
+
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
+                    *out[0] = current_synchro_data;
                     d_sample_counter_seconds = d_sample_counter_seconds + (((double)samples_offset) / (double)d_fs_in);
                     d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples
                     d_pull_in = false;
@@ -332,13 +343,6 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attri
                     return 1;
                 }
 
-            // 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;
-
-            const gr_complex* in = (gr_complex*) input_items[0]; //PRN start block alignement
-            Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0];
 
             // Update the prn length based on code freq (variable) and
             // sampling frequency (fixed)
@@ -465,10 +469,8 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attri
             current_synchro_data.Carrier_Doppler_hz = (double)d_carrier_doppler_hz;
             current_synchro_data.Code_phase_secs = (double)d_code_phase_samples * (1/(float)d_fs_in);
             current_synchro_data.CN0_dB_hz = (double)d_CN0_SNV_dB_Hz;
-            current_synchro_data.Flag_valid_pseudorange = false;
             current_synchro_data.Flag_valid_symbol_output = true;
             current_synchro_data.correlation_length_ms=1;
-            *out[0] = current_synchro_data;
         }
     else
         {
@@ -476,16 +478,15 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items __attri
             *d_Early = gr_complex(0,0);
             *d_Prompt = gr_complex(0,0);
             *d_Late = gr_complex(0,0);
-            Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; //block output streams pointer
             // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
-            d_acquisition_gnss_synchro->Flag_valid_pseudorange = false;
+            current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter + (double)d_rem_code_phase_samples)/(double)d_fs_in;
-            *out[0] = *d_acquisition_gnss_synchro;
-
             //! When tracking is disabled an array of 1's is sent to maintain the TCP connection
             boost::array<float, NUM_TX_VARIABLES_GPS_L1_CA> tx_variables_array = {{1,1,1,1,1,1,1,1,0}};
             d_tcp_com.send_receive_tcp_packet_gps_l1_ca(tx_variables_array, &tcp_data);
         }
 
+    //assign the GNURadio block output data
+    *out[0] = current_synchro_data;
     if(d_dump)
         {
             // MULTIPLEXED FILE RECORDING - Record results to file
@@ -591,9 +592,5 @@ void Gps_L1_Ca_Tcp_Connector_Tracking_cc::set_channel_queue(concurrent_queue<int
 void Gps_L1_Ca_Tcp_Connector_Tracking_cc::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
 {
     d_acquisition_gnss_synchro = p_gnss_synchro;
-    //	Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
-    //DLOG(INFO) << "Tracking code phase set to " << d_acq_code_phase_samples;
-    //DLOG(INFO) << "Tracking carrier doppler set to " << d_acq_carrier_doppler_hz;
-    //DLOG(INFO) << "Tracking Satellite set to " << d_satellite;
 
 }

src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc

@@ -303,6 +303,9 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items __attribute__(
 
     if (d_enable_tracking == true)
         {
+
+    		// Fill the acquisition data
+            current_synchro_data = *d_acquisition_gnss_synchro;
             // Receiver signal alignment
             if (d_pull_in == true)
                 {
@@ -312,26 +315,14 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items __attribute__(
                     acq_to_trk_delay_samples = (d_sample_counter - (d_acq_sample_stamp-d_current_prn_length_samples));
                     acq_trk_shif_correction_samples = -fmod(static_cast<float>(acq_to_trk_delay_samples), static_cast<float>(d_current_prn_length_samples));
                     samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);//+(1.5*(d_fs_in/GPS_L2_M_CODE_RATE_HZ)));
-                    // /todo: Check if the sample counter sent to the next block as a time reference should be incremented AFTER sended or BEFORE
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
-                    //d_sample_counter_seconds = d_sample_counter_seconds + (((double)samples_offset) / static_cast<double>(d_fs_in));
+                    *out[0] = current_synchro_data;
                     d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples
                     d_pull_in = false;
-                    std::cout<<" acq_to_trk_delay_samples="<<acq_to_trk_delay_samples<<std::endl;
-                    std::cout<<" acq_trk_shif_correction_samples="<<acq_trk_shif_correction_samples<<std::endl;
-                    std::cout<<" d_acq_code_phase_samples="<<d_acq_code_phase_samples<<std::endl;
-                    std::cout<<" d_current_prn_length_samples="<<d_current_prn_length_samples<<std::endl;
-                    std::cout<<" samples_offset="<<samples_offset<<std::endl;
-                    // Fill the acquisition data
-                    current_synchro_data = *d_acquisition_gnss_synchro;
-                    current_synchro_data.Flag_valid_tracking = false;
-                    *out[0] = current_synchro_data;
                     consume_each(samples_offset); //shift input to perform alignment with local replica
                     return 1;
                 }
 
-            // Fill the acquisition data
-            current_synchro_data = *d_acquisition_gnss_synchro;
-
             // ################# 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);
@@ -441,9 +432,8 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items __attribute__(
             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_tracking = true;
             current_synchro_data.Flag_valid_symbol_output = true;
-            *out[0] = current_synchro_data;
+            current_synchro_data.correlation_length_ms=20;
 
         }
     else
@@ -452,11 +442,10 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items __attribute__(
                 {
                     d_correlator_outs[n] = gr_complex(0,0);
                 }
-
+            current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
-            current_synchro_data.Flag_valid_pseudorange = false;
-            current_synchro_data.Flag_valid_symbol_output = false;
-            *out[0] = current_synchro_data;
         }
+    //assign the GNURadio block output data
+    *out[0] = current_synchro_data;
 
     if(d_dump)
         {

src/core/system_parameters/gnss_synchro.h

@@ -50,7 +50,7 @@ public:
     double Acq_delay_samples;                  //!< Set by Acquisition processing block
     double Acq_doppler_hz;                     //!< Set by Acquisition processing block
     unsigned long int Acq_samplestamp_samples; //!< Set by Acquisition processing block
-    bool Flag_valid_acquisition;
+    bool Flag_valid_acquisition; //!< Set by Acquisition processing block
     //Tracking
     double Prompt_I;                //!< Set by Tracking processing block
     double Prompt_Q;                //!< Set by Tracking processing block
@@ -59,9 +59,8 @@ public:
     double Carrier_phase_rads;      //!< Set by Tracking processing block
     double Code_phase_secs;         //!< Set by Tracking processing block
     double Tracking_timestamp_secs; //!< Set by Tracking processing block
-    bool Flag_valid_tracking;
 
-    bool Flag_valid_symbol_output;
+    bool Flag_valid_symbol_output; //!< Set by Tracking processing block
     int correlation_length_ms; //!< Set by Tracking processing block
 
     //Telemetry Decoder