mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-12 19:20:32 +00:00
Code Issues Releases Wiki Activity

Refactoring of GPS L1 CA telemetry decoder. PVT is not yet fully tested

Browse Source
This commit is contained in:
Javier Arribas 2016-03-18 17:36:29 +01:00
parent 840bb1b9a3
commit 083350bd61
6 changed files with 75 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
conf/gnss-sdr_Hybrid_gr_complex.conf
View File

@ -240,14 +240,20 @@ Tracking_1C.dump=true
;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number. ;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number.
Tracking_1C.dump_filename=../data/epl_tracking_ch_ Tracking_1C.dump_filename=../data/epl_tracking_ch_
;# Extended correlation after telemetry bit synchronization
;# Valid values are: [1,2,4,5,10,20] (integer divisors of the GPS L1 CA bit period (20 ms) )
;# Longer integration period require more stable front-end LO
Tracking_1C.extend_correlation_ms=5
;#pll_bw_hz: PLL loop filter bandwidth [Hz] ;#pll_bw_hz: PLL loop filter bandwidth [Hz]
Tracking_1C.pll_bw_hz=20; Tracking_1C.pll_bw_hz=20;
Tracking_1C.pll_bw_narrow_hz=5; Tracking_1C.pll_bw_narrow_hz=10;
;#dll_bw_hz: DLL loop filter bandwidth [Hz] ;#dll_bw_hz: DLL loop filter bandwidth [Hz]
Tracking_1C.dll_bw_hz=4.0; Tracking_1C.dll_bw_hz=3.0;
Tracking_1C.dll_bw_narrow_hz=1.5; Tracking_1C.dll_bw_narrow_hz=2.0;
;#fll_bw_hz: FLL loop filter bandwidth [Hz] ;#fll_bw_hz: FLL loop filter bandwidth [Hz]
Tracking_1C.fll_bw_hz=2.0; Tracking_1C.fll_bw_hz=2.0;

15
conf/gnss-sdr_Hybrid_nsr.conf
View File

@ -195,11 +195,11 @@ Acquisition_1C.sampled_ms=1
Acquisition_1C.implementation=GPS_L1_CA_PCPS_Acquisition Acquisition_1C.implementation=GPS_L1_CA_PCPS_Acquisition
Acquisition_1C.use_CFAR_algorithm=false; Acquisition_1C.use_CFAR_algorithm=false;
;#threshold: Acquisition threshold ;#threshold: Acquisition threshold
Acquisition_1C.threshold=40 Acquisition_1C.threshold=10
;#pfa: Acquisition false alarm probability. This option overrides the threshold option. Only use with implementations: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition] ;#pfa: Acquisition false alarm probability. This option overrides the threshold option. Only use with implementations: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
;Acquisition_1C.pfa=0.01 ;Acquisition_1C.pfa=0.01
;#doppler_max: Maximum expected Doppler shift [Hz] ;#doppler_max: Maximum expected Doppler shift [Hz]
Acquisition_1C.doppler_max=10000 Acquisition_1C.doppler_max=5000
;#doppler_max: Doppler step in the grid search [Hz] ;#doppler_max: Doppler step in the grid search [Hz]
Acquisition_1C.doppler_step=250 Acquisition_1C.doppler_step=250
@ -243,11 +243,20 @@ Tracking_1C.dump=true
;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number. ;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number.
Tracking_1C.dump_filename=../data/epl_tracking_ch_ Tracking_1C.dump_filename=../data/epl_tracking_ch_
;# Extended correlation after telemetry bit synchronization
;# Valid values are: [1,2,4,5,10,20] (integer divisors of the GPS L1 CA bit period (20 ms) )
;# Longer integration period require more stable front-end LO
Tracking_1C.extend_correlation_ms=1
;#pll_bw_hz: PLL loop filter bandwidth [Hz] ;#pll_bw_hz: PLL loop filter bandwidth [Hz]
Tracking_1C.pll_bw_hz=40; Tracking_1C.pll_bw_hz=40;
Tracking_1C.pll_bw_narrow_hz=20;
;#dll_bw_hz: DLL loop filter bandwidth [Hz] ;#dll_bw_hz: DLL loop filter bandwidth [Hz]
Tracking_1C.dll_bw_hz=2.5; Tracking_1C.dll_bw_hz=2.0;
Tracking_1C.dll_bw_narrow_hz=2.0;
;#fll_bw_hz: FLL loop filter bandwidth [Hz] ;#fll_bw_hz: FLL loop filter bandwidth [Hz]
Tracking_1C.fll_bw_hz=2.0; Tracking_1C.fll_bw_hz=2.0;

99
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc
View File

@ -36,6 +36,7 @@
#include "gps_l1_ca_telemetry_decoder_cc.h" #include "gps_l1_ca_telemetry_decoder_cc.h"
#include <iostream> #include <iostream>
#include <bitset>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
#include <pmt/pmt.h> #include <pmt/pmt.h>
@ -58,20 +59,6 @@ gps_l1_ca_make_telemetry_decoder_cc(Gnss_Satellite satellite, boost::shared_ptr<
} }
//void gps_l1_ca_telemetry_decoder_cc::forecast (int noutput_items, gr_vector_int &ninput_items_required)
//{
// if (noutput_items != 0)
// {
// for (unsigned i = 0; i < 3; i++)
// {
// ninput_items_required[i] = d_samples_per_bit * 8; //set the required sample history
// }
// }
//}
gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc( gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc(
Gnss_Satellite satellite, Gnss_Satellite satellite,
boost::shared_ptr<gr::msg_queue> queue, boost::shared_ptr<gr::msg_queue> queue,
@ -94,14 +81,14 @@ gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc(
memcpy((unsigned short int*)this->d_preambles_bits, (unsigned short int*)preambles_bits, GPS_CA_PREAMBLE_LENGTH_BITS*sizeof(unsigned short int)); memcpy((unsigned short int*)this->d_preambles_bits, (unsigned short int*)preambles_bits, GPS_CA_PREAMBLE_LENGTH_BITS*sizeof(unsigned short int));
// preamble bits to sampled symbols // preamble bits to sampled symbols (reversed)
d_preambles_symbols = (signed int*)malloc(sizeof(signed int) * GPS_CA_PREAMBLE_LENGTH_BITS * d_samples_per_bit); d_preambles_symbols = (signed int*)malloc(sizeof(signed int) * GPS_CA_PREAMBLE_LENGTH_BITS * d_samples_per_bit);
int n = 0; int n = 0;
for (int i = 0; i < GPS_CA_PREAMBLE_LENGTH_BITS; i++) for (int i = 0; i < GPS_CA_PREAMBLE_LENGTH_BITS; i++)
{ {
for (unsigned int j = 0; j < d_samples_per_bit; j++) for (unsigned int j = 0; j < d_samples_per_bit; j++)
{ {
if (d_preambles_bits[i] == 1) if (d_preambles_bits[GPS_CA_PREAMBLE_LENGTH_BITS-i-1] == 1)
{ {
d_preambles_symbols[n] = 1; d_preambles_symbols[n] = 1;
} }
@ -181,39 +168,44 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i
// ########### Output the tracking data to navigation and PVT ########## // ########### Output the tracking data to navigation and PVT ##########
const Gnss_Synchro **in = (const Gnss_Synchro **) &input_items[0]; //Get the input samples pointer const Gnss_Synchro **in = (const Gnss_Synchro **) &input_items[0]; //Get the input samples pointer
// keep the last valid symbols // record last symbols (clipped to +1,-1) and its correlation length to perform preamble correlation
if (in[0]->Flag_valid_symbol_output==true) if (in[0]->Flag_valid_symbol_output==true)
{ {
d_symbol_history.push_back(in[0]->Prompt_I); d_symbol_history.push_front(in[0]->Prompt_I);
d_correlation_length_ms_history.push_front(in[0]->correlation_length_ms);
if (static_cast<int>(d_symbol_history.size())>GPS_CA_PREAMBLE_LENGTH_SYMBOLS) if (static_cast<int>(d_symbol_history.size())>GPS_CA_PREAMBLE_LENGTH_SYMBOLS)
{ {
d_symbol_history.pop_front(); d_symbol_history.pop_back();
d_correlation_length_ms_history.pop_back();
} }
if (d_symbol_history.size()==GPS_CA_PREAMBLE_LENGTH_SYMBOLS) if (d_symbol_history.size()==GPS_CA_PREAMBLE_LENGTH_SYMBOLS)
{ {
//******* preamble correlation ********
int current_symbol_index=0; //******* preamble correlation (in reverse order due to the variable correlator length)
for (int i = 0; i < GPS_CA_PREAMBLE_LENGTH_SYMBOLS/in[0]->correlation_length_ms; i++) int input_symbol_index=0;
{ int preamble_index=0;
current_symbol_index=i*in[0]->correlation_length_ms;//+static_cast<int>(floor(in[0]->correlation_length_ms/2)); do{
if (d_symbol_history.at(i) < 0) // symbols clipping if (d_symbol_history.at(input_symbol_index) < 0) // symbols clipping
{ {
//symbol weight expansion using the current tracking correlation length //symbol weight expansion using its tracking correlation length
corr_value -= d_preambles_symbols[current_symbol_index]*in[0]->correlation_length_ms; corr_value -= d_preambles_symbols[preamble_index]*d_correlation_length_ms_history.at(input_symbol_index);
} }
else else
{ {
//symbol weight expansion using the current tracking correlation length //symbol weight expansion using its tracking correlation length
corr_value += d_preambles_symbols[current_symbol_index]*in[0]->correlation_length_ms; corr_value += d_preambles_symbols[preamble_index]*d_correlation_length_ms_history.at(input_symbol_index);
} }
} preamble_index+=d_correlation_length_ms_history.at(input_symbol_index);
input_symbol_index++;
}while(preamble_index<GPS_CA_PREAMBLE_LENGTH_SYMBOLS);
} }
if (abs(corr_value)>120)
{
std::cout<<abs(corr_value)<<std::endl;
}
} }
consume_each(1); //always consume one by one tracking output
d_flag_preamble = false; d_flag_preamble = false;
//******* frame sync ****************** //******* frame sync ******************
@ -223,45 +215,46 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i
{ {
d_GPS_FSM.Event_gps_word_preamble(); d_GPS_FSM.Event_gps_word_preamble();
d_preamble_index = d_sample_counter;//record the preamble sample stamp d_preamble_index = d_sample_counter;//record the preamble sample stamp
std::cout << "Preamble detection for SAT " << this->d_satellite; DLOG(INFO) << "Preamble detection for SAT " << this->d_satellite <<" d_sample_counter="<<d_sample_counter<<std::endl;
d_symbol_accumulator = 0; //sync the symbol to bits integrator d_symbol_accumulator = 0; //sync the symbol to bits integrator
d_symbol_accumulator_counter = 0; d_symbol_accumulator_counter = GPS_CA_TELEMETRY_SYMBOLS_PER_BIT-in[0]->correlation_length_ms;
d_frame_bit_index = 7; d_frame_bit_index = 7;
d_stat = 1; // enter into frame pre-detection status d_stat = 1; // enter into frame pre-detection status
} }
else if (d_stat == 1) //check 6 seconds of preamble separation else if (d_stat == 1) //check 6 seconds of preamble separation
{ {
preamble_diff = d_sample_counter - d_preamble_index; preamble_diff = d_sample_counter - d_preamble_index;
if (abs(preamble_diff - 6000) < 1) if (abs(preamble_diff - GPS_SUBFRAME_MS) < 1)
{ {
std::cout <<"preamble! corr lenght="<<in[0]->correlation_length_ms<<std::endl; //DLOG(INFO)<<"preamble! corr lenght="<<in[0]->correlation_length_ms<<" d_sample_counter="<<d_sample_counter<<std::endl;
d_GPS_FSM.Event_gps_word_preamble(); d_GPS_FSM.Event_gps_word_preamble();
d_flag_preamble = true; d_flag_preamble = true;
d_preamble_index = d_sample_counter; //record the preamble sample stamp (t_P) d_preamble_index = d_sample_counter; //record the preamble sample stamp (t_P)
d_preamble_time_seconds = in[0][0].Tracking_timestamp_secs;// - d_preamble_duration_seconds; //record the PRN start sample index associated to the preamble d_preamble_time_seconds = in[0][0].Tracking_timestamp_secs;// - d_preamble_duration_seconds; //record the PRN start sample index associated to the preamble
d_symbol_accumulator_counter = GPS_CA_TELEMETRY_SYMBOLS_PER_BIT-in[0]->correlation_length_ms;
d_frame_bit_index = 7; d_frame_bit_index = 7;
if (!d_flag_frame_sync) if (!d_flag_frame_sync)
{ {
//send asynchronous message to tracking to inform of frame sync and extend correlation time //send asynchronous message to tracking to inform of frame sync and extend correlation time
pmt::pmt_t value = pmt::from_long(d_preamble_index-2); pmt::pmt_t value = pmt::from_long(d_preamble_index-1);
this->message_port_pub(pmt::mp("preamble_index"),value); this->message_port_pub(pmt::mp("preamble_index"),value);
d_flag_frame_sync = true; d_flag_frame_sync = true;
if (corr_value < 0) if (corr_value < 0)
{ {
flag_PLL_180_deg_phase_locked = true; //PLL is locked to opposite phase! flag_PLL_180_deg_phase_locked = true; //PLL is locked to opposite phase!
std::cout << " PLL in opposite phase for Sat "<< this->d_satellite.get_PRN(); DLOG(INFO) << " PLL in opposite phase for Sat "<< this->d_satellite.get_PRN();
} }
else else
{ {
flag_PLL_180_deg_phase_locked = false; flag_PLL_180_deg_phase_locked = false;
} }
std::cout << " Frame sync SAT " << this->d_satellite << " with preamble start at " << d_preamble_time_seconds << " [s]"; DLOG(INFO) << " Frame sync SAT " << this->d_satellite << " with preamble start at " << d_preamble_time_seconds << " [s]";
} }
}else{ }else{
if (preamble_diff > 6001) if (preamble_diff > GPS_SUBFRAME_MS+1)
{ {
std::cout << "Lost of frame sync SAT " << this->d_satellite << " preamble_diff= " << preamble_diff; DLOG(INFO) << "Lost of frame sync SAT " << this->d_satellite << " preamble_diff= " << preamble_diff<<" d_sample_counter="<<d_sample_counter<<std::endl;
d_stat = 0; //lost of frame sync d_stat = 0; //lost of frame sync
d_flag_frame_sync = false; d_flag_frame_sync = false;
flag_TOW_set = false; flag_TOW_set = false;
@ -278,7 +271,7 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i
d_symbol_accumulator_counter+=in[0]->correlation_length_ms; d_symbol_accumulator_counter+=in[0]->correlation_length_ms;
} }
if (d_symbol_accumulator_counter == 20 ) if (d_symbol_accumulator_counter >= GPS_CA_TELEMETRY_SYMBOLS_PER_BIT )
{ {
if (d_symbol_accumulator > 0) if (d_symbol_accumulator > 0)
{ //symbol to bit { //symbol to bit
@ -288,8 +281,9 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i
d_symbol_accumulator_counter = 0; d_symbol_accumulator_counter = 0;
//******* bits to words ****** //******* bits to words ******
d_frame_bit_index++; d_frame_bit_index++;
if (d_frame_bit_index == 30) if (d_frame_bit_index == GPS_WORD_BITS)
{ {
//std::cout<<"word bits = "<<std::bitset<32>(d_GPS_frame_4bytes)<<std::endl;
d_frame_bit_index = 0; d_frame_bit_index = 0;
// parity check // parity check
// Each word in wordbuff is composed of: // Each word in wordbuff is composed of:
@ -331,7 +325,6 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i
} }
} }
// output the frame // output the frame
consume_each(1); //one by one
Gnss_Synchro current_synchro_data; //structure to save the synchronization information and send the output object to the next block Gnss_Synchro current_synchro_data; //structure to save the synchronization information and send the output object to the next block
//1. Copy the current tracking output //1. Copy the current tracking output
current_synchro_data = in[0][0]; current_synchro_data = in[0][0];
@ -419,7 +412,7 @@ void gps_l1_ca_telemetry_decoder_cc::set_decimation(int decimation)
void gps_l1_ca_telemetry_decoder_cc::set_satellite(Gnss_Satellite satellite) void gps_l1_ca_telemetry_decoder_cc::set_satellite(Gnss_Satellite satellite)
{ {
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN()); d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
LOG(INFO) << "Setting decoder Finite State Machine to satellite " << d_satellite; DLOG(INFO) << "Setting decoder Finite State Machine to satellite " << d_satellite;
d_GPS_FSM.i_satellite_PRN = d_satellite.get_PRN(); d_GPS_FSM.i_satellite_PRN = d_satellite.get_PRN();
DLOG(INFO) << "Navigation Satellite set to " << d_satellite; DLOG(INFO) << "Navigation Satellite set to " << d_satellite;
} }
@ -442,7 +435,7 @@ void gps_l1_ca_telemetry_decoder_cc::set_channel(int channel)
d_dump_filename.append(".dat"); d_dump_filename.append(".dat");
d_dump_file.exceptions ( std::ifstream::failbit | std::ifstream::badbit ); 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.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
LOG(INFO) << "Telemetry decoder dump enabled on channel " << d_channel DLOG(INFO) << "Telemetry decoder dump enabled on channel " << d_channel
<< " Log file: " << d_dump_filename.c_str(); << " Log file: " << d_dump_filename.c_str();
} }
catch (std::ifstream::failure e) catch (std::ifstream::failure e)

1
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.h
View File

@ -108,6 +108,7 @@ private:
// symbols // symbols
std::deque<double> d_symbol_history; std::deque<double> d_symbol_history;
std::deque<int> d_correlation_length_ms_history;
double d_symbol_accumulator; double d_symbol_accumulator;
short int d_symbol_accumulator_counter; short int d_symbol_accumulator_counter;

19
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_cc.cc
View File

@ -90,7 +90,7 @@ void gps_l1_ca_dll_pll_c_aid_tracking_cc::forecast (int noutput_items,
void gps_l1_ca_dll_pll_c_aid_tracking_cc::msg_handler_preamble_index(pmt::pmt_t msg) void gps_l1_ca_dll_pll_c_aid_tracking_cc::msg_handler_preamble_index(pmt::pmt_t msg)
{ {
//pmt::print(msg); //pmt::print(msg);
DLOG(INFO) << "Extended correlation for Tracking CH " << d_channel << ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)<< std::endl; DLOG(INFO) << "Extended correlation enabled for Tracking CH " << d_channel << ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)<< std::endl;
if (d_enable_extended_integration==false) //avoid re-setting preamble indicator if (d_enable_extended_integration==false) //avoid re-setting preamble indicator
{ {
d_preamble_index=pmt::to_long(msg); d_preamble_index=pmt::to_long(msg);
@ -380,7 +380,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
if (d_enable_extended_integration==true) if (d_enable_extended_integration==true)
{ {
long int symbol_diff=d_symbol_counter-d_preamble_index; long int symbol_diff=d_symbol_counter-d_preamble_index;
if (symbol_diff % d_extend_correlation_ms == 0) if (symbol_diff>0 and symbol_diff % d_extend_correlation_ms == 0)
{ {
// compute coherent integration and enable tracking loop // compute coherent integration and enable tracking loop
// perform coherent integration using correlator output history // perform coherent integration using correlator output history
@ -400,7 +400,8 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
d_code_loop_filter.set_DLL_BW(d_dll_bw_narrow_hz); 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_carrier_loop_filter.set_params(10.0, d_pll_bw_narrow_hz,2);
d_preamble_synchronized=true; d_preamble_synchronized=true;
std::cout<<"dll="<<d_dll_bw_hz<<" dll_n="<<d_dll_bw_narrow_hz<<" pll="<<d_pll_bw_hz<<" pll_n="<<d_pll_bw_narrow_hz<<std::endl; std::cout<<"Enabled extended correlator for CH "<< d_channel <<" : Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
<<" dll_narrow_bw="<<d_dll_bw_narrow_hz<<" pll_narrow_bw="<<d_pll_bw_narrow_hz<<std::endl;
} }
// UPDATE INTEGRATION TIME // UPDATE INTEGRATION TIME
@ -411,8 +412,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
if(d_preamble_synchronized==true) if(d_preamble_synchronized==true)
{ {
// continue extended coherent correlation // continue extended coherent correlation
//TODO: Take into account the extended correlation to update the accumulated carrier phase for carrier phase observables!!
//remnant carrier phase [rads] //remnant carrier phase [rads]
d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GPS_TWO_PI); d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GPS_TWO_PI);
@ -572,8 +571,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
} }
*out[0] = current_synchro_data; *out[0] = current_synchro_data;
}else{ }else{
//todo: fill synchronization data to produce output while coherent integration is running
current_synchro_data.Flag_valid_symbol_output = false;
current_synchro_data.Prompt_I = static_cast<double>((d_correlator_outs[1]).real()); current_synchro_data.Prompt_I = static_cast<double>((d_correlator_outs[1]).real());
current_synchro_data.Prompt_Q = static_cast<double>((d_correlator_outs[1]).imag()); current_synchro_data.Prompt_Q = static_cast<double>((d_correlator_outs[1]).imag());
// Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!) // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!)
@ -584,12 +581,8 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;// todo: project the carrier doppler 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.CN0_dB_hz = d_CN0_SNV_dB_Hz;
current_synchro_data.Flag_valid_pseudorange = false; current_synchro_data.Flag_valid_pseudorange = false;
if (d_preamble_synchronized==true) current_synchro_data.Flag_valid_symbol_output = false;
{ current_synchro_data.correlation_length_ms=1;
current_synchro_data.correlation_length_ms=d_extend_correlation_ms;
}else{
current_synchro_data.correlation_length_ms=1;
}
*out[0] = current_synchro_data; *out[0] = current_synchro_data;
} }

1
src/core/system_parameters/GPS_L1_CA.h
View File

@ -82,6 +82,7 @@ const int GPS_WORD_LENGTH = 4; //!< CRC + GPS WORD (-2 -1 0
const int GPS_SUBFRAME_LENGTH = 40; //!< GPS_WORD_LENGTH x 10 = 40 bytes const int GPS_SUBFRAME_LENGTH = 40; //!< GPS_WORD_LENGTH x 10 = 40 bytes
const int GPS_SUBFRAME_BITS = 300; //!< Number of bits per subframe in the NAV message [bits] const int GPS_SUBFRAME_BITS = 300; //!< Number of bits per subframe in the NAV message [bits]
const int GPS_SUBFRAME_SECONDS = 6; //!< Subframe duration [seconds] const int GPS_SUBFRAME_SECONDS = 6; //!< Subframe duration [seconds]
const int GPS_SUBFRAME_MS = 6000; //!< Subframe duration [seconds]
const int GPS_WORD_BITS = 30; //!< Number of bits per word in the NAV message [bits] const int GPS_WORD_BITS = 30; //!< Number of bits per word in the NAV message [bits]
// GPS NAVIGATION MESSAGE STRUCTURE // GPS NAVIGATION MESSAGE STRUCTURE