mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-11-12 05:13:04 +00:00
Code Issues Releases Wiki Activity

- Galileo channels now supports all the published PRN IDs in acquisition and tracking

Browse Source 
- Changes in Galileo telemetry decoding (still under construction)
- Bug correction in tracking blocks that could cause random segmentation faults on some configurations

git-svn-id: https://svn.code.sf.net/p/gnss-sdr/code/trunk@431 64b25241-fba3-4117-9849-534c7e92360d
This commit is contained in:
Javier Arribas
2013-10-25 16:07:24 +00:00
parent 0f79be7e77
commit 4d66f6c6ab
13 changed files with 492 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
src/algorithms/observables/gnuradio_blocks/galileo_e1_observables_cc.cc
View File

@@ -90,20 +90,12 @@ galileo_e1_observables_cc::~galileo_e1_observables_cc()
{
d_dump_file.close();
}
//
//bool galileo_e1_observables_cc::pairCompare_gnss_synchro_Prn_delay_ms( std::pair<int,Gnss_Synchro> a, std::pair<int,Gnss_Synchro> b)
//{
// return (a.second.Prn_timestamp_ms) < (b.second.Prn_timestamp_ms);
//}
bool Galileo_pairCompare_gnss_synchro_Prn_delay_ms( std::pair<int,Gnss_Synchro> a, std::pair<int,Gnss_Synchro> b)
{
return (a.second.Prn_timestamp_ms) < (b.second.Prn_timestamp_ms);
}
//bool galileo_e1_observables_cc::pairCompare_gnss_synchro_d_TOW_at_current_symbol( std::pair<int,Gnss_Synchro> a, std::pair<int,Gnss_Synchro> b)
//{
// return (a.second.d_TOW_at_current_symbol) < (b.second.d_TOW_at_current_symbol);
//}
bool Galileo_pairCompare_gnss_synchro_d_TOW_at_current_symbol( std::pair<int,Gnss_Synchro> a, std::pair<int,Gnss_Synchro> b)
{
@@ -121,7 +113,6 @@ int galileo_e1_observables_cc::general_work (int noutput_items, gr_vector_int &n
Gnss_Synchro current_gnss_synchro[d_nchannels];
std::map<int,Gnss_Synchro> current_gnss_synchro_map;
std::map<int,Gnss_Synchro>::iterator gnss_synchro_iter;
// std::cout<<"entrato nella funzione general work linea 121***********************************"<<std::endl;
d_sample_counter++; //count for the processed samples
/*
* 1. Read the GNSS SYNCHRO objects from available channels
@@ -152,15 +143,10 @@ int galileo_e1_observables_cc::general_work (int noutput_items, gr_vector_int &n
*/
//;
// what is the most recent symbol TOW in the current set? -> this will be the reference symbol
//IL CANALE CON IL TIME COUNTER TOW PIÙ BASSO VIENE PRESO COME RIFERIMENTO
gnss_synchro_iter = max_element(current_gnss_synchro_map.begin(), current_gnss_synchro_map.end(), Galileo_pairCompare_gnss_synchro_d_TOW_at_current_symbol);
double d_TOW_reference = gnss_synchro_iter->second.d_TOW_at_current_symbol;
//std::cout<< "accedo agli elementi di syncro d_TOW_reference =" << gnss_synchro_iter->second.d_TOW_at_current_symbol<<std::endl;
double d_ref_PRN_rx_time_ms = gnss_synchro_iter->second.Prn_timestamp_ms;
//std::cout<< "accedo agli elementi di syncro d_ref_PRN_rx_time_ms=" << gnss_synchro_iter->second.Prn_timestamp_ms<<std::endl;
int reference_channel= gnss_synchro_iter->second.Channel_ID;
//std::cout<< "reference_channel=" << reference_channel<<std::endl;
//int reference_channel= gnss_synchro_iter->second.Channel_ID;
// Now compute RX time differences due to the PRN alignement in the correlators
double traveltime_ms;
@@ -168,52 +154,50 @@ int galileo_e1_observables_cc::general_work (int noutput_items, gr_vector_int &n
double delta_rx_time_ms;
for(gnss_synchro_iter = current_gnss_synchro_map.begin(); gnss_synchro_iter != current_gnss_synchro_map.end(); gnss_synchro_iter++)
{
// //std::cout<<"entrato nell'iterator di common reception time 147***********************************"<<std::endl;
// // compute the required symbol history shift in order to match the reference symbol
// compute the required symbol history shift in order to match the reference symbol
delta_rx_time_ms = gnss_synchro_iter->second.Prn_timestamp_ms-d_ref_PRN_rx_time_ms;
//std::cout<<"gnss_synchro_iter->second.Prn_timestamp_ms="<<gnss_synchro_iter->second.Prn_timestamp_ms << std::endl;
//std::cout<<"d_ref_PRN_rx_time_ms="<<d_ref_PRN_rx_time_ms << std::endl;
// //compute the pseudorange
//std::cout<<"delta_rx_time_ms["<<gnss_synchro_iter->second.Channel_ID<<"]="<<delta_rx_time_ms<<std::endl;
//compute the pseudorange
traveltime_ms = (d_TOW_reference-gnss_synchro_iter->second.d_TOW_at_current_symbol)*1000.0 + delta_rx_time_ms + GALILEO_STARTOFFSET_ms;
//std::cout<<"traveltime_ms="<<traveltime_ms<<std::endl;
pseudorange_m = traveltime_ms * GALILEO_C_m_ms; // [m]
//std::cout<<"pseudorange_m="<<pseudorange_m<<std::endl;
//std::cout<<"pseudorange_m["<<gnss_synchro_iter->second.Channel_ID<<"]="<<pseudorange_m<<std::endl;
// 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].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 + GALILEO_STARTOFFSET_ms/1000.0;
//std::cout<<"current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Pseudorange_m=" << current_gnss_synchro[gnss_synchro_iter->second.Channel_ID].Pseudorange_m <<std::endl;
}
}
if(d_dump == true)
{
// MULTIPLEXED FILE RECORDING - Record results to file
try
{
double tmp_double;
for (unsigned int i=0; i<d_nchannels ; i++)
{
tmp_double = current_gnss_synchro[i].d_TOW_at_current_symbol;
d_dump_file.write((char*)&tmp_double, sizeof(double));
tmp_double = current_gnss_synchro[i].Prn_timestamp_ms;
d_dump_file.write((char*)&tmp_double, sizeof(double));
tmp_double = current_gnss_synchro[i].Pseudorange_m;
d_dump_file.write((char*)&tmp_double, sizeof(double));
tmp_double = 0;
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));
}
}
catch (const std::ifstream::failure& e)
{
std::cout << "Exception writing observables dump file " << e.what() << std::endl;
}
}
//
// if(d_dump == true)
// {
// // MULTIPLEXED FILE RECORDING - Record results to file
// try
// {
// double tmp_double;
// for (unsigned int i=0; i<d_nchannels ; i++)
// {
// tmp_double = current_gnss_synchro[i].d_TOW_at_current_symbol;
// d_dump_file.write((char*)&tmp_double, sizeof(double));
// tmp_double = current_gnss_synchro[i].Prn_timestamp_ms;
// d_dump_file.write((char*)&tmp_double, sizeof(double));
// tmp_double = current_gnss_synchro[i].Pseudorange_m;
// d_dump_file.write((char*)&tmp_double, sizeof(double));
// tmp_double = 0;
// 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));
// }
// }
// catch (std::ifstream::failure e)
// {
// std::cout << "Exception writing observables dump file " << e.what() << std::endl;
// }
// }
//
consume_each(1); //one by one
for (unsigned int i=0; i<d_nchannels ; i++)
{

3
src/algorithms/observables/gnuradio_blocks/galileo_e1_observables_cc.h
View File

@@ -69,9 +69,6 @@ private:
galileo_e1_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);
galileo_e1_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);
bool pairCompare_gnss_synchro_Prn_delay_ms( std::pair<int,Gnss_Synchro> a, std::pair<int,Gnss_Synchro> b);
bool pairCompare_gnss_synchro_d_TOW_at_current_symbol( std::pair<int,Gnss_Synchro> a, std::pair<int,Gnss_Synchro> b);
// class private vars
boost::shared_ptr<gr::msg_queue> d_queue;
bool d_dump;

28
src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_e1b_telemetry_decoder_cc.cc
View File

@@ -364,11 +364,11 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items, gr_vector
//2. Add the telemetry decoder information
if (this->d_flag_preamble==true and d_nav.flag_TOW_set==true) //update TOW at the preamble instant (todo: check for valid d_TOW) //flag preamble is true after the all page (even or odd) is recevived
{
std::cout<<"time stamp, identified preamble and TOW set" << std::endl;
//std::cout<<"time stamp, identified preamble and TOW set" << std::endl;
Prn_timestamp_at_preamble_ms = in[0][0].Tracking_timestamp_secs * 1000.0;
if((d_nav.flag_TOW_5 == 1) and (d_nav.Page_type_time_stamp == 5)) //page 5 arrived and decoded, so we are in the odd page (since Tow refers to the even page, we have to add 1 sec)
{
std::cout<< "Using TOW_5 for timestamping" << std::endl;
//std::cout<< "Using TOW_5 for timestamping" << std::endl;
d_TOW_at_Preamble = d_nav.TOW_5+GALILEO_PAGE_SECONDS; //TOW_5 refers to the even preamble, but when we decode it we are in the odd part, so 1 second later
std::cout << "d_TOW_at_Preamble="<< d_TOW_at_Preamble<< std::endl;
/* 1 sec (GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD) is added because if we have a TOW value it means that we are at the and of the odd page*/
@@ -380,11 +380,11 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items, gr_vector
else if((d_nav.flag_TOW_6 == 1) and (d_nav.Page_type_time_stamp == 6)) //page 6 arrived and decoded, so we are in the odd page (since Tow refers to the even page, we have to add 1 sec)
{
std::cout<< "Using TOW_6 for timestamping" << std::endl;
//std::cout<< "Using TOW_6 for timestamping" << std::endl;
d_TOW_at_Preamble = d_nav.TOW_6+GALILEO_PAGE_SECONDS; //TOW_5 refers to the even preamble, but when we decode it we are in the odd part, so 1 second later
std::cout << "d_TOW_at_Preamble="<< d_TOW_at_Preamble<< std::endl;
//std::cout << "d_TOW_at_Preamble="<< d_TOW_at_Preamble<< std::endl;
d_TOW_at_current_symbol = d_TOW_at_Preamble + GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD;
std::cout << "d_TOW_at_current_symbol="<< d_TOW_at_current_symbol << std::endl;
//std::cout << "d_TOW_at_current_symbol="<< d_TOW_at_current_symbol << std::endl;
d_nav.flag_TOW_6 = 0;
}
@@ -393,12 +393,12 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items, gr_vector
else
{
d_TOW_at_Preamble = d_TOW_at_Preamble + GALILEO_PAGE_SECONDS; //this is the even preamble after the last odd preamble
std::cout << "d_TOW_at_Preamble="<< d_TOW_at_Preamble << std::endl;
//std::cout << "d_TOW_at_Preamble="<< d_TOW_at_Preamble << std::endl;
d_TOW_at_current_symbol = d_TOW_at_Preamble + GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD;
std::cout << "d_TOW_at_current_symbol="<< d_TOW_at_current_symbol << std::endl;
//std::cout << "d_TOW_at_current_symbol="<< d_TOW_at_current_symbol << std::endl;
}
std::cout << "Prn_timestamp_at_preamble_ms ="<< Prn_timestamp_at_preamble_ms << std::endl;
//std::cout << "Prn_timestamp_at_preamble_ms ="<< Prn_timestamp_at_preamble_ms << std::endl;
}
@@ -408,14 +408,16 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items, gr_vector
//std::cout << "d_TOW_at_current_symbol="<< d_TOW_at_current_symbol << std::endl;
}
if (d_flag_frame_sync == true and d_nav.flag_TOW_set==true and d_nav.flag_CRC_test == true)
//if (d_flag_frame_sync == true and d_nav.flag_TOW_set==true and d_nav.flag_CRC_test == true)
if (d_flag_frame_sync == true and d_nav.flag_TOW_set==true)
{
current_synchro_data.Flag_valid_word = true;
}else{
current_synchro_data.Flag_valid_word = false;
}
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.Flag_valid_word = true;
//current_synchro_data.Flag_valid_word = (d_flag_frame_sync == true and d_nav.flag_TOW_set==true and d_nav.flag_CRC_test == true);
current_synchro_data.Flag_preamble = d_flag_preamble;
current_synchro_data.Prn_timestamp_ms = in[0][0].Tracking_timestamp_secs * 1000.0;
@@ -434,7 +436,7 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items, gr_vector
tmp_double = d_TOW_at_Preamble;
d_dump_file.write((char*)&tmp_double, sizeof(double));
}
catch (std::ifstream::failure e)
catch (const std::ifstream::failure& e)
{
std::cout << "Exception writing observables dump file " << e.what() << std::endl;
}

5
src/algorithms/tracking/gnuradio_blocks/galileo_e1_dll_pll_veml_tracking_cc.cc
View File

@@ -441,7 +441,6 @@ int galileo_e1_dll_pll_veml_tracking_cc::general_work (int noutput_items,gr_vect
current_synchro_data.Carrier_Doppler_hz = (double)d_carrier_doppler_hz;
current_synchro_data.CN0_dB_hz = (double)d_CN0_SNV_dB_Hz;
*out[0] = current_synchro_data;
// ########## DEBUG OUTPUT
/*!
* \todo The stop timer has to be moved to the signal source!
@@ -455,7 +454,6 @@ int galileo_e1_dll_pll_veml_tracking_cc::general_work (int noutput_items,gr_vect
std::cout << "Current input signal time = " << d_last_seg << " [s]" << std::endl;
std::cout << "Tracking CH " << d_channel << ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
<< ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]" << std::endl;
}
}
else
@@ -475,8 +473,7 @@ int galileo_e1_dll_pll_veml_tracking_cc::general_work (int noutput_items,gr_vect
*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
Gnss_Synchro current_synchro_data;
*out[0] = current_synchro_data;
*out[0] = *d_acquisition_gnss_synchro;
}
if(d_dump)

3
src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc
View File

@@ -487,8 +487,7 @@ int Galileo_E1_Tcp_Connector_Tracking_cc::general_work (int noutput_items, gr_ve
*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
Gnss_Synchro current_synchro_data;
*out[0] = current_synchro_data;
*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_GALILEO_E1> tx_variables_array = {{1,1,1,1,1,1,1,1,1,1,1,1,0}};

3
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_optim_tracking_cc.cc
View File

@@ -531,8 +531,7 @@ int Gps_L1_Ca_Dll_Pll_Optim_Tracking_cc::general_work (int noutput_items, gr_vec
*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
Gnss_Synchro current_synchro_data;
*out[0] = current_synchro_data;
*out[0] = *d_acquisition_gnss_synchro;
}
if(d_dump)

3
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc
View File

@@ -537,8 +537,7 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in
*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
Gnss_Synchro current_synchro_data;
*out[0] = current_synchro_data;
*out[0] = *d_acquisition_gnss_synchro;
}
if(d_dump)

3
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc
View File

@@ -571,8 +571,7 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items, gr_vec
*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
Gnss_Synchro current_synchro_data;
*out[0] = current_synchro_data;
*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}};