mirror of https://github.com/gnss-sdr/gnss-sdr
GSoC 2013 commit from Mara Branzanti: Galileo E1 observables under construction!
git-svn-id: https://svn.code.sf.net/p/gnss-sdr/code/trunk@422 64b25241-fba3-4117-9849-534c7e92360d
This commit is contained in:
Javier Arribas
parent
ee43872704
commit
806af3e98f
|
|
@ -151,7 +151,10 @@ int galileo_e1_pvt_cc::general_work (int noutput_items, gr_vector_int &ninput_it
|
|||
|
||||
// ############ 1. READ EPHEMERIS/UTC_MODE/IONO FROM GLOBAL MAPS ####
|
||||
|
||||
d_ls_pvt->galileo_ephemeris_map = global_galileo_ephemeris_map.get_map_copy();
|
||||
if (global_galileo_ephemeris_map.size()>0)
|
||||
{
|
||||
d_ls_pvt->galileo_ephemeris_map = global_galileo_ephemeris_map.get_map_copy();
|
||||
}
|
||||
|
||||
if (global_galileo_utc_model_map.size()>0)
|
||||
{
|
||||
|
|
@ -162,7 +165,7 @@ int galileo_e1_pvt_cc::general_work (int noutput_items, gr_vector_int &ninput_it
|
|||
if (global_galileo_iono_map.size()>0)
|
||||
{
|
||||
// IONO data is shared for all the Galileo satellites. Read always at ID=0
|
||||
global_galileo_iono_map.read(0,d_ls_pvt->galileo_iono);
|
||||
global_galileo_iono_map.read(0,d_ls_pvt->galileo_iono);
|
||||
}
|
||||
|
||||
// ############ 2 COMPUTE THE PVT ################################
|
||||
|
|
@ -243,7 +246,8 @@ int galileo_e1_pvt_cc::general_work (int noutput_items, gr_vector_int &ninput_it
|
|||
// }
|
||||
// }
|
||||
//
|
||||
// consume_each(1); //one by one
|
||||
|
||||
consume_each(1); //one by one
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -91,85 +91,104 @@ 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)
|
||||
//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_e1_observables_cc::pairCompare_gnss_synchro_d_TOW_at_current_symbol( std::pair<int,Gnss_Synchro> a, std::pair<int,Gnss_Synchro> b)
|
||||
bool Galileo_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);
|
||||
}
|
||||
|
||||
|
||||
|
||||
int galileo_e1_observables_cc::general_work (int noutput_items, gr_vector_int &ninput_items,
|
||||
gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
|
||||
{
|
||||
// Gnss_Synchro **in = (Gnss_Synchro **) &input_items[0]; //Get the input pointer
|
||||
// Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; //Get the output pointer
|
||||
//
|
||||
// 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;
|
||||
//
|
||||
// d_sample_counter++; //count for the processed samples
|
||||
// /*
|
||||
// * 1. Read the GNSS SYNCHRO objects from available channels
|
||||
// */
|
||||
// for (unsigned int i=0; i<d_nchannels ; i++)
|
||||
// {
|
||||
// //Copy the telemetry decoder data to local copy
|
||||
// current_gnss_synchro[i] = in[i][0];
|
||||
// /*
|
||||
// * 1.2 Assume no valid pseudoranges
|
||||
// */
|
||||
// current_gnss_synchro[i].Flag_valid_pseudorange = false;
|
||||
// current_gnss_synchro[i].Pseudorange_m = 0.0;
|
||||
// if (current_gnss_synchro[i].Flag_valid_word) //if this channel have valid word
|
||||
// {
|
||||
// //record the word structure in a map for pseudorange computation
|
||||
// current_gnss_synchro_map.insert(std::pair<int, Gnss_Synchro>(current_gnss_synchro[i].Channel_ID, current_gnss_synchro[i]));
|
||||
// }
|
||||
// }
|
||||
// /*
|
||||
// * 2. Compute RAW pseudoranges using COMMON RECEPTION TIME algorithm. Use only the valid channels (channels that are tracking a satellite)
|
||||
// */
|
||||
// if(current_gnss_synchro_map.size() > 0)
|
||||
// {
|
||||
// /*
|
||||
// * 2.1 Use CURRENT set of measurements and find the nearest satellite
|
||||
// * common RX time algorithm
|
||||
// */
|
||||
// //;
|
||||
// // what is the most recent symbol TOW in the current set? -> this will be the reference symbol
|
||||
// gnss_synchro_iter = max_element(current_gnss_synchro_map.begin(), current_gnss_synchro_map.end(), pairCompare_gnss_synchro_d_TOW_at_current_symbol);
|
||||
// double d_TOW_reference = gnss_synchro_iter->second.d_TOW_at_current_symbol;
|
||||
// double d_ref_PRN_rx_time_ms = gnss_synchro_iter->second.Prn_timestamp_ms;
|
||||
// //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;
|
||||
// double pseudorange_m;
|
||||
// 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++)
|
||||
// {
|
||||
Gnss_Synchro **in = (Gnss_Synchro **) &input_items[0]; //Get the input pointer
|
||||
Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; //Get the output pointer
|
||||
|
||||
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
|
||||
*/
|
||||
for (unsigned int i=0; i<d_nchannels ; i++) //legge gli input per ogni canale e prepare i dati da riempire
|
||||
{
|
||||
//Copy the telemetry decoder data to local copy
|
||||
current_gnss_synchro[i] = in[i][0];
|
||||
/*
|
||||
* 1.2 Assume no valid pseudoranges
|
||||
*/
|
||||
current_gnss_synchro[i].Flag_valid_pseudorange = false;
|
||||
current_gnss_synchro[i].Pseudorange_m = 0.0;
|
||||
if (current_gnss_synchro[i].Flag_valid_word) //if this channel have valid word, ciò viene definito nel telemetry decoder
|
||||
{
|
||||
//record the word structure in a map for pseudorange computation
|
||||
current_gnss_synchro_map.insert(std::pair<int, Gnss_Synchro>(current_gnss_synchro[i].Channel_ID, current_gnss_synchro[i]));
|
||||
}
|
||||
}
|
||||
/*
|
||||
* 2. Compute RAW pseudoranges using COMMON RECEPTION TIME algorithm. Use only the valid channels (channels that are tracking a satellite)
|
||||
*/
|
||||
if(current_gnss_synchro_map.size() > 0)
|
||||
{
|
||||
/*
|
||||
* 2.1 Use CURRENT set of measurements and find the nearest satellite
|
||||
* common RX time algorithm
|
||||
*/
|
||||
//;
|
||||
// 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;
|
||||
|
||||
// Now compute RX time differences due to the PRN alignement in the correlators
|
||||
double traveltime_ms;
|
||||
double pseudorange_m;
|
||||
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
|
||||
// delta_rx_time_ms = gnss_synchro_iter->second.Prn_timestamp_ms-d_ref_PRN_rx_time_ms;
|
||||
// //std::cout<<"delta_rx_time_ms="<<delta_rx_time_ms<<std::endl;
|
||||
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
|
||||
// traveltime_ms = (d_TOW_reference-gnss_synchro_iter->second.d_TOW_at_current_symbol)*1000.0 + delta_rx_time_ms + GPS_STARTOFFSET_ms;
|
||||
// pseudorange_m = traveltime_ms * GPS_C_m_ms; // [m]
|
||||
// // 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 + GPS_STARTOFFSET_ms/1000.0;
|
||||
// }
|
||||
// }
|
||||
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;
|
||||
// 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)
|
||||
// if(d_dump == true)
|
||||
// {
|
||||
// // MULTIPLEXED FILE RECORDING - Record results to file
|
||||
// try
|
||||
|
|
@ -196,10 +215,10 @@ int galileo_e1_observables_cc::general_work (int noutput_items, gr_vector_int &n
|
|||
// }
|
||||
//
|
||||
consume_each(1); //one by one
|
||||
// for (unsigned int i=0; i<d_nchannels ; i++)
|
||||
// {
|
||||
// *out[i] = current_gnss_synchro[i];
|
||||
// }
|
||||
for (unsigned int i=0; i<d_nchannels ; i++)
|
||||
{
|
||||
*out[i] = current_gnss_synchro[i];
|
||||
}
|
||||
return 1; //Output the observables
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -39,10 +39,11 @@
|
|||
#include <boost/thread/mutex.hpp>
|
||||
#include <boost/thread/thread.hpp>
|
||||
#include "concurrent_queue.h"
|
||||
//#include "gps_navigation_message.h" //to removed
|
||||
|
||||
#include "galileo_navigation_message.h"
|
||||
#include "rinex_printer.h"
|
||||
//#include "GPS_L1_CA.h" //to remove
|
||||
#include "Galileo_E1.h"
|
||||
|
||||
#include "gnss_synchro.h"
|
||||
|
||||
class galileo_e1_observables_cc;
|
||||
|
|
|
|||
|
|
@ -175,9 +175,9 @@ galileo_e1b_telemetry_decoder_cc::galileo_e1b_telemetry_decoder_cc(
|
|||
d_flag_frame_sync = false;
|
||||
|
||||
d_flag_parity = false;
|
||||
d_TOW_at_Preamble = 0;
|
||||
d_TOW_at_Preamble= 0;
|
||||
d_TOW_at_current_symbol = 0;
|
||||
flag_TOW_set = false;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -360,19 +360,63 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items, gr_vector
|
|||
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
|
||||
current_synchro_data = in[0][0];
|
||||
//std::cout<<"flag TOW before add the telemetry decoder information: d_nav.flag_TOW_set"<<std::endl;
|
||||
//2. Add the telemetry decoder information
|
||||
if (this->d_flag_preamble==true) //update TOW at the preamble instant (todo: check for valid d_TOW)
|
||||
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;
|
||||
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;
|
||||
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*/
|
||||
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;
|
||||
|
||||
d_nav.flag_TOW_5 = 0;
|
||||
}
|
||||
|
||||
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;
|
||||
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;
|
||||
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;
|
||||
|
||||
d_nav.flag_TOW_6 = 0;
|
||||
}
|
||||
|
||||
|
||||
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;
|
||||
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 << "Prn_timestamp_at_preamble_ms ="<< Prn_timestamp_at_preamble_ms << std::endl;
|
||||
|
||||
|
||||
}
|
||||
else
|
||||
else //if there is not a new preamble, we define the TOW of the current symbol
|
||||
{
|
||||
//d_TOW_at_current_symbol = d_TOW_at_current_symbol + Galileo_E1_CODE_PERIOD;
|
||||
d_TOW_at_current_symbol = d_TOW_at_current_symbol + GALIELO_E1_CODE_PERIOD;
|
||||
//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)
|
||||
current_synchro_data.Flag_valid_word = true;
|
||||
|
||||
|
||||
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 = (d_flag_frame_sync == true and d_flag_parity == true and flag_TOW_set==true);
|
||||
//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;
|
||||
current_synchro_data.Prn_timestamp_at_preamble_ms = Prn_timestamp_at_preamble_ms;
|
||||
|
|
|
|||
|
|
@ -45,6 +45,8 @@ const double GALILEO_PI = 3.1415926535898; //!< Pi as defined in GAL
|
|||
const double GALILEO_GM = 3.986004418e14; //!< Geocentric gravitational constant[m^3/s^2]
|
||||
const double GALILEO_OMEGA_EARTH_DOT = 7.2921151467e-5; //!< Mean angular velocity of the Earth [rad/s]
|
||||
const double GALILEO_C_m_s = 299792458.0; //!< The speed of light, [m/s]
|
||||
const double GALILEO_C_m_ms = 299792.4580; //!< The speed of light, [m/ms]
|
||||
|
||||
const double GALILEO_F = -4.442807633e-10; //!< Constant, [s/(m)^(1/2)]
|
||||
// carrier and code frequencies
|
||||
const double Galileo_E1_FREQ_HZ = 1.57542e9; //!< E1 [Hz]
|
||||
|
|
@ -57,6 +59,9 @@ const double Galileo_E1_B_SYMBOL_RATE_BPS = 250.0; //!< Galileo E1-B symbol rate
|
|||
const double Galileo_E1_C_SECONDARY_CODE_LENGTH = 25.0; //!< Galileo E1-C secondary code length [chips]
|
||||
const int Galileo_E1_NUMBER_OF_CODES = 50;
|
||||
|
||||
//#define NAVIGATION_SOLUTION_RATE_MS 1000 // this cannot go here
|
||||
const double GALILEO_STARTOFFSET_ms = 68.802; //[ms] Initial sign. travel time (this cannot go here)
|
||||
|
||||
// Galileo INAV Telemetry structure
|
||||
|
||||
#define GALILEO_INAV_PREAMBLE {0, 1, 0, 1, 1, 0, 0, 0, 0, 0}
|
||||
|
|
@ -65,14 +70,15 @@ const int GALILEO_INAV_PREAMBLE_LENGTH_BITS = 10;
|
|||
const int GALILEO_INAV_PREAMBLE_PERIOD_SYMBOLS = 250;
|
||||
const int GALILEO_INAV_PAGE_PART_SYMBOLS = 250; //!< Each Galileo INAV pages are composed of two parts (even and odd) each of 250 symbols, including preamble. See Galileo ICD 4.3.2
|
||||
const int GALILEO_INAV_PAGE_SYMBOLS = 500; //!< The complete Galileo INAV page length
|
||||
|
||||
const int GALILEO_PAGE_SECONDS = 1; //a page last 1 sec
|
||||
const int GALILEO_INAV_INTERLEAVER_ROWS = 8;
|
||||
const int GALILEO_INAV_INTERLEAVER_COLS = 30;
|
||||
|
||||
const int GALILEO_TELEMETRY_RATE_BITS_SECOND = 250; //bps
|
||||
const int GALILEO_PAGE_TYPE_BITS = 6;
|
||||
const int GALILEO_DATA_JK_BITS =128;
|
||||
const int GALILEO_DATA_FRAME_BITS =196;
|
||||
const int GALILEO_DATA_FRAME_BYTES =25;
|
||||
const double GALIELO_E1_CODE_PERIOD = 0.004;
|
||||
|
||||
const std::vector<std::pair<int,int>> type({{1,6}});
|
||||
const std::vector<std::pair<int,int>> PAGE_TYPE_bit({{1,6}});;
|
||||
|
|
|
|||
|
|
@ -33,7 +33,8 @@
|
|||
#include <boost/date_time/posix_time/posix_time.hpp>
|
||||
#include <boost/crc.hpp> // for boost::crc_basic, boost::crc_optimal
|
||||
#include <boost/dynamic_bitset.hpp>
|
||||
|
||||
#include <glog/log_severity.h>
|
||||
#include <glog/logging.h>
|
||||
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
|
|
@ -45,7 +46,9 @@ typedef boost::crc_optimal<24, 0x1864CFBu, 0x0, 0x0, false, false> CRC_Galileo_I
|
|||
void Galileo_Navigation_Message::reset()
|
||||
{
|
||||
flag_even_word = 0;
|
||||
Page_type_time_stamp = 0;
|
||||
|
||||
flag_CRC_test = false;
|
||||
flag_all_ephemeris = false; // flag indicating that all words containing ephemeris have been received
|
||||
flag_ephemeris_1 = false; // flag indicating that ephemeris 1/4 (word 1) have been received
|
||||
flag_ephemeris_2 = false; // flag indicating that ephemeris 2/4 (word 2) have been received
|
||||
|
|
@ -61,6 +64,8 @@ void Galileo_Navigation_Message::reset()
|
|||
flag_almanac_3 = false; // flag indicating that almanac 3/4 (word 9) have been received
|
||||
flag_almanac_4 = false; // flag indicating that almanac 4/4 (word 10) have been received
|
||||
|
||||
flag_TOW_5 = 0;
|
||||
flag_TOW_set = false;
|
||||
|
||||
IOD_ephemeris = 0;
|
||||
/*Word type 1: Ephemeris (1/4)*/
|
||||
|
|
@ -366,7 +371,7 @@ void Galileo_Navigation_Message::split_page(const char *page, int flag_even_word
|
|||
// ToDo: Clean all the tests and create an independent google test code for the telemetry decoder.
|
||||
|
||||
|
||||
std::cout << "Entered in Galileo_Navigation_Message::split_page(const char *page, int flag_even_word" << std::endl << std::endl;;
|
||||
//std::cout << "Entered in Galileo_Navigation_Message::split_page(const char *page, int flag_even_word" << std::endl << std::endl;;
|
||||
std::string page_string = page;
|
||||
//char correct_tail[7]="011110"; //the viterbi decoder output change the tail to this value (why?)
|
||||
|
||||
|
|
@ -375,7 +380,7 @@ void Galileo_Navigation_Message::split_page(const char *page, int flag_even_word
|
|||
int Page_type=0;
|
||||
static std::string page_Even; //declare in this way it can "remember the previous even page while reading the odd page..ok!
|
||||
|
||||
std::cout << "Start decoding Galileo I/NAV " << std::endl;
|
||||
//std::cout << "Start decoding Galileo I/NAV " << std::endl;
|
||||
|
||||
if(page_string.at(0)=='1')// if page is odd
|
||||
{
|
||||
|
|
@ -396,9 +401,9 @@ void Galileo_Navigation_Message::split_page(const char *page, int flag_even_word
|
|||
//std::cout << "Page type even = " << Page_type_even << endl;
|
||||
std::string nominal = "0";
|
||||
|
||||
if (Page_type_even.compare(nominal) != 0)
|
||||
std::cout << "Alert frame "<< std::endl;
|
||||
else std::cout << "Nominal Page" << std::endl;
|
||||
//if (Page_type_even.compare(nominal) != 0)
|
||||
// std::cout << "Alert frame "<< std::endl;
|
||||
//else std::cout << "Nominal Page" << std::endl;
|
||||
|
||||
std::string Data_k = page_INAV.substr (2,112);
|
||||
//std::cout << "Data_k " << endl << Data_k << endl;
|
||||
|
|
@ -431,15 +436,17 @@ void Galileo_Navigation_Message::split_page(const char *page, int flag_even_word
|
|||
|
||||
if (CRC_test(TLM_word_for_CRC_bits,checksum.to_ulong())==true)
|
||||
{
|
||||
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;
|
||||
|
||||
std::bitset<GALILEO_PAGE_TYPE_BITS> page_type_bits (page_number_bits); // from string to bitset
|
||||
Page_type = (int)read_page_type_unsigned(page_type_bits, type);
|
||||
std::cout << "Page number (first 6 bits of Data k converted to decimal) = " << Page_type << std::endl;
|
||||
Page_type_time_stamp = Page_type;
|
||||
//std::cout << "Page number (first 6 bits of Data k converted to decimal) = " << Page_type << std::endl;
|
||||
std::string Data_jk_ephemeris = Data_k + Data_j;
|
||||
//std::cout<<"Data j k ephemeris" << endl << Data_jk_ephemeris << endl;
|
||||
|
||||
|
|
@ -690,115 +697,119 @@ Galileo_Almanac Galileo_Navigation_Message::get_almanac()
|
|||
|
||||
int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
{
|
||||
std::cout << "--------------------------------------------------------------------------" << std::endl;
|
||||
std::cout<< "Entered in function Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)" << std::endl;
|
||||
//DLOG(INFO) << "--------------------------------------------------------------------------" << std::endl;
|
||||
//DLOG(INFO)<< "Entered in function Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)" << std::endl;
|
||||
|
||||
int page_number = 0;
|
||||
|
||||
std::string data_jk_string = data_jk;
|
||||
std::bitset<GALILEO_DATA_JK_BITS> data_jk_bits (data_jk_string);
|
||||
|
||||
//std::cout << "Data_jk_bits (bitset) "<< endl << data_jk_bits << endl;
|
||||
//DLOG(INFO) << "Data_jk_bits (bitset) "<< endl << data_jk_bits << endl;
|
||||
|
||||
page_number = (int)read_navigation_unsigned(data_jk_bits, PAGE_TYPE_bit);
|
||||
std::cout << "Page number = " << page_number << std::endl;
|
||||
DLOG(INFO) << "Page number = " << page_number << std::endl;
|
||||
|
||||
switch (page_number)
|
||||
{
|
||||
case 1: /*Word type 1: Ephemeris (1/4)*/
|
||||
IOD_nav_1=(int)read_navigation_unsigned(data_jk_bits, IOD_nav_1_bit);
|
||||
std::cout<<"IOD_nav_1= "<< IOD_nav_1 <<std::endl;
|
||||
DLOG(INFO)<<"IOD_nav_1= "<< IOD_nav_1 <<std::endl;
|
||||
|
||||
t0e_1=(double)read_navigation_unsigned(data_jk_bits, T0E_1_bit);
|
||||
t0e_1 = t0e_1 * t0e_1_LSB;
|
||||
std::cout << "t0e_1= " << t0e_1 <<std::endl;
|
||||
DLOG(INFO) << "t0e_1= " << t0e_1 <<std::endl;
|
||||
|
||||
M0_1 = (double)read_navigation_unsigned(data_jk_bits, M0_1_bit);
|
||||
M0_1 = M0_1 * M0_1_LSB;
|
||||
std::cout << "M0_1= " << M0_1<<std::endl;
|
||||
DLOG(INFO) << "M0_1= " << M0_1<<std::endl;
|
||||
|
||||
e_1 = (double)read_navigation_unsigned(data_jk_bits, e_1_bit);
|
||||
e_1 = e_1 * e_1_LSB;
|
||||
std::cout << "e_1= " << e_1 <<std::endl;
|
||||
DLOG(INFO) << "e_1= " << e_1 <<std::endl;
|
||||
|
||||
A_1 = (double)read_navigation_unsigned(data_jk_bits, A_1_bit);
|
||||
A_1 = A_1 * A_1_LSB_gal;
|
||||
std::cout << "A_1= " << A_1 <<std::endl;
|
||||
DLOG(INFO) << "A_1= " << A_1 <<std::endl;
|
||||
flag_ephemeris_1 = true;
|
||||
break;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
|
||||
case 2: /*Word type 2: Ephemeris (2/4)*/
|
||||
IOD_nav_2 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_2_bit);
|
||||
std::cout<<"IOD_nav_2= "<< IOD_nav_2 <<std::endl;
|
||||
DLOG(INFO)<<"IOD_nav_2= "<< IOD_nav_2 <<std::endl;
|
||||
|
||||
OMEGA_0_2 = (double)read_navigation_unsigned(data_jk_bits, OMEGA_0_2_bit);
|
||||
OMEGA_0_2 = OMEGA_0_2 * OMEGA_0_2_LSB;
|
||||
std::cout<<"OMEGA_0_2= "<< OMEGA_0_2 <<std::endl;
|
||||
DLOG(INFO)<<"OMEGA_0_2= "<< OMEGA_0_2 <<std::endl;
|
||||
i_0_2 = (double)read_navigation_unsigned(data_jk_bits, i_0_2_bit);
|
||||
i_0_2 = i_0_2 * i_0_2_LSB;
|
||||
std::cout<<"i_0_2= "<< i_0_2 <<std::endl;
|
||||
DLOG(INFO)<<"i_0_2= "<< i_0_2 <<std::endl;
|
||||
omega_2 = (double)read_navigation_unsigned(data_jk_bits, omega_2_bit);
|
||||
omega_2 = omega_2 * omega_2_LSB;
|
||||
std::cout<<"omega_2= "<< omega_2 <<std::endl;
|
||||
DLOG(INFO)<<"omega_2= "<< omega_2 <<std::endl;
|
||||
iDot_2 = (double)read_navigation_unsigned(data_jk_bits, iDot_2_bit);
|
||||
iDot_2 = iDot_2 * iDot_2_LSB;
|
||||
std::cout<<"iDot_2= "<< iDot_2 <<std::endl;
|
||||
DLOG(INFO)<<"iDot_2= "<< iDot_2 <<std::endl;
|
||||
flag_ephemeris_2 = true;
|
||||
break;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
|
||||
case 3: /*Word type 3: Ephemeris (3/4) and SISA*/
|
||||
IOD_nav_3 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_3_bit);
|
||||
std::cout<<"IOD_nav_3= "<< IOD_nav_3 <<std::endl;
|
||||
DLOG(INFO)<<"IOD_nav_3= "<< IOD_nav_3 <<std::endl;
|
||||
OMEGA_dot_3 = (double)read_navigation_unsigned(data_jk_bits, OMEGA_dot_3_bit);
|
||||
OMEGA_dot_3 = OMEGA_dot_3 * OMEGA_dot_3_LSB;
|
||||
std::cout<<"OMEGA_dot_3= "<< OMEGA_dot_3 <<std::endl;
|
||||
DLOG(INFO)<<"OMEGA_dot_3= "<< OMEGA_dot_3 <<std::endl;
|
||||
delta_n_3 = (double)read_navigation_unsigned(data_jk_bits, delta_n_3_bit);
|
||||
delta_n_3 = delta_n_3 * delta_n_3_LSB;
|
||||
std::cout<<"delta_n_3= "<< delta_n_3 <<std::endl;
|
||||
DLOG(INFO)<<"delta_n_3= "<< delta_n_3 <<std::endl;
|
||||
C_uc_3 = (double)read_navigation_unsigned(data_jk_bits, C_uc_3_bit);
|
||||
C_uc_3 = C_uc_3 * C_uc_3_LSB;
|
||||
std::cout<<"C_uc_3= "<< C_uc_3 <<std::endl;
|
||||
DLOG(INFO)<<"C_uc_3= "<< C_uc_3 <<std::endl;
|
||||
C_us_3 = (double)read_navigation_unsigned(data_jk_bits, C_us_3_bit);
|
||||
C_us_3 = C_us_3 * C_us_3_LSB;
|
||||
std::cout<<"C_us_3= "<< C_us_3 <<std::endl;
|
||||
DLOG(INFO)<<"C_us_3= "<< C_us_3 <<std::endl;
|
||||
C_rc_3 = (double)read_navigation_unsigned(data_jk_bits, C_rc_3_bit);
|
||||
C_rc_3 = C_rc_3 * C_rc_3_LSB;
|
||||
std::cout<<"C_rc_3= "<< C_rc_3 <<std::endl;
|
||||
DLOG(INFO)<<"C_rc_3= "<< C_rc_3 <<std::endl;
|
||||
C_rs_3 = (double)read_navigation_unsigned(data_jk_bits, C_rs_3_bit);
|
||||
C_rs_3 = C_rs_3 * C_rs_3_LSB;
|
||||
std::cout<<"C_rs_3= "<< C_rs_3 <<std::endl;
|
||||
DLOG(INFO)<<"C_rs_3= "<< C_rs_3 <<std::endl;
|
||||
SISA_3 = (double)read_navigation_unsigned(data_jk_bits, SISA_3_bit);
|
||||
std::cout<<"SISA_3= "<< SISA_3 <<std::endl;
|
||||
DLOG(INFO)<<"SISA_3= "<< SISA_3 <<std::endl;
|
||||
flag_ephemeris_3 = true;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
break;
|
||||
|
||||
case 4: /* Word type 4: Ephemeris (4/4) and Clock correction parameters*/
|
||||
IOD_nav_4 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_4_bit);
|
||||
std::cout<<"IOD_nav_4= "<< IOD_nav_4 <<std::endl;
|
||||
DLOG(INFO)<<"IOD_nav_4= "<< IOD_nav_4 <<std::endl;
|
||||
SV_ID_PRN_4 = (int)read_navigation_unsigned(data_jk_bits, SV_ID_PRN_4_bit);
|
||||
std::cout<<"SV_ID_PRN_4= "<< SV_ID_PRN_4 <<std::endl;
|
||||
DLOG(INFO)<<"SV_ID_PRN_4= "<< SV_ID_PRN_4 <<std::endl;
|
||||
C_ic_4 = (double)read_navigation_unsigned(data_jk_bits, C_ic_4_bit);
|
||||
C_ic_4 = C_ic_4 * C_ic_4_LSB;
|
||||
std::cout<<"C_ic_4= "<< C_ic_4 <<std::endl;
|
||||
DLOG(INFO)<<"C_ic_4= "<< C_ic_4 <<std::endl;
|
||||
C_is_4 = (double)read_navigation_unsigned(data_jk_bits, C_is_4_bit);
|
||||
C_is_4 = C_is_4 * C_is_4_LSB;
|
||||
std::cout<<"C_is_4= "<< C_is_4 <<std::endl;
|
||||
DLOG(INFO)<<"C_is_4= "<< C_is_4 <<std::endl;
|
||||
/*Clock correction parameters*/
|
||||
t0c_4 = (double)read_navigation_unsigned(data_jk_bits, t0c_4_bit);
|
||||
t0c_4 = t0c_4 * t0c_4_LSB;
|
||||
std::cout<<"t0c_4= "<< t0c_4 <<std::endl;
|
||||
DLOG(INFO)<<"t0c_4= "<< t0c_4 <<std::endl;
|
||||
af0_4 = (double)read_navigation_unsigned(data_jk_bits, af0_4_bit);
|
||||
af0_4 = af0_4 * af0_4_LSB;
|
||||
std::cout<<"af0_4 = "<< af0_4 <<std::endl;
|
||||
DLOG(INFO)<<"af0_4 = "<< af0_4 <<std::endl;
|
||||
af1_4 = (double)read_navigation_unsigned(data_jk_bits, af1_4_bit);
|
||||
af1_4 = af1_4 * af1_4_LSB;
|
||||
std::cout<<"af1_4 = "<< af1_4 <<std::endl;
|
||||
DLOG(INFO)<<"af1_4 = "<< af1_4 <<std::endl;
|
||||
af2_4 = (double)read_navigation_unsigned(data_jk_bits, af2_4_bit);
|
||||
af2_4 = af2_4 * af2_4_LSB;
|
||||
std::cout<<"af2_4 = "<< af2_4 <<std::endl;
|
||||
DLOG(INFO)<<"af2_4 = "<< af2_4 <<std::endl;
|
||||
spare_4 = (double)read_navigation_unsigned(data_jk_bits, spare_4_bit);
|
||||
std::cout<<"spare_4 = "<< spare_4 <<std::endl;
|
||||
DLOG(INFO)<<"spare_4 = "<< spare_4 <<std::endl;
|
||||
flag_ephemeris_4 = true;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
break;
|
||||
|
||||
case 5: /*Word type 5: Ionospheric correction, BGD, signal health and data validity status and GST*/
|
||||
|
|
@ -806,283 +817,294 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
|||
/*Az*/
|
||||
ai0_5 = (double)read_navigation_unsigned(data_jk_bits, ai0_5_bit);
|
||||
ai0_5 = ai0_5 * ai0_5_LSB;
|
||||
std::cout<<"ai0_5= "<< ai0_5 <<std::endl;
|
||||
DLOG(INFO)<<"ai0_5= "<< ai0_5 <<std::endl;
|
||||
ai1_5 = (double)read_navigation_unsigned(data_jk_bits, ai1_5_bit);
|
||||
ai1_5 = ai1_5 * ai1_5_LSB;
|
||||
std::cout<<"ai1_5= "<< ai1_5 <<std::endl;
|
||||
DLOG(INFO)<<"ai1_5= "<< ai1_5 <<std::endl;
|
||||
ai2_5 = (double)read_navigation_unsigned(data_jk_bits, ai2_5_bit);
|
||||
ai2_5 = ai2_5 * ai2_5_LSB;
|
||||
std::cout<<"ai2_5= "<< ai2_5 <<std::endl;
|
||||
DLOG(INFO)<<"ai2_5= "<< ai2_5 <<std::endl;
|
||||
/*Ionospheric disturbance flag*/
|
||||
Region1_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region1_5_bit);
|
||||
std::cout<<"Region1_flag_5= "<< Region1_flag_5 <<std::endl;
|
||||
DLOG(INFO)<<"Region1_flag_5= "<< Region1_flag_5 <<std::endl;
|
||||
Region2_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region2_5_bit);
|
||||
std::cout<<"Region2_flag_5= "<< Region2_flag_5 <<std::endl;
|
||||
DLOG(INFO)<<"Region2_flag_5= "<< Region2_flag_5 <<std::endl;
|
||||
Region3_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region3_5_bit);
|
||||
std::cout<<"Region3_flag_5= "<< Region3_flag_5 <<std::endl;
|
||||
DLOG(INFO)<<"Region3_flag_5= "<< Region3_flag_5 <<std::endl;
|
||||
Region4_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region4_5_bit);
|
||||
std::cout<<"Region4_flag_5= "<< Region4_flag_5 <<std::endl;
|
||||
DLOG(INFO)<<"Region4_flag_5= "<< Region4_flag_5 <<std::endl;
|
||||
Region5_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region5_5_bit);
|
||||
std::cout<<"Region5_flag_5= "<< Region5_flag_5 <<std::endl;
|
||||
DLOG(INFO)<<"Region5_flag_5= "<< Region5_flag_5 <<std::endl;
|
||||
BGD_E1E5a_5 = (double)read_navigation_unsigned(data_jk_bits, BGD_E1E5a_5_bit);
|
||||
BGD_E1E5a_5 = BGD_E1E5a_5 * BGD_E1E5a_5_LSB;
|
||||
std::cout<<"BGD_E1E5a_5= "<< BGD_E1E5a_5 <<std::endl;
|
||||
DLOG(INFO)<<"BGD_E1E5a_5= "<< BGD_E1E5a_5 <<std::endl;
|
||||
BGD_E1E5b_5 = (double)read_navigation_unsigned(data_jk_bits, BGD_E1E5b_5_bit);
|
||||
BGD_E1E5b_5 = BGD_E1E5b_5 * BGD_E1E5b_5_LSB;
|
||||
std::cout<<"BGD_E1E5b_5= "<< BGD_E1E5b_5 <<std::endl;
|
||||
DLOG(INFO)<<"BGD_E1E5b_5= "<< BGD_E1E5b_5 <<std::endl;
|
||||
E5b_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_5_bit);
|
||||
std::cout<<"E5b_HS_5= "<< E5b_HS_5 <<std::endl;
|
||||
DLOG(INFO)<<"E5b_HS_5= "<< E5b_HS_5 <<std::endl;
|
||||
E1B_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_5_bit);
|
||||
std::cout<<"E1B_HS_5= "<< E1B_HS_5 <<std::endl;
|
||||
DLOG(INFO)<<"E1B_HS_5= "<< E1B_HS_5 <<std::endl;
|
||||
E5b_DVS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_DVS_5_bit);
|
||||
std::cout<<"E5b_DVS_5= "<< E5b_DVS_5 <<std::endl;
|
||||
DLOG(INFO)<<"E5b_DVS_5= "<< E5b_DVS_5 <<std::endl;
|
||||
E1B_DVS_5 = (double)read_navigation_unsigned(data_jk_bits, E1B_DVS_5_bit);
|
||||
std::cout<<"E1B_DVS_5= "<< E1B_DVS_5 <<std::endl;
|
||||
DLOG(INFO)<<"E1B_DVS_5= "<< E1B_DVS_5 <<std::endl;
|
||||
/*GST*/
|
||||
WN_5 = (double)read_navigation_unsigned(data_jk_bits, WN_5_bit);
|
||||
std::cout<<"WN_5= "<< WN_5 <<std::endl;
|
||||
DLOG(INFO)<<"WN_5= "<< WN_5 <<std::endl;
|
||||
TOW_5 = (double)read_navigation_unsigned(data_jk_bits, TOW_5_bit);
|
||||
std::cout<<"TOW_5= "<< TOW_5 <<std::endl;
|
||||
DLOG(INFO)<<"TOW_5= "<< TOW_5 <<std::endl;
|
||||
flag_TOW_5 = 1;
|
||||
spare_5 = (double)read_navigation_unsigned(data_jk_bits, spare_5_bit);
|
||||
std::cout<<"spare_5= "<< spare_5 <<std::endl;
|
||||
DLOG(INFO)<<"spare_5= "<< spare_5 <<std::endl;
|
||||
flag_iono_and_GST = true;
|
||||
flag_TOW_set = true;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
break;
|
||||
|
||||
case 6: /*Word type 6: GST-UTC conversion parameters*/
|
||||
A0_6= (double)read_navigation_unsigned(data_jk_bits, A0_6_bit);
|
||||
A0_6= A0_6 * A0_6_LSB;
|
||||
std::cout << "A0_6= " << A0_6 << std::endl;
|
||||
DLOG(INFO) << "A0_6= " << A0_6 << std::endl;
|
||||
|
||||
A1_6= (double)read_navigation_unsigned(data_jk_bits, A1_6_bit);
|
||||
A1_6= A1_6 * A1_6_LSB;
|
||||
std::cout << "A1_6= " << A1_6 << std::endl;
|
||||
DLOG(INFO) << "A1_6= " << A1_6 << std::endl;
|
||||
|
||||
Delta_tLS_6= (double)read_navigation_unsigned(data_jk_bits, Delta_tLS_6_bit);
|
||||
std::cout << "Delta_tLS_6= " << Delta_tLS_6 << std::endl;
|
||||
DLOG(INFO) << "Delta_tLS_6= " << Delta_tLS_6 << std::endl;
|
||||
|
||||
t0t_6= (double)read_navigation_unsigned(data_jk_bits, t0t_6_bit);
|
||||
t0t_6= t0t_6 * t0t_6_LSB;
|
||||
std::cout << "t0t_6= " << t0t_6 << std::endl;
|
||||
DLOG(INFO) << "t0t_6= " << t0t_6 << std::endl;
|
||||
|
||||
WNot_6= (double)read_navigation_unsigned(data_jk_bits, WNot_6_bit);
|
||||
std::cout << "WNot_6= " << WNot_6 << std::endl;
|
||||
DLOG(INFO) << "WNot_6= " << WNot_6 << std::endl;
|
||||
|
||||
WN_LSF_6= (double)read_navigation_unsigned(data_jk_bits, WN_LSF_6_bit);
|
||||
std::cout << "WN_LSF_6= " << WN_LSF_6 << std::endl;
|
||||
DLOG(INFO) << "WN_LSF_6= " << WN_LSF_6 << std::endl;
|
||||
|
||||
DN_6= (double)read_navigation_unsigned(data_jk_bits, DN_6_bit);
|
||||
std::cout << "DN_6= " << DN_6 << std::endl;
|
||||
DLOG(INFO) << "DN_6= " << DN_6 << std::endl;
|
||||
|
||||
Delta_tLSF_6= (double)read_navigation_unsigned(data_jk_bits, Delta_tLSF_6_bit);
|
||||
std::cout << "Delta_tLSF_6= " << Delta_tLSF_6 << std::endl;
|
||||
DLOG(INFO) << "Delta_tLSF_6= " << Delta_tLSF_6 << std::endl;
|
||||
|
||||
TOW_6= (double)read_navigation_unsigned(data_jk_bits, TOW_6_bit);
|
||||
std::cout << "TOW_6= " << TOW_6 << std::endl;
|
||||
DLOG(INFO) << "TOW_6= " << TOW_6 << std::endl;
|
||||
flag_TOW_6 = 1;
|
||||
flag_utc_model = true;
|
||||
flag_TOW_set = true;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
break;
|
||||
|
||||
case 7: /*Word type 7: Almanac for SVID1 (1/2), almanac reference time and almanac reference week number*/
|
||||
|
||||
IOD_a_7= (double)read_navigation_unsigned(data_jk_bits, IOD_a_7_bit);
|
||||
std::cout << "IOD_a_7= " << IOD_a_7 << std::endl;
|
||||
DLOG(INFO) << "IOD_a_7= " << IOD_a_7 << std::endl;
|
||||
|
||||
WN_a_7= (double)read_navigation_unsigned(data_jk_bits, WN_a_7_bit);
|
||||
std::cout << "WN_a_7= " << WN_a_7 << std::endl;
|
||||
DLOG(INFO) << "WN_a_7= " << WN_a_7 << std::endl;
|
||||
|
||||
t0a_7= (double)read_navigation_unsigned(data_jk_bits, t0a_7_bit);
|
||||
t0a_7= t0a_7 * t0a_7_LSB;
|
||||
std::cout << "t0a_7= " << t0a_7 << std::endl;
|
||||
DLOG(INFO) << "t0a_7= " << t0a_7 << std::endl;
|
||||
|
||||
SVID1_7= (double)read_navigation_unsigned(data_jk_bits, SVID1_7_bit);
|
||||
std::cout << "SVID1_7= " << SVID1_7 << std::endl;
|
||||
DLOG(INFO) << "SVID1_7= " << SVID1_7 << std::endl;
|
||||
|
||||
DELTA_A_7= (double)read_navigation_unsigned(data_jk_bits, DELTA_A_7_bit);
|
||||
DELTA_A_7= DELTA_A_7 * DELTA_A_7_LSB;
|
||||
std::cout << "DELTA_A_7= " << DELTA_A_7 << std::endl;
|
||||
DLOG(INFO) << "DELTA_A_7= " << DELTA_A_7 << std::endl;
|
||||
|
||||
e_7= (double)read_navigation_unsigned(data_jk_bits, e_7_bit);
|
||||
e_7= e_7 * e_7_LSB;
|
||||
std::cout << "e_7= " << e_7 << std::endl;
|
||||
DLOG(INFO) << "e_7= " << e_7 << std::endl;
|
||||
|
||||
omega_7= (double)read_navigation_unsigned(data_jk_bits, omega_7_bit);
|
||||
omega_7= omega_7 * omega_7_LSB;
|
||||
std::cout << "omega_7= " << omega_7 << std::endl;
|
||||
DLOG(INFO) << "omega_7= " << omega_7 << std::endl;
|
||||
|
||||
delta_i_7= (double)read_navigation_unsigned(data_jk_bits, delta_i_7_bit);
|
||||
delta_i_7= delta_i_7 * delta_i_7_LSB;
|
||||
std::cout << "delta_i_7= " << delta_i_7 << std::endl;
|
||||
DLOG(INFO) << "delta_i_7= " << delta_i_7 << std::endl;
|
||||
|
||||
Omega0_7= (double)read_navigation_unsigned(data_jk_bits, Omega0_7_bit);
|
||||
Omega0_7= Omega0_7 * Omega0_7_LSB;
|
||||
std::cout << "Omega0_7= " << Omega0_7 << std::endl;
|
||||
DLOG(INFO) << "Omega0_7= " << Omega0_7 << std::endl;
|
||||
|
||||
Omega_dot_7= (double)read_navigation_unsigned(data_jk_bits, Omega_dot_7_bit);
|
||||
Omega_dot_7= Omega_dot_7 * Omega_dot_7_LSB;
|
||||
std::cout << "Omega_dot_7= " << Omega_dot_7 << std::endl;
|
||||
DLOG(INFO) << "Omega_dot_7= " << Omega_dot_7 << std::endl;
|
||||
|
||||
M0_7= (double)read_navigation_unsigned(data_jk_bits, M0_7_bit);
|
||||
M0_7= M0_7 * M0_7_LSB;
|
||||
std::cout << "M0_7= " << M0_7 << std::endl;
|
||||
DLOG(INFO) << "M0_7= " << M0_7 << std::endl;
|
||||
flag_almanac_1 = true;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
break;
|
||||
|
||||
case 8: /*Word type 8: Almanac for SVID1 (2/2) and SVID2 (1/2)*/
|
||||
|
||||
IOD_a_8= (double)read_navigation_unsigned(data_jk_bits, IOD_a_8_bit);
|
||||
std::cout << "IOD_a_8= " << IOD_a_8 << std::endl;
|
||||
DLOG(INFO) << "IOD_a_8= " << IOD_a_8 << std::endl;
|
||||
|
||||
af0_8= (double)read_navigation_unsigned(data_jk_bits, af0_8_bit);
|
||||
af0_8= af0_8 * af0_8_LSB;
|
||||
std::cout << "af0_8= " << af0_8 << std::endl;
|
||||
DLOG(INFO) << "af0_8= " << af0_8 << std::endl;
|
||||
|
||||
af1_8= (double)read_navigation_unsigned(data_jk_bits, af1_8_bit);
|
||||
af1_8= af1_8 * af1_8_LSB;
|
||||
std::cout << "af1_8= " << af1_8 << std::endl;
|
||||
DLOG(INFO) << "af1_8= " << af1_8 << std::endl;
|
||||
|
||||
E5b_HS_8= (double)read_navigation_unsigned(data_jk_bits, E5b_HS_8_bit);
|
||||
std::cout << "E5b_HS_8= " << E5b_HS_8 << std::endl;
|
||||
DLOG(INFO) << "E5b_HS_8= " << E5b_HS_8 << std::endl;
|
||||
|
||||
E1B_HS_8= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_8_bit);
|
||||
std::cout << "E1B_HS_8= " << E1B_HS_8 << std::endl;
|
||||
DLOG(INFO) << "E1B_HS_8= " << E1B_HS_8 << std::endl;
|
||||
|
||||
SVID2_8= (double)read_navigation_unsigned(data_jk_bits, SVID2_8_bit);
|
||||
std::cout << "SVID2_8= " << SVID2_8 << std::endl;
|
||||
DLOG(INFO) << "SVID2_8= " << SVID2_8 << std::endl;
|
||||
|
||||
DELTA_A_8= (double)read_navigation_unsigned(data_jk_bits, DELTA_A_8_bit);
|
||||
DELTA_A_8= DELTA_A_8 * DELTA_A_8_LSB;
|
||||
std::cout << "DELTA_A_8= " << DELTA_A_8 << std::endl;
|
||||
DLOG(INFO) << "DELTA_A_8= " << DELTA_A_8 << std::endl;
|
||||
|
||||
e_8= (double)read_navigation_unsigned(data_jk_bits, e_8_bit);
|
||||
e_8= e_8 * e_8_LSB;
|
||||
std::cout << "e_8= " << e_8 << std::endl;
|
||||
DLOG(INFO) << "e_8= " << e_8 << std::endl;
|
||||
|
||||
omega_8= (double)read_navigation_unsigned(data_jk_bits, omega_8_bit);
|
||||
omega_8= omega_8 * omega_8_LSB;
|
||||
std::cout << "omega_8= " << omega_8 << std::endl;
|
||||
DLOG(INFO) << "omega_8= " << omega_8 << std::endl;
|
||||
|
||||
delta_i_8= (double)read_navigation_unsigned(data_jk_bits, delta_i_8_bit);
|
||||
delta_i_8= delta_i_8 * delta_i_8_LSB;
|
||||
std::cout << "delta_i_8= " << delta_i_8 << std::endl;
|
||||
DLOG(INFO) << "delta_i_8= " << delta_i_8 << std::endl;
|
||||
|
||||
Omega0_8= (double)read_navigation_unsigned(data_jk_bits, Omega0_8_bit);
|
||||
Omega0_8= Omega0_8 * Omega0_8_LSB;
|
||||
std::cout << "Omega0_8= " << Omega0_8 << std::endl;
|
||||
DLOG(INFO) << "Omega0_8= " << Omega0_8 << std::endl;
|
||||
|
||||
Omega_dot_8= (double)read_navigation_unsigned(data_jk_bits, Omega_dot_8_bit);
|
||||
Omega_dot_8= Omega_dot_8 * Omega_dot_8_LSB;
|
||||
std::cout << "Omega_dot_8= " << Omega_dot_8 << std::endl;
|
||||
DLOG(INFO) << "Omega_dot_8= " << Omega_dot_8 << std::endl;
|
||||
flag_almanac_2 = true;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
break;
|
||||
|
||||
case 9: /*Word type 9: Almanac for SVID2 (2/2) and SVID3 (1/2)*/
|
||||
|
||||
IOD_a_9= (double)read_navigation_unsigned(data_jk_bits, IOD_a_9_bit);
|
||||
std::cout << "IOD_a_9= " << IOD_a_9 << std::endl;
|
||||
DLOG(INFO) << "IOD_a_9= " << IOD_a_9 << std::endl;
|
||||
|
||||
WN_a_9= (double)read_navigation_unsigned(data_jk_bits, WN_a_9_bit);
|
||||
std::cout << "WN_a_9= " << WN_a_9 << std::endl;
|
||||
DLOG(INFO) << "WN_a_9= " << WN_a_9 << std::endl;
|
||||
|
||||
t0a_9= (double)read_navigation_unsigned(data_jk_bits, t0a_9_bit);
|
||||
t0a_9= t0a_9 * t0a_9_LSB;
|
||||
std::cout << "t0a_9= " << t0a_9 << std::endl;
|
||||
DLOG(INFO) << "t0a_9= " << t0a_9 << std::endl;
|
||||
|
||||
M0_9= (double)read_navigation_unsigned(data_jk_bits, M0_9_bit);
|
||||
M0_9= M0_9 * M0_9_LSB;
|
||||
std::cout << "M0_9= " << M0_9 << std::endl;
|
||||
DLOG(INFO) << "M0_9= " << M0_9 << std::endl;
|
||||
|
||||
af0_9= (double)read_navigation_unsigned(data_jk_bits, af0_9_bit);
|
||||
af0_9= af0_9 * af0_9_LSB;
|
||||
std::cout << "af0_9= " << af0_9 << std::endl;
|
||||
DLOG(INFO) << "af0_9= " << af0_9 << std::endl;
|
||||
|
||||
af1_9= (double)read_navigation_unsigned(data_jk_bits, af1_9_bit);
|
||||
af1_9= af1_9 * af1_9_LSB;
|
||||
std::cout << "af1_9= " << af1_9 << std::endl;
|
||||
DLOG(INFO) << "af1_9= " << af1_9 << std::endl;
|
||||
|
||||
E1B_HS_9= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit);
|
||||
std::cout << "E1B_HS_9= " << E1B_HS_9 << std::endl;
|
||||
DLOG(INFO) << "E1B_HS_9= " << E1B_HS_9 << std::endl;
|
||||
|
||||
E1B_HS_9= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit);
|
||||
std::cout << "E1B_HS_9= " << E1B_HS_9 << std::endl;
|
||||
DLOG(INFO) << "E1B_HS_9= " << E1B_HS_9 << std::endl;
|
||||
|
||||
SVID3_9= (double)read_navigation_unsigned(data_jk_bits,SVID3_9_bit);
|
||||
std::cout << "SVID3_9= " << SVID3_9 << std::endl;
|
||||
DLOG(INFO) << "SVID3_9= " << SVID3_9 << std::endl;
|
||||
|
||||
|
||||
DELTA_A_9= (double)read_navigation_unsigned(data_jk_bits, DELTA_A_9_bit);
|
||||
DELTA_A_9= DELTA_A_9 * DELTA_A_9_LSB;
|
||||
std::cout << "DELTA_A_9= " << DELTA_A_9 << std::endl;
|
||||
DLOG(INFO) << "DELTA_A_9= " << DELTA_A_9 << std::endl;
|
||||
|
||||
e_9= (double)read_navigation_unsigned(data_jk_bits, e_9_bit);
|
||||
e_9= e_9 * e_9_LSB;
|
||||
std::cout << "e_9= " << e_9 << std::endl;
|
||||
DLOG(INFO) << "e_9= " << e_9 << std::endl;
|
||||
|
||||
omega_9= (double)read_navigation_unsigned(data_jk_bits, omega_9_bit);
|
||||
omega_9= omega_9 * omega_9_LSB;
|
||||
std::cout << "omega_9= " << omega_9 << std::endl;
|
||||
DLOG(INFO) << "omega_9= " << omega_9 << std::endl;
|
||||
|
||||
delta_i_9= (double)read_navigation_unsigned(data_jk_bits, delta_i_9_bit);
|
||||
delta_i_9= delta_i_9 * delta_i_9_LSB;
|
||||
std::cout << "delta_i_9= " << delta_i_9 << std::endl;
|
||||
DLOG(INFO) << "delta_i_9= " << delta_i_9 << std::endl;
|
||||
flag_almanac_3 = true;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
break;
|
||||
|
||||
case 10: /*Word type 10: Almanac for SVID3 (2/2) and GST-GPS conversion parameters*/
|
||||
|
||||
IOD_a_10= (double)read_navigation_unsigned(data_jk_bits, IOD_a_10_bit);
|
||||
std::cout << "IOD_a_10= " << IOD_a_10 << std::endl;
|
||||
DLOG(INFO) << "IOD_a_10= " << IOD_a_10 << std::endl;
|
||||
|
||||
Omega0_10= (double)read_navigation_unsigned(data_jk_bits, Omega0_10_bit);
|
||||
Omega0_10= Omega0_10 * Omega0_10_LSB;
|
||||
std::cout << "Omega0_10= " << Omega0_10 << std::endl;
|
||||
DLOG(INFO) << "Omega0_10= " << Omega0_10 << std::endl;
|
||||
|
||||
Omega_dot_10= (double)read_navigation_unsigned(data_jk_bits, Omega_dot_10_bit);
|
||||
Omega_dot_10= Omega_dot_10 * Omega_dot_10_LSB;
|
||||
std::cout << "Omega_dot_10= " << Omega_dot_10 << std::endl;
|
||||
DLOG(INFO) << "Omega_dot_10= " << Omega_dot_10 << std::endl;
|
||||
|
||||
M0_10= (double)read_navigation_unsigned(data_jk_bits, M0_10_bit);
|
||||
M0_10= M0_10 * M0_10_LSB;
|
||||
std::cout << "M0_10= " << M0_10 << std::endl;
|
||||
DLOG(INFO) << "M0_10= " << M0_10 << std::endl;
|
||||
|
||||
af0_10= (double)read_navigation_unsigned(data_jk_bits, af0_10_bit);
|
||||
af0_10= af0_10 * af0_10_LSB;
|
||||
std::cout << "af0_10= " << af0_10 << std::endl;
|
||||
DLOG(INFO) << "af0_10= " << af0_10 << std::endl;
|
||||
|
||||
af1_10= (double)read_navigation_unsigned(data_jk_bits, af1_10_bit);
|
||||
af1_10= af1_10 * af1_10_LSB;
|
||||
std::cout << "af1_10= " << af1_10 << std::endl;
|
||||
DLOG(INFO) << "af1_10= " << af1_10 << std::endl;
|
||||
|
||||
E5b_HS_10= (double)read_navigation_unsigned(data_jk_bits, E5b_HS_10_bit);
|
||||
std::cout << "E5b_HS_10= " << E5b_HS_10 << std::endl;
|
||||
DLOG(INFO) << "E5b_HS_10= " << E5b_HS_10 << std::endl;
|
||||
|
||||
E1B_HS_10= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_10_bit);
|
||||
std::cout << "E1B_HS_10= " << E1B_HS_10 << std::endl;
|
||||
DLOG(INFO) << "E1B_HS_10= " << E1B_HS_10 << std::endl;
|
||||
|
||||
A_0G_10= (double)read_navigation_unsigned(data_jk_bits, A_0G_10_bit);
|
||||
A_0G_10= A_0G_10 * A_0G_10_LSB;
|
||||
std::cout << "A_0G_10= " << A_0G_10 << std::endl;
|
||||
DLOG(INFO) << "A_0G_10= " << A_0G_10 << std::endl;
|
||||
|
||||
A_1G_10= (double)read_navigation_unsigned(data_jk_bits, A_1G_10_bit);
|
||||
A_1G_10= A_1G_10 * A_1G_10_LSB;
|
||||
std::cout << "A_1G_10= " << A_1G_10 << std::endl;
|
||||
DLOG(INFO) << "A_1G_10= " << A_1G_10 << std::endl;
|
||||
|
||||
t_0G_10= (double)read_navigation_unsigned(data_jk_bits, A_1G_10_bit);
|
||||
t_0G_10= t_0G_10 * t_0G_10_LSB;
|
||||
std::cout << "t_0G_10= " << t_0G_10 << std::endl;
|
||||
DLOG(INFO) << "t_0G_10= " << t_0G_10 << std::endl;
|
||||
|
||||
WN_0G_10= (double)read_navigation_unsigned(data_jk_bits, WN_0G_10_bit);
|
||||
std::cout << "WN_0G_10= " << WN_0G_10 << std::endl;
|
||||
DLOG(INFO) << "WN_0G_10= " << WN_0G_10 << std::endl;
|
||||
flag_almanac_4 = true;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
break;
|
||||
|
||||
case 0: /*Word type 0: I/NAV Spare Word*/
|
||||
Time_0= (double)read_navigation_unsigned(data_jk_bits, Time_0_bit);
|
||||
std::cout << "Time_0= " << Time_0 << std::endl;
|
||||
DLOG(INFO) << "Time_0= " << Time_0 << std::endl;
|
||||
|
||||
WN_0= (double)read_navigation_unsigned(data_jk_bits, WN_0_bit);
|
||||
std::cout << "WN_0= " << WN_0 << std::endl;
|
||||
DLOG(INFO) << "WN_0= " << WN_0 << std::endl;
|
||||
|
||||
TOW_0= (double)read_navigation_unsigned(data_jk_bits, TOW_0_bit);
|
||||
std::cout << "TOW_0= " << TOW_0 << std::endl;
|
||||
DLOG(INFO) << "TOW_0= " << TOW_0 << std::endl;
|
||||
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
|
||||
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -71,8 +71,9 @@ private:
|
|||
int x,y;
|
||||
|
||||
public:
|
||||
int Page_type_time_stamp;
|
||||
int flag_even_word;
|
||||
|
||||
bool flag_CRC_test;
|
||||
bool flag_all_ephemeris; // flag indicating that all words containing ephemeris have been received
|
||||
bool flag_ephemeris_1; // flag indicating that ephemeris 1/4 (word 1) have been received
|
||||
bool flag_ephemeris_2; // flag indicating that ephemeris 2/4 (word 2) have been received
|
||||
|
|
@ -80,6 +81,9 @@ public:
|
|||
bool flag_ephemeris_4; // flag indicating that ephemeris 4/4 (word 4) have been received
|
||||
|
||||
bool flag_iono_and_GST; // flag indicating that ionospheric and GST parameters (word 5) have been received
|
||||
bool flag_TOW_5;
|
||||
bool flag_TOW_6;
|
||||
bool flag_TOW_set; // it is true when page 5 or page 6 arrives
|
||||
bool flag_utc_model; // flag indicating that utc model parameters (word 6) have been received
|
||||
|
||||
bool flag_all_almanac; // flag indicating that all almanac have been received
|
||||
|
|
|
|||
Loading…
Reference in New Issue