mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-10-24 12:07:40 +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}};

68
src/core/receiver/gnss_flowgraph.cc
View File

@@ -535,45 +535,60 @@ void GNSSFlowgraph::set_signals_list()
* See http://igscb.jpl.nasa.gov/igscb/data/format/rinex301.pdf (page 5)
*/
/*
* Read GNSS-SDR default GNSS system and signal
*/
std::string default_system = configuration_->property("Channel.system",std::string("GPS"));
std::string default_signal = configuration_->property("Channel.signal",std::string("1C"));
/*
* Loop to create the list of GNSS Signals
* To add signals from other systems, add another loop 'for'
*/
/*
* Loop to create GPS L1 C/A signals
*/
std::set<unsigned int> available_gps_prn = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28,
29, 30, 31, 32 };
if (default_system.compare(std::string("GPS"))==0)
{
/*
* Loop to create GPS L1 C/A signals
*/
std::set<unsigned int> available_gps_prn = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28,
29, 30, 31, 32 };
for (available_gnss_prn_iter = available_gps_prn.begin(); available_gnss_prn_iter
!= available_gps_prn.end(); available_gnss_prn_iter++)
{
available_GNSS_signals_.push_back(Gnss_Signal(Gnss_Satellite(std::string("GPS"),
*available_gnss_prn_iter), std::string("1C")));
}
for (available_gnss_prn_iter = available_gps_prn.begin(); available_gnss_prn_iter
!= available_gps_prn.end(); available_gnss_prn_iter++)
{
available_GNSS_signals_.push_back(Gnss_Signal(Gnss_Satellite(std::string("GPS"),
*available_gnss_prn_iter), std::string("1C")));
}
}
/*
* Loop to create SBAS L1 C/A signals
*/
std::set<unsigned int> available_sbas_prn = { 120, 124, 126};
if (default_system.compare(std::string("SBAS"))==0)
{
/*
* Loop to create SBAS L1 C/A signals
*/
std::set<unsigned int> available_sbas_prn = { 120, 124, 126};
for (available_gnss_prn_iter = available_sbas_prn.begin(); available_gnss_prn_iter
!= available_sbas_prn.end(); available_gnss_prn_iter++)
{
available_GNSS_signals_.push_back(Gnss_Signal(Gnss_Satellite(std::string("SBAS"),
*available_gnss_prn_iter), std::string("1C")));
}
for (available_gnss_prn_iter = available_sbas_prn.begin(); available_gnss_prn_iter
!= available_sbas_prn.end(); available_gnss_prn_iter++)
{
available_GNSS_signals_.push_back(Gnss_Signal(Gnss_Satellite(std::string("SBAS"),
*available_gnss_prn_iter), std::string("1C")));
}
}
if (default_system.compare(std::string("Galileo"))==0)
{
/*
* Loop to create the list of Galileo E1 B signals
*/
std::set<unsigned int> available_galileo_prn = { 11, 12, 19, 20 };
std::set<unsigned int> available_galileo_prn = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36};
for (available_gnss_prn_iter = available_galileo_prn.begin(); available_gnss_prn_iter
!= available_galileo_prn.end(); available_gnss_prn_iter++)
@@ -581,7 +596,7 @@ void GNSSFlowgraph::set_signals_list()
available_GNSS_signals_.push_back(Gnss_Signal(Gnss_Satellite(std::string("Galileo"),
*available_gnss_prn_iter), std::string("1B")));
}
}
/*
* Ordering the list of signals from configuration file
@@ -589,9 +604,6 @@ void GNSSFlowgraph::set_signals_list()
std::list<Gnss_Signal>::iterator gnss_it = available_GNSS_signals_.begin();
std::string default_system = (configuration_->property("Channel.system",std::string("GPS")));
std::string default_signal = configuration_->property("Channel.signal",std::string("1C"));
for (unsigned int i = 0; i < channels_count_; i++)
{
std::string gnss_system = (configuration_->property("Channel"
@@ -622,6 +634,8 @@ void GNSSFlowgraph::set_signals_list()
}
// **** FOR DEBUGGING THE LIST OF GNSS SIGNALS ****
//
//std::cout<<"default_system="<<default_system<<std::endl;
//std::cout<<"default_signal="<<default_signal<<std::endl;
// std::list<Gnss_Signal>::iterator available_gnss_list_iter;
// for (available_gnss_list_iter = available_GNSS_signals_.begin(); available_gnss_list_iter
// != available_GNSS_signals_.end(); available_gnss_list_iter++)

3
src/core/system_parameters/galileo_navigation_message.cc
View File

@@ -438,7 +438,7 @@ void Galileo_Navigation_Message::split_page(const char *page, int flag_even_word
{
flag_CRC_test = true;
// CRC correct: Decode word
//std::cout<<"CRC correct!"<<std::endl;
std::cout<<"CRC correct!"<<std::endl;
std::string page_number_bits = Data_k.substr (0,6);
//std::cout << "Page number bits from Data k" << std::endl << page_number_bits << std::endl;
@@ -472,6 +472,7 @@ void Galileo_Navigation_Message::split_page(const char *page, int flag_even_word
}else{
// CRC wrong.. discard frame
std::cout<<"CRC error!"<<std::endl;
flag_CRC_test= false;
}
//********** end of CRC checksum control ***/
}

36
src/core/system_parameters/gnss_satellite.cc
View File

@@ -145,7 +145,7 @@ void Gnss_Satellite::set_PRN(unsigned int PRN_)
}
if (system.compare("GPS") == 0)
{
if (PRN_ < 1 or PRN > 32)
if (PRN_ < 1 or PRN_ > 32)
{
DLOG(INFO) << "This PRN is not defined";
PRN = 0;
@@ -157,7 +157,7 @@ void Gnss_Satellite::set_PRN(unsigned int PRN_)
}
else if (system.compare("Glonass") == 0)
{
if (PRN_ < 1 or PRN > 24)
if (PRN_ < 1 or PRN_ > 24)
{
DLOG(INFO) << "This PRN is not defined";
PRN = 0;
@@ -181,29 +181,17 @@ void Gnss_Satellite::set_PRN(unsigned int PRN_)
}
}
else if (system.compare("Galileo") == 0)
{
if (PRN_ < 1 or PRN_ > 36)
{
if (PRN_ == 11)
{
PRN = 11;
}
else if (PRN_ == 12)
{
PRN = 12;
}
else if (PRN_ == 19)
{
PRN = 19;
}
else if (PRN_ == 20)
{
PRN = 20;
}
else
{
DLOG(INFO) << "This PRN is not defined";
PRN = 0;
}
DLOG(INFO) << "This PRN is not defined";
PRN = 0;
}
else
{
PRN = PRN_;
}
}
else
{
DLOG(INFO) << "System " << system << " is not defined";
@@ -517,7 +505,7 @@ void Gnss_Satellite::set_block(std::string system_, unsigned int PRN_ )
block = std::string("IOV"); // Galileo In-Orbit Validation (IOV) satellite FM4 (Flight Model 4)
break;
default:
block = std::string("Unknown");
block = std::string("Unknown(Simulated)");
}
}
}