mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-06-03 23:24:09 +00:00
Code Issues Releases Wiki Activity

FIRST GALILEO STANDALONE PVT FIX!!

Browse Source 
- Bug fixes at Galileo telemetry decoder state machine
- Bug fixes at Galileo Ephemeris decoder (two complement's data interpreted as unsigned, mismatch at the LSB weights)

Galileo KML output is avalable!!

Galileo RINEX is still under construction

git-svn-id: https://svn.code.sf.net/p/gnss-sdr/code/trunk@433 64b25241-fba3-4117-9849-534c7e92360d
This commit is contained in:
Javier Arribas 2013-11-06 20:14:40 +00:00
parent 83a9d41b05
commit 87c5c212a4
20 changed files with 535 additions and 553 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
conf/gnss-sdr_Galileo_E1_IFEN.conf
View File

@ -151,7 +151,7 @@ Resampler.implementation=Pass_Through
;######### CHANNELS GLOBAL CONFIG ############ ;######### CHANNELS GLOBAL CONFIG ############
;#count: Number of available satellite channels. ;#count: Number of available satellite channels.
Channels.count=1 Channels.count=6
;#in_acquisition: Number of channels simultaneously acquiring ;#in_acquisition: Number of channels simultaneously acquiring
Channels.in_acquisition=1 Channels.in_acquisition=1
;#system: GPS, GLONASS, GALILEO, SBAS or COMPASS ;#system: GPS, GLONASS, GALILEO, SBAS or COMPASS
@ -234,7 +234,7 @@ Acquisition.implementation=Galileo_E1_PCPS_Ambiguous_Acquisition
;#threshold: Acquisition threshold ;#threshold: Acquisition threshold
;Acquisition.threshold=0 ;Acquisition.threshold=0
;#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.pfa=0.00005 Acquisition.pfa=0.00001
;#doppler_max: Maximum expected Doppler shift [Hz] ;#doppler_max: Maximum expected Doppler shift [Hz]
Acquisition.doppler_max=10000 Acquisition.doppler_max=10000
;#doppler_max: Doppler step in the grid search [Hz] ;#doppler_max: Doppler step in the grid search [Hz]
@ -271,10 +271,10 @@ Tracking.dump=false
Tracking.dump_filename=../data/veml_tracking_ch_ Tracking.dump_filename=../data/veml_tracking_ch_
;#pll_bw_hz: PLL loop filter bandwidth [Hz] ;#pll_bw_hz: PLL loop filter bandwidth [Hz]
Tracking.pll_bw_hz=15.0; Tracking.pll_bw_hz=20.0;
;#dll_bw_hz: DLL loop filter bandwidth [Hz] ;#dll_bw_hz: DLL loop filter bandwidth [Hz]
Tracking.dll_bw_hz=1.0; Tracking.dll_bw_hz=2.0;
;#order: PLL/DLL loop filter order [2] or [3] ;#order: PLL/DLL loop filter order [2] or [3]
Tracking.order=3; Tracking.order=3;
@ -295,7 +295,7 @@ TelemetryDecoder.dump=false
Observables.implementation=Galileo_E1B_Observables Observables.implementation=Galileo_E1B_Observables
;#dump: Enable or disable the Observables internal binary data file logging [true] or [false] ;#dump: Enable or disable the Observables internal binary data file logging [true] or [false]
Observables.dump=true Observables.dump=false
;#dump_filename: Log path and filename. ;#dump_filename: Log path and filename.
Observables.dump_filename=./observables.dat Observables.dump_filename=./observables.dat

9
src/algorithms/PVT/gnuradio_blocks/galileo_e1_pvt_cc.cc
View File

@ -177,10 +177,11 @@ int galileo_e1_pvt_cc::general_work (int noutput_items, gr_vector_int &ninput_it
bool pvt_result; bool pvt_result;
pvt_result = d_ls_pvt->get_PVT(gnss_pseudoranges_map, d_rx_time, d_flag_averaging); pvt_result = d_ls_pvt->get_PVT(gnss_pseudoranges_map, d_rx_time, d_flag_averaging);
if (pvt_result==true)
{
d_kml_dump.print_position_galileo(d_ls_pvt, d_flag_averaging);
//ToDo: Implement Galileo RINEX and Galileo NMEA outputs //ToDo: Implement Galileo RINEX and Galileo NMEA outputs
// if (pvt_result==true)
// {
// d_kml_dump.print_position(d_ls_pvt, d_flag_averaging);
// d_nmea_printer->Print_Nmea_Line(d_ls_pvt, d_flag_averaging); // d_nmea_printer->Print_Nmea_Line(d_ls_pvt, d_flag_averaging);
// //
// if (!b_rinex_header_writen) // & we have utc data in nav message! // if (!b_rinex_header_writen) // & we have utc data in nav message!
@ -210,7 +211,7 @@ int galileo_e1_pvt_cc::general_work (int noutput_items, gr_vector_int &ninput_it
// rp->log_rinex_obs(rp->obsFile, gps_ephemeris_iter->second, d_rx_time, gnss_pseudoranges_map); // rp->log_rinex_obs(rp->obsFile, gps_ephemeris_iter->second, d_rx_time, gnss_pseudoranges_map);
// } // }
// } // }
// } }
} }
// DEBUG MESSAGE: Display position in console output // DEBUG MESSAGE: Display position in console output

2
src/algorithms/PVT/gnuradio_blocks/galileo_e1_pvt_cc.h
View File

@ -43,7 +43,7 @@
#include "nmea_printer.h" #include "nmea_printer.h"
#include "kml_printer.h" #include "kml_printer.h"
#include "rinex_printer.h" #include "rinex_printer.h"
#include "galileo_e1_ls_pvt.h" //this file is just a copy of gps #include "galileo_e1_ls_pvt.h"
#include "GPS_L1_CA.h" #include "GPS_L1_CA.h"
#include "Galileo_E1.h" #include "Galileo_E1.h"

26
src/algorithms/PVT/libs/galileo_e1_ls_pvt.cc
View File

@ -245,7 +245,7 @@ bool galileo_e1_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map
double TX_time_corrected_s; double TX_time_corrected_s;
double SV_clock_bias_s = 0; double SV_clock_bias_s = 0;
double GST=0; //double GST=0;
d_flag_averaging = flag_averaging; d_flag_averaging = flag_averaging;
@ -269,7 +269,18 @@ bool galileo_e1_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map
// COMMON RX TIME PVT ALGORITHM MODIFICATION (Like RINEX files) // COMMON RX TIME PVT ALGORITHM MODIFICATION (Like RINEX files)
// first estimate of transmit time // first estimate of transmit time
//Galileo_week_number = galileo_ephemeris_iter->second.WN_5;//for GST
//double sec_in_day = 86400;
//double day_in_week = 7;
// t = WN*sec_in_day*day_in_week + TOW; // t is Galileo System Time to use to compute satellite positions
//JAVIER VERSION:
double Rx_time = galileo_current_time; double Rx_time = galileo_current_time;
//to compute satellite position we need GST = WN+TOW (everything expressed in seconds)
//double Rx_time = galileo_current_time + Galileo_week_number*sec_in_day*day_in_week;
double Tx_time = Rx_time - gnss_pseudoranges_iter->second.Pseudorange_m/GALILEO_C_m_s; double Tx_time = Rx_time - gnss_pseudoranges_iter->second.Pseudorange_m/GALILEO_C_m_s;
// 2- compute the clock drift using the clock model (broadcast) for this SV // 2- compute the clock drift using the clock model (broadcast) for this SV
@ -299,11 +310,12 @@ bool galileo_e1_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map
double GST=galileo_ephemeris_iter->second.Galileo_System_Time(Galileo_week_number,galileo_current_time); double GST=galileo_ephemeris_iter->second.Galileo_System_Time(Galileo_week_number,galileo_current_time);
utc = galileo_utc_model.GST_to_UTC_time(GST, Galileo_week_number); utc = galileo_utc_model.GST_to_UTC_time(GST, Galileo_week_number);
// get time string gregorian calendar // get time string gregorian calendar
//std::cout<<"UTC_raw="<<utc<<std::endl;
boost::posix_time::time_duration t = boost::posix_time::seconds(utc); boost::posix_time::time_duration t = boost::posix_time::seconds(utc);
// 22 August 1999 00:00 last Galileo start GST epoch (ICD sec 5.1.2) // 22 August 1999 00:00 last Galileo start GST epoch (ICD sec 5.1.2)
boost::posix_time::ptime p_time(boost::gregorian::date(1999, 8, 22), t); boost::posix_time::ptime p_time(boost::gregorian::date(1999, 8, 22), t);
d_position_UTC_time = p_time; d_position_UTC_time = p_time;
std::cout << "Galileo RX time at " << boost::posix_time::to_simple_string(p_time)<<std::endl; //std::cout << "Galileo RX time at " << boost::posix_time::to_simple_string(p_time)<<std::endl;
//end debug //end debug
// SV ECEF DEBUG OUTPUT // SV ECEF DEBUG OUTPUT
@ -345,12 +357,16 @@ bool galileo_e1_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map
// 22 August 1999 00:00 last Galileo start GST epoch (ICD sec 5.1.2) // 22 August 1999 00:00 last Galileo start GST epoch (ICD sec 5.1.2)
boost::posix_time::ptime p_time(boost::gregorian::date(1999, 8, 22), t); boost::posix_time::ptime p_time(boost::gregorian::date(1999, 8, 22), t);
d_position_UTC_time = p_time; d_position_UTC_time = p_time;
std::cout << "Galileo RX time at " << boost::posix_time::to_simple_string(p_time)<<std::endl; //std::cout << "Galileo RX time at " << boost::posix_time::to_simple_string(p_time)<<std::endl;
DLOG(INFO) << "Galileo Position at TOW=" << galileo_current_time << " in ECEF (X,Y,Z) = " << mypos << std::endl; DLOG(INFO) << "Galileo Position at TOW=" << galileo_current_time << " in ECEF (X,Y,Z) = " << mypos << std::endl;
cart2geo((double)mypos(0), (double)mypos(1), (double)mypos(2), 4); cart2geo((double)mypos(0), (double)mypos(1), (double)mypos(2), 4);
// TODO: Compute UTC time and print PVT solution //ToDo: Find an Observables/PVT random bug with some satellite configurations that gives an erratic PVT solution (i.e. height>50 km)
if (d_height_m>50000)
{
b_valid_position=false;
return false; //erratic PVT
}
DLOG(INFO) << "Galileo Position at " << boost::posix_time::to_simple_string(p_time) DLOG(INFO) << "Galileo Position at " << boost::posix_time::to_simple_string(p_time)
<< " is Lat = " << d_latitude_d << " [deg], Long = " << d_longitude_d << " is Lat = " << d_latitude_d << " [deg], Long = " << d_longitude_d
<< " [deg], Height= " << d_height_m << " [m]" << std::endl; << " [deg], Height= " << d_height_m << " [m]" << std::endl;

30
src/algorithms/PVT/libs/kml_printer.cc
View File

@ -110,6 +110,36 @@ bool Kml_Printer::print_position(gps_l1_ca_ls_pvt* position,bool print_average_v
} }
} }
//ToDo: make the class ls_pvt generic and heritate the particular gps/gal/glo ls_pvt in order to
// reuse kml_printer functions
bool Kml_Printer::print_position_galileo(galileo_e1_ls_pvt* position,bool print_average_values)
{
double latitude;
double longitude;
double height;
if (print_average_values == false)
{
latitude = position->d_latitude_d;
longitude = position->d_longitude_d;
height = position->d_height_m;
}
else
{
latitude = position->d_avg_latitude_d;
longitude = position->d_avg_longitude_d;
height = position->d_avg_height_m;
}
if (kml_file.is_open())
{
kml_file << longitude << "," << latitude << "," << height << std::endl;
return true;
}
else
{
return false;
}
}
bool Kml_Printer::close_file() bool Kml_Printer::close_file()

6
src/algorithms/PVT/libs/kml_printer.h
View File

@ -30,12 +30,13 @@
*/ */
#ifndef GNSS_SDR_KML_PRINTER_H_ #ifndef GNSS_SDR_KML_PRINTER_H_
#define GNSS_SDR_KML_PRINTER_H_ #define GNSS_SDR_KML_PRINTER_H_
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
#include "gps_l1_ca_ls_pvt.h" #include "gps_l1_ca_ls_pvt.h"
#include "galileo_e1_ls_pvt.h"
/*! /*!
@ -50,6 +51,7 @@ private:
public: public:
bool set_headers(std::string filename); bool set_headers(std::string filename);
bool print_position(gps_l1_ca_ls_pvt* position, bool print_average_values); bool print_position(gps_l1_ca_ls_pvt* position, bool print_average_values);
bool print_position_galileo(galileo_e1_ls_pvt* position, bool print_average_values);
bool close_file(); bool close_file();
Kml_Printer(); Kml_Printer();
~Kml_Printer(); ~Kml_Printer();

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

@ -157,6 +157,7 @@ int galileo_e1_observables_cc::general_work (int noutput_items, gr_vector_int &n
// 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; delta_rx_time_ms = gnss_synchro_iter->second.Prn_timestamp_ms-d_ref_PRN_rx_time_ms;
//std::cout<<"delta_rx_time_ms["<<gnss_synchro_iter->second.Channel_ID<<"]="<<delta_rx_time_ms<<std::endl; //std::cout<<"delta_rx_time_ms["<<gnss_synchro_iter->second.Channel_ID<<"]="<<delta_rx_time_ms<<std::endl;
//std::cout<<"d_TOW_at_current_symbol["<<gnss_synchro_iter->second.Channel_ID<<"]="<<gnss_synchro_iter->second.d_TOW_at_current_symbol<<std::endl;
//compute the pseudorange //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; 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; //std::cout<<"traveltime_ms="<<traveltime_ms<<std::endl;

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

@ -64,10 +64,7 @@ galileo_e1b_make_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, lo
void galileo_e1b_telemetry_decoder_cc::forecast (int noutput_items, gr_vector_int &ninput_items_required) void galileo_e1b_telemetry_decoder_cc::forecast (int noutput_items, gr_vector_int &ninput_items_required)
{ {
for (unsigned i = 0; i < 3; i++) ninput_items_required[0] = GALILEO_INAV_PAGE_SYMBOLS; //set the required sample history
{
ninput_items_required[i] = GALILEO_INAV_PAGE_SYMBOLS; //set the required sample history
}
} }
@ -386,50 +383,45 @@ 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 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];
//std::cout<<"flag TOW before add the telemetry decoder information: d_nav.flag_TOW_set"<<std::endl;
//2. Add the telemetry decoder information //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 if (this->d_flag_preamble==true and d_nav.flag_TOW_set==true)
//update TOW at the preamble instant
//flag preamble is true after the all page (even and odd) is recevived. I/NAV page period is 2 SECONDS
{ {
//std::cout<<"time stamp, identified preamble and TOW set" << std::endl;
Prn_timestamp_at_preamble_ms = in[0][0].Tracking_timestamp_secs * 1000.0; 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) if(d_nav.flag_TOW_5 == true) //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 d_TOW_at_Preamble = d_nav.TOW_5+GALILEO_INAV_PAGE_PART_SECONDS; //TOW_5 refers to the even preamble, but when we decode it we are in the odd part, so 1 second later
/* 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*/ /* 1 sec (GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD) is added because
d_TOW_at_current_symbol = d_TOW_at_Preamble + GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD; * if we have a TOW value it means that we are at the begining of the last page part
//std::cout << "d_TOW_at_current_symbol="<< d_TOW_at_current_symbol << std::endl; * (GNU Radio history keeps in a buffer the rest of the incomming frame part)*/
d_nav.flag_TOW_5 = 0; d_TOW_at_current_symbol = d_TOW_at_Preamble;// + GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD;
d_nav.flag_TOW_5 = false;
} }
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) else if(d_nav.flag_TOW_6 == true) //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 d_TOW_at_Preamble = d_nav.TOW_6+GALILEO_INAV_PAGE_PART_SECONDS;
//std::cout << "d_TOW_at_Preamble="<< d_TOW_at_Preamble<< std::endl; //TOW_6 refers to the even preamble, but when we decode it we are in the odd part, so 1 second later
d_TOW_at_current_symbol = d_TOW_at_Preamble + GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD; /* 1 sec (GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD) is added because
//std::cout << "d_TOW_at_current_symbol="<< d_TOW_at_current_symbol << std::endl; * if we have a TOW value it means that we are at the begining of the last page part
* (GNU Radio history keeps in a buffer the rest of the incomming frame part)*/
d_nav.flag_TOW_6 = 0; d_TOW_at_current_symbol = d_TOW_at_Preamble;// + GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD;
d_nav.flag_TOW_6 = false;
} }
else else
{ {
d_TOW_at_Preamble = d_TOW_at_Preamble + GALILEO_PAGE_SECONDS; //this is the even preamble after the last odd preamble //this page has no timming information
//std::cout << "d_TOW_at_Preamble="<< d_TOW_at_Preamble << std::endl; d_TOW_at_Preamble = d_TOW_at_Preamble + GALILEO_INAV_PAGE_SECONDS;
d_TOW_at_current_symbol = d_TOW_at_Preamble + GALILEO_INAV_PAGE_PART_SYMBOLS*GALIELO_E1_CODE_PERIOD; d_TOW_at_current_symbol = d_TOW_at_current_symbol + GALIELO_E1_CODE_PERIOD;// + 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 //if there is not a new preamble, we define the TOW of the current symbol 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 + GALIELO_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) //if (d_flag_frame_sync == true and d_nav.flag_TOW_set==true and d_nav.flag_CRC_test == true)
@ -442,7 +434,6 @@ int galileo_e1b_telemetry_decoder_cc::general_work (int noutput_items, gr_vector
current_synchro_data.d_TOW = d_TOW_at_Preamble; 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.d_TOW_at_current_symbol = d_TOW_at_current_symbol;
//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.Flag_preamble = d_flag_preamble;
current_synchro_data.Prn_timestamp_ms = in[0][0].Tracking_timestamp_secs * 1000.0; 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; current_synchro_data.Prn_timestamp_at_preamble_ms = Prn_timestamp_at_preamble_ms;

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

@ -444,26 +444,28 @@ int galileo_e1_dll_pll_veml_tracking_cc::general_work (int noutput_items,gr_vect
/*! /*!
* \todo The stop timer has to be moved to the signal source! * \todo The stop timer has to be moved to the signal source!
*/ */
// debug: Second counter in channel 0 // stream to collect cout calls to improve thread safety
if (d_channel == 0) std::stringstream tmp_str_stream;
{ if (floor(d_sample_counter / d_fs_in) != d_last_seg)
if (floor(d_sample_counter / d_fs_in) != d_last_seg) {
{ d_last_seg = floor(d_sample_counter / d_fs_in);
d_last_seg = floor(d_sample_counter / d_fs_in);
std::cout << "Current input signal time = " << d_last_seg << " [s]" << std::endl; if (d_channel == 0)
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; // debug: Second counter in channel 0
} tmp_str_stream << "Current input signal time = " << d_last_seg << " [s]" << std::endl << std::flush;
} std::cout << tmp_str_stream.rdbuf() << std::flush;
else }
{
if (floor(d_sample_counter / d_fs_in) != d_last_seg) tmp_str_stream << "Tracking CH " << d_channel << ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
{ << ", Doppler="<<d_carrier_doppler_hz<<" [Hz] CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]" << std::endl;
d_last_seg = floor(d_sample_counter / d_fs_in); std::cout << tmp_str_stream.rdbuf() << std::flush;
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; //std::cout<<"TRK CH "<<d_channel<<" Carrier_lock_test="<<d_carrier_lock_test<< std::endl;
} //if (d_channel == 0 || d_last_seg==5) d_carrier_lock_fail_counter=500; //DEBUG: force unlock!
} }
} }
else else
{ {

4
src/core/receiver/control_thread.cc
View File

@ -571,12 +571,12 @@ void ControlThread::galileo_iono_data_collector()
if (global_galileo_iono_map.read(0,galileo_iono_old)) if (global_galileo_iono_map.read(0,galileo_iono_old))
{ {
// Check the Iono timestamp from UTC page (page 6). If it is newer, then update the Iono parameters // Check the Iono timestamp from UTC page (page 6). If it is newer, then update the Iono parameters
if (galileo_iono.WNot_6 > galileo_iono_old.WNot_6) if (galileo_iono.WN_5 > galileo_iono_old.WN_5)
{ {
std::cout << "IONO record updated in global map--new GALILEO UTC-IONO Week Number"<< std::endl; std::cout << "IONO record updated in global map--new GALILEO UTC-IONO Week Number"<< std::endl;
global_galileo_iono_map.write(0,galileo_iono); global_galileo_iono_map.write(0,galileo_iono);
}else{ }else{
if (galileo_iono.t0t_6 > galileo_iono_old.t0t_6) if (galileo_iono.TOW_5 > galileo_iono_old.TOW_5)
{ {
std::cout << "IONO record updated in global map--new GALILEO UTC-IONO time of Week" << std::endl; std::cout << "IONO record updated in global map--new GALILEO UTC-IONO time of Week" << std::endl;
global_galileo_iono_map.write(0,galileo_iono); global_galileo_iono_map.write(0,galileo_iono);

19
src/core/system_parameters/Galileo_E1.h
View File

@ -70,7 +70,8 @@ const int GALILEO_INAV_PREAMBLE_LENGTH_BITS = 10;
const int GALILEO_INAV_PREAMBLE_PERIOD_SYMBOLS = 250; 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_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_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_PAGE_PART_SECONDS = 1; //a page part last 2 sec
const int GALILEO_INAV_PAGE_SECONDS = 2; //a full page last 2 sec
const int GALILEO_INAV_INTERLEAVER_ROWS = 8; const int GALILEO_INAV_INTERLEAVER_ROWS = 8;
const int GALILEO_INAV_INTERLEAVER_COLS = 30; const int GALILEO_INAV_INTERLEAVER_COLS = 30;
const int GALILEO_TELEMETRY_RATE_BITS_SECOND = 250; //bps const int GALILEO_TELEMETRY_RATE_BITS_SECOND = 250; //bps
@ -88,7 +89,7 @@ const std::vector<std::pair<int,int>> IOD_nav_1_bit({{7,10}});
const std::vector<std::pair<int,int>> T0E_1_bit({{17,14}}); const std::vector<std::pair<int,int>> T0E_1_bit({{17,14}});
const double t0e_1_LSB = 60; const double t0e_1_LSB = 60;
const std::vector<std::pair<int,int>> M0_1_bit({{31,32}}); const std::vector<std::pair<int,int>> M0_1_bit({{31,32}});
const double M0_1_LSB = TWO_N31; const double M0_1_LSB = PI_TWO_N31;
const std::vector<std::pair<int,int>> e_1_bit({{63,32}}); const std::vector<std::pair<int,int>> e_1_bit({{63,32}});
const double e_1_LSB = TWO_N33; const double e_1_LSB = TWO_N33;
const std::vector<std::pair<int,int>> A_1_bit({{95,32}}); const std::vector<std::pair<int,int>> A_1_bit({{95,32}});
@ -99,22 +100,22 @@ const double A_1_LSB_gal = TWO_N19;
/*Page 2 - Word type 2: Ephemeris (2/4)*/ /*Page 2 - Word type 2: Ephemeris (2/4)*/
const std::vector<std::pair<int,int>> IOD_nav_2_bit({{7,10}}); const std::vector<std::pair<int,int>> IOD_nav_2_bit({{7,10}});
const std::vector<std::pair<int,int>> OMEGA_0_2_bit({{17,32}}); const std::vector<std::pair<int,int>> OMEGA_0_2_bit({{17,32}});
const double OMEGA_0_2_LSB = TWO_N31; const double OMEGA_0_2_LSB = PI_TWO_N31;
const std::vector<std::pair<int,int>> i_0_2_bit({{49,32}}); const std::vector<std::pair<int,int>> i_0_2_bit({{49,32}});
const double i_0_2_LSB = TWO_N31; const double i_0_2_LSB = PI_TWO_N31;
const std::vector<std::pair<int,int>> omega_2_bit({{81,32}}); const std::vector<std::pair<int,int>> omega_2_bit({{81,32}});
const double omega_2_LSB = TWO_N31; const double omega_2_LSB = PI_TWO_N31;
const std::vector<std::pair<int,int>> iDot_2_bit({{113,14}}); const std::vector<std::pair<int,int>> iDot_2_bit({{113,14}});
const double iDot_2_LSB = TWO_N43; const double iDot_2_LSB = PI_TWO_N43;
//last two bits are reserved //last two bits are reserved
/*Word type 3: Ephemeris (3/4) and SISA*/ /*Word type 3: Ephemeris (3/4) and SISA*/
const std::vector<std::pair<int,int>> IOD_nav_3_bit({{7,10}}); const std::vector<std::pair<int,int>> IOD_nav_3_bit({{7,10}});
const std::vector<std::pair<int,int>> OMEGA_dot_3_bit({{17,24}}); const std::vector<std::pair<int,int>> OMEGA_dot_3_bit({{17,24}});
const double OMEGA_dot_3_LSB = TWO_N43; const double OMEGA_dot_3_LSB = PI_TWO_N43;
const std::vector<std::pair<int,int>> delta_n_3_bit({{41,16}}); const std::vector<std::pair<int,int>> delta_n_3_bit({{41,16}});
const double delta_n_3_LSB = TWO_N43; const double delta_n_3_LSB = PI_TWO_N43;
const std::vector<std::pair<int,int>> C_uc_3_bit({{57,16}}); const std::vector<std::pair<int,int>> C_uc_3_bit({{57,16}});
const double C_uc_3_LSB = TWO_N29; const double C_uc_3_LSB = TWO_N29;
const std::vector<std::pair<int,int>> C_us_3_bit({{73,16}}); const std::vector<std::pair<int,int>> C_us_3_bit({{73,16}});
@ -272,7 +273,7 @@ const double A_0G_10_LSB = TWO_N35;
const std::vector<std::pair<int,int>>A_1G_10_bit({{103,12}}); const std::vector<std::pair<int,int>>A_1G_10_bit({{103,12}});
const double A_1G_10_LSB = TWO_N51; const double A_1G_10_LSB = TWO_N51;
const std::vector<std::pair<int,int>>t_0G_10_bit({{115,9}}); const std::vector<std::pair<int,int>>t_0G_10_bit({{115,8}});
const double t_0G_10_LSB = 3600; const double t_0G_10_LSB = 3600;
const std::vector<std::pair<int,int>>WN_0G_10_bit({{123,6}}); const std::vector<std::pair<int,int>>WN_0G_10_bit({{123,6}});

1
src/core/system_parameters/galileo_ephemeris.cc
View File

@ -205,6 +205,7 @@ void Galileo_Ephemeris::satellitePosition(double transmitTime) //when this funct
//t = WN_5*86400*7 + TOW_5; //WN_5*86400*7 are the second from the origin of the Galileo time //t = WN_5*86400*7 + TOW_5; //WN_5*86400*7 are the second from the origin of the Galileo time
tk = transmitTime - t0e_1; tk = transmitTime - t0e_1;
//std::cout<<"Diff t_tx-t_oe="<<tk<<std::endl;
// Corrected mean motion // Corrected mean motion
n = n0 + delta_n_3; n = n0 + delta_n_3;

63
src/core/system_parameters/galileo_ephemeris.h
View File

@ -80,6 +80,7 @@ public:
double af2_4; //SV clock drift rate correction coefficient [s/s^2] double af2_4; //SV clock drift rate correction coefficient [s/s^2]
/*GST*/ /*GST*/
//Not belong to ephemeris set (page 1 to 4)
double WN_5; //Week number double WN_5; //Week number
double TOW_5; //Time of Week double TOW_5; //Time of Week
@ -97,67 +98,7 @@ public:
unsigned int i_satellite_PRN; // SV PRN NUMBER unsigned int i_satellite_PRN; // SV PRN NUMBER
/*The following parameters refers to GPS /*
double d_TOW; //!< Time of GPS Week of the ephemeris set (taken from subframes TOW) [s]
double d_Crs; //!< Amplitude of the Sine Harmonic Correction Term to the Orbit Radius [m]
double d_Delta_n; //!< Mean Motion Difference From Computed Value [semi-circles/s]
double d_M_0; //!< Mean Anomaly at Reference Time [semi-circles]
double d_Cuc; //!< Amplitude of the Cosine Harmonic Correction Term to the Argument of Latitude [rad]
double d_e_eccentricity; //!< Eccentricity [dimensionless]
double d_Cus; //!< Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad]
double d_sqrt_A; //!< Square Root of the Semi-Major Axis [sqrt(m)]
double d_Toe; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200E) [s]
double d_Toc; //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200E) [s]
double d_Cic; //!< Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad]
double d_OMEGA0; //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles]
double d_Cis; //!< Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad]
double d_i_0; //!< Inclination Angle at Reference Time [semi-circles]
double d_Crc; //!< Amplitude of the Cosine Harmonic Correction Term to the Orbit Radius [m]
double d_OMEGA; //!< Argument of Perigee [semi-cicles]
double d_OMEGA_DOT; //!< Rate of Right Ascension [semi-circles/s]
double d_IDOT; //!< Rate of Inclination Angle [semi-circles/s]
int i_code_on_L2; //!< If 1, P code ON in L2; if 2, C/A code ON in L2;
int i_GPS_week; //!< GPS week number, aka WN [week]
bool b_L2_P_data_flag; //!< When true, indicates that the NAV data stream was commanded OFF on the P-code of the L2 channel
int i_SV_accuracy; //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200E)
int i_SV_health;
double d_TGD; //!< Estimated Group Delay Differential: L1-L2 correction term only for the benefit of "L1 P(Y)" or "L2 P(Y)" s users [s]
double d_IODC; //!< Issue of Data, Clock
int i_AODO; //!< Age of Data Offset (AODO) term for the navigation message correction table (NMCT) contained in subframe 4 (reference paragraph 20.3.3.5.1.9) [s]
bool b_fit_interval_flag;//!< indicates the curve-fit interval used by the CS (Block II/IIA/IIR/IIR-M/IIF) and SS (Block IIIA) in determining the ephemeris parameters, as follows: 0 = 4 hours, 1 = greater than 4 hours.
double d_spare1;
double d_spare2;
double d_A_f0; //!< Coefficient 0 of code phase offset model [s]
double d_A_f1; //!< Coefficient 1 of code phase offset model [s/s]
double d_A_f2; //!< Coefficient 2 of code phase offset model [s/s^2]
// Flags
bool b_integrity_status_flag;
bool b_alert_flag; //!< If true, indicates that the SV URA may be worse than indicated in d_SV_accuracy, use that SV at our own risk.
bool b_antispoofing_flag; //!< If true, the AntiSpoofing mode is ON in that SV
// clock terms derived from ephemeris data
double d_satClkDrift; // GPS clock error
double d_dtr; // relativistic clock correction term
// satellite positions
double d_satpos_X; //!< Earth-fixed coordinate x of the satellite [m]. Intersection of the IERS Reference Meridian (IRM) and the plane passing through the origin and normal to the Z-axis.
double d_satpos_Y; //!< Earth-fixed coordinate y of the satellite [m]. Completes a right-handed, Earth-Centered, Earth-Fixed orthogonal coordinate system.
double d_satpos_Z; //!< Earth-fixed coordinate z of the satellite [m]. The direction of the IERS (International Earth Rotation and Reference Systems Service) Reference Pole (IRP).
// Satellite velocity
double d_satvel_X; //!< Earth-fixed velocity coordinate x of the satellite [m]
double d_satvel_Y; //!< Earth-fixed velocity coordinate y of the satellite [m]
double d_satvel_Z; //!< Earth-fixed velocity coordinate z of the satellite [m]
std::map<int,std::string> satelliteBlock; //!< Map that stores to which block the PRN belongs http://www.navcen.uscg.gov/?Do=constellationStatus
template<class Archive> template<class Archive>
\\brief Serialize is a boost standard method to be called by the boost XML serialization. Here is used to save the ephemeris data on disk file. \\brief Serialize is a boost standard method to be called by the boost XML serialization. Here is used to save the ephemeris data on disk file.

4
src/core/system_parameters/galileo_iono.cc
View File

@ -47,8 +47,8 @@ Galileo_Iono::Galileo_Iono()
Region4_flag_5 = false; // Ionospheric Disturbance Flag for region 4 Region4_flag_5 = false; // Ionospheric Disturbance Flag for region 4
Region5_flag_5 = false; // Ionospheric Disturbance Flag for region 5 Region5_flag_5 = false; // Ionospheric Disturbance Flag for region 5
t0t_6 = 0; TOW_5 = 0;
WNot_6 = 0; WN_5 = 0;
} }

6
src/core/system_parameters/galileo_iono.h
View File

@ -60,9 +60,9 @@ public:
bool Region4_flag_5; // Ionospheric Disturbance Flag for region 4 bool Region4_flag_5; // Ionospheric Disturbance Flag for region 4
bool Region5_flag_5; // Ionospheric Disturbance Flag for region 5 bool Region5_flag_5; // Ionospheric Disturbance Flag for region 5
/*from page 6 (UTC) to have a timestamp*/ /*from page 5 (UTC) to have a timestamp*/
double t0t_6;//UTC data reference Time of Week [s] double TOW_5;//UTC data reference Time of Week [s]
double WNot_6; //UTC data reference Week number [week] double WN_5; //UTC data reference Week number [week]
/*! /*!

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

@ -370,7 +370,7 @@ void Galileo_Navigation_Message::split_page(std::string page_string, int flag_ev
// ToDo: Clean all the tests and create an independent google test code for the telemetry decoder. // ToDo: Clean all the tests and create an independent google test code for the telemetry decoder.
//char correct_tail[7]="011110"; //the viterbi decoder output change the tail to this value (why?) //char correct_tail[7]="011110"; //the viterbi decoder output change the tail to this value (why?)
char correct_tail[7]="000000"; //char correct_tail[7]="000000";
int Page_type=0; int Page_type=0;
//std::cout << "Start decoding Galileo I/NAV " << std::endl; //std::cout << "Start decoding Galileo I/NAV " << std::endl;
@ -486,7 +486,7 @@ void Galileo_Navigation_Message::split_page(std::string page_string, int flag_ev
bool Galileo_Navigation_Message::have_new_ephemeris() //Check if we have a new ephemeris stored in the galileo navigation class bool Galileo_Navigation_Message::have_new_ephemeris() //Check if we have a new ephemeris stored in the galileo navigation class
{ {
if ((flag_ephemeris_1 == true) and (flag_ephemeris_2 == true) and (flag_ephemeris_3 == true) and (flag_ephemeris_4 == true)) if ((flag_ephemeris_1 == true) and (flag_ephemeris_2 == true) and (flag_ephemeris_3 == true) and (flag_ephemeris_4 == true) and (flag_iono_and_GST == true))
{ {
//if all ephemeris pages have the same IOD, then they belong to the same block //if all ephemeris pages have the same IOD, then they belong to the same block
if ((IOD_nav_1 == IOD_nav_2) and (IOD_nav_3 == IOD_nav_4) and (IOD_nav_1 == IOD_nav_3)) if ((IOD_nav_1 == IOD_nav_2) and (IOD_nav_3 == IOD_nav_4) and (IOD_nav_1 == IOD_nav_3))
@ -602,8 +602,10 @@ Galileo_Iono Galileo_Navigation_Message::get_iono()
iono.Region4_flag_5 = Region4_flag_5; // Ionospheric Disturbance Flag for region 4 iono.Region4_flag_5 = Region4_flag_5; // Ionospheric Disturbance Flag for region 4
iono.Region5_flag_5 = Region5_flag_5; // Ionospheric Disturbance Flag for region 5 iono.Region5_flag_5 = Region5_flag_5; // Ionospheric Disturbance Flag for region 5
iono.t0t_6 = t0t_6; /*GST*/
iono.WNot_6 = WNot_6; // This is the ONLY page containing the Week Number (WN)
iono.TOW_5 = TOW_5;
iono.WN_5 = WN_5;
return iono; return iono;
} }
@ -713,7 +715,7 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
t0e_1 = t0e_1 * t0e_1_LSB; t0e_1 = t0e_1 * t0e_1_LSB;
DLOG(INFO) << "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 = (double)read_navigation_signed(data_jk_bits, M0_1_bit);
M0_1 = M0_1 * M0_1_LSB; M0_1 = M0_1 * M0_1_LSB;
DLOG(INFO) << "M0_1= " << M0_1<<std::endl; DLOG(INFO) << "M0_1= " << M0_1<<std::endl;
@ -725,48 +727,46 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
A_1 = A_1 * A_1_LSB_gal; A_1 = A_1 * A_1_LSB_gal;
DLOG(INFO) << "A_1= " << A_1 <<std::endl; DLOG(INFO) << "A_1= " << A_1 <<std::endl;
flag_ephemeris_1 = true; flag_ephemeris_1 = true;
break;
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl; DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
break;
case 2: /*Word type 2: Ephemeris (2/4)*/ case 2: /*Word type 2: Ephemeris (2/4)*/
IOD_nav_2 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_2_bit); IOD_nav_2 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_2_bit);
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, OMEGA_0_2_bit);
OMEGA_0_2 = OMEGA_0_2 * OMEGA_0_2_LSB; OMEGA_0_2 = OMEGA_0_2 * OMEGA_0_2_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, i_0_2_bit);
i_0_2 = i_0_2 * i_0_2_LSB; i_0_2 = i_0_2 * i_0_2_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, omega_2_bit);
omega_2 = omega_2 * omega_2_LSB; omega_2 = omega_2 * omega_2_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, iDot_2_bit);
iDot_2 = iDot_2 * iDot_2_LSB; iDot_2 = iDot_2 * iDot_2_LSB;
DLOG(INFO)<<"iDot_2= "<< iDot_2 <<std::endl; DLOG(INFO)<<"iDot_2= "<< iDot_2 <<std::endl;
flag_ephemeris_2 = true; flag_ephemeris_2 = true;
break;
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl; DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
break;
case 3: /*Word type 3: Ephemeris (3/4) and SISA*/ case 3: /*Word type 3: Ephemeris (3/4) and SISA*/
IOD_nav_3 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_3_bit); IOD_nav_3 = (int)read_navigation_unsigned(data_jk_bits, IOD_nav_3_bit);
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, OMEGA_dot_3_bit);
OMEGA_dot_3 = OMEGA_dot_3 * OMEGA_dot_3_LSB; OMEGA_dot_3 = OMEGA_dot_3 * OMEGA_dot_3_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, delta_n_3_bit);
delta_n_3 = delta_n_3 * delta_n_3_LSB; delta_n_3 = delta_n_3 * delta_n_3_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, C_uc_3_bit);
C_uc_3 = C_uc_3 * C_uc_3_LSB; C_uc_3 = C_uc_3 * C_uc_3_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, C_us_3_bit);
C_us_3 = C_us_3 * C_us_3_LSB; C_us_3 = C_us_3 * C_us_3_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, C_rc_3_bit);
C_rc_3 = C_rc_3 * C_rc_3_LSB; C_rc_3 = C_rc_3 * C_rc_3_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, C_rs_3_bit);
C_rs_3 = C_rs_3 * C_rs_3_LSB; C_rs_3 = C_rs_3 * C_rs_3_LSB;
DLOG(INFO)<<"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); SISA_3 = (double)read_navigation_unsigned(data_jk_bits, SISA_3_bit);
@ -780,23 +780,23 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
DLOG(INFO)<<"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); SV_ID_PRN_4 = (int)read_navigation_unsigned(data_jk_bits, SV_ID_PRN_4_bit);
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, C_ic_4_bit);
C_ic_4 = C_ic_4 * C_ic_4_LSB; C_ic_4 = C_ic_4 * C_ic_4_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, C_is_4_bit);
C_is_4 = C_is_4 * C_is_4_LSB; C_is_4 = C_is_4 * C_is_4_LSB;
DLOG(INFO)<<"C_is_4= "<< C_is_4 <<std::endl; DLOG(INFO)<<"C_is_4= "<< C_is_4 <<std::endl;
/*Clock correction parameters*/ /*Clock correction parameters*/
t0c_4 = (double)read_navigation_unsigned(data_jk_bits, t0c_4_bit); t0c_4 = (double)read_navigation_unsigned(data_jk_bits, t0c_4_bit);
t0c_4 = t0c_4 * t0c_4_LSB; t0c_4 = t0c_4 * t0c_4_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, af0_4_bit);
af0_4 = af0_4 * af0_4_LSB; af0_4 = af0_4 * af0_4_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, af1_4_bit);
af1_4 = af1_4 * af1_4_LSB; af1_4 = af1_4 * af1_4_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, af2_4_bit);
af2_4 = af2_4 * af2_4_LSB; af2_4 = af2_4 * af2_4_LSB;
DLOG(INFO)<<"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); spare_4 = (double)read_navigation_unsigned(data_jk_bits, spare_4_bit);
@ -811,10 +811,10 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
ai0_5 = (double)read_navigation_unsigned(data_jk_bits, ai0_5_bit); ai0_5 = (double)read_navigation_unsigned(data_jk_bits, ai0_5_bit);
ai0_5 = ai0_5 * ai0_5_LSB; ai0_5 = ai0_5 * ai0_5_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, ai1_5_bit);
ai1_5 = ai1_5 * ai1_5_LSB; ai1_5 = ai1_5 * ai1_5_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, ai2_5_bit);
ai2_5 = ai2_5 * ai2_5_LSB; ai2_5 = ai2_5 * ai2_5_LSB;
DLOG(INFO)<<"ai2_5= "<< ai2_5 <<std::endl; DLOG(INFO)<<"ai2_5= "<< ai2_5 <<std::endl;
/*Ionospheric disturbance flag*/ /*Ionospheric disturbance flag*/
@ -828,10 +828,10 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
DLOG(INFO)<<"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); Region5_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region5_5_bit);
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, BGD_E1E5a_5_bit);
BGD_E1E5a_5 = BGD_E1E5a_5 * BGD_E1E5a_5_LSB; BGD_E1E5a_5 = BGD_E1E5a_5 * BGD_E1E5a_5_LSB;
DLOG(INFO)<<"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 = (double)read_navigation_signed(data_jk_bits, BGD_E1E5b_5_bit);
BGD_E1E5b_5 = BGD_E1E5b_5 * BGD_E1E5b_5_LSB; BGD_E1E5b_5 = BGD_E1E5b_5 * BGD_E1E5b_5_LSB;
DLOG(INFO)<<"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); E5b_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_5_bit);
@ -847,24 +847,24 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
DLOG(INFO)<<"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); TOW_5 = (double)read_navigation_unsigned(data_jk_bits, TOW_5_bit);
DLOG(INFO)<<"TOW_5= "<< TOW_5 <<std::endl; DLOG(INFO)<<"TOW_5= "<< TOW_5 <<std::endl;
flag_TOW_5 = 1; flag_TOW_5 = true; //set to false externally
spare_5 = (double)read_navigation_unsigned(data_jk_bits, spare_5_bit); spare_5 = (double)read_navigation_unsigned(data_jk_bits, spare_5_bit);
DLOG(INFO)<<"spare_5= "<< spare_5 <<std::endl; DLOG(INFO)<<"spare_5= "<< spare_5 <<std::endl;
flag_iono_and_GST = true; flag_iono_and_GST = true; //set to false externally
flag_TOW_set = true; flag_TOW_set = true; //set to false externally
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl; DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
break; break;
case 6: /*Word type 6: GST-UTC conversion parameters*/ case 6: /*Word type 6: GST-UTC conversion parameters*/
A0_6= (double)read_navigation_unsigned(data_jk_bits, A0_6_bit); A0_6= (double)read_navigation_signed(data_jk_bits, A0_6_bit);
A0_6= A0_6 * A0_6_LSB; A0_6= A0_6 * A0_6_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, A1_6_bit);
A1_6= A1_6 * A1_6_LSB; A1_6= A1_6 * A1_6_LSB;
DLOG(INFO) << "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); Delta_tLS_6= (double)read_navigation_signed(data_jk_bits, Delta_tLS_6_bit);
DLOG(INFO) << "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= (double)read_navigation_unsigned(data_jk_bits, t0t_6_bit);
@ -880,14 +880,14 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
DN_6= (double)read_navigation_unsigned(data_jk_bits, DN_6_bit); DN_6= (double)read_navigation_unsigned(data_jk_bits, DN_6_bit);
DLOG(INFO) << "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); Delta_tLSF_6= (double)read_navigation_signed(data_jk_bits, Delta_tLSF_6_bit);
DLOG(INFO) << "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); TOW_6= (double)read_navigation_unsigned(data_jk_bits, TOW_6_bit);
DLOG(INFO) << "TOW_6= " << TOW_6 << std::endl; DLOG(INFO) << "TOW_6= " << TOW_6 << std::endl;
flag_TOW_6 = 1; flag_TOW_6 = true; //set to false externally
flag_utc_model = true; flag_utc_model = true; //set to false externally
flag_TOW_set = true; flag_TOW_set = true; //set to false externally
DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl; DLOG(INFO)<<"flag_tow_set"<< flag_TOW_set << std::endl;
break; break;
@ -906,7 +906,7 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
SVID1_7= (double)read_navigation_unsigned(data_jk_bits, SVID1_7_bit); SVID1_7= (double)read_navigation_unsigned(data_jk_bits, SVID1_7_bit);
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, DELTA_A_7_bit);
DELTA_A_7= DELTA_A_7 * DELTA_A_7_LSB; DELTA_A_7= DELTA_A_7 * DELTA_A_7_LSB;
DLOG(INFO) << "DELTA_A_7= " << DELTA_A_7 << std::endl; DLOG(INFO) << "DELTA_A_7= " << DELTA_A_7 << std::endl;
@ -914,23 +914,23 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
e_7= e_7 * e_7_LSB; e_7= e_7 * e_7_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, omega_7_bit);
omega_7= omega_7 * omega_7_LSB; omega_7= omega_7 * omega_7_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, delta_i_7_bit);
delta_i_7= delta_i_7 * delta_i_7_LSB; delta_i_7= delta_i_7 * delta_i_7_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, Omega0_7_bit);
Omega0_7= Omega0_7 * Omega0_7_LSB; Omega0_7= Omega0_7 * Omega0_7_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, Omega_dot_7_bit);
Omega_dot_7= Omega_dot_7 * Omega_dot_7_LSB; Omega_dot_7= Omega_dot_7 * Omega_dot_7_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, M0_7_bit);
M0_7= M0_7 * M0_7_LSB; M0_7= M0_7 * M0_7_LSB;
DLOG(INFO) << "M0_7= " << M0_7 << std::endl; DLOG(INFO) << "M0_7= " << M0_7 << std::endl;
flag_almanac_1 = true; flag_almanac_1 = true;
@ -939,14 +939,14 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
case 8: /*Word type 8: Almanac for SVID1 (2/2) and SVID2 (1/2)*/ 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); IOD_a_8= (double)read_navigation_signed(data_jk_bits, IOD_a_8_bit);
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, af0_8_bit);
af0_8= af0_8 * af0_8_LSB; af0_8= af0_8 * af0_8_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, af1_8_bit);
af1_8= af1_8 * af1_8_LSB; af1_8= af1_8 * af1_8_LSB;
DLOG(INFO) << "af1_8= " << af1_8 << std::endl; DLOG(INFO) << "af1_8= " << af1_8 << std::endl;
@ -959,7 +959,7 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
SVID2_8= (double)read_navigation_unsigned(data_jk_bits, SVID2_8_bit); SVID2_8= (double)read_navigation_unsigned(data_jk_bits, SVID2_8_bit);
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, DELTA_A_8_bit);
DELTA_A_8= DELTA_A_8 * DELTA_A_8_LSB; DELTA_A_8= DELTA_A_8 * DELTA_A_8_LSB;
DLOG(INFO) << "DELTA_A_8= " << DELTA_A_8 << std::endl; DLOG(INFO) << "DELTA_A_8= " << DELTA_A_8 << std::endl;
@ -967,19 +967,19 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
e_8= e_8 * e_8_LSB; e_8= e_8 * e_8_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, omega_8_bit);
omega_8= omega_8 * omega_8_LSB; omega_8= omega_8 * omega_8_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, delta_i_8_bit);
delta_i_8= delta_i_8 * delta_i_8_LSB; delta_i_8= delta_i_8 * delta_i_8_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, Omega0_8_bit);
Omega0_8= Omega0_8 * Omega0_8_LSB; Omega0_8= Omega0_8 * Omega0_8_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, Omega_dot_8_bit);
Omega_dot_8= Omega_dot_8 * Omega_dot_8_LSB; Omega_dot_8= Omega_dot_8 * Omega_dot_8_LSB;
DLOG(INFO) << "Omega_dot_8= " << Omega_dot_8 << std::endl; DLOG(INFO) << "Omega_dot_8= " << Omega_dot_8 << std::endl;
flag_almanac_2 = true; flag_almanac_2 = true;
@ -998,15 +998,15 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
t0a_9= t0a_9 * t0a_9_LSB; t0a_9= t0a_9 * t0a_9_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, M0_9_bit);
M0_9= M0_9 * M0_9_LSB; M0_9= M0_9 * M0_9_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, af0_9_bit);
af0_9= af0_9 * af0_9_LSB; af0_9= af0_9 * af0_9_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, af1_9_bit);
af1_9= af1_9 * af1_9_LSB; af1_9= af1_9 * af1_9_LSB;
DLOG(INFO) << "af1_9= " << af1_9 << std::endl; DLOG(INFO) << "af1_9= " << af1_9 << std::endl;
@ -1020,7 +1020,7 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, DELTA_A_9_bit);
DELTA_A_9= DELTA_A_9 * DELTA_A_9_LSB; DELTA_A_9= DELTA_A_9 * DELTA_A_9_LSB;
DLOG(INFO) << "DELTA_A_9= " << DELTA_A_9 << std::endl; DLOG(INFO) << "DELTA_A_9= " << DELTA_A_9 << std::endl;
@ -1028,11 +1028,11 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
e_9= e_9 * e_9_LSB; e_9= e_9 * e_9_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, omega_9_bit);
omega_9= omega_9 * omega_9_LSB; omega_9= omega_9 * omega_9_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, delta_i_9_bit);
delta_i_9= delta_i_9 * delta_i_9_LSB; delta_i_9= delta_i_9 * delta_i_9_LSB;
DLOG(INFO) << "delta_i_9= " << delta_i_9 << std::endl; DLOG(INFO) << "delta_i_9= " << delta_i_9 << std::endl;
flag_almanac_3 = true; flag_almanac_3 = true;
@ -1044,23 +1044,23 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
IOD_a_10= (double)read_navigation_unsigned(data_jk_bits, IOD_a_10_bit); IOD_a_10= (double)read_navigation_unsigned(data_jk_bits, IOD_a_10_bit);
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, Omega0_10_bit);
Omega0_10= Omega0_10 * Omega0_10_LSB; Omega0_10= Omega0_10 * Omega0_10_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, Omega_dot_10_bit);
Omega_dot_10= Omega_dot_10 * Omega_dot_10_LSB; Omega_dot_10= Omega_dot_10 * Omega_dot_10_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, M0_10_bit);
M0_10= M0_10 * M0_10_LSB; M0_10= M0_10 * M0_10_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, af0_10_bit);
af0_10= af0_10 * af0_10_LSB; af0_10= af0_10 * af0_10_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, af1_10_bit);
af1_10= af1_10 * af1_10_LSB; af1_10= af1_10 * af1_10_LSB;
DLOG(INFO) << "af1_10= " << af1_10 << std::endl; DLOG(INFO) << "af1_10= " << af1_10 << std::endl;
@ -1070,15 +1070,15 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
E1B_HS_10= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_10_bit); E1B_HS_10= (double)read_navigation_unsigned(data_jk_bits, E1B_HS_10_bit);
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, A_0G_10_bit);
A_0G_10= A_0G_10 * A_0G_10_LSB; A_0G_10= A_0G_10 * A_0G_10_LSB;
DLOG(INFO) << "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= (double)read_navigation_signed(data_jk_bits, A_1G_10_bit);
A_1G_10= A_1G_10 * A_1G_10_LSB; A_1G_10= A_1G_10 * A_1G_10_LSB;
DLOG(INFO) << "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= (double)read_navigation_unsigned(data_jk_bits, t_0G_10_bit);
t_0G_10= t_0G_10 * t_0G_10_LSB; t_0G_10= t_0G_10 * t_0G_10_LSB;
DLOG(INFO) << "t_0G_10= " << t_0G_10 << std::endl; DLOG(INFO) << "t_0G_10= " << t_0G_10 << std::endl;
@ -1107,278 +1107,278 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
void Galileo_Navigation_Message::satellitePosition(double transmitTime) //when this function in used, the input must be the transmitted time (t) in second computed by Galileo_System_Time (above function) //void Galileo_Navigation_Message::satellitePosition(double transmitTime) //when this function in used, the input must be the transmitted time (t) in second computed by Galileo_System_Time (above function)
{ //{
//
double tk; // Time from ephemeris reference epoch // double tk; // Time from ephemeris reference epoch
//double t; // Galileo System Time (ICD, paragraph 5.1.2) // //double t; // Galileo System Time (ICD, paragraph 5.1.2)
double a; // Semi-major axis // double a; // Semi-major axis
double n; // Corrected mean motion // double n; // Corrected mean motion
double n0; // Computed mean motion // double n0; // Computed mean motion
double M; // Mean anomaly // double M; // Mean anomaly
double E; //Eccentric Anomaly (to be solved by iteration) // double E; //Eccentric Anomaly (to be solved by iteration)
double E_old; // double E_old;
double dE; // double dE;
double nu; //True anomaly // double nu; //True anomaly
double phi; //argument of Latitude // double phi; //argument of Latitude
double u; // Correct argument of latitude // double u; // Correct argument of latitude
double r; // Correct radius // double r; // Correct radius
double i; // double i;
double Omega; // double Omega;
//
// Find Galileo satellite's position ---------------------------------------------- // // Find Galileo satellite's position ----------------------------------------------
//
// Restore semi-major axis // // Restore semi-major axis
a = A_1*A_1; // a = A_1*A_1;
//
// Computed mean motion // // Computed mean motion
n0 = sqrt(GALILEO_GM / (a*a*a)); // n0 = sqrt(GALILEO_GM / (a*a*a));
//
// Time from ephemeris reference epoch // // Time from ephemeris reference epoch
//tk = check_t(transmitTime - d_Toe); this is tk for GPS; for Galileo it is different // //tk = check_t(transmitTime - d_Toe); this is tk for GPS; for Galileo it is different
//t = WN_5*86400*7 + TOW_5; //WN_5*86400*7 are the second from the origin of the Galileo time // //t = WN_5*86400*7 + TOW_5; //WN_5*86400*7 are the second from the origin of the Galileo time
tk = transmitTime - t0e_1; // tk = transmitTime - t0e_1;
//
// Corrected mean motion // // Corrected mean motion
n = n0 + delta_n_3; // n = n0 + delta_n_3;
//
// Mean anomaly // // Mean anomaly
M = M0_1 + n * tk; // M = M0_1 + n * tk;
//
// Reduce mean anomaly to between 0 and 2pi // // Reduce mean anomaly to between 0 and 2pi
M = fmod((M + 2* GALILEO_PI), (2* GALILEO_PI)); // M = fmod((M + 2* GALILEO_PI), (2* GALILEO_PI));
//
// Initial guess of eccentric anomaly // // Initial guess of eccentric anomaly
E = M; // E = M;
//
// --- Iteratively compute eccentric anomaly ---------------------------- // // --- Iteratively compute eccentric anomaly ----------------------------
for (int ii = 1; ii<20; ii++) // for (int ii = 1; ii<20; ii++)
{ // {
E_old = E; // E_old = E;
E = M + e_1 * sin(E); // E = M + e_1 * sin(E);
dE = fmod(E - E_old, 2*GALILEO_PI); // dE = fmod(E - E_old, 2*GALILEO_PI);
if (fabs(dE) < 1e-12) // if (fabs(dE) < 1e-12)
{ // {
//Necessary precision is reached, exit from the loop // //Necessary precision is reached, exit from the loop
break; // break;
} // }
} // }
//
// Compute the true anomaly // // Compute the true anomaly
//
double tmp_Y = sqrt(1.0 - e_1 * e_1) * sin(E); // double tmp_Y = sqrt(1.0 - e_1 * e_1) * sin(E);
double tmp_X = cos(E) - e_1; // double tmp_X = cos(E) - e_1;
nu = atan2(tmp_Y, tmp_X); // nu = atan2(tmp_Y, tmp_X);
//
// Compute angle phi (argument of Latitude) // // Compute angle phi (argument of Latitude)
phi = nu + omega_2; // phi = nu + omega_2;
//
// Reduce phi to between 0 and 2*pi rad // // Reduce phi to between 0 and 2*pi rad
phi = fmod((phi), (2*GALILEO_PI)); // phi = fmod((phi), (2*GALILEO_PI));
//
// Correct argument of latitude // // Correct argument of latitude
u = phi + C_uc_3 * cos(2*phi) + C_us_3 * sin(2*phi); // u = phi + C_uc_3 * cos(2*phi) + C_us_3 * sin(2*phi);
//
// Correct radius // // Correct radius
r = a * (1 - e_1*cos(E)) + C_rc_3 * cos(2*phi) + C_rs_3 * sin(2*phi); // r = a * (1 - e_1*cos(E)) + C_rc_3 * cos(2*phi) + C_rs_3 * sin(2*phi);
//
// Correct inclination // // Correct inclination
i = i_0_2 + iDot_2 * tk + C_ic_4 * cos(2*phi) + C_is_4 * sin(2*phi); // i = i_0_2 + iDot_2 * tk + C_ic_4 * cos(2*phi) + C_is_4 * sin(2*phi);
//
// Compute the angle between the ascending node and the Greenwich meridian // // Compute the angle between the ascending node and the Greenwich meridian
Omega = OMEGA_0_2 + (OMEGA_dot_3 - GALILEO_OMEGA_EARTH_DOT)*tk - GALILEO_OMEGA_EARTH_DOT * t0e_1; // Omega = OMEGA_0_2 + (OMEGA_dot_3 - GALILEO_OMEGA_EARTH_DOT)*tk - GALILEO_OMEGA_EARTH_DOT * t0e_1;
//
// Reduce to between 0 and 2*pi rad // // Reduce to between 0 and 2*pi rad
Omega = fmod((Omega + 2*GALILEO_PI), (2*GALILEO_PI)); // Omega = fmod((Omega + 2*GALILEO_PI), (2*GALILEO_PI));
//
// --- Compute satellite coordinates in Earth-fixed coordinates // // --- Compute satellite coordinates in Earth-fixed coordinates
galileo_satpos_X = cos(u) * r * cos(Omega) - sin(u) * r * cos(i) * sin(Omega); // galileo_satpos_X = cos(u) * r * cos(Omega) - sin(u) * r * cos(i) * sin(Omega);
galileo_satpos_Y = cos(u) * r * sin(Omega) + sin(u) * r * cos(i) * cos(Omega); //***********************NOTE: in GALILEO ICD this expression is not correct because it has minus (- sin(u) * r * cos(i) * cos(Omega)) instead of plus // galileo_satpos_Y = cos(u) * r * sin(Omega) + sin(u) * r * cos(i) * cos(Omega); //***********************NOTE: in GALILEO ICD this expression is not correct because it has minus (- sin(u) * r * cos(i) * cos(Omega)) instead of plus
galileo_satpos_Z = sin(u) * r * sin(i); // galileo_satpos_Z = sin(u) * r * sin(i);
//
std::cout << "Galileo satellite position X [m]: " << galileo_satpos_X << std::endl; // std::cout << "Galileo satellite position X [m]: " << galileo_satpos_X << std::endl;
std::cout << "Galileo satellite position Y [m]: " << galileo_satpos_Y << std::endl; // std::cout << "Galileo satellite position Y [m]: " << galileo_satpos_Y << std::endl;
std::cout << "Galileo satellite position Z [m]: " << galileo_satpos_Z << std::endl; // std::cout << "Galileo satellite position Z [m]: " << galileo_satpos_Z << std::endl;
double vector_position = sqrt(galileo_satpos_X*galileo_satpos_X + galileo_satpos_Y*galileo_satpos_Y + galileo_satpos_Z*galileo_satpos_Z); // double vector_position = sqrt(galileo_satpos_X*galileo_satpos_X + galileo_satpos_Y*galileo_satpos_Y + galileo_satpos_Z*galileo_satpos_Z);
std::cout << "Vector Earth Center-Satellite [Km]: " << vector_position/1000 << std::endl; // std::cout << "Vector Earth Center-Satellite [Km]: " << vector_position/1000 << std::endl;
//
// Satellite's velocity. Can be useful for Vector Tracking loops // // Satellite's velocity. Can be useful for Vector Tracking loops
double Omega_dot = OMEGA_dot_3 - GALILEO_OMEGA_EARTH_DOT; // double Omega_dot = OMEGA_dot_3 - GALILEO_OMEGA_EARTH_DOT;
galileo_satvel_X = - Omega_dot * (cos(u) * r + sin(u) * r * cos(i)) + galileo_satpos_X * cos(Omega) - galileo_satpos_Y * cos(i) * sin(Omega); // galileo_satvel_X = - Omega_dot * (cos(u) * r + sin(u) * r * cos(i)) + galileo_satpos_X * cos(Omega) - galileo_satpos_Y * cos(i) * sin(Omega);
galileo_satvel_Y = Omega_dot * (cos(u) * r * cos(Omega) - sin(u) * r * cos(i) * sin(Omega)) + galileo_satpos_X * sin(Omega) + galileo_satpos_Y * cos(i) * cos(Omega); // galileo_satvel_Y = Omega_dot * (cos(u) * r * cos(Omega) - sin(u) * r * cos(i) * sin(Omega)) + galileo_satpos_X * sin(Omega) + galileo_satpos_Y * cos(i) * cos(Omega);
galileo_satvel_Z = galileo_satpos_Y * sin(i); // galileo_satvel_Z = galileo_satpos_Y * sin(i);
//
} //}
//
//
double Galileo_Navigation_Message::Galileo_System_Time(double WN, double TOW){ //double Galileo_Navigation_Message::Galileo_System_Time(double WN, double TOW){
/* GALIELO SYSTEM TIME, ICD 5.1.2 // /* GALIELO SYSTEM TIME, ICD 5.1.2
* input parameter: // * input parameter:
* WN: The Week Number is an integer counter that gives the sequential week number // * WN: The Week Number is an integer counter that gives the sequential week number
from the origin of the Galileo time. It covers 4096 weeks (about 78 years). // from the origin of the Galileo time. It covers 4096 weeks (about 78 years).
Then the counter is reset to zero to cover additional period modulo 4096 // Then the counter is reset to zero to cover additional period modulo 4096
//
TOW: The Time of Week is defined as the number of seconds that have occurred since // TOW: The Time of Week is defined as the number of seconds that have occurred since
the transition from the previous week. The TOW covers an entire week from 0 to // the transition from the previous week. The TOW covers an entire week from 0 to
604799 seconds and is reset to zero at the end of each week // 604799 seconds and is reset to zero at the end of each week
//
WN and TOW are received in page 5 // WN and TOW are received in page 5
//
output: // output:
t: it is the transmitted time in Galileo System Time (expressed in seconds) // t: it is the transmitted time in Galileo System Time (expressed in seconds)
//
The GST start epoch shall be 00:00 UT on Sunday 22nd August 1999 (midnight between 21st and 22nd August). // The GST start epoch shall be 00:00 UT on Sunday 22nd August 1999 (midnight between 21st and 22nd August).
At the start epoch, GST shall be ahead of UTC by thirteen (13) // At the start epoch, GST shall be ahead of UTC by thirteen (13)
leap seconds. Since the next leap second was inserted at 01.01.2006, this implies that // leap seconds. Since the next leap second was inserted at 01.01.2006, this implies that
as of 01.01.2006 GST is ahead of UTC by fourteen (14) leap seconds. // as of 01.01.2006 GST is ahead of UTC by fourteen (14) leap seconds.
//
The epoch denoted in the navigation messages by TOW and WN // The epoch denoted in the navigation messages by TOW and WN
will be measured relative to the leading edge of the first chip of the // will be measured relative to the leading edge of the first chip of the
first code sequence of the first page symbol. The transmission timing of the navigation // first code sequence of the first page symbol. The transmission timing of the navigation
message provided through the TOW is synchronised to each satellite’s version of Galileo System Time (GST). // message provided through the TOW is synchronised to each satellite’s version of Galileo System Time (GST).
* // *
*/ // */
double t=0; // double t=0;
double sec_in_day = 86400; // double sec_in_day = 86400;
double day_in_week = 7; // double day_in_week = 7;
t = WN * sec_in_day * day_in_week + TOW; // second from the origin of the Galileo time // t = WN * sec_in_day * day_in_week + TOW; // second from the origin of the Galileo time
//
return t; // return t;
//
} //}
//
//
//
double Galileo_Navigation_Message::sv_clock_drift(double transmitTime){ //double Galileo_Navigation_Message::sv_clock_drift(double transmitTime){
/* Satellite Time Correction Algorithm, ICD 5.1.4 // /* Satellite Time Correction Algorithm, ICD 5.1.4
* // *
*/ // */
double dt; // double dt;
dt = transmitTime - t0c_4; // dt = transmitTime - t0c_4;
Galileo_satClkDrift = af0_4 + af1_4*dt + (af2_4 * dt)*(af2_4 * dt) + Galileo_dtr; // Galileo_satClkDrift = af0_4 + af1_4*dt + (af2_4 * dt)*(af2_4 * dt) + Galileo_dtr;
return Galileo_satClkDrift; // return Galileo_satClkDrift;
} //}
//
// compute the relativistic correction term //// compute the relativistic correction term
double Galileo_Navigation_Message::sv_clock_relativistic_term(double transmitTime) //Satellite Time Correction Algorithm, ICD 5.1.4 //double Galileo_Navigation_Message::sv_clock_relativistic_term(double transmitTime) //Satellite Time Correction Algorithm, ICD 5.1.4
{ //{
double tk; // double tk;
double a; // double a;
double n; // double n;
double n0; // double n0;
double E; // double E;
double E_old; // double E_old;
double dE; // double dE;
double M; // double M;
//
// Restore semi-major axis // // Restore semi-major axis
a = A_1*A_1; // a = A_1*A_1;
//
n0 = sqrt(GALILEO_GM / (a*a*a)); // n0 = sqrt(GALILEO_GM / (a*a*a));
//
// Time from ephemeris reference epoch // // Time from ephemeris reference epoch
//tk = check_t(transmitTime - d_Toe); this is tk for GPS; for Galileo it is different // //tk = check_t(transmitTime - d_Toe); this is tk for GPS; for Galileo it is different
//t = WN_5*86400*7 + TOW_5; //WN_5*86400*7 are the second from the origin of the Galileo time // //t = WN_5*86400*7 + TOW_5; //WN_5*86400*7 are the second from the origin of the Galileo time
tk = transmitTime - t0e_1; // tk = transmitTime - t0e_1;
//
// Corrected mean motion // // Corrected mean motion
n = n0 + delta_n_3; // n = n0 + delta_n_3;
//
// Mean anomaly // // Mean anomaly
M = M0_1 + n * tk; // M = M0_1 + n * tk;
//
// Reduce mean anomaly to between 0 and 2pi // // Reduce mean anomaly to between 0 and 2pi
M = fmod((M + 2* GALILEO_PI), (2* GALILEO_PI)); // M = fmod((M + 2* GALILEO_PI), (2* GALILEO_PI));
//
// Initial guess of eccentric anomaly // // Initial guess of eccentric anomaly
E = M; // E = M;
//
// --- Iteratively compute eccentric anomaly ---------------------------- // // --- Iteratively compute eccentric anomaly ----------------------------
for (int ii = 1; ii<20; ii++) // for (int ii = 1; ii<20; ii++)
{ // {
E_old = E; // E_old = E;
E = M + e_1 * sin(E); // E = M + e_1 * sin(E);
dE = fmod(E - E_old, 2*GALILEO_PI); // dE = fmod(E - E_old, 2*GALILEO_PI);
if (fabs(dE) < 1e-12) // if (fabs(dE) < 1e-12)
{ // {
//Necessary precision is reached, exit from the loop // //Necessary precision is reached, exit from the loop
break; // break;
} // }
} // }
//
//
// Compute relativistic correction term // // Compute relativistic correction term
Galileo_dtr = GALILEO_F * e_1* A_1 * sin(E); // Galileo_dtr = GALILEO_F * e_1* A_1 * sin(E);
return Galileo_dtr; // return Galileo_dtr;
} //}
double Galileo_Navigation_Message::GST_to_UTC_time(double t_e, int WN) //t_e is GST (WN+TOW) in second
{
double t_Utc;
double t_Utc_daytime;
double Delta_t_Utc = Delta_tLS_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)(WN - WNot_6));
// Determine if the effectivity time of the leap second event is in the past
int weeksToLeapSecondEvent = WN_LSF_6 - WN;
if ((weeksToLeapSecondEvent) >= 0) // is not in the past
{
//Detect if the effectivity time and user's time is within six hours = 6 * 60 *60 = 21600 s
int secondOfLeapSecondEvent = DN_6 * 24 * 60 * 60;
if (weeksToLeapSecondEvent > 0)
{
t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
}
else //we are in the same week than the leap second event
{
if (abs(t_e - secondOfLeapSecondEvent) > 21600)
{
/* 5.1.7a
* Whenever the leap second adjusted time indicated by the WN_LSF and the DN values
* is not in the past (relative to the user's present time), and the user's
* present time does not fall in the time span which starts at six hours prior
* to the effective time and ends at six hours after the effective time,
* the GST/Utc relationship is given by
*/
t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
}
else
{
/* 5.1.7b
* Whenever the user's current time falls within the time span of six hours
* prior to the leap second adjustment to six hours after the adjustment time, ,
* the effective time is computed according to the following equations:
*/
int W = fmod(t_e - Delta_t_Utc - 43200, 86400) + 43200;
t_Utc_daytime = fmod(W, 86400 + Delta_tLSF_6 - Delta_tLS_6);
//implement something to handle a leap second event!
}
if ( (t_e - secondOfLeapSecondEvent) > 21600)
{
Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800*(double)(WN - WNot_6));
t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
}
}
}
else // the effectivity time is in the past
{
/* 5.1.7c
* Whenever the leap second adjustment time, as indicated by the WN_LSF and DN values,
* is in the past (relative to the user’s current time) and the user’s present time does not
* fall in the time span which starts six hours prior to the leap second adjustment time and
* ends six hours after the adjustment time, the effective time is computed according to
* the following equation:
*/
Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)(WN - WNot_6));
t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
}
double secondsOfWeekBeforeToday = 43200 * floor(t_e / 43200);
t_Utc = secondsOfWeekBeforeToday + t_Utc_daytime;
return t_Utc;
}
//double Galileo_Navigation_Message::GST_to_UTC_time(double t_e, int WN) //t_e is GST (WN+TOW) in second
//{
// double t_Utc;
// double t_Utc_daytime;
// double Delta_t_Utc = Delta_tLS_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)(WN - WNot_6));
//
// // Determine if the effectivity time of the leap second event is in the past
// int weeksToLeapSecondEvent = WN_LSF_6 - WN;
//
// if ((weeksToLeapSecondEvent) >= 0) // is not in the past
// {
// //Detect if the effectivity time and user's time is within six hours = 6 * 60 *60 = 21600 s
// int secondOfLeapSecondEvent = DN_6 * 24 * 60 * 60;
// if (weeksToLeapSecondEvent > 0)
// {
// t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
// }
// else //we are in the same week than the leap second event
// {
// if (abs(t_e - secondOfLeapSecondEvent) > 21600)
// {
// /* 5.1.7a
// * Whenever the leap second adjusted time indicated by the WN_LSF and the DN values
// * is not in the past (relative to the user's present time), and the user's
// * present time does not fall in the time span which starts at six hours prior
// * to the effective time and ends at six hours after the effective time,
// * the GST/Utc relationship is given by
// */
// t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
// }
// else
// {
// /* 5.1.7b
// * Whenever the user's current time falls within the time span of six hours
// * prior to the leap second adjustment to six hours after the adjustment time, ,
// * the effective time is computed according to the following equations:
// */
//
// int W = fmod(t_e - Delta_t_Utc - 43200, 86400) + 43200;
// t_Utc_daytime = fmod(W, 86400 + Delta_tLSF_6 - Delta_tLS_6);
// //implement something to handle a leap second event!
// }
// if ( (t_e - secondOfLeapSecondEvent) > 21600)
// {
// Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800*(double)(WN - WNot_6));
// t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
// }
// }
// }
// else // the effectivity time is in the past
// {
// /* 5.1.7c
// * Whenever the leap second adjustment time, as indicated by the WN_LSF and DN values,
// * is in the past (relative to the user’s current time) and the user’s present time does not
// * fall in the time span which starts six hours prior to the leap second adjustment time and
// * ends six hours after the adjustment time, the effective time is computed according to
// * the following equation:
// */
// Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)(WN - WNot_6));
// t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
// }
//
// double secondsOfWeekBeforeToday = 43200 * floor(t_e / 43200);
// t_Utc = secondsOfWeekBeforeToday + t_Utc_daytime;
// return t_Utc;
//
//}
//
//
//

18
src/core/system_parameters/galileo_navigation_message.h
View File

@ -296,15 +296,15 @@ public:
*/ */
Galileo_Almanac get_almanac(); Galileo_Almanac get_almanac();
void satellitePosition(double transmitTime); // void satellitePosition(double transmitTime);
//
double Galileo_System_Time(double WN, double TOW); // Galileo System Time (GST), ICD paragraph 5.1.2 // double Galileo_System_Time(double WN, double TOW); // Galileo System Time (GST), ICD paragraph 5.1.2
//
double sv_clock_drift(double transmitTime); //Satellite Time Correction Algorithm, ICD 5.1.4 // double sv_clock_drift(double transmitTime); //Satellite Time Correction Algorithm, ICD 5.1.4
//
double sv_clock_relativistic_term(double transmitTime); //Satellite Time Correction Algorithm, ICD 5.1.4 // double sv_clock_relativistic_term(double transmitTime); //Satellite Time Correction Algorithm, ICD 5.1.4
//
double GST_to_UTC_time(double t_e, int WN); //GST-UTC Conversion Algorithm and Parameters // double GST_to_UTC_time(double t_e, int WN); //GST-UTC Conversion Algorithm and Parameters
Galileo_Navigation_Message(); Galileo_Navigation_Message();
}; };

97
src/core/system_parameters/galileo_utc_model.cc
View File

@ -49,63 +49,54 @@ double Galileo_Utc_Model::GST_to_UTC_time(double t_e, int WN)
{ {
double t_Utc; double t_Utc;
double t_Utc_daytime; double t_Utc_daytime;
double Delta_t_Utc = Delta_tLS_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)(WN - WNot_6)); double Delta_t_Utc=0;
// Determine if the effectivity time of the leap second event is in the past // Determine if the effectivity time of the leap second event is in the past
int weeksToLeapSecondEvent = WN_LSF_6 - WN; int weeksToLeapSecondEvent = WN_LSF_6 - (WN % 256);
if ((weeksToLeapSecondEvent) >= 0) // is not in the past if ((weeksToLeapSecondEvent) >= 0) // is not in the past
{ {
//Detect if the effectivity time and user's time is within six hours = 6 * 60 *60 = 21600 s //Detect if the effectivity time and user's time is within six hours = 6 * 60 *60 = 21600 s
int secondOfLeapSecondEvent = DN_6 * 24 * 60 * 60; int secondOfLeapSecondEvent = DN_6 * 24 * 60 * 60;
if (weeksToLeapSecondEvent > 0) if (abs(t_e - secondOfLeapSecondEvent) > 21600)
{ {
t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400); /* 5.1.7a
} * Whenever the leap second adjusted time indicated by the WN_LSF and the DN values
else //we are in the same week than the leap second event * is not in the past (relative to the user's present time), and the user's
{ * present time does not fall in the time span which starts at six hours prior
if (abs(t_e - secondOfLeapSecondEvent) > 21600) * to the effective time and ends at six hours after the effective time,
{ * the GST/Utc relationship is given by
/* 5.1.7a */
* Whenever the leap second adjusted time indicated by the WN_LSF and the DN values //std::cout<<"GST->UTC case a"<<std::endl;
* is not in the past (relative to the user's present time), and the user's Delta_t_Utc = Delta_tLS_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)((WN % 256) - WNot_6));
* present time does not fall in the time span which starts at six hours prior t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
* to the effective time and ends at six hours after the effective time, }
* the GST/Utc relationship is given by else
*/ {
t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400); /* 5.1.7b
} * Whenever the user's current time falls within the time span of six hours
else * prior to the leap second adjustment to six hours after the adjustment time, ,
{ * the effective time is computed according to the following equations:
/* 5.1.7b */
* Whenever the user's current time falls within the time span of six hours //std::cout<<"GST->UTC case b"<<std::endl;
* prior to the leap second adjustment to six hours after the adjustment time, , Delta_t_Utc = Delta_tLS_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)((WN % 256) - WNot_6));
* the effective time is computed according to the following equations: double W = fmod(t_e - Delta_t_Utc - 43200, 86400) + 43200;
*/ t_Utc_daytime = fmod(W, 86400 + Delta_tLSF_6 - Delta_tLS_6);
//implement something to handle a leap second event!
int W = fmod(t_e - Delta_t_Utc - 43200, 86400) + 43200; }
t_Utc_daytime = fmod(W, 86400 + Delta_tLSF_6 - Delta_tLS_6); }
//implement something to handle a leap second event!
}
if ( (t_e - secondOfLeapSecondEvent) > 21600)
{
Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800*(double)(WN - WNot_6));
t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
}
}
}
else // the effectivity time is in the past else // the effectivity time is in the past
{ {
/* 5.1.7c /* 5.1.7c
* Whenever the leap second adjustment time, as indicated by the WN_LSF and DN values, * Whenever the leap second adjustment time, as indicated by the WN_LSF and DN values,
* is in the past (relative to the user’s current time) and the user’s present time does not * is in the past (relative to the user’s current time) and the user’s present time does not
* fall in the time span which starts six hours prior to the leap second adjustment time and * fall in the time span which starts six hours prior to the leap second adjustment time and
* ends six hours after the adjustment time, the effective time is computed according to * ends six hours after the adjustment time, the effective time is computed according to
* the following equation: * the following equation:
*/ */
Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)(WN - WNot_6)); //std::cout<<"GST->UTC case c"<<std::endl;
t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400); Delta_t_Utc = Delta_tLSF_6 + A0_6 + A1_6 * (t_e - t0t_6 + 604800 * (double)((WN % 256) - WNot_6));
} t_Utc_daytime = fmod(t_e - Delta_t_Utc, 86400);
}
double secondsOfWeekBeforeToday = 43200 * floor(t_e / 43200); double secondsOfWeekBeforeToday = 43200 * floor(t_e / 43200);
t_Utc = secondsOfWeekBeforeToday + t_Utc_daytime; t_Utc = secondsOfWeekBeforeToday + t_Utc_daytime;

6
src/utils/matlab/galileo_e1_dll_pll_veml_plot_sample_32bits.m
View File

@ -29,10 +29,10 @@
% */ % */
close all; close all;
clear all; clear all;
samplingFreq = 64e6/8; %[Hz] samplingFreq = 20480000/4; %[Hz]
channels=2; channels=8;
%path='/home/javier/workspace/gnss-sdr/trunk/install/'; %path='/home/javier/workspace/gnss-sdr/trunk/install/';
path='/home/javier/workspace/gnss-sdr/trunk/data/'; path='/home/gnss/workspace/gnss-sdr/trunk/data/';
clear PRN_absolute_sample_start; clear PRN_absolute_sample_start;
for N=1:1:channels for N=1:1:channels
tracking_log_path=[path 'veml_tracking_ch_' num2str(N-1) '.dat']; tracking_log_path=[path 'veml_tracking_ch_' num2str(N-1) '.dat'];

11
src/utils/matlab/galileo_e1b_observables_plot_sample.m
View File

@ -6,12 +6,17 @@ close all;
%IFEN NSR Sampler Fs=20480000 %IFEN NSR Sampler Fs=20480000
% GNSS-SDR decimation factor 8 % GNSS-SDR decimation factor 8
samplingFreq = 20480000/8; %[Hz] samplingFreq = 20480000/8; %[Hz]
channels=8; channels=4;
path='/home/gnss/workspace/gnss-sdr/trunk/install/'; path='/home/gnss/workspace/gnss-sdr/trunk/install/';
observables_log_path=[path 'observables.dat']; observables_log_path=[path 'observables.dat'];
GNSS_observables= gps_l1_ca_read_observables_dump(channels,observables_log_path); GNSS_observables= gps_l1_ca_read_observables_dump(channels,observables_log_path);
skip=10000; skip=9000;
ref_channel=1; ref_channel=1;
plot(GNSS_observables.d_TOW_at_current_symbol(ref_channel,skip:end),GNSS_observables.Pseudorange_m(1:6,skip:end).') plot(GNSS_observables.d_TOW_at_current_symbol(ref_channel,skip:end),GNSS_observables.Pseudorange_m(:,skip:end).')
title('psudoranges');
figure
plot(GNSS_observables.d_TOW_at_current_symbol(ref_channel,skip:end),GNSS_observables.Prn_timestamp_ms(:,skip:end).')
title('Prn_timestamps');