mirror of
https://github.com/gnss-sdr/gnss-sdr
synced 2024-12-13 19:50:34 +00:00
Changing some C-styled cast to C++
This commit is contained in:
Carles Fernandez
parent
966f5c7333
commit
798b54e87c
@ -259,8 +259,8 @@ std::string Nmea_Printer::longitude_to_hm(double longitude)
|
||||
{
|
||||
east = true;
|
||||
}
|
||||
int deg = (int)longitude;
|
||||
double mins = longitude - (double)deg;
|
||||
int deg = static_cast<int>(longitude);
|
||||
double mins = longitude - static_cast<double>(deg);
|
||||
mins *= 60.0 ;
|
||||
std::ostringstream out_string;
|
||||
out_string.setf(std::ios::fixed, std::ios::floatfield);
|
||||
@ -422,7 +422,7 @@ std::string Nmea_Printer::get_GPRMC()
|
||||
sentence_str << "*";
|
||||
sentence_str.width(2);
|
||||
sentence_str.fill('0');
|
||||
sentence_str << std::hex << (int)checksum;
|
||||
sentence_str << std::hex << static_cast<int>(checksum);
|
||||
|
||||
// end NMEA sentence
|
||||
sentence_str << "\r\n";
|
||||
@ -507,7 +507,7 @@ std::string Nmea_Printer::get_GPGSA()
|
||||
sentence_str << "*";
|
||||
sentence_str.width(2);
|
||||
sentence_str.fill('0');
|
||||
sentence_str << std::hex << (int)checksum;
|
||||
sentence_str << std::hex << static_cast<int>(checksum);
|
||||
|
||||
// end NMEA sentence
|
||||
sentence_str << "\r\n";
|
||||
@ -532,7 +532,7 @@ std::string Nmea_Printer::get_GPGSV()
|
||||
// 1st step: How many GPGSV frames we need? (up to 3)
|
||||
// Each frame contains up to 4 satellites
|
||||
int n_frames;
|
||||
n_frames = std::ceil(((double)n_sats_used) / 4.0);
|
||||
n_frames = std::ceil((static_cast<double>(n_sats_used)) / 4.0);
|
||||
|
||||
// generate the frames
|
||||
int current_satellite = 0;
|
||||
@ -566,17 +566,17 @@ std::string Nmea_Printer::get_GPGSV()
|
||||
frame_str << ",";
|
||||
frame_str.width(2);
|
||||
frame_str.fill('0');
|
||||
frame_str << std::dec << (int)d_PVT_data->d_visible_satellites_El[current_satellite];
|
||||
frame_str << std::dec << static_cast<int>(d_PVT_data->d_visible_satellites_El[current_satellite]);
|
||||
|
||||
frame_str << ",";
|
||||
frame_str.width(3);
|
||||
frame_str.fill('0');
|
||||
frame_str << std::dec << (int)d_PVT_data->d_visible_satellites_Az[current_satellite];
|
||||
frame_str << std::dec << static_cast<int>(d_PVT_data->d_visible_satellites_Az[current_satellite]);
|
||||
|
||||
frame_str << ",";
|
||||
frame_str.width(2);
|
||||
frame_str.fill('0');
|
||||
frame_str << std::dec << (int)d_PVT_data->d_visible_satellites_CN0_dB[current_satellite];
|
||||
frame_str << std::dec << static_cast<int>(d_PVT_data->d_visible_satellites_CN0_dB[current_satellite]);
|
||||
|
||||
current_satellite++;
|
||||
|
||||
@ -592,7 +592,7 @@ std::string Nmea_Printer::get_GPGSV()
|
||||
frame_str << "*";
|
||||
frame_str.width(2);
|
||||
frame_str.fill('0');
|
||||
frame_str << std::hex << (int)checksum;
|
||||
frame_str << std::hex << static_cast<int>(checksum);
|
||||
|
||||
// end NMEA sentence
|
||||
frame_str << "\r\n";
|
||||
@ -712,7 +712,7 @@ std::string Nmea_Printer::get_GPGGA()
|
||||
sentence_str << "*";
|
||||
sentence_str.width(2);
|
||||
sentence_str.fill('0');
|
||||
sentence_str << std::hex <<(int)checksum;
|
||||
sentence_str << std::hex << static_cast<int>(checksum);
|
||||
|
||||
// end NMEA sentence
|
||||
sentence_str << "\r\n";
|
||||
|
||||
@ -143,7 +143,7 @@ Rinex_Printer::Rinex_Printer()
|
||||
if ( FLAGS_RINEX_version.compare("3.01") == 0 )
|
||||
{
|
||||
version = 3;
|
||||
stringVersion = "3.02";
|
||||
stringVersion = "3.01";
|
||||
}
|
||||
else if ( FLAGS_RINEX_version.compare("3.02") == 0 )
|
||||
{
|
||||
@ -163,7 +163,7 @@ Rinex_Printer::Rinex_Printer()
|
||||
else if ( FLAGS_RINEX_version.compare("2.10") == 0 )
|
||||
{
|
||||
version = 2;
|
||||
stringVersion = "2.11";
|
||||
stringVersion = "2.10";
|
||||
}
|
||||
else if ( FLAGS_RINEX_version.compare("2") == 0 )
|
||||
{
|
||||
@ -1129,12 +1129,12 @@ void Rinex_Printer::log_rinex_nav(std::ofstream& out, std::map<int,Gps_Ephemeris
|
||||
}
|
||||
line += Rinex_Printer::doub2for(gps_ephemeris_iter->second.d_IDOT, 18, 2);
|
||||
line += std::string(1, ' ');
|
||||
line += Rinex_Printer::doub2for((double)(gps_ephemeris_iter->second.i_code_on_L2), 18, 2);
|
||||
line += Rinex_Printer::doub2for(static_cast<double>(gps_ephemeris_iter->second.i_code_on_L2), 18, 2);
|
||||
line += std::string(1, ' ');
|
||||
double GPS_week_continuous_number = (double)(gps_ephemeris_iter->second.i_GPS_week + 1024); // valid until April 7, 2019 (check http://www.colorado.edu/geography/gcraft/notes/gps/gpseow.htm)
|
||||
double GPS_week_continuous_number = static_cast<double>(gps_ephemeris_iter->second.i_GPS_week + 1024); // valid until April 7, 2019 (check http://www.colorado.edu/geography/gcraft/notes/gps/gpseow.htm)
|
||||
line += Rinex_Printer::doub2for(GPS_week_continuous_number, 18, 2);
|
||||
line += std::string(1, ' ');
|
||||
line += Rinex_Printer::doub2for((double)(gps_ephemeris_iter->second.i_code_on_L2), 18, 2);
|
||||
line += Rinex_Printer::doub2for(static_cast<double>(gps_ephemeris_iter->second.i_code_on_L2), 18, 2);
|
||||
if (version == 2)
|
||||
{
|
||||
line += std::string(1, ' ');
|
||||
@ -1153,9 +1153,9 @@ void Rinex_Printer::log_rinex_nav(std::ofstream& out, std::map<int,Gps_Ephemeris
|
||||
{
|
||||
line += std::string(5, ' ');
|
||||
}
|
||||
line += Rinex_Printer::doub2for((double)(gps_ephemeris_iter->second.i_SV_accuracy), 18, 2);
|
||||
line += Rinex_Printer::doub2for(static_cast<double>(gps_ephemeris_iter->second.i_SV_accuracy), 18, 2);
|
||||
line += std::string(1, ' ');
|
||||
line += Rinex_Printer::doub2for((double)(gps_ephemeris_iter->second.i_SV_health), 18, 2);
|
||||
line += Rinex_Printer::doub2for(static_cast<double>(gps_ephemeris_iter->second.i_SV_health), 18, 2);
|
||||
line += std::string(1, ' ');
|
||||
line += Rinex_Printer::doub2for(gps_ephemeris_iter->second.d_TGD, 18, 2);
|
||||
line += std::string(1, ' ');
|
||||
@ -1331,7 +1331,7 @@ void Rinex_Printer::log_rinex_nav(std::ofstream& out, std::map<int, Galileo_Ephe
|
||||
int data_source_INAV = Rinex_Printer::toInt(iNAVE1B, 10);
|
||||
line += Rinex_Printer::doub2for(static_cast<double>(data_source_INAV), 18, 2);
|
||||
line += std::string(1, ' ');
|
||||
double GST_week = (double)(galileo_ephemeris_iter->second.WN_5);
|
||||
double GST_week = static_cast<double>(galileo_ephemeris_iter->second.WN_5);
|
||||
double num_GST_rollovers = floor((GST_week + 1024.0) / 4096.0 );
|
||||
double Galileo_week_continuous_number = GST_week + 1024.0 + num_GST_rollovers * 4096.0;
|
||||
line += Rinex_Printer::doub2for(Galileo_week_continuous_number, 18, 2);
|
||||
@ -2167,8 +2167,8 @@ void Rinex_Printer::log_rinex_obs(std::ofstream& out, Gps_Ephemeris eph, double
|
||||
pseudoranges_iter++)
|
||||
{
|
||||
line += satelliteSystem["GPS"];
|
||||
if ((int)pseudoranges_iter->first < 10) line += std::string(1, '0');
|
||||
line += boost::lexical_cast<std::string>((int)pseudoranges_iter->first);
|
||||
if (static_cast<int>(pseudoranges_iter->first) < 10) line += std::string(1, '0');
|
||||
line += boost::lexical_cast<std::string>(static_cast<int>(pseudoranges_iter->first));
|
||||
}
|
||||
// Receiver clock offset (optional)
|
||||
//line += rightJustify(asString(clockOffset, 12), 15);
|
||||
@ -2263,8 +2263,8 @@ void Rinex_Printer::log_rinex_obs(std::ofstream& out, Gps_Ephemeris eph, double
|
||||
std::string lineObs;
|
||||
lineObs.clear();
|
||||
lineObs += satelliteSystem["GPS"];
|
||||
if ((int)pseudoranges_iter->first < 10) lineObs += std::string(1, '0');
|
||||
lineObs += boost::lexical_cast<std::string>((int)pseudoranges_iter->first);
|
||||
if (static_cast<int>(pseudoranges_iter->first) < 10) lineObs += std::string(1, '0');
|
||||
lineObs += boost::lexical_cast<std::string>(static_cast<int>(pseudoranges_iter->first));
|
||||
//lineObs += std::string(2, ' ');
|
||||
lineObs += Rinex_Printer::rightJustify(asString(pseudoranges_iter->second.Pseudorange_m, 3), 14);
|
||||
|
||||
@ -2364,8 +2364,8 @@ void Rinex_Printer::log_rinex_obs(std::ofstream& out, Galileo_Ephemeris eph, dou
|
||||
std::string lineObs;
|
||||
lineObs.clear();
|
||||
lineObs += satelliteSystem["Galileo"];
|
||||
if ((int)pseudoranges_iter->first < 10) lineObs += std::string(1, '0');
|
||||
lineObs += boost::lexical_cast<std::string>((int)pseudoranges_iter->first);
|
||||
if (static_cast<int>(pseudoranges_iter->first) < 10) lineObs += std::string(1, '0');
|
||||
lineObs += boost::lexical_cast<std::string>(static_cast<int>(pseudoranges_iter->first));
|
||||
//lineObs += std::string(2, ' ');
|
||||
lineObs += Rinex_Printer::rightJustify(asString(pseudoranges_iter->second.Pseudorange_m, 3), 14);
|
||||
|
||||
@ -2460,8 +2460,8 @@ void Rinex_Printer::log_rinex_obs(std::ofstream& out, Gps_Ephemeris gps_eph, Gal
|
||||
s.assign(1, pseudoranges_iter->second.System);
|
||||
if(s.compare("G") == 0) lineObs += satelliteSystem["GPS"];
|
||||
if(s.compare("E") == 0) lineObs += satelliteSystem["Galileo"];
|
||||
if ((int)pseudoranges_iter->first < 10) lineObs += std::string(1, '0');
|
||||
lineObs += boost::lexical_cast<std::string>((int)pseudoranges_iter->first);
|
||||
if (static_cast<int>(pseudoranges_iter->first) < 10) lineObs += std::string(1, '0');
|
||||
lineObs += boost::lexical_cast<std::string>(static_cast<int>(pseudoranges_iter->first));
|
||||
lineObs += Rinex_Printer::rightJustify(asString(pseudoranges_iter->second.Pseudorange_m, 3), 14);
|
||||
|
||||
//Loss of lock indicator (LLI)
|
||||
@ -2658,7 +2658,7 @@ boost::posix_time::ptime Rinex_Printer::compute_UTC_time(Gps_Navigation_Message
|
||||
// if we are processing a file -> wait to leap second to resolve the ambiguity else take the week from the local system time
|
||||
//: idea resolve the ambiguity with the leap second http://www.colorado.edu/geography/gcraft/notes/gps/gpseow.htm
|
||||
double utc_t = nav_msg.utc_time(nav_msg.d_TOW);
|
||||
boost::posix_time::time_duration t = boost::posix_time::millisec((utc_t + 604800*(double)(nav_msg.i_GPS_week))*1000);
|
||||
boost::posix_time::time_duration t = boost::posix_time::millisec((utc_t + 604800 * static_cast<double>(nav_msg.i_GPS_week)) * 1000);
|
||||
boost::posix_time::ptime p_time(boost::gregorian::date(1999, 8, 22), t);
|
||||
return p_time;
|
||||
}
|
||||
@ -2671,7 +2671,7 @@ boost::posix_time::ptime Rinex_Printer::compute_GPS_time(Gps_Ephemeris eph, doub
|
||||
// (see Pag. 17 in http://igscb.jpl.nasa.gov/igscb/data/format/rinex300.pdf)
|
||||
// --??? No time correction here, since it will be done in the RINEX processor
|
||||
double gps_t = obs_time;
|
||||
boost::posix_time::time_duration t = boost::posix_time::millisec((gps_t + 604800*(double)(eph.i_GPS_week % 1024))*1000);
|
||||
boost::posix_time::time_duration t = boost::posix_time::millisec((gps_t + 604800 * static_cast<double>(eph.i_GPS_week % 1024)) * 1000);
|
||||
boost::posix_time::ptime p_time(boost::gregorian::date(1999, 8, 22), t);
|
||||
return p_time;
|
||||
}
|
||||
@ -2683,7 +2683,7 @@ boost::posix_time::ptime Rinex_Printer::compute_Galileo_time(Galileo_Ephemeris e
|
||||
// (see Pag. 17 in http://igscb.jpl.nasa.gov/igscb/data/format/rinex301.pdf)
|
||||
// --??? No time correction here, since it will be done in the RINEX processor
|
||||
double galileo_t = obs_time;
|
||||
boost::posix_time::time_duration t = boost::posix_time::millisec((galileo_t + 604800*(double)(eph.WN_5))*1000); //
|
||||
boost::posix_time::time_duration t = boost::posix_time::millisec((galileo_t + 604800 * static_cast<double>(eph.WN_5)) * 1000); //
|
||||
boost::posix_time::ptime p_time(boost::gregorian::date(1999, 8, 22), t);
|
||||
return p_time;
|
||||
}
|
||||
|
||||
@ -277,7 +277,7 @@ std::string Rtcm_Printer::print_M1005_test ()
|
||||
{
|
||||
std::bitset<152> m1005 = get_M1005_test();
|
||||
unsigned int msg_length_bits = m1005.to_string().length();
|
||||
unsigned int msg_length_bytes = std::ceil((float)msg_length_bits / 8.0);
|
||||
unsigned int msg_length_bytes = std::ceil(static_cast<float>(msg_length_bits) / 8.0);
|
||||
message_length = std::bitset<10>(msg_length_bytes);
|
||||
unsigned int zeros_to_fill = 8*msg_length_bytes - msg_length_bits;
|
||||
std::string b(zeros_to_fill, '0');
|
||||
@ -313,11 +313,11 @@ void Rtcm_Printer::print_M1001 ()
|
||||
{
|
||||
std::bitset<122> m1001 = get_M1001();
|
||||
unsigned int msg_length_bits = m1001.to_string().length();
|
||||
unsigned int msg_length_bytes = std::ceil((float)msg_length_bits/8.0);
|
||||
unsigned int msg_length_bytes = std::ceil(static_cast<float>(msg_length_bits) / 8.0);
|
||||
message_length = std::bitset<10>(msg_length_bytes);
|
||||
unsigned int zeros_to_fill = 8*msg_length_bytes - msg_length_bits;
|
||||
std::string b(zeros_to_fill, '0');
|
||||
message_length = std::bitset<10>((int)msg_length_bytes);
|
||||
message_length = std::bitset<10>(static_cast<int>(msg_length_bytes));
|
||||
std::string msg_content = m1001.to_string() + b;
|
||||
std::string msg_without_crc = preamble.to_string() +
|
||||
reserved_field.to_string() +
|
||||
|
||||
@ -28,12 +28,12 @@
|
||||
* -------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include <gnuradio/io_signature.h>
|
||||
#include "signal_generator_c.h"
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <stdlib.h>
|
||||
#include <gnuradio/io_signature.h>
|
||||
#include <volk/volk.h>
|
||||
#include "signal_generator_c.h"
|
||||
#include "gps_sdr_signal_processing.h"
|
||||
#include "galileo_e1_signal_processing.h"
|
||||
#include "nco_lib.h"
|
||||
@ -63,7 +63,7 @@ signal_generator_c::signal_generator_c (std::vector<std::string> signal1, std::v
|
||||
unsigned int fs_in, unsigned int vector_length, float BW_BB) :
|
||||
|
||||
gr::block ("signal_gen_cc", gr::io_signature::make(0, 0, sizeof(gr_complex)),
|
||||
gr::io_signature::make(1, 1, sizeof(gr_complex)*vector_length)),
|
||||
gr::io_signature::make(1, 1, sizeof(gr_complex) * vector_length)),
|
||||
signal_(signal1),
|
||||
system_(system),
|
||||
PRN_(PRN),
|
||||
@ -76,7 +76,7 @@ signal_generator_c::signal_generator_c (std::vector<std::string> signal1, std::v
|
||||
fs_in_(fs_in),
|
||||
num_sats_(PRN.size()),
|
||||
vector_length_(vector_length),
|
||||
BW_BB_(BW_BB*(float)fs_in/2.0)
|
||||
BW_BB_(BW_BB * static_cast<float>(fs_in) / 2.0)
|
||||
{
|
||||
init();
|
||||
generate_codes();
|
||||
@ -89,7 +89,7 @@ void signal_generator_c::init()
|
||||
complex_phase_ = static_cast<gr_complex*>(volk_malloc(vector_length_ * sizeof(gr_complex), volk_get_alignment()));
|
||||
|
||||
// True if Galileo satellites are present
|
||||
bool gallileo_signal = std::find(system_.begin(), system_.end(), "E") != system_.end();
|
||||
bool galileo_signal = std::find(system_.begin(), system_.end(), "E") != system_.end();
|
||||
|
||||
for (unsigned int sat = 0; sat < num_sats_; sat++)
|
||||
{
|
||||
@ -97,24 +97,23 @@ void signal_generator_c::init()
|
||||
current_data_bit_int_.push_back(1);
|
||||
current_data_bits_.push_back(gr_complex(1, 0));
|
||||
ms_counter_.push_back(0);
|
||||
data_modulation_.push_back((Galileo_E5a_I_SECONDARY_CODE.at(0)=='0' ? 1 : -1));
|
||||
pilot_modulation_.push_back((Galileo_E5a_Q_SECONDARY_CODE[PRN_[sat]].at(0)=='0' ? 1 : -1));
|
||||
|
||||
data_modulation_.push_back((Galileo_E5a_I_SECONDARY_CODE.at(0) == '0' ? 1 : -1));
|
||||
pilot_modulation_.push_back((Galileo_E5a_Q_SECONDARY_CODE[PRN_[sat]].at(0) == '0' ? 1 : -1));
|
||||
|
||||
if (system_[sat] == "G")
|
||||
{
|
||||
samples_per_code_.push_back(round((float)fs_in_
|
||||
samples_per_code_.push_back(round(static_cast<float>(fs_in_)
|
||||
/ (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS)));
|
||||
|
||||
num_of_codes_per_vector_.push_back(gallileo_signal ? 4*(int)Galileo_E1_C_SECONDARY_CODE_LENGTH : 1);
|
||||
data_bit_duration_ms_.push_back(1e3/GPS_CA_TELEMETRY_RATE_BITS_SECOND);
|
||||
num_of_codes_per_vector_.push_back(galileo_signal ? 4 * static_cast<int>(Galileo_E1_C_SECONDARY_CODE_LENGTH) : 1);
|
||||
data_bit_duration_ms_.push_back(1e3 / GPS_CA_TELEMETRY_RATE_BITS_SECOND);
|
||||
}
|
||||
else if (system_[sat] == "E")
|
||||
{
|
||||
if (signal_[sat].at(0)=='5')
|
||||
if (signal_[sat].at(0) == '5')
|
||||
{
|
||||
int codelen = (int)Galileo_E5a_CODE_LENGTH_CHIPS;
|
||||
samples_per_code_.push_back(round((float)fs_in_ / (Galileo_E5a_CODE_CHIP_RATE_HZ
|
||||
int codelen = static_cast<int>(Galileo_E5a_CODE_LENGTH_CHIPS);
|
||||
samples_per_code_.push_back(round(static_cast<float>(fs_in_) / (Galileo_E5a_CODE_CHIP_RATE_HZ
|
||||
/ codelen)));
|
||||
num_of_codes_per_vector_.push_back(1);
|
||||
|
||||
@ -122,18 +121,18 @@ void signal_generator_c::init()
|
||||
}
|
||||
else
|
||||
{
|
||||
samples_per_code_.push_back(round((float)fs_in_ / (Galileo_E1_CODE_CHIP_RATE_HZ
|
||||
samples_per_code_.push_back(round(static_cast<float>(fs_in_) / (Galileo_E1_CODE_CHIP_RATE_HZ
|
||||
/ Galileo_E1_B_CODE_LENGTH_CHIPS)));
|
||||
|
||||
num_of_codes_per_vector_.push_back((int)Galileo_E1_C_SECONDARY_CODE_LENGTH);
|
||||
data_bit_duration_ms_.push_back(1e3/Galileo_E1_B_SYMBOL_RATE_BPS);
|
||||
num_of_codes_per_vector_.push_back(static_cast<int>(Galileo_E1_C_SECONDARY_CODE_LENGTH));
|
||||
data_bit_duration_ms_.push_back(1e3 / Galileo_E1_B_SYMBOL_RATE_BPS);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
random_ = new gr::random();
|
||||
}
|
||||
|
||||
|
||||
void signal_generator_c::generate_codes()
|
||||
{
|
||||
sampled_code_data_.reset(new gr_complex*[num_sats_]);
|
||||
@ -141,17 +140,15 @@ void signal_generator_c::generate_codes()
|
||||
|
||||
for (unsigned int sat = 0; sat < num_sats_; sat++)
|
||||
{
|
||||
//if (posix_memalign((void**)&(sampled_code_data_[sat]), 16,
|
||||
// vector_length_ * sizeof(gr_complex)) == 0){};
|
||||
sampled_code_data_[sat] = static_cast<gr_complex*>(std::malloc(vector_length_ * sizeof(gr_complex)));
|
||||
|
||||
gr_complex code[64000];//[samples_per_code_[sat]];
|
||||
gr_complex code[64000]; //[samples_per_code_[sat]];
|
||||
|
||||
if (system_[sat] == "G")
|
||||
{
|
||||
// Generate one code-period of 1C signal
|
||||
gps_l1_ca_code_gen_complex_sampled(code, PRN_[sat], fs_in_,
|
||||
(int)GPS_L1_CA_CODE_LENGTH_CHIPS - delay_chips_[sat]);
|
||||
static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS) - delay_chips_[sat]);
|
||||
|
||||
// Obtain the desired CN0 assuming that Pn = 1.
|
||||
if (noise_flag_)
|
||||
@ -165,19 +162,19 @@ void signal_generator_c::generate_codes()
|
||||
// Concatenate "num_of_codes_per_vector_" codes
|
||||
for (unsigned int i = 0; i < num_of_codes_per_vector_[sat]; i++)
|
||||
{
|
||||
memcpy(&(sampled_code_data_[sat][i*samples_per_code_[sat]]),
|
||||
code, sizeof(gr_complex)*samples_per_code_[sat]);
|
||||
memcpy(&(sampled_code_data_[sat][i * samples_per_code_[sat]]),
|
||||
code, sizeof(gr_complex) * samples_per_code_[sat]);
|
||||
}
|
||||
}
|
||||
else if (system_[sat] == "E")
|
||||
{
|
||||
if(signal_[sat].at(0)=='5')
|
||||
if(signal_[sat].at(0) == '5')
|
||||
{
|
||||
char signal[3];
|
||||
strcpy(signal,"5X");
|
||||
strcpy(signal, "5X");
|
||||
|
||||
galileo_e5_a_code_gen_complex_sampled(sampled_code_data_[sat] , signal, PRN_[sat], fs_in_,
|
||||
(int)Galileo_E5a_CODE_LENGTH_CHIPS-delay_chips_[sat]);
|
||||
static_cast<int>(Galileo_E5a_CODE_LENGTH_CHIPS) - delay_chips_[sat]);
|
||||
//noise
|
||||
if (noise_flag_)
|
||||
{
|
||||
@ -195,7 +192,7 @@ void signal_generator_c::generate_codes()
|
||||
strcpy(signal, "1B");
|
||||
|
||||
galileo_e1_code_gen_complex_sampled(code, signal, cboc, PRN_[sat], fs_in_,
|
||||
(int)Galileo_E1_B_CODE_LENGTH_CHIPS - delay_chips_[sat]);
|
||||
static_cast<int>(Galileo_E1_B_CODE_LENGTH_CHIPS) - delay_chips_[sat]);
|
||||
|
||||
// Obtain the desired CN0 assuming that Pn = 1.
|
||||
if (noise_flag_)
|
||||
@ -209,8 +206,8 @@ void signal_generator_c::generate_codes()
|
||||
// Concatenate "num_of_codes_per_vector_" codes
|
||||
for (unsigned int i = 0; i < num_of_codes_per_vector_[sat]; i++)
|
||||
{
|
||||
memcpy(&(sampled_code_data_[sat][i*samples_per_code_[sat]]),
|
||||
code, sizeof(gr_complex)*samples_per_code_[sat]);
|
||||
memcpy(&(sampled_code_data_[sat][i * samples_per_code_[sat]]),
|
||||
code, sizeof(gr_complex) * samples_per_code_[sat]);
|
||||
}
|
||||
|
||||
// Generate E1C signal (25 code-periods, with secondary code)
|
||||
@ -219,7 +216,7 @@ void signal_generator_c::generate_codes()
|
||||
strcpy(signal, "1C");
|
||||
|
||||
galileo_e1_code_gen_complex_sampled(sampled_code_pilot_[sat], signal, cboc, PRN_[sat], fs_in_,
|
||||
(int)Galileo_E1_B_CODE_LENGTH_CHIPS-delay_chips_[sat], true);
|
||||
static_cast<int>(Galileo_E1_B_CODE_LENGTH_CHIPS) - delay_chips_[sat], true);
|
||||
|
||||
// Obtain the desired CN0 assuming that Pn = 1.
|
||||
if (noise_flag_)
|
||||
@ -271,7 +268,7 @@ gr_vector_void_star &output_items)
|
||||
|
||||
for (unsigned int sat = 0; sat < num_sats_; sat++)
|
||||
{
|
||||
float phase_step_rad = -(float)GPS_TWO_PI*doppler_Hz_[sat] / (float)fs_in_;
|
||||
float phase_step_rad = -static_cast<float>(GPS_TWO_PI) * doppler_Hz_[sat] / static_cast<float>(fs_in_);
|
||||
fxp_nco(complex_phase_, vector_length_, start_phase_rad_[sat], phase_step_rad);
|
||||
start_phase_rad_[sat] += vector_length_ * phase_step_rad;
|
||||
|
||||
@ -279,7 +276,7 @@ gr_vector_void_star &output_items)
|
||||
|
||||
if (system_[sat] == "G")
|
||||
{
|
||||
unsigned int delay_samples = (delay_chips_[sat] % (int)GPS_L1_CA_CODE_LENGTH_CHIPS)
|
||||
unsigned int delay_samples = (delay_chips_[sat] % static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS))
|
||||
* samples_per_code_[sat] / GPS_L1_CA_CODE_LENGTH_CHIPS;
|
||||
|
||||
for (i = 0; i < num_of_codes_per_vector_[sat]; i++)
|
||||
@ -295,7 +292,7 @@ gr_vector_void_star &output_items)
|
||||
if (ms_counter_[sat] == 0 && data_flag_)
|
||||
{
|
||||
// New random data bit
|
||||
current_data_bits_[sat] = gr_complex((rand()%2) == 0 ? 1 : -1, 0);
|
||||
current_data_bits_[sat] = gr_complex((rand() % 2) == 0 ? 1 : -1, 0);
|
||||
}
|
||||
|
||||
for (k = delay_samples; k < samples_per_code_[sat]; k++)
|
||||
@ -306,7 +303,7 @@ gr_vector_void_star &output_items)
|
||||
out_idx++;
|
||||
}
|
||||
|
||||
ms_counter_[sat] = (ms_counter_[sat] + (int)round(1e3*GPS_L1_CA_CODE_PERIOD))
|
||||
ms_counter_[sat] = (ms_counter_[sat] + static_cast<int>(round(1e3*GPS_L1_CA_CODE_PERIOD)))
|
||||
% data_bit_duration_ms_[sat];
|
||||
}
|
||||
}
|
||||
@ -316,12 +313,12 @@ gr_vector_void_star &output_items)
|
||||
if(signal_[sat].at(0)=='5')
|
||||
{
|
||||
// EACH WORK outputs 1 modulated primary code
|
||||
int codelen = (int)Galileo_E5a_CODE_LENGTH_CHIPS;
|
||||
int codelen = static_cast<int>(Galileo_E5a_CODE_LENGTH_CHIPS);
|
||||
unsigned int delay_samples = (delay_chips_[sat] % codelen)
|
||||
* samples_per_code_[sat] / codelen;
|
||||
for (k = 0; k < delay_samples; k++)
|
||||
{
|
||||
out[out_idx] += (gr_complex(sampled_code_data_[sat][out_idx].real()*data_modulation_[sat] ,
|
||||
out[out_idx] += (gr_complex(sampled_code_data_[sat][out_idx].real()*data_modulation_[sat],
|
||||
sampled_code_data_[sat][out_idx].imag()*pilot_modulation_[sat]) )
|
||||
* complex_phase_[out_idx];
|
||||
out_idx++;
|
||||
@ -333,22 +330,21 @@ gr_vector_void_star &output_items)
|
||||
current_data_bit_int_[sat] = (rand()%2) == 0 ? 1 : -1;
|
||||
}
|
||||
data_modulation_[sat] = current_data_bit_int_[sat] * (Galileo_E5a_I_SECONDARY_CODE.at((ms_counter_[sat]+delay_sec_[sat])%20)=='0' ? 1 : -1);
|
||||
pilot_modulation_[sat] = (Galileo_E5a_Q_SECONDARY_CODE[PRN_[sat]-1].at((ms_counter_[sat]+delay_sec_[sat])%100)=='0' ? 1 : -1);
|
||||
pilot_modulation_[sat] = (Galileo_E5a_Q_SECONDARY_CODE[PRN_[sat] - 1].at((ms_counter_[sat] + delay_sec_[sat]) % 100)=='0' ? 1 : -1);
|
||||
|
||||
ms_counter_[sat] = ms_counter_[sat] + (int)round(1e3*GALILEO_E5a_CODE_PERIOD);
|
||||
ms_counter_[sat] = ms_counter_[sat] + static_cast<int>(round(1e3*GALILEO_E5a_CODE_PERIOD));
|
||||
|
||||
for (k = delay_samples; k < samples_per_code_[sat]; k++)
|
||||
{
|
||||
out[out_idx] += (gr_complex(sampled_code_data_[sat][out_idx].real()*data_modulation_[sat] ,
|
||||
sampled_code_data_[sat][out_idx].imag()*pilot_modulation_[sat]) )
|
||||
* complex_phase_[out_idx];
|
||||
out[out_idx] += (gr_complex(sampled_code_data_[sat][out_idx].real() * data_modulation_[sat] ,
|
||||
sampled_code_data_[sat][out_idx].imag() * pilot_modulation_[sat]) )
|
||||
* complex_phase_[out_idx];
|
||||
out_idx++;
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned int delay_samples = (delay_chips_[sat] % (int)Galileo_E1_B_CODE_LENGTH_CHIPS)
|
||||
unsigned int delay_samples = (delay_chips_[sat] % static_cast<int>(Galileo_E1_B_CODE_LENGTH_CHIPS))
|
||||
* samples_per_code_[sat] / Galileo_E1_B_CODE_LENGTH_CHIPS;
|
||||
|
||||
for (i = 0; i < num_of_codes_per_vector_[sat]; i++)
|
||||
@ -356,29 +352,25 @@ gr_vector_void_star &output_items)
|
||||
for (k = 0; k < delay_samples; k++)
|
||||
{
|
||||
out[out_idx] += (sampled_code_data_[sat][out_idx] * current_data_bits_[sat]
|
||||
- sampled_code_pilot_[sat][out_idx])
|
||||
* complex_phase_[out_idx];
|
||||
- sampled_code_pilot_[sat][out_idx]) * complex_phase_[out_idx];
|
||||
out_idx++;
|
||||
}
|
||||
|
||||
if (ms_counter_[sat] == 0 && data_flag_)
|
||||
{
|
||||
// New random data bit
|
||||
current_data_bits_[sat] = gr_complex((rand()%2) == 0 ? 1 : -1, 0);
|
||||
current_data_bits_[sat] = gr_complex((rand() % 2) == 0 ? 1 : -1, 0);
|
||||
}
|
||||
|
||||
for (k = delay_samples; k < samples_per_code_[sat]; k++)
|
||||
{
|
||||
out[out_idx] += (sampled_code_data_[sat][out_idx] * current_data_bits_[sat]
|
||||
- sampled_code_pilot_[sat][out_idx])
|
||||
* complex_phase_[out_idx];
|
||||
- sampled_code_pilot_[sat][out_idx])
|
||||
* complex_phase_[out_idx];
|
||||
out_idx++;
|
||||
}
|
||||
|
||||
|
||||
ms_counter_[sat] = (ms_counter_[sat] + (int)round(1e3*Galileo_E1_CODE_PERIOD))
|
||||
% data_bit_duration_ms_[sat];
|
||||
|
||||
ms_counter_[sat] = (ms_counter_[sat] + static_cast<int>(round(1e3 * Galileo_E1_CODE_PERIOD))) % data_bit_duration_ms_[sat];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -194,8 +194,8 @@ Galileo_Fnav_Message::Galileo_Fnav_Message()
|
||||
//}
|
||||
void Galileo_Fnav_Message::split_page(std::string page_string)
|
||||
{
|
||||
std::string message_word = page_string.substr(0,214);
|
||||
std::string CRC_data = page_string.substr(214,24);
|
||||
std::string message_word = page_string.substr(0, 214);
|
||||
std::string CRC_data = page_string.substr(214, 24);
|
||||
std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> Word_for_CRC_bits(message_word);
|
||||
std::bitset<24> checksum(CRC_data);
|
||||
if (_CRC_test(Word_for_CRC_bits, checksum.to_ulong()) == true)
|
||||
@ -210,7 +210,7 @@ void Galileo_Fnav_Message::split_page(std::string page_string)
|
||||
}
|
||||
}
|
||||
|
||||
bool Galileo_Fnav_Message::_CRC_test(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> bits,boost::uint32_t checksum)
|
||||
bool Galileo_Fnav_Message::_CRC_test(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> bits, boost::uint32_t checksum)
|
||||
{
|
||||
CRC_Galileo_FNAV_type CRC_Galileo;
|
||||
|
||||
@ -225,7 +225,7 @@ bool Galileo_Fnav_Message::_CRC_test(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> b
|
||||
|
||||
std::vector<unsigned char> bytes;
|
||||
boost::to_block_range(frame_bits, std::back_inserter(bytes));
|
||||
std::reverse(bytes.begin(),bytes.end());
|
||||
std::reverse(bytes.begin(), bytes.end());
|
||||
|
||||
CRC_Galileo.process_bytes( bytes.data(), GALILEO_FNAV_DATA_FRAME_BYTES );
|
||||
|
||||
@ -242,206 +242,206 @@ bool Galileo_Fnav_Message::_CRC_test(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> b
|
||||
void Galileo_Fnav_Message::decode_page(std::string data)
|
||||
{
|
||||
std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> data_bits(data);
|
||||
page_type = read_navigation_unsigned(data_bits,FNAV_PAGE_TYPE_bit);
|
||||
page_type = read_navigation_unsigned(data_bits, FNAV_PAGE_TYPE_bit);
|
||||
switch(page_type)
|
||||
{
|
||||
case 1: // SVID, Clock correction, SISA, Ionospheric correction, BGD, GST, Signal health and Data validity status
|
||||
FNAV_SV_ID_PRN_1=(int)read_navigation_unsigned(data_bits,FNAV_SV_ID_PRN_1_bit);
|
||||
FNAV_IODnav_1=(int)read_navigation_unsigned(data_bits,FNAV_IODnav_1_bit);
|
||||
FNAV_t0c_1=(double)read_navigation_unsigned(data_bits,FNAV_t0c_1_bit);
|
||||
FNAV_SV_ID_PRN_1 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_SV_ID_PRN_1_bit));
|
||||
FNAV_IODnav_1 =static_cast<int>(read_navigation_unsigned(data_bits, FNAV_IODnav_1_bit));
|
||||
FNAV_t0c_1 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_t0c_1_bit));
|
||||
FNAV_t0c_1 *= FNAV_t0c_1_LSB;
|
||||
FNAV_af0_1=(double)read_navigation_signed(data_bits,FNAV_af0_1_bit);
|
||||
FNAV_af0_1 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af0_1_bit));
|
||||
FNAV_af0_1 *= FNAV_af0_1_LSB;
|
||||
FNAV_af1_1=(double)read_navigation_signed(data_bits,FNAV_af1_1_bit);
|
||||
FNAV_af1_1 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af1_1_bit));
|
||||
FNAV_af1_1 *= FNAV_af1_1_LSB;
|
||||
FNAV_af2_1=(double)read_navigation_signed(data_bits,FNAV_af2_1_bit);
|
||||
FNAV_af2_1 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af2_1_bit));
|
||||
FNAV_af2_1 *= FNAV_af2_1_LSB;
|
||||
FNAV_SISA_1=(double)read_navigation_unsigned(data_bits,FNAV_SISA_1_bit);
|
||||
FNAV_ai0_1=(double)read_navigation_unsigned(data_bits,FNAV_ai0_1_bit);
|
||||
FNAV_SISA_1 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_SISA_1_bit));
|
||||
FNAV_ai0_1 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_ai0_1_bit));
|
||||
FNAV_ai0_1 *= FNAV_ai0_1_LSB;
|
||||
FNAV_ai1_1=(double)read_navigation_signed(data_bits,FNAV_ai1_1_bit);
|
||||
FNAV_ai1_1 = static_cast<double>(read_navigation_signed(data_bits, FNAV_ai1_1_bit));
|
||||
FNAV_ai1_1 *= FNAV_ai1_1_LSB;
|
||||
FNAV_ai2_1=(double)read_navigation_signed(data_bits,FNAV_ai2_1_bit);
|
||||
FNAV_ai2_1 = static_cast<double>(read_navigation_signed(data_bits, FNAV_ai2_1_bit));
|
||||
FNAV_ai2_1 *= FNAV_ai2_1_LSB;
|
||||
FNAV_region1_1=(bool)read_navigation_unsigned(data_bits,FNAV_region1_1_bit);
|
||||
FNAV_region2_1=(bool)read_navigation_unsigned(data_bits,FNAV_region2_1_bit);
|
||||
FNAV_region3_1=(bool)read_navigation_unsigned(data_bits,FNAV_region3_1_bit);
|
||||
FNAV_region4_1=(bool)read_navigation_unsigned(data_bits,FNAV_region4_1_bit);
|
||||
FNAV_region5_1=(bool)read_navigation_unsigned(data_bits,FNAV_region5_1_bit);
|
||||
FNAV_BGD_1=(double)read_navigation_signed(data_bits,FNAV_BGD_1_bit);
|
||||
FNAV_region1_1 = static_cast<bool>(read_navigation_unsigned(data_bits, FNAV_region1_1_bit));
|
||||
FNAV_region2_1 = static_cast<bool>(read_navigation_unsigned(data_bits, FNAV_region2_1_bit));
|
||||
FNAV_region3_1 = static_cast<bool>(read_navigation_unsigned(data_bits, FNAV_region3_1_bit));
|
||||
FNAV_region4_1 = static_cast<bool>(read_navigation_unsigned(data_bits, FNAV_region4_1_bit));
|
||||
FNAV_region5_1 = static_cast<bool>(read_navigation_unsigned(data_bits, FNAV_region5_1_bit));
|
||||
FNAV_BGD_1 = static_cast<double>(read_navigation_signed(data_bits, FNAV_BGD_1_bit));
|
||||
FNAV_BGD_1 *= FNAV_BGD_1_LSB;
|
||||
FNAV_E5ahs_1=(double)read_navigation_unsigned(data_bits,FNAV_E5ahs_1_bit);
|
||||
FNAV_WN_1=(double)read_navigation_unsigned(data_bits,FNAV_WN_1_bit);
|
||||
FNAV_TOW_1=(double)read_navigation_unsigned(data_bits,FNAV_TOW_1_bit);
|
||||
FNAV_E5advs_1=(double)read_navigation_unsigned(data_bits,FNAV_E5advs_1_bit);
|
||||
FNAV_E5ahs_1 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_E5ahs_1_bit));
|
||||
FNAV_WN_1 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_WN_1_bit));
|
||||
FNAV_TOW_1 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_TOW_1_bit));
|
||||
FNAV_E5advs_1 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_E5advs_1_bit));
|
||||
|
||||
flag_TOW_1=true;
|
||||
flag_TOW_set=true;
|
||||
flag_iono_and_GST = true; //set to false externally
|
||||
flag_TOW_1 = true;
|
||||
flag_TOW_set = true;
|
||||
flag_iono_and_GST = true; //set to false externally
|
||||
break;
|
||||
case 2: // Ephemeris (1/3) and GST
|
||||
FNAV_IODnav_2=(int)read_navigation_unsigned(data_bits,FNAV_IODnav_2_bit);
|
||||
FNAV_M0_2=(double)read_navigation_unsigned(data_bits,FNAV_M0_2_bit);
|
||||
FNAV_IODnav_2 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_IODnav_2_bit));
|
||||
FNAV_M0_2 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_M0_2_bit));
|
||||
FNAV_M0_2 *= FNAV_M0_2_LSB;
|
||||
FNAV_omegadot_2=(double)read_navigation_signed(data_bits,FNAV_omegadot_2_bit);
|
||||
FNAV_omegadot_2 = static_cast<double>(read_navigation_signed(data_bits, FNAV_omegadot_2_bit));
|
||||
FNAV_omegadot_2 *= FNAV_omegadot_2_LSB;
|
||||
FNAV_e_2=(double)read_navigation_unsigned(data_bits,FNAV_e_2_bit);
|
||||
FNAV_e_2 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_e_2_bit));
|
||||
FNAV_e_2 *= FNAV_e_2_LSB;
|
||||
FNAV_a12_2=(double)read_navigation_unsigned(data_bits,FNAV_a12_2_bit);
|
||||
FNAV_a12_2 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_a12_2_bit));
|
||||
FNAV_a12_2 *= FNAV_a12_2_LSB;
|
||||
FNAV_omega0_2=(double)read_navigation_signed(data_bits,FNAV_omega0_2_bit);
|
||||
FNAV_omega0_2 = static_cast<double>(read_navigation_signed(data_bits, FNAV_omega0_2_bit));
|
||||
FNAV_omega0_2 *= FNAV_omega0_2_LSB;
|
||||
FNAV_idot_2=(double)read_navigation_signed(data_bits,FNAV_idot_2_bit);
|
||||
FNAV_idot_2 = static_cast<double>(read_navigation_signed(data_bits, FNAV_idot_2_bit));
|
||||
FNAV_idot_2 *= FNAV_idot_2_LSB;
|
||||
FNAV_WN_2=(double)read_navigation_unsigned(data_bits,FNAV_WN_2_bit);
|
||||
FNAV_TOW_2=(double)read_navigation_unsigned(data_bits,FNAV_TOW_2_bit);
|
||||
FNAV_WN_2 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_WN_2_bit));
|
||||
FNAV_TOW_2 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_TOW_2_bit));
|
||||
|
||||
flag_TOW_2=true;
|
||||
flag_TOW_set=true;
|
||||
flag_ephemeris_1=true;
|
||||
flag_TOW_2 = true;
|
||||
flag_TOW_set = true;
|
||||
flag_ephemeris_1 = true;
|
||||
break;
|
||||
case 3: // Ephemeris (2/3) and GST
|
||||
FNAV_IODnav_3=(int)read_navigation_unsigned(data_bits,FNAV_IODnav_3_bit);
|
||||
FNAV_i0_3=(double)read_navigation_signed(data_bits,FNAV_i0_3_bit);
|
||||
FNAV_IODnav_3 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_IODnav_3_bit));
|
||||
FNAV_i0_3 = static_cast<double>(read_navigation_signed(data_bits, FNAV_i0_3_bit));
|
||||
FNAV_i0_3 *= FNAV_i0_3_LSB;
|
||||
FNAV_w_3=(double)read_navigation_signed(data_bits,FNAV_w_3_bit);
|
||||
FNAV_w_3=static_cast<double>(read_navigation_signed(data_bits, FNAV_w_3_bit));
|
||||
FNAV_w_3 *= FNAV_w_3_LSB;
|
||||
FNAV_deltan_3=(double)read_navigation_unsigned(data_bits,FNAV_deltan_3_bit);
|
||||
FNAV_deltan_3 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_deltan_3_bit));
|
||||
FNAV_deltan_3 *= FNAV_deltan_3_LSB;
|
||||
FNAV_Cuc_3=(double)read_navigation_signed(data_bits,FNAV_Cuc_3_bit);
|
||||
FNAV_Cuc_3 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Cuc_3_bit));
|
||||
FNAV_Cuc_3 *= FNAV_Cuc_3_LSB;
|
||||
FNAV_Cus_3=(double)read_navigation_signed(data_bits,FNAV_Cus_3_bit);
|
||||
FNAV_Cus_3 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Cus_3_bit));
|
||||
FNAV_Cus_3 *= FNAV_Cus_3_LSB;
|
||||
FNAV_Crc_3=(double)read_navigation_signed(data_bits,FNAV_Crc_3_bit);
|
||||
FNAV_Crc_3 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Crc_3_bit));
|
||||
FNAV_Crc_3 *= FNAV_Crc_3_LSB;
|
||||
FNAV_Crs_3=(double)read_navigation_signed(data_bits,FNAV_Crs_3_bit);
|
||||
FNAV_Crs_3 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Crs_3_bit));
|
||||
FNAV_Crs_3 *= FNAV_Crs_3_LSB;
|
||||
FNAV_t0e_3=(double)read_navigation_unsigned(data_bits,FNAV_t0e_3_bit);
|
||||
FNAV_t0e_3 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_t0e_3_bit));
|
||||
FNAV_t0e_3 *= FNAV_t0e_3_LSB;
|
||||
FNAV_WN_3=(double)read_navigation_unsigned(data_bits,FNAV_WN_3_bit);
|
||||
FNAV_TOW_3=(double)read_navigation_unsigned(data_bits,FNAV_TOW_3_bit);
|
||||
FNAV_WN_3 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_WN_3_bit));
|
||||
FNAV_TOW_3 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_TOW_3_bit));
|
||||
|
||||
flag_TOW_3=true;
|
||||
flag_TOW_set=true;
|
||||
flag_ephemeris_2=true;
|
||||
flag_TOW_3 = true;
|
||||
flag_TOW_set = true;
|
||||
flag_ephemeris_2 = true;
|
||||
break;
|
||||
case 4: // Ephemeris (3/3), GST-UTC conversion, GST-GPS conversion and TOW
|
||||
FNAV_IODnav_4=(int)read_navigation_unsigned(data_bits,FNAV_IODnav_4_bit);
|
||||
FNAV_Cic_4=(double)read_navigation_unsigned(data_bits,FNAV_Cic_4_bit);
|
||||
case 4: // Ephemeris (3/3), GST-UTC conversion, GST-GPS conversion and TOW
|
||||
FNAV_IODnav_4 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_IODnav_4_bit));
|
||||
FNAV_Cic_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_Cic_4_bit));
|
||||
FNAV_Cic_4 *= FNAV_Cic_4_LSB;
|
||||
FNAV_Cis_4=(double)read_navigation_unsigned(data_bits,FNAV_Cis_4_bit);
|
||||
FNAV_Cis_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_Cis_4_bit));
|
||||
FNAV_Cis_4 *= FNAV_Cis_4_LSB;
|
||||
FNAV_A0_4=(double)read_navigation_unsigned(data_bits,FNAV_A0_4_bit);
|
||||
FNAV_A0_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_A0_4_bit));
|
||||
FNAV_A0_4 *= FNAV_A0_4_LSB;
|
||||
FNAV_A1_4=(double)read_navigation_unsigned(data_bits,FNAV_A1_4_bit);
|
||||
FNAV_A1_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_A1_4_bit));
|
||||
FNAV_A1_4 *= FNAV_A1_4_LSB;
|
||||
FNAV_deltatls_4=(double)read_navigation_signed(data_bits,FNAV_deltatls_4_bit);
|
||||
FNAV_t0t_4=(double)read_navigation_unsigned(data_bits,FNAV_t0t_4_bit);
|
||||
FNAV_deltatls_4 = static_cast<double>(read_navigation_signed(data_bits, FNAV_deltatls_4_bit));
|
||||
FNAV_t0t_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_t0t_4_bit));
|
||||
FNAV_t0t_4 *= FNAV_t0t_4_LSB;
|
||||
FNAV_WNot_4=(double)read_navigation_unsigned(data_bits,FNAV_WNot_4_bit);
|
||||
FNAV_WNlsf_4=(double)read_navigation_unsigned(data_bits,FNAV_WNlsf_4_bit);
|
||||
FNAV_DN_4=(double)read_navigation_unsigned(data_bits,FNAV_DN_4_bit);
|
||||
FNAV_deltatlsf_4=(double)read_navigation_signed(data_bits,FNAV_deltatlsf_4_bit);
|
||||
FNAV_t0g_4=(double)read_navigation_unsigned(data_bits,FNAV_t0g_4_bit);
|
||||
FNAV_WNot_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_WNot_4_bit));
|
||||
FNAV_WNlsf_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_WNlsf_4_bit));
|
||||
FNAV_DN_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_DN_4_bit));
|
||||
FNAV_deltatlsf_4 = static_cast<double>(read_navigation_signed(data_bits, FNAV_deltatlsf_4_bit));
|
||||
FNAV_t0g_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_t0g_4_bit));
|
||||
FNAV_t0g_4 *= FNAV_t0g_4_LSB;
|
||||
FNAV_A0g_4=(double)read_navigation_signed(data_bits,FNAV_A0g_4_bit);
|
||||
FNAV_A0g_4 = static_cast<double>(read_navigation_signed(data_bits, FNAV_A0g_4_bit));
|
||||
FNAV_A0g_4 *= FNAV_A0g_4_LSB;
|
||||
FNAV_A1g_4=(double)read_navigation_signed(data_bits,FNAV_A1g_4_bit);
|
||||
FNAV_A1g_4 = static_cast<double>(read_navigation_signed(data_bits, FNAV_A1g_4_bit));
|
||||
FNAV_A1g_4 *= FNAV_A1g_4_LSB;
|
||||
FNAV_WN0g_4=(double)read_navigation_unsigned(data_bits,FNAV_WN0g_4_bit);
|
||||
FNAV_TOW_4=(double)read_navigation_unsigned(data_bits,FNAV_TOW_4_bit);
|
||||
FNAV_WN0g_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_WN0g_4_bit));
|
||||
FNAV_TOW_4 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_TOW_4_bit));
|
||||
|
||||
flag_TOW_4=true;
|
||||
flag_TOW_set=true;
|
||||
flag_ephemeris_3=true;
|
||||
flag_TOW_4 = true;
|
||||
flag_TOW_set = true;
|
||||
flag_ephemeris_3 = true;
|
||||
flag_utc_model = true; //set to false externally
|
||||
break;
|
||||
case 5: // Almanac (SVID1 and SVID2(1/2)), Week Number and almanac reference time
|
||||
FNAV_IODa_5=(int)read_navigation_unsigned(data_bits,FNAV_IODa_5_bit);
|
||||
FNAV_WNa_5=(double)read_navigation_unsigned(data_bits,FNAV_WNa_5_bit);
|
||||
FNAV_t0a_5=(double)read_navigation_unsigned(data_bits,FNAV_t0a_5_bit);
|
||||
FNAV_IODa_5 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_IODa_5_bit));
|
||||
FNAV_WNa_5 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_WNa_5_bit));
|
||||
FNAV_t0a_5 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_t0a_5_bit));
|
||||
FNAV_t0a_5 *= FNAV_t0a_5_LSB;
|
||||
FNAV_SVID1_5=(int)read_navigation_unsigned(data_bits,FNAV_SVID1_5_bit);
|
||||
FNAV_Deltaa12_1_5=(double)read_navigation_signed(data_bits,FNAV_Deltaa12_1_5_bit);
|
||||
FNAV_SVID1_5 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_SVID1_5_bit));
|
||||
FNAV_Deltaa12_1_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Deltaa12_1_5_bit));
|
||||
FNAV_Deltaa12_1_5 *= FNAV_Deltaa12_5_LSB;
|
||||
FNAV_e_1_5=(double)read_navigation_unsigned(data_bits,FNAV_e_1_5_bit);
|
||||
FNAV_e_1_5 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_e_1_5_bit));
|
||||
FNAV_e_1_5 *= FNAV_e_5_LSB;
|
||||
FNAV_w_1_5=(double)read_navigation_signed(data_bits,FNAV_w_1_5_bit);
|
||||
FNAV_w_1_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_w_1_5_bit));
|
||||
FNAV_w_1_5 *= FNAV_w_5_LSB;
|
||||
FNAV_deltai_1_5=(double)read_navigation_signed(data_bits,FNAV_deltai_1_5_bit);
|
||||
FNAV_deltai_1_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_deltai_1_5_bit));
|
||||
FNAV_deltai_1_5 *= FNAV_deltai_5_LSB;
|
||||
FNAV_Omega0_1_5=(double)read_navigation_signed(data_bits,FNAV_Omega0_1_5_bit);
|
||||
FNAV_Omega0_1_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Omega0_1_5_bit));
|
||||
FNAV_Omega0_1_5 *= FNAV_Omega0_5_LSB;
|
||||
FNAV_Omegadot_1_5=(double)read_navigation_signed(data_bits,FNAV_Omegadot_1_5_bit);
|
||||
FNAV_Omegadot_1_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Omegadot_1_5_bit));
|
||||
FNAV_Omegadot_1_5 *= FNAV_Omegadot_5_LSB;
|
||||
FNAV_M0_1_5=(double)read_navigation_signed(data_bits,FNAV_M0_1_5_bit);
|
||||
FNAV_M0_1_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_M0_1_5_bit));
|
||||
FNAV_M0_1_5 *= FNAV_M0_5_LSB;
|
||||
FNAV_af0_1_5=(double)read_navigation_signed(data_bits,FNAV_af0_1_5_bit);
|
||||
FNAV_af0_1_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af0_1_5_bit));
|
||||
FNAV_af0_1_5 *= FNAV_af0_5_LSB;
|
||||
FNAV_af1_1_5=(double)read_navigation_signed(data_bits,FNAV_af1_1_5_bit);
|
||||
FNAV_af1_1_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af1_1_5_bit));
|
||||
FNAV_af1_1_5 *= FNAV_af1_5_LSB;
|
||||
FNAV_E5ahs_1_5=(double)read_navigation_unsigned(data_bits,FNAV_E5ahs_1_5_bit);
|
||||
FNAV_SVID2_5=(int)read_navigation_unsigned(data_bits,FNAV_SVID2_5_bit);
|
||||
FNAV_Deltaa12_2_5=(double)read_navigation_signed(data_bits,FNAV_Deltaa12_2_5_bit);
|
||||
FNAV_E5ahs_1_5 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_E5ahs_1_5_bit));
|
||||
FNAV_SVID2_5 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_SVID2_5_bit));
|
||||
FNAV_Deltaa12_2_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Deltaa12_2_5_bit));
|
||||
FNAV_Deltaa12_2_5 *= FNAV_Deltaa12_5_LSB;
|
||||
FNAV_e_2_5=(double)read_navigation_unsigned(data_bits,FNAV_e_2_5_bit);
|
||||
FNAV_e_2_5 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_e_2_5_bit));
|
||||
FNAV_e_2_5 *= FNAV_e_5_LSB;
|
||||
FNAV_w_2_5=(double)read_navigation_signed(data_bits,FNAV_w_2_5_bit);
|
||||
FNAV_w_2_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_w_2_5_bit));
|
||||
FNAV_w_2_5 *= FNAV_w_5_LSB;
|
||||
FNAV_deltai_2_5=(double)read_navigation_signed(data_bits,FNAV_deltai_2_5_bit);
|
||||
FNAV_deltai_2_5 = static_cast<double>(read_navigation_signed(data_bits, FNAV_deltai_2_5_bit));
|
||||
FNAV_deltai_2_5 *= FNAV_deltai_5_LSB;
|
||||
//TODO check this
|
||||
// Omega0_2 must be decoded when the two pieces are joined
|
||||
omega0_1=data.substr(210,4);
|
||||
omega0_1 = data.substr(210, 4);
|
||||
//omega_flag=true;
|
||||
//
|
||||
//FNAV_Omega012_2_5=(double)read_navigation_signed(data_bits,FNAV_Omega012_2_5_bit);
|
||||
//FNAV_Omega012_2_5=static_cast<double>(read_navigation_signed(data_bits, FNAV_Omega012_2_5_bit);
|
||||
|
||||
flag_almanac_1=true;
|
||||
flag_almanac_1 = true;
|
||||
break;
|
||||
case 6: // Almanac (SVID2(2/2) and SVID3)
|
||||
FNAV_IODa_6=(int)read_navigation_unsigned(data_bits,FNAV_IODa_6_bit);
|
||||
FNAV_IODa_6 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_IODa_6_bit));
|
||||
|
||||
/* Don't worry about omega pieces. If page 5 has not been received, all_ephemeris
|
||||
* flag will be set to false and the data won't be recorded.*/
|
||||
std::string omega0_2 = data.substr(10,12);
|
||||
std::string omega0_2 = data.substr(10, 12);
|
||||
std::string Omega0 = omega0_1 + omega0_2;
|
||||
std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> omega_bits(Omega0);
|
||||
const std::vector<std::pair<int,int>> om_bit({{0,12}});
|
||||
FNAV_Omega0_2_6=(double)read_navigation_signed(omega_bits,om_bit);
|
||||
const std::vector<std::pair<int, int>> om_bit({{0, 12}});
|
||||
FNAV_Omega0_2_6 = static_cast<double>(read_navigation_signed(omega_bits, om_bit));
|
||||
FNAV_Omega0_2_6 *= FNAV_Omega0_5_LSB;
|
||||
//
|
||||
FNAV_Omegadot_2_6=(double)read_navigation_signed(data_bits,FNAV_Omegadot_2_6_bit);
|
||||
FNAV_Omegadot_2_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Omegadot_2_6_bit));
|
||||
FNAV_Omegadot_2_6 *= FNAV_Omegadot_5_LSB;
|
||||
FNAV_M0_2_6=(double)read_navigation_signed(data_bits,FNAV_M0_2_6_bit);
|
||||
FNAV_M0_2_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_M0_2_6_bit));
|
||||
FNAV_M0_2_6 *= FNAV_M0_5_LSB;
|
||||
FNAV_af0_2_6=(double)read_navigation_signed(data_bits,FNAV_af0_2_6_bit);
|
||||
FNAV_af0_2_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af0_2_6_bit));
|
||||
FNAV_af0_2_6 *= FNAV_af0_5_LSB;
|
||||
FNAV_af1_2_6=(double)read_navigation_signed(data_bits,FNAV_af1_2_6_bit);
|
||||
FNAV_af1_2_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af1_2_6_bit));
|
||||
FNAV_af1_2_6 *= FNAV_af1_5_LSB;
|
||||
FNAV_E5ahs_2_6=(double)read_navigation_unsigned(data_bits,FNAV_E5ahs_2_6_bit);
|
||||
FNAV_SVID3_6=(int)read_navigation_unsigned(data_bits,FNAV_SVID3_6_bit);
|
||||
FNAV_Deltaa12_3_6=(double)read_navigation_signed(data_bits,FNAV_Deltaa12_3_6_bit);
|
||||
FNAV_E5ahs_2_6 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_E5ahs_2_6_bit));
|
||||
FNAV_SVID3_6 = static_cast<int>(read_navigation_unsigned(data_bits, FNAV_SVID3_6_bit));
|
||||
FNAV_Deltaa12_3_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Deltaa12_3_6_bit));
|
||||
FNAV_Deltaa12_3_6 *= FNAV_Deltaa12_5_LSB;
|
||||
FNAV_e_3_6=(double)read_navigation_unsigned(data_bits,FNAV_e_3_6_bit);
|
||||
FNAV_e_3_6 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_e_3_6_bit));
|
||||
FNAV_e_3_6 *= FNAV_e_5_LSB;
|
||||
FNAV_w_3_6=(double)read_navigation_signed(data_bits,FNAV_w_3_6_bit);
|
||||
FNAV_w_3_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_w_3_6_bit));
|
||||
FNAV_w_3_6 *= FNAV_w_5_LSB;
|
||||
FNAV_deltai_3_6=(double)read_navigation_signed(data_bits,FNAV_deltai_3_6_bit);
|
||||
FNAV_deltai_3_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_deltai_3_6_bit));
|
||||
FNAV_deltai_3_6 *= FNAV_deltai_5_LSB;
|
||||
FNAV_Omega0_3_6=(double)read_navigation_signed(data_bits,FNAV_Omega0_3_6_bit);
|
||||
FNAV_Omega0_3_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Omega0_3_6_bit));
|
||||
FNAV_Omega0_3_6 *= FNAV_Omega0_5_LSB;
|
||||
FNAV_Omegadot_3_6=(double)read_navigation_signed(data_bits,FNAV_Omegadot_3_6_bit);
|
||||
FNAV_Omegadot_3_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_Omegadot_3_6_bit));
|
||||
FNAV_Omegadot_3_6 *= FNAV_Omegadot_5_LSB;
|
||||
FNAV_M0_3_6=(double)read_navigation_signed(data_bits,FNAV_M0_3_6_bit);
|
||||
FNAV_M0_3_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_M0_3_6_bit));
|
||||
FNAV_M0_3_6 *= FNAV_M0_5_LSB;
|
||||
FNAV_af0_3_6=(double)read_navigation_signed(data_bits,FNAV_af0_3_6_bit);
|
||||
FNAV_af0_3_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af0_3_6_bit));
|
||||
FNAV_af0_3_6 *= FNAV_af0_5_LSB;
|
||||
FNAV_af1_3_6=(double)read_navigation_signed(data_bits,FNAV_af1_3_6_bit);
|
||||
FNAV_af1_3_6 = static_cast<double>(read_navigation_signed(data_bits, FNAV_af1_3_6_bit));
|
||||
FNAV_af1_3_6 *= FNAV_af1_5_LSB;
|
||||
FNAV_E5ahs_3_6=(double)read_navigation_unsigned(data_bits,FNAV_E5ahs_3_6_bit);
|
||||
FNAV_E5ahs_3_6 = static_cast<double>(read_navigation_unsigned(data_bits, FNAV_E5ahs_3_6_bit));
|
||||
|
||||
flag_almanac_2=true;
|
||||
flag_almanac_2 = true;
|
||||
break;
|
||||
}
|
||||
|
||||
@ -528,6 +528,7 @@ signed long int Galileo_Fnav_Message::read_navigation_signed(std::bitset<GALILEO
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
bool Galileo_Fnav_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_iono_and_GST == true))
|
||||
@ -552,6 +553,8 @@ bool Galileo_Fnav_Message::have_new_ephemeris() //Check if we have a new ephemer
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool Galileo_Fnav_Message::have_new_iono_and_GST() //Check if we have a new iono data set stored in the galileo navigation class
|
||||
{
|
||||
if ((flag_iono_and_GST == true) and (flag_utc_model == true)) //the condition on flag_utc_model is added to have a time stamp for iono
|
||||
@ -562,6 +565,8 @@ bool Galileo_Fnav_Message::have_new_iono_and_GST() //Check if we have a new iono
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool Galileo_Fnav_Message::have_new_utc_model() // Check if we have a new utc data set stored in the galileo navigation class
|
||||
{
|
||||
if (flag_utc_model == true)
|
||||
@ -572,6 +577,8 @@ bool Galileo_Fnav_Message::have_new_utc_model() // Check if we have a new utc da
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool Galileo_Fnav_Message::have_new_almanac() //Check if we have a new almanac data set stored in the galileo navigation class
|
||||
{
|
||||
if ((flag_almanac_1 == true) and (flag_almanac_2 == true))
|
||||
@ -586,6 +593,8 @@ bool Galileo_Fnav_Message::have_new_almanac() //Check if we have a new almanac d
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Galileo_Ephemeris Galileo_Fnav_Message::get_ephemeris()
|
||||
{
|
||||
Galileo_Ephemeris ephemeris;
|
||||
@ -622,6 +631,8 @@ Galileo_Ephemeris Galileo_Fnav_Message::get_ephemeris()
|
||||
return ephemeris;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Galileo_Iono Galileo_Fnav_Message::get_iono()
|
||||
{
|
||||
Galileo_Iono iono;
|
||||
@ -644,6 +655,8 @@ Galileo_Iono Galileo_Fnav_Message::get_iono()
|
||||
return iono;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Galileo_Utc_Model Galileo_Fnav_Message::get_utc_model()
|
||||
{
|
||||
Galileo_Utc_Model utc_model;
|
||||
@ -664,6 +677,8 @@ Galileo_Utc_Model Galileo_Fnav_Message::get_utc_model()
|
||||
return utc_model;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Galileo_Almanac Galileo_Fnav_Message::get_almanac()
|
||||
{
|
||||
Galileo_Almanac almanac;
|
||||
|
||||
@ -66,11 +66,11 @@ void Galileo_Navigation_Message::reset()
|
||||
flag_TOW_5 = 0;
|
||||
flag_TOW_set = false;
|
||||
|
||||
flag_GGTO= false;
|
||||
flag_GGTO_1= false;
|
||||
flag_GGTO_2= false;
|
||||
flag_GGTO_3= false;
|
||||
flag_GGTO_4= false;
|
||||
flag_GGTO = false;
|
||||
flag_GGTO_1 = false;
|
||||
flag_GGTO_2 = false;
|
||||
flag_GGTO_3 = false;
|
||||
flag_GGTO_4 = false;
|
||||
|
||||
IOD_ephemeris = 0;
|
||||
/*Word type 1: Ephemeris (1/4)*/
|
||||
@ -420,7 +420,7 @@ void Galileo_Navigation_Message::split_page(std::string page_string, int flag_ev
|
||||
// CRC correct: Decode word
|
||||
std::string page_number_bits = Data_k.substr (0,6);
|
||||
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);
|
||||
Page_type = static_cast<int>(read_page_type_unsigned(page_type_bits, type));
|
||||
Page_type_time_stamp = Page_type;
|
||||
std::string Data_jk_ephemeris = Data_k + Data_j;
|
||||
page_jk_decoder(Data_jk_ephemeris.c_str());
|
||||
@ -677,24 +677,24 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
std::bitset<GALILEO_DATA_JK_BITS> data_jk_bits (data_jk_string);
|
||||
//DLOG(INFO) << "Data_jk_bits (bitset) "<< endl << data_jk_bits << endl;
|
||||
|
||||
page_number = (int)read_navigation_unsigned(data_jk_bits, PAGE_TYPE_bit);
|
||||
page_number = static_cast<int>(read_navigation_unsigned(data_jk_bits, PAGE_TYPE_bit));
|
||||
LOG(INFO) << "Page number = " << page_number;
|
||||
|
||||
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);
|
||||
IOD_nav_1 = static_cast<int>(read_navigation_unsigned(data_jk_bits, IOD_nav_1_bit));
|
||||
DLOG(INFO) << "IOD_nav_1= " << IOD_nav_1;
|
||||
t0e_1 = (double)read_navigation_unsigned(data_jk_bits, T0E_1_bit);
|
||||
t0e_1 = static_cast<double>(read_navigation_unsigned(data_jk_bits, T0E_1_bit));
|
||||
t0e_1 = t0e_1 * t0e_1_LSB;
|
||||
DLOG(INFO) << "t0e_1= " << t0e_1;
|
||||
M0_1 = (double)read_navigation_signed(data_jk_bits, M0_1_bit);
|
||||
M0_1 = static_cast<double>(read_navigation_signed(data_jk_bits, M0_1_bit));
|
||||
M0_1 = M0_1 * M0_1_LSB;
|
||||
DLOG(INFO) << "M0_1= " << M0_1;
|
||||
e_1 = (double)read_navigation_unsigned(data_jk_bits, e_1_bit);
|
||||
e_1 = static_cast<double>(read_navigation_unsigned(data_jk_bits, e_1_bit));
|
||||
e_1 = e_1 * e_1_LSB;
|
||||
DLOG(INFO) << "e_1= " << e_1;
|
||||
A_1 = (double)read_navigation_unsigned(data_jk_bits, A_1_bit);
|
||||
A_1 = static_cast<double>(read_navigation_unsigned(data_jk_bits, A_1_bit));
|
||||
A_1 = A_1 * A_1_LSB_gal;
|
||||
DLOG(INFO) << "A_1= " << A_1;
|
||||
flag_ephemeris_1 = true;
|
||||
@ -702,18 +702,18 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
break;
|
||||
|
||||
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 = static_cast<int>(read_navigation_unsigned(data_jk_bits, IOD_nav_2_bit));
|
||||
DLOG(INFO) << "IOD_nav_2= " << IOD_nav_2;
|
||||
OMEGA_0_2 = (double)read_navigation_signed(data_jk_bits, OMEGA_0_2_bit);
|
||||
OMEGA_0_2 = static_cast<double>(read_navigation_signed(data_jk_bits, OMEGA_0_2_bit));
|
||||
OMEGA_0_2 = OMEGA_0_2 * OMEGA_0_2_LSB;
|
||||
DLOG(INFO) << "OMEGA_0_2= " << OMEGA_0_2 ;
|
||||
i_0_2 = (double)read_navigation_signed(data_jk_bits, i_0_2_bit);
|
||||
i_0_2 = static_cast<double>(read_navigation_signed(data_jk_bits, i_0_2_bit));
|
||||
i_0_2 = i_0_2 * i_0_2_LSB;
|
||||
DLOG(INFO) << "i_0_2= " << i_0_2 ;
|
||||
omega_2 = (double)read_navigation_signed(data_jk_bits, omega_2_bit);
|
||||
omega_2 = static_cast<double>(read_navigation_signed(data_jk_bits, omega_2_bit));
|
||||
omega_2 = omega_2 * omega_2_LSB;
|
||||
DLOG(INFO) << "omega_2= " << omega_2;
|
||||
iDot_2 = (double)read_navigation_signed(data_jk_bits, iDot_2_bit);
|
||||
iDot_2 = static_cast<double>(read_navigation_signed(data_jk_bits, iDot_2_bit));
|
||||
iDot_2 = iDot_2 * iDot_2_LSB;
|
||||
DLOG(INFO) << "iDot_2= " << iDot_2;
|
||||
flag_ephemeris_2 = true;
|
||||
@ -721,57 +721,57 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
break;
|
||||
|
||||
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 = static_cast<int>(read_navigation_unsigned(data_jk_bits, IOD_nav_3_bit));
|
||||
DLOG(INFO) << "IOD_nav_3= " << IOD_nav_3 ;
|
||||
OMEGA_dot_3 = (double)read_navigation_signed(data_jk_bits, OMEGA_dot_3_bit);
|
||||
OMEGA_dot_3 = static_cast<double>(read_navigation_signed(data_jk_bits, OMEGA_dot_3_bit));
|
||||
OMEGA_dot_3 = OMEGA_dot_3 * OMEGA_dot_3_LSB;
|
||||
DLOG(INFO) <<"OMEGA_dot_3= " << OMEGA_dot_3 ;
|
||||
delta_n_3 = (double)read_navigation_signed(data_jk_bits, delta_n_3_bit);
|
||||
delta_n_3 = static_cast<double>(read_navigation_signed(data_jk_bits, delta_n_3_bit));
|
||||
delta_n_3 = delta_n_3 * delta_n_3_LSB;
|
||||
DLOG(INFO) << "delta_n_3= " << delta_n_3 ;
|
||||
C_uc_3 = (double)read_navigation_signed(data_jk_bits, C_uc_3_bit);
|
||||
C_uc_3 = static_cast<double>(read_navigation_signed(data_jk_bits, C_uc_3_bit));
|
||||
C_uc_3 = C_uc_3 * C_uc_3_LSB;
|
||||
DLOG(INFO) << "C_uc_3= " << C_uc_3;
|
||||
C_us_3 = (double)read_navigation_signed(data_jk_bits, C_us_3_bit);
|
||||
C_us_3 = static_cast<double>(read_navigation_signed(data_jk_bits, C_us_3_bit));
|
||||
C_us_3 = C_us_3 * C_us_3_LSB;
|
||||
DLOG(INFO) << "C_us_3= " << C_us_3;
|
||||
C_rc_3 = (double)read_navigation_signed(data_jk_bits, C_rc_3_bit);
|
||||
C_rc_3 = static_cast<double>(read_navigation_signed(data_jk_bits, C_rc_3_bit));
|
||||
C_rc_3 = C_rc_3 * C_rc_3_LSB;
|
||||
DLOG(INFO) << "C_rc_3= " << C_rc_3;
|
||||
C_rs_3 = (double)read_navigation_signed(data_jk_bits, C_rs_3_bit);
|
||||
C_rs_3 = static_cast<double>(read_navigation_signed(data_jk_bits, C_rs_3_bit));
|
||||
C_rs_3 = C_rs_3 * C_rs_3_LSB;
|
||||
DLOG(INFO) << "C_rs_3= " << C_rs_3;
|
||||
SISA_3 = (double)read_navigation_unsigned(data_jk_bits, SISA_3_bit);
|
||||
SISA_3 = static_cast<double>(read_navigation_unsigned(data_jk_bits, SISA_3_bit));
|
||||
DLOG(INFO) << "SISA_3= " << SISA_3;
|
||||
flag_ephemeris_3 = true;
|
||||
DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
|
||||
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);
|
||||
IOD_nav_4 = static_cast<int>(read_navigation_unsigned(data_jk_bits, IOD_nav_4_bit));
|
||||
DLOG(INFO) << "IOD_nav_4= " << IOD_nav_4 ;
|
||||
SV_ID_PRN_4 = (int)read_navigation_unsigned(data_jk_bits, SV_ID_PRN_4_bit);
|
||||
SV_ID_PRN_4 = static_cast<int>(read_navigation_unsigned(data_jk_bits, SV_ID_PRN_4_bit));
|
||||
DLOG(INFO) << "SV_ID_PRN_4= " << SV_ID_PRN_4 ;
|
||||
C_ic_4 = (double)read_navigation_signed(data_jk_bits, C_ic_4_bit);
|
||||
C_ic_4 = static_cast<double>(read_navigation_signed(data_jk_bits, C_ic_4_bit));
|
||||
C_ic_4 = C_ic_4 * C_ic_4_LSB;
|
||||
DLOG(INFO) << "C_ic_4= " << C_ic_4;
|
||||
C_is_4 = (double)read_navigation_signed(data_jk_bits, C_is_4_bit);
|
||||
C_is_4 = static_cast<double>(read_navigation_signed(data_jk_bits, C_is_4_bit));
|
||||
C_is_4 = C_is_4 * C_is_4_LSB;
|
||||
DLOG(INFO) << "C_is_4= " << C_is_4;
|
||||
/*Clock correction parameters*/
|
||||
t0c_4 = (double)read_navigation_unsigned(data_jk_bits, t0c_4_bit);
|
||||
t0c_4 = static_cast<double>(read_navigation_unsigned(data_jk_bits, t0c_4_bit));
|
||||
t0c_4 = t0c_4 * t0c_4_LSB;
|
||||
DLOG(INFO) << "t0c_4= " << t0c_4;
|
||||
af0_4 = (double)read_navigation_signed(data_jk_bits, af0_4_bit);
|
||||
af0_4 = static_cast<double>(read_navigation_signed(data_jk_bits, af0_4_bit));
|
||||
af0_4 = af0_4 * af0_4_LSB;
|
||||
DLOG(INFO) << "af0_4 = " << af0_4;
|
||||
af1_4 = (double)read_navigation_signed(data_jk_bits, af1_4_bit);
|
||||
af1_4 = static_cast<double>(read_navigation_signed(data_jk_bits, af1_4_bit));
|
||||
af1_4 = af1_4 * af1_4_LSB;
|
||||
DLOG(INFO) << "af1_4 = " << af1_4;
|
||||
af2_4 = (double)read_navigation_signed(data_jk_bits, af2_4_bit);
|
||||
af2_4 = static_cast<double>(read_navigation_signed(data_jk_bits, af2_4_bit));
|
||||
af2_4 = af2_4 * af2_4_LSB;
|
||||
DLOG(INFO) << "af2_4 = " << af2_4;
|
||||
spare_4 = (double)read_navigation_unsigned(data_jk_bits, spare_4_bit);
|
||||
spare_4 = static_cast<double>(read_navigation_unsigned(data_jk_bits, spare_4_bit));
|
||||
DLOG(INFO) << "spare_4 = " << spare_4;
|
||||
flag_ephemeris_4 = true;
|
||||
DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
|
||||
@ -780,47 +780,47 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
case 5: /*Word type 5: Ionospheric correction, BGD, signal health and data validity status and GST*/
|
||||
/*Ionospheric correction*/
|
||||
/*Az*/
|
||||
ai0_5 = (double)read_navigation_unsigned(data_jk_bits, ai0_5_bit);
|
||||
ai0_5 = static_cast<double>(read_navigation_unsigned(data_jk_bits, ai0_5_bit));
|
||||
ai0_5 = ai0_5 * ai0_5_LSB;
|
||||
DLOG(INFO) << "ai0_5= " << ai0_5;
|
||||
ai1_5 = (double)read_navigation_signed(data_jk_bits, ai1_5_bit);
|
||||
ai1_5 = static_cast<double>(read_navigation_signed(data_jk_bits, ai1_5_bit));
|
||||
ai1_5 = ai1_5 * ai1_5_LSB;
|
||||
DLOG(INFO) << "ai1_5= " << ai1_5;
|
||||
ai2_5 = (double)read_navigation_signed(data_jk_bits, ai2_5_bit);
|
||||
ai2_5 = static_cast<double>(read_navigation_signed(data_jk_bits, ai2_5_bit));
|
||||
ai2_5 = ai2_5 * ai2_5_LSB;
|
||||
DLOG(INFO) << "ai2_5= " << ai2_5;
|
||||
/*Ionospheric disturbance flag*/
|
||||
Region1_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region1_5_bit);
|
||||
Region1_flag_5 = static_cast<bool>(read_navigation_bool(data_jk_bits, Region1_5_bit));
|
||||
DLOG(INFO) << "Region1_flag_5= " << Region1_flag_5;
|
||||
Region2_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region2_5_bit);
|
||||
Region2_flag_5 = static_cast<bool>(read_navigation_bool(data_jk_bits, Region2_5_bit));
|
||||
DLOG(INFO) << "Region2_flag_5= " << Region2_flag_5;
|
||||
Region3_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region3_5_bit);
|
||||
Region3_flag_5 = static_cast<bool>(read_navigation_bool(data_jk_bits, Region3_5_bit));
|
||||
DLOG(INFO) << "Region3_flag_5= " << Region3_flag_5;
|
||||
Region4_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region4_5_bit);
|
||||
Region4_flag_5 = static_cast<bool>(read_navigation_bool(data_jk_bits, Region4_5_bit));
|
||||
DLOG(INFO) << "Region4_flag_5= " << Region4_flag_5;
|
||||
Region5_flag_5 = (bool)read_navigation_bool(data_jk_bits, Region5_5_bit);
|
||||
Region5_flag_5 = static_cast<bool>(read_navigation_bool(data_jk_bits, Region5_5_bit));
|
||||
DLOG(INFO) << "Region5_flag_5= " << Region5_flag_5;
|
||||
BGD_E1E5a_5 = (double)read_navigation_signed(data_jk_bits, BGD_E1E5a_5_bit);
|
||||
BGD_E1E5a_5 = static_cast<double>(read_navigation_signed(data_jk_bits, BGD_E1E5a_5_bit));
|
||||
BGD_E1E5a_5 = BGD_E1E5a_5 * BGD_E1E5a_5_LSB;
|
||||
DLOG(INFO) << "BGD_E1E5a_5= " << BGD_E1E5a_5;
|
||||
BGD_E1E5b_5 = (double)read_navigation_signed(data_jk_bits, BGD_E1E5b_5_bit);
|
||||
BGD_E1E5b_5 = static_cast<double>(read_navigation_signed(data_jk_bits, BGD_E1E5b_5_bit));
|
||||
BGD_E1E5b_5 = BGD_E1E5b_5 * BGD_E1E5b_5_LSB;
|
||||
DLOG(INFO) << "BGD_E1E5b_5= " << BGD_E1E5b_5;
|
||||
E5b_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_5_bit);
|
||||
E5b_HS_5 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E5b_HS_5_bit));
|
||||
DLOG(INFO) << "E5b_HS_5= " << E5b_HS_5;
|
||||
E1B_HS_5 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_5_bit);
|
||||
E1B_HS_5 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E1B_HS_5_bit));
|
||||
DLOG(INFO) << "E1B_HS_5= " << E1B_HS_5;
|
||||
E5b_DVS_5 = (double)read_navigation_unsigned(data_jk_bits, E5b_DVS_5_bit);
|
||||
E5b_DVS_5 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E5b_DVS_5_bit));
|
||||
DLOG(INFO) << "E5b_DVS_5= " << E5b_DVS_5;
|
||||
E1B_DVS_5 = (double)read_navigation_unsigned(data_jk_bits, E1B_DVS_5_bit);
|
||||
E1B_DVS_5 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E1B_DVS_5_bit));
|
||||
DLOG(INFO) << "E1B_DVS_5= " << E1B_DVS_5;
|
||||
/*GST*/
|
||||
WN_5 = (double)read_navigation_unsigned(data_jk_bits, WN_5_bit);
|
||||
WN_5 = static_cast<double>(read_navigation_unsigned(data_jk_bits, WN_5_bit));
|
||||
DLOG(INFO) << "WN_5= " << WN_5;
|
||||
TOW_5 = (double)read_navigation_unsigned(data_jk_bits, TOW_5_bit);
|
||||
TOW_5 = static_cast<double>(read_navigation_unsigned(data_jk_bits, TOW_5_bit));
|
||||
DLOG(INFO) << "TOW_5= " << TOW_5;
|
||||
flag_TOW_5 = true; //set to false externally
|
||||
spare_5 = (double)read_navigation_unsigned(data_jk_bits, spare_5_bit);
|
||||
spare_5 = static_cast<double>(read_navigation_unsigned(data_jk_bits, spare_5_bit));
|
||||
DLOG(INFO) << "spare_5= " << spare_5;
|
||||
flag_iono_and_GST = true; //set to false externally
|
||||
flag_TOW_set = true; //set to false externally
|
||||
@ -828,26 +828,26 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
break;
|
||||
|
||||
case 6: /*Word type 6: GST-UTC conversion parameters*/
|
||||
A0_6 = (double)read_navigation_signed(data_jk_bits, A0_6_bit);
|
||||
A0_6 = static_cast<double>(read_navigation_signed(data_jk_bits, A0_6_bit));
|
||||
A0_6 = A0_6 * A0_6_LSB;
|
||||
DLOG(INFO) << "A0_6= " << A0_6;
|
||||
A1_6 = (double)read_navigation_signed(data_jk_bits, A1_6_bit);
|
||||
A1_6 = static_cast<double>(read_navigation_signed(data_jk_bits, A1_6_bit));
|
||||
A1_6 = A1_6 * A1_6_LSB;
|
||||
DLOG(INFO) << "A1_6= " << A1_6;
|
||||
Delta_tLS_6 = (double)read_navigation_signed(data_jk_bits, Delta_tLS_6_bit);
|
||||
Delta_tLS_6 = static_cast<double>(read_navigation_signed(data_jk_bits, Delta_tLS_6_bit));
|
||||
DLOG(INFO) << "Delta_tLS_6= " << Delta_tLS_6;
|
||||
t0t_6 = (double)read_navigation_unsigned(data_jk_bits, t0t_6_bit);
|
||||
t0t_6 = static_cast<double>(read_navigation_unsigned(data_jk_bits, t0t_6_bit));
|
||||
t0t_6 = t0t_6 * t0t_6_LSB;
|
||||
DLOG(INFO) << "t0t_6= " << t0t_6;
|
||||
WNot_6 = (double)read_navigation_unsigned(data_jk_bits, WNot_6_bit);
|
||||
WNot_6 = static_cast<double>(read_navigation_unsigned(data_jk_bits, WNot_6_bit));
|
||||
DLOG(INFO) << "WNot_6= " << WNot_6;
|
||||
WN_LSF_6 = (double)read_navigation_unsigned(data_jk_bits, WN_LSF_6_bit);
|
||||
WN_LSF_6 = static_cast<double>(read_navigation_unsigned(data_jk_bits, WN_LSF_6_bit));
|
||||
DLOG(INFO) << "WN_LSF_6= " << WN_LSF_6;
|
||||
DN_6 = (double)read_navigation_unsigned(data_jk_bits, DN_6_bit);
|
||||
DN_6 = static_cast<double>(read_navigation_unsigned(data_jk_bits, DN_6_bit));
|
||||
DLOG(INFO) << "DN_6= " << DN_6;
|
||||
Delta_tLSF_6 = (double)read_navigation_signed(data_jk_bits, Delta_tLSF_6_bit);
|
||||
Delta_tLSF_6 = static_cast<double>(read_navigation_signed(data_jk_bits, Delta_tLSF_6_bit));
|
||||
DLOG(INFO) << "Delta_tLSF_6= " << Delta_tLSF_6;
|
||||
TOW_6 = (double)read_navigation_unsigned(data_jk_bits, TOW_6_bit);
|
||||
TOW_6 = static_cast<double>(read_navigation_unsigned(data_jk_bits, TOW_6_bit));
|
||||
DLOG(INFO) << "TOW_6= " << TOW_6;
|
||||
flag_TOW_6 = true; //set to false externally
|
||||
flag_utc_model = true; //set to false externally
|
||||
@ -856,34 +856,34 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
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);
|
||||
IOD_a_7 = static_cast<double>(read_navigation_unsigned(data_jk_bits, IOD_a_7_bit));
|
||||
DLOG(INFO) << "IOD_a_7= " << IOD_a_7;
|
||||
WN_a_7 = (double)read_navigation_unsigned(data_jk_bits, WN_a_7_bit);
|
||||
WN_a_7 = static_cast<double>(read_navigation_unsigned(data_jk_bits, WN_a_7_bit));
|
||||
DLOG(INFO) << "WN_a_7= " << WN_a_7;
|
||||
t0a_7 = (double)read_navigation_unsigned(data_jk_bits, t0a_7_bit);
|
||||
t0a_7 = static_cast<double>(read_navigation_unsigned(data_jk_bits, t0a_7_bit));
|
||||
t0a_7 = t0a_7 * t0a_7_LSB;
|
||||
DLOG(INFO) << "t0a_7= " << t0a_7;
|
||||
SVID1_7 = (double)read_navigation_unsigned(data_jk_bits, SVID1_7_bit);
|
||||
SVID1_7 = static_cast<double>(read_navigation_unsigned(data_jk_bits, SVID1_7_bit));
|
||||
DLOG(INFO) << "SVID1_7= " << SVID1_7;
|
||||
DELTA_A_7 = (double)read_navigation_signed(data_jk_bits, DELTA_A_7_bit);
|
||||
DELTA_A_7 = static_cast<double>(read_navigation_signed(data_jk_bits, DELTA_A_7_bit));
|
||||
DELTA_A_7 = DELTA_A_7 * DELTA_A_7_LSB;
|
||||
DLOG(INFO) << "DELTA_A_7= " << DELTA_A_7;
|
||||
e_7 = (double)read_navigation_unsigned(data_jk_bits, e_7_bit);
|
||||
e_7 = static_cast<double>(read_navigation_unsigned(data_jk_bits, e_7_bit));
|
||||
e_7 = e_7 * e_7_LSB;
|
||||
DLOG(INFO) << "e_7= " << e_7;
|
||||
omega_7 = (double)read_navigation_signed(data_jk_bits, omega_7_bit);
|
||||
omega_7 = static_cast<double>(read_navigation_signed(data_jk_bits, omega_7_bit));
|
||||
omega_7 = omega_7 * omega_7_LSB;
|
||||
DLOG(INFO) << "omega_7= " << omega_7;
|
||||
delta_i_7 = (double)read_navigation_signed(data_jk_bits, delta_i_7_bit);
|
||||
delta_i_7 = static_cast<double>(read_navigation_signed(data_jk_bits, delta_i_7_bit));
|
||||
delta_i_7 = delta_i_7 * delta_i_7_LSB;
|
||||
DLOG(INFO) << "delta_i_7= " << delta_i_7;
|
||||
Omega0_7 = (double)read_navigation_signed(data_jk_bits, Omega0_7_bit);
|
||||
Omega0_7 = static_cast<double>(read_navigation_signed(data_jk_bits, Omega0_7_bit));
|
||||
Omega0_7 = Omega0_7 * Omega0_7_LSB;
|
||||
DLOG(INFO) << "Omega0_7= " << Omega0_7;
|
||||
Omega_dot_7 = (double)read_navigation_signed(data_jk_bits, Omega_dot_7_bit);
|
||||
Omega_dot_7 = static_cast<double>(read_navigation_signed(data_jk_bits, Omega_dot_7_bit));
|
||||
Omega_dot_7 = Omega_dot_7 * Omega_dot_7_LSB;
|
||||
DLOG(INFO) << "Omega_dot_7= " << Omega_dot_7;
|
||||
M0_7 = (double)read_navigation_signed(data_jk_bits, M0_7_bit);
|
||||
M0_7 = static_cast<double>(read_navigation_signed(data_jk_bits, M0_7_bit));
|
||||
M0_7 = M0_7 * M0_7_LSB;
|
||||
DLOG(INFO) << "M0_7= " << M0_7;
|
||||
flag_almanac_1 = true;
|
||||
@ -891,36 +891,36 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
break;
|
||||
|
||||
case 8: /*Word type 8: Almanac for SVID1 (2/2) and SVID2 (1/2)*/
|
||||
IOD_a_8 = (double)read_navigation_signed(data_jk_bits, IOD_a_8_bit);
|
||||
IOD_a_8 = static_cast<double>(read_navigation_signed(data_jk_bits, IOD_a_8_bit));
|
||||
DLOG(INFO) << "IOD_a_8= " << IOD_a_8;
|
||||
af0_8 = (double)read_navigation_signed(data_jk_bits, af0_8_bit);
|
||||
af0_8 = static_cast<double>(read_navigation_signed(data_jk_bits, af0_8_bit));
|
||||
af0_8 = af0_8 * af0_8_LSB;
|
||||
DLOG(INFO) << "af0_8= " << af0_8;
|
||||
af1_8 = (double)read_navigation_signed(data_jk_bits, af1_8_bit);
|
||||
af1_8 = static_cast<double>(read_navigation_signed(data_jk_bits, af1_8_bit));
|
||||
af1_8 = af1_8 * af1_8_LSB;
|
||||
DLOG(INFO) << "af1_8= " << af1_8;
|
||||
E5b_HS_8 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_8_bit);
|
||||
E5b_HS_8 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E5b_HS_8_bit));
|
||||
DLOG(INFO) << "E5b_HS_8= " << E5b_HS_8;
|
||||
E1B_HS_8 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_8_bit);
|
||||
E1B_HS_8 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E1B_HS_8_bit));
|
||||
DLOG(INFO) << "E1B_HS_8= " << E1B_HS_8;
|
||||
SVID2_8 = (double)read_navigation_unsigned(data_jk_bits, SVID2_8_bit);
|
||||
SVID2_8 = static_cast<double>(read_navigation_unsigned(data_jk_bits, SVID2_8_bit));
|
||||
DLOG(INFO) << "SVID2_8= " << SVID2_8;
|
||||
DELTA_A_8 = (double)read_navigation_signed(data_jk_bits, DELTA_A_8_bit);
|
||||
DELTA_A_8 = static_cast<double>(read_navigation_signed(data_jk_bits, DELTA_A_8_bit));
|
||||
DELTA_A_8 = DELTA_A_8 * DELTA_A_8_LSB;
|
||||
DLOG(INFO) << "DELTA_A_8= " << DELTA_A_8;
|
||||
e_8 = (double)read_navigation_unsigned(data_jk_bits, e_8_bit);
|
||||
e_8 = static_cast<double>(read_navigation_unsigned(data_jk_bits, e_8_bit));
|
||||
e_8 = e_8 * e_8_LSB;
|
||||
DLOG(INFO) << "e_8= " << e_8;
|
||||
omega_8 = (double)read_navigation_signed(data_jk_bits, omega_8_bit);
|
||||
omega_8 = static_cast<double>(read_navigation_signed(data_jk_bits, omega_8_bit));
|
||||
omega_8 = omega_8 * omega_8_LSB;
|
||||
DLOG(INFO) << "omega_8= " << omega_8;
|
||||
delta_i_8 = (double)read_navigation_signed(data_jk_bits, delta_i_8_bit);
|
||||
delta_i_8 = static_cast<double>(read_navigation_signed(data_jk_bits, delta_i_8_bit));
|
||||
delta_i_8 = delta_i_8 * delta_i_8_LSB;
|
||||
DLOG(INFO) << "delta_i_8= " << delta_i_8;
|
||||
Omega0_8 = (double)read_navigation_signed(data_jk_bits, Omega0_8_bit);
|
||||
Omega0_8 = static_cast<double>(read_navigation_signed(data_jk_bits, Omega0_8_bit));
|
||||
Omega0_8 = Omega0_8 * Omega0_8_LSB;
|
||||
DLOG(INFO) << "Omega0_8= " << Omega0_8;
|
||||
Omega_dot_8 = (double)read_navigation_signed(data_jk_bits, Omega_dot_8_bit);
|
||||
Omega_dot_8 = static_cast<double>(read_navigation_signed(data_jk_bits, Omega_dot_8_bit));
|
||||
Omega_dot_8 = Omega_dot_8 * Omega_dot_8_LSB;
|
||||
DLOG(INFO) << "Omega_dot_8= " << Omega_dot_8;
|
||||
flag_almanac_2 = true;
|
||||
@ -928,38 +928,38 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
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);
|
||||
IOD_a_9 = static_cast<double>(read_navigation_unsigned(data_jk_bits, IOD_a_9_bit));
|
||||
DLOG(INFO) << "IOD_a_9= " << IOD_a_9;
|
||||
WN_a_9 = (double)read_navigation_unsigned(data_jk_bits, WN_a_9_bit);
|
||||
WN_a_9 = static_cast<double>(read_navigation_unsigned(data_jk_bits, WN_a_9_bit));
|
||||
DLOG(INFO) << "WN_a_9= " << WN_a_9;
|
||||
t0a_9 = (double)read_navigation_unsigned(data_jk_bits, t0a_9_bit);
|
||||
t0a_9 = static_cast<double>(read_navigation_unsigned(data_jk_bits, t0a_9_bit));
|
||||
t0a_9 = t0a_9 * t0a_9_LSB;
|
||||
DLOG(INFO) << "t0a_9= " << t0a_9;
|
||||
M0_9 = (double)read_navigation_signed(data_jk_bits, M0_9_bit);
|
||||
M0_9 = static_cast<double>(read_navigation_signed(data_jk_bits, M0_9_bit));
|
||||
M0_9 = M0_9 * M0_9_LSB;
|
||||
DLOG(INFO) << "M0_9= " << M0_9;
|
||||
af0_9 = (double)read_navigation_signed(data_jk_bits, af0_9_bit);
|
||||
af0_9 = static_cast<double>(read_navigation_signed(data_jk_bits, af0_9_bit));
|
||||
af0_9 = af0_9 * af0_9_LSB;
|
||||
DLOG(INFO) << "af0_9= " << af0_9;
|
||||
af1_9 = (double)read_navigation_signed(data_jk_bits, af1_9_bit);
|
||||
af1_9 = static_cast<double>(read_navigation_signed(data_jk_bits, af1_9_bit));
|
||||
af1_9 = af1_9 * af1_9_LSB;
|
||||
DLOG(INFO) << "af1_9= " << af1_9;
|
||||
E1B_HS_9 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit);
|
||||
E1B_HS_9 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit));
|
||||
DLOG(INFO) << "E1B_HS_9= " << E1B_HS_9;
|
||||
E1B_HS_9 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit);
|
||||
E1B_HS_9 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E1B_HS_9_bit));
|
||||
DLOG(INFO) << "E1B_HS_9= " << E1B_HS_9;
|
||||
SVID3_9 = (double)read_navigation_unsigned(data_jk_bits,SVID3_9_bit);
|
||||
SVID3_9 = static_cast<double>(read_navigation_unsigned(data_jk_bits,SVID3_9_bit));
|
||||
DLOG(INFO) << "SVID3_9= " << SVID3_9;
|
||||
DELTA_A_9 = (double)read_navigation_signed(data_jk_bits, DELTA_A_9_bit);
|
||||
DELTA_A_9 = static_cast<double>(read_navigation_signed(data_jk_bits, DELTA_A_9_bit));
|
||||
DELTA_A_9 = DELTA_A_9 * DELTA_A_9_LSB;
|
||||
DLOG(INFO) << "DELTA_A_9= " << DELTA_A_9;
|
||||
e_9 = (double)read_navigation_unsigned(data_jk_bits, e_9_bit);
|
||||
e_9 = static_cast<double>(read_navigation_unsigned(data_jk_bits, e_9_bit));
|
||||
e_9 = e_9 * e_9_LSB;
|
||||
DLOG(INFO) << "e_9= " << e_9;
|
||||
omega_9 = (double)read_navigation_signed(data_jk_bits, omega_9_bit);
|
||||
omega_9 = static_cast<double>(read_navigation_signed(data_jk_bits, omega_9_bit));
|
||||
omega_9 = omega_9 * omega_9_LSB;
|
||||
DLOG(INFO) << "omega_9= " << omega_9;
|
||||
delta_i_9 = (double)read_navigation_signed(data_jk_bits, delta_i_9_bit);
|
||||
delta_i_9 = static_cast<double>(read_navigation_signed(data_jk_bits, delta_i_9_bit));
|
||||
delta_i_9 = delta_i_9 * delta_i_9_LSB;
|
||||
DLOG(INFO) << "delta_i_9= " << delta_i_9;
|
||||
flag_almanac_3 = true;
|
||||
@ -967,40 +967,40 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
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);
|
||||
IOD_a_10 = static_cast<double>(read_navigation_unsigned(data_jk_bits, IOD_a_10_bit));
|
||||
DLOG(INFO) << "IOD_a_10= " << IOD_a_10;
|
||||
Omega0_10 = (double)read_navigation_signed(data_jk_bits, Omega0_10_bit);
|
||||
Omega0_10 = static_cast<double>(read_navigation_signed(data_jk_bits, Omega0_10_bit));
|
||||
Omega0_10 = Omega0_10 * Omega0_10_LSB;
|
||||
DLOG(INFO) << "Omega0_10= " << Omega0_10;
|
||||
Omega_dot_10 = (double)read_navigation_signed(data_jk_bits, Omega_dot_10_bit);
|
||||
Omega_dot_10 = static_cast<double>(read_navigation_signed(data_jk_bits, Omega_dot_10_bit));
|
||||
Omega_dot_10 = Omega_dot_10 * Omega_dot_10_LSB;
|
||||
DLOG(INFO) << "Omega_dot_10= " << Omega_dot_10 ;
|
||||
M0_10 = (double)read_navigation_signed(data_jk_bits, M0_10_bit);
|
||||
M0_10 = static_cast<double>(read_navigation_signed(data_jk_bits, M0_10_bit));
|
||||
M0_10 = M0_10 * M0_10_LSB;
|
||||
DLOG(INFO) << "M0_10= " << M0_10;
|
||||
af0_10 = (double)read_navigation_signed(data_jk_bits, af0_10_bit);
|
||||
af0_10 = static_cast<double>(read_navigation_signed(data_jk_bits, af0_10_bit));
|
||||
af0_10 = af0_10 * af0_10_LSB;
|
||||
DLOG(INFO) << "af0_10= " << af0_10;
|
||||
af1_10 = (double)read_navigation_signed(data_jk_bits, af1_10_bit);
|
||||
af1_10 = static_cast<double>(read_navigation_signed(data_jk_bits, af1_10_bit));
|
||||
af1_10 = af1_10 * af1_10_LSB;
|
||||
DLOG(INFO) << "af1_10= " << af1_10;
|
||||
E5b_HS_10 = (double)read_navigation_unsigned(data_jk_bits, E5b_HS_10_bit);
|
||||
E5b_HS_10 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E5b_HS_10_bit));
|
||||
DLOG(INFO) << "E5b_HS_10= " << E5b_HS_10;
|
||||
E1B_HS_10 = (double)read_navigation_unsigned(data_jk_bits, E1B_HS_10_bit);
|
||||
E1B_HS_10 = static_cast<double>(read_navigation_unsigned(data_jk_bits, E1B_HS_10_bit));
|
||||
DLOG(INFO) << "E1B_HS_10= " << E1B_HS_10;
|
||||
A_0G_10 = (double)read_navigation_signed(data_jk_bits, A_0G_10_bit);
|
||||
A_0G_10 = static_cast<double>(read_navigation_signed(data_jk_bits, A_0G_10_bit));
|
||||
A_0G_10 = A_0G_10 * A_0G_10_LSB;
|
||||
flag_GGTO_1=true;
|
||||
DLOG(INFO) << "A_0G_10= " << A_0G_10;
|
||||
A_1G_10 = (double)read_navigation_signed(data_jk_bits, A_1G_10_bit);
|
||||
A_1G_10 = static_cast<double>(read_navigation_signed(data_jk_bits, A_1G_10_bit));
|
||||
A_1G_10 = A_1G_10 * A_1G_10_LSB;
|
||||
flag_GGTO_2=true;
|
||||
DLOG(INFO) << "A_1G_10= " << A_1G_10;
|
||||
t_0G_10 = (double)read_navigation_unsigned(data_jk_bits, t_0G_10_bit);
|
||||
t_0G_10 = static_cast<double>(read_navigation_unsigned(data_jk_bits, t_0G_10_bit));
|
||||
t_0G_10 = t_0G_10 * t_0G_10_LSB;
|
||||
flag_GGTO_3=true;
|
||||
DLOG(INFO) << "t_0G_10= " << t_0G_10;
|
||||
WN_0G_10 = (double)read_navigation_unsigned(data_jk_bits, WN_0G_10_bit);
|
||||
WN_0G_10 = static_cast<double>(read_navigation_unsigned(data_jk_bits, WN_0G_10_bit));
|
||||
flag_GGTO_4=true;
|
||||
DLOG(INFO) << "WN_0G_10= " << WN_0G_10;
|
||||
flag_almanac_4 = true;
|
||||
@ -1008,11 +1008,11 @@ int Galileo_Navigation_Message::page_jk_decoder(const char *data_jk)
|
||||
break;
|
||||
|
||||
case 0: /*Word type 0: I/NAV Spare Word*/
|
||||
Time_0 = (double)read_navigation_unsigned(data_jk_bits, Time_0_bit);
|
||||
Time_0 = static_cast<double>(read_navigation_unsigned(data_jk_bits, Time_0_bit));
|
||||
DLOG(INFO) << "Time_0= " << Time_0;
|
||||
WN_0 = (double)read_navigation_unsigned(data_jk_bits, WN_0_bit);
|
||||
WN_0 = static_cast<double>(read_navigation_unsigned(data_jk_bits, WN_0_bit));
|
||||
DLOG(INFO) << "WN_0= " << WN_0;
|
||||
TOW_0 = (double)read_navigation_unsigned(data_jk_bits, TOW_0_bit);
|
||||
TOW_0 = static_cast<double>(read_navigation_unsigned(data_jk_bits, TOW_0_bit));
|
||||
DLOG(INFO) << "TOW_0= " << TOW_0;
|
||||
DLOG(INFO) << "flag_tow_set" << flag_TOW_set;
|
||||
break;
|
||||
|
||||
@ -303,11 +303,11 @@ double Gps_Navigation_Message::check_t(double time)
|
||||
corrTime = time;
|
||||
if (time > half_week)
|
||||
{
|
||||
corrTime = time - 2*half_week;
|
||||
corrTime = time - 2 * half_week;
|
||||
}
|
||||
else if (time < -half_week)
|
||||
{
|
||||
corrTime = time + 2*half_week;
|
||||
corrTime = time + 2 * half_week;
|
||||
}
|
||||
return corrTime;
|
||||
}
|
||||
@ -349,13 +349,13 @@ void Gps_Navigation_Message::satellitePosition(double transmitTime)
|
||||
// Find satellite's position ----------------------------------------------
|
||||
|
||||
// Restore semi-major axis
|
||||
a = d_sqrt_A*d_sqrt_A;
|
||||
a = d_sqrt_A * d_sqrt_A;
|
||||
|
||||
// Time from ephemeris reference epoch
|
||||
tk = check_t(transmitTime - d_Toe);
|
||||
|
||||
// Computed mean motion
|
||||
n0 = sqrt(GM / (a*a*a));
|
||||
n0 = sqrt(GM / (a * a * a));
|
||||
|
||||
// Corrected mean motion
|
||||
n = n0 + d_Delta_n;
|
||||
@ -364,7 +364,7 @@ void Gps_Navigation_Message::satellitePosition(double transmitTime)
|
||||
M = d_M_0 + n * tk;
|
||||
|
||||
// Reduce mean anomaly to between 0 and 2pi
|
||||
M = fmod((M + 2*GPS_PI), (2*GPS_PI));
|
||||
M = fmod((M + 2 * GPS_PI), (2 * GPS_PI));
|
||||
|
||||
// Initial guess of eccentric anomaly
|
||||
E = M;
|
||||
@ -374,7 +374,7 @@ void Gps_Navigation_Message::satellitePosition(double transmitTime)
|
||||
{
|
||||
E_old = E;
|
||||
E = M + d_e_eccentricity * sin(E);
|
||||
dE = fmod(E - E_old, 2*GPS_PI);
|
||||
dE = fmod(E - E_old, 2 * GPS_PI);
|
||||
if (fabs(dE) < 1e-12)
|
||||
{
|
||||
//Necessary precision is reached, exit from the loop
|
||||
@ -394,22 +394,22 @@ void Gps_Navigation_Message::satellitePosition(double transmitTime)
|
||||
phi = nu + d_OMEGA;
|
||||
|
||||
// Reduce phi to between 0 and 2*pi rad
|
||||
phi = fmod((phi), (2*GPS_PI));
|
||||
phi = fmod((phi), (2 * GPS_PI));
|
||||
|
||||
// Correct argument of latitude
|
||||
u = phi + d_Cuc * cos(2*phi) + d_Cus * sin(2*phi);
|
||||
u = phi + d_Cuc * cos(2 * phi) + d_Cus * sin(2 * phi);
|
||||
|
||||
// Correct radius
|
||||
r = a * (1 - d_e_eccentricity*cos(E)) + d_Crc * cos(2*phi) + d_Crs * sin(2*phi);
|
||||
r = a * (1 - d_e_eccentricity * cos(E)) + d_Crc * cos(2 * phi) + d_Crs * sin(2 * phi);
|
||||
|
||||
// Correct inclination
|
||||
i = d_i_0 + d_IDOT * tk + d_Cic * cos(2*phi) + d_Cis * sin(2*phi);
|
||||
i = d_i_0 + d_IDOT * tk + d_Cic * cos(2 * phi) + d_Cis * sin(2 * phi);
|
||||
|
||||
// Compute the angle between the ascending node and the Greenwich meridian
|
||||
Omega = d_OMEGA0 + (d_OMEGA_DOT - OMEGA_EARTH_DOT)*tk - OMEGA_EARTH_DOT * d_Toe;
|
||||
Omega = d_OMEGA0 + (d_OMEGA_DOT - OMEGA_EARTH_DOT) * tk - OMEGA_EARTH_DOT * d_Toe;
|
||||
|
||||
// Reduce to between 0 and 2*pi rad
|
||||
Omega = fmod((Omega + 2*GPS_PI), (2*GPS_PI));
|
||||
Omega = fmod((Omega + 2 * GPS_PI), (2 * GPS_PI));
|
||||
|
||||
// --- Compute satellite coordinates in Earth-fixed coordinates
|
||||
d_satpos_X = cos(u) * r * cos(Omega) - sin(u) * r * cos(i) * sin(Omega);
|
||||
@ -438,18 +438,18 @@ int Gps_Navigation_Message::subframe_decoder(char *subframe)
|
||||
|
||||
// UNPACK BYTES TO BITS AND REMOVE THE CRC REDUNDANCE
|
||||
std::bitset<GPS_SUBFRAME_BITS> subframe_bits;
|
||||
std::bitset<GPS_WORD_BITS+2> word_bits;
|
||||
std::bitset<GPS_WORD_BITS + 2> word_bits;
|
||||
for (int i=0; i<10; i++)
|
||||
{
|
||||
memcpy(&gps_word, &subframe[i*4], sizeof(char)*4);
|
||||
word_bits = std::bitset<(GPS_WORD_BITS+2)>(gps_word);
|
||||
for (int j=0; j<GPS_WORD_BITS; j++)
|
||||
memcpy(&gps_word, &subframe[i * 4], sizeof(char) * 4);
|
||||
word_bits = std::bitset<(GPS_WORD_BITS + 2) > (gps_word);
|
||||
for (int j = 0; j < GPS_WORD_BITS; j++)
|
||||
{
|
||||
subframe_bits[GPS_WORD_BITS*(9-i) + j] = word_bits[j];
|
||||
subframe_bits[GPS_WORD_BITS * (9 - i) + j] = word_bits[j];
|
||||
}
|
||||
}
|
||||
|
||||
subframe_ID = (int)read_navigation_unsigned(subframe_bits, SUBFRAME_ID);
|
||||
subframe_ID = static_cast<int>(read_navigation_unsigned(subframe_bits, SUBFRAME_ID));
|
||||
|
||||
// Decode all 5 sub-frames
|
||||
switch (subframe_ID)
|
||||
@ -463,98 +463,98 @@ int Gps_Navigation_Message::subframe_decoder(char *subframe)
|
||||
// subframe and we need the TOW of the first subframe in this data block
|
||||
// (the variable subframe at this point contains bits of the last subframe).
|
||||
//TOW = bin2dec(subframe(31:47)) * 6 - 30;
|
||||
d_TOW_SF1 = (double)read_navigation_unsigned(subframe_bits, TOW);
|
||||
d_TOW_SF1 = static_cast<double>(read_navigation_unsigned(subframe_bits, TOW));
|
||||
//we are in the first subframe (the transmitted TOW is the start time of the next subframe) !
|
||||
d_TOW_SF1 = d_TOW_SF1*6;
|
||||
d_TOW_SF1 = d_TOW_SF1 * 6;
|
||||
d_TOW = d_TOW_SF1 - 6; // Set transmission time
|
||||
b_integrity_status_flag = read_navigation_bool(subframe_bits, INTEGRITY_STATUS_FLAG);
|
||||
b_alert_flag = read_navigation_bool(subframe_bits, ALERT_FLAG);
|
||||
b_antispoofing_flag = read_navigation_bool(subframe_bits, ANTI_SPOOFING_FLAG);
|
||||
i_GPS_week = (int)read_navigation_unsigned(subframe_bits, GPS_WEEK);
|
||||
i_SV_accuracy = (int)read_navigation_unsigned(subframe_bits, SV_ACCURACY); // (20.3.3.3.1.3)
|
||||
i_SV_health = (int)read_navigation_unsigned(subframe_bits, SV_HEALTH);
|
||||
i_GPS_week = static_cast<int>(read_navigation_unsigned(subframe_bits, GPS_WEEK));
|
||||
i_SV_accuracy = static_cast<int>(read_navigation_unsigned(subframe_bits, SV_ACCURACY)); // (20.3.3.3.1.3)
|
||||
i_SV_health = static_cast<int>(read_navigation_unsigned(subframe_bits, SV_HEALTH));
|
||||
b_L2_P_data_flag = read_navigation_bool(subframe_bits, L2_P_DATA_FLAG); //
|
||||
i_code_on_L2 = (int)read_navigation_unsigned(subframe_bits, CA_OR_P_ON_L2);
|
||||
d_TGD = (double)read_navigation_signed(subframe_bits, T_GD);
|
||||
d_TGD = d_TGD*T_GD_LSB;
|
||||
d_IODC = (double)read_navigation_unsigned(subframe_bits, IODC);
|
||||
d_Toc = (double)read_navigation_unsigned(subframe_bits, T_OC);
|
||||
d_Toc = d_Toc*T_OC_LSB;
|
||||
d_A_f0 = (double)read_navigation_signed(subframe_bits, A_F0);
|
||||
d_A_f0 = d_A_f0*A_F0_LSB;
|
||||
d_A_f1 = (double)read_navigation_signed(subframe_bits, A_F1);
|
||||
d_A_f1 = d_A_f1*A_F1_LSB;
|
||||
d_A_f2 = (double)read_navigation_signed(subframe_bits, A_F2);
|
||||
d_A_f2 = d_A_f2*A_F2_LSB;
|
||||
i_code_on_L2 = static_cast<int>(read_navigation_unsigned(subframe_bits, CA_OR_P_ON_L2));
|
||||
d_TGD = static_cast<double>(read_navigation_signed(subframe_bits, T_GD));
|
||||
d_TGD = d_TGD * T_GD_LSB;
|
||||
d_IODC = static_cast<double>(read_navigation_unsigned(subframe_bits, IODC));
|
||||
d_Toc = static_cast<double>(read_navigation_unsigned(subframe_bits, T_OC));
|
||||
d_Toc = d_Toc * T_OC_LSB;
|
||||
d_A_f0 = static_cast<double>(read_navigation_signed(subframe_bits, A_F0));
|
||||
d_A_f0 = d_A_f0 * A_F0_LSB;
|
||||
d_A_f1 = static_cast<double>(read_navigation_signed(subframe_bits, A_F1));
|
||||
d_A_f1 = d_A_f1 * A_F1_LSB;
|
||||
d_A_f2 = static_cast<double>(read_navigation_signed(subframe_bits, A_F2));
|
||||
d_A_f2 = d_A_f2 * A_F2_LSB;
|
||||
|
||||
break;
|
||||
|
||||
case 2: //--- It is subframe 2 -------------------
|
||||
d_TOW_SF2 = (double)read_navigation_unsigned(subframe_bits, TOW);
|
||||
d_TOW_SF2 = d_TOW_SF2*6;
|
||||
d_TOW_SF2 = static_cast<double>(read_navigation_unsigned(subframe_bits, TOW));
|
||||
d_TOW_SF2 = d_TOW_SF2 * 6;
|
||||
d_TOW = d_TOW_SF2 - 6; // Set transmission time
|
||||
b_integrity_status_flag = read_navigation_bool(subframe_bits, INTEGRITY_STATUS_FLAG);
|
||||
b_alert_flag = read_navigation_bool(subframe_bits, ALERT_FLAG);
|
||||
b_antispoofing_flag = read_navigation_bool(subframe_bits, ANTI_SPOOFING_FLAG);
|
||||
d_IODE_SF2 = (double)read_navigation_unsigned(subframe_bits, IODE_SF2);
|
||||
d_Crs = (double)read_navigation_signed(subframe_bits, C_RS);
|
||||
d_IODE_SF2 = static_cast<double>(read_navigation_unsigned(subframe_bits, IODE_SF2));
|
||||
d_Crs = static_cast<double>(read_navigation_signed(subframe_bits, C_RS));
|
||||
d_Crs = d_Crs * C_RS_LSB;
|
||||
d_Delta_n = (double)read_navigation_signed(subframe_bits, DELTA_N);
|
||||
d_Delta_n = static_cast<double>(read_navigation_signed(subframe_bits, DELTA_N));
|
||||
d_Delta_n = d_Delta_n * DELTA_N_LSB;
|
||||
d_M_0 = (double)read_navigation_signed(subframe_bits, M_0);
|
||||
d_M_0 = static_cast<double>(read_navigation_signed(subframe_bits, M_0));
|
||||
d_M_0 = d_M_0 * M_0_LSB;
|
||||
d_Cuc = (double)read_navigation_signed(subframe_bits, C_UC);
|
||||
d_Cuc = static_cast<double>(read_navigation_signed(subframe_bits, C_UC));
|
||||
d_Cuc = d_Cuc * C_UC_LSB;
|
||||
d_e_eccentricity = (double)read_navigation_unsigned(subframe_bits, E);
|
||||
d_e_eccentricity = static_cast<double>(read_navigation_unsigned(subframe_bits, E));
|
||||
d_e_eccentricity = d_e_eccentricity * E_LSB;
|
||||
d_Cus = (double)read_navigation_signed(subframe_bits, C_US);
|
||||
d_Cus = static_cast<double>(read_navigation_signed(subframe_bits, C_US));
|
||||
d_Cus = d_Cus * C_US_LSB;
|
||||
d_sqrt_A = (double)read_navigation_unsigned(subframe_bits, SQRT_A);
|
||||
d_sqrt_A = static_cast<double>(read_navigation_unsigned(subframe_bits, SQRT_A));
|
||||
d_sqrt_A = d_sqrt_A * SQRT_A_LSB;
|
||||
d_Toe = (double)read_navigation_unsigned(subframe_bits, T_OE);
|
||||
d_Toe = static_cast<double>(read_navigation_unsigned(subframe_bits, T_OE));
|
||||
d_Toe = d_Toe * T_OE_LSB;
|
||||
b_fit_interval_flag = read_navigation_bool(subframe_bits, FIT_INTERVAL_FLAG);
|
||||
i_AODO = (int)read_navigation_unsigned(subframe_bits, AODO);
|
||||
i_AODO = static_cast<int>(read_navigation_unsigned(subframe_bits, AODO));
|
||||
i_AODO = i_AODO * AODO_LSB;
|
||||
|
||||
break;
|
||||
|
||||
case 3: // --- It is subframe 3 -------------------------------------
|
||||
d_TOW_SF3 = (double)read_navigation_unsigned(subframe_bits, TOW);
|
||||
d_TOW_SF3 = d_TOW_SF3*6;
|
||||
d_TOW_SF3 = static_cast<double>(read_navigation_unsigned(subframe_bits, TOW));
|
||||
d_TOW_SF3 = d_TOW_SF3 * 6;
|
||||
d_TOW = d_TOW_SF3 - 6; // Set transmission time
|
||||
b_integrity_status_flag = read_navigation_bool(subframe_bits, INTEGRITY_STATUS_FLAG);
|
||||
b_alert_flag = read_navigation_bool(subframe_bits, ALERT_FLAG);
|
||||
b_antispoofing_flag = read_navigation_bool(subframe_bits, ANTI_SPOOFING_FLAG);
|
||||
d_Cic = (double)read_navigation_signed(subframe_bits, C_IC);
|
||||
d_Cic = static_cast<double>(read_navigation_signed(subframe_bits, C_IC));
|
||||
d_Cic = d_Cic * C_IC_LSB;
|
||||
d_OMEGA0 = (double)read_navigation_signed(subframe_bits, OMEGA_0);
|
||||
d_OMEGA0 = static_cast<double>(read_navigation_signed(subframe_bits, OMEGA_0));
|
||||
d_OMEGA0 = d_OMEGA0 * OMEGA_0_LSB;
|
||||
d_Cis = (double)read_navigation_signed(subframe_bits, C_IS);
|
||||
d_Cis = static_cast<double>(read_navigation_signed(subframe_bits, C_IS));
|
||||
d_Cis = d_Cis * C_IS_LSB;
|
||||
d_i_0 = (double)read_navigation_signed(subframe_bits, I_0);
|
||||
d_i_0 = static_cast<double>(read_navigation_signed(subframe_bits, I_0));
|
||||
d_i_0 = d_i_0 * I_0_LSB;
|
||||
d_Crc = (double)read_navigation_signed(subframe_bits, C_RC);
|
||||
d_Crc = static_cast<double>(read_navigation_signed(subframe_bits, C_RC));
|
||||
d_Crc = d_Crc * C_RC_LSB;
|
||||
d_OMEGA = (double)read_navigation_signed(subframe_bits, OMEGA);
|
||||
d_OMEGA = static_cast<double>(read_navigation_signed(subframe_bits, OMEGA));
|
||||
d_OMEGA = d_OMEGA * OMEGA_LSB;
|
||||
d_OMEGA_DOT = (double)read_navigation_signed(subframe_bits, OMEGA_DOT);
|
||||
d_OMEGA_DOT = static_cast<double>(read_navigation_signed(subframe_bits, OMEGA_DOT));
|
||||
d_OMEGA_DOT = d_OMEGA_DOT * OMEGA_DOT_LSB;
|
||||
d_IODE_SF3 = (double)read_navigation_unsigned(subframe_bits, IODE_SF3);
|
||||
d_IDOT = (double)read_navigation_signed(subframe_bits, I_DOT);
|
||||
d_IDOT = d_IDOT*I_DOT_LSB;
|
||||
d_IODE_SF3 = static_cast<double>(read_navigation_unsigned(subframe_bits, IODE_SF3));
|
||||
d_IDOT = static_cast<double>(read_navigation_signed(subframe_bits, I_DOT));
|
||||
d_IDOT = d_IDOT * I_DOT_LSB;
|
||||
|
||||
break;
|
||||
|
||||
case 4: // --- It is subframe 4 ---------- Almanac, ionospheric model, UTC parameters, SV health (PRN: 25-32)
|
||||
d_TOW_SF4 = (double)read_navigation_unsigned(subframe_bits, TOW);
|
||||
d_TOW_SF4 = d_TOW_SF4*6;
|
||||
d_TOW_SF4 = static_cast<double>(read_navigation_unsigned(subframe_bits, TOW));
|
||||
d_TOW_SF4 = d_TOW_SF4 * 6;
|
||||
d_TOW = d_TOW_SF4 - 6; // Set transmission time
|
||||
b_integrity_status_flag = read_navigation_bool(subframe_bits, INTEGRITY_STATUS_FLAG);
|
||||
b_alert_flag = read_navigation_bool(subframe_bits, ALERT_FLAG);
|
||||
b_antispoofing_flag = read_navigation_bool(subframe_bits, ANTI_SPOOFING_FLAG);
|
||||
SV_data_ID = (int)read_navigation_unsigned(subframe_bits, SV_DATA_ID);
|
||||
SV_page = (int)read_navigation_unsigned(subframe_bits, SV_PAGE);
|
||||
SV_data_ID = static_cast<int>(read_navigation_unsigned(subframe_bits, SV_DATA_ID));
|
||||
SV_page = static_cast<int>(read_navigation_unsigned(subframe_bits, SV_PAGE));
|
||||
|
||||
if (SV_page == 13)
|
||||
{
|
||||
@ -564,33 +564,33 @@ int Gps_Navigation_Message::subframe_decoder(char *subframe)
|
||||
if (SV_page == 18)
|
||||
{
|
||||
// Page 18 - Ionospheric and UTC data
|
||||
d_alpha0 = (double)read_navigation_signed(subframe_bits, ALPHA_0);
|
||||
d_alpha0 = static_cast<double>(read_navigation_signed(subframe_bits, ALPHA_0));
|
||||
d_alpha0 = d_alpha0 * ALPHA_0_LSB;
|
||||
d_alpha1 = (double)read_navigation_signed(subframe_bits, ALPHA_1);
|
||||
d_alpha1 = static_cast<double>(read_navigation_signed(subframe_bits, ALPHA_1));
|
||||
d_alpha1 = d_alpha1 * ALPHA_1_LSB;
|
||||
d_alpha2 = (double)read_navigation_signed(subframe_bits, ALPHA_2);
|
||||
d_alpha2 = static_cast<double>(read_navigation_signed(subframe_bits, ALPHA_2));
|
||||
d_alpha2 = d_alpha2 * ALPHA_2_LSB;
|
||||
d_alpha3 = (double)read_navigation_signed(subframe_bits, ALPHA_3);
|
||||
d_alpha3 = static_cast<double>(read_navigation_signed(subframe_bits, ALPHA_3));
|
||||
d_alpha3 = d_alpha3 * ALPHA_3_LSB;
|
||||
d_beta0 = (double)read_navigation_signed(subframe_bits, BETA_0);
|
||||
d_beta0 = static_cast<double>(read_navigation_signed(subframe_bits, BETA_0));
|
||||
d_beta0 = d_beta0 * BETA_0_LSB;
|
||||
d_beta1 = (double)read_navigation_signed(subframe_bits, BETA_1);
|
||||
d_beta1 = static_cast<double>(read_navigation_signed(subframe_bits, BETA_1));
|
||||
d_beta1 = d_beta1 * BETA_1_LSB;
|
||||
d_beta2 = (double)read_navigation_signed(subframe_bits, BETA_2);
|
||||
d_beta2 = static_cast<double>(read_navigation_signed(subframe_bits, BETA_2));
|
||||
d_beta2 = d_beta2 * BETA_2_LSB;
|
||||
d_beta3 = (double)read_navigation_signed(subframe_bits, BETA_3);
|
||||
d_beta3 = static_cast<double>(read_navigation_signed(subframe_bits, BETA_3));
|
||||
d_beta3 = d_beta3 * BETA_3_LSB;
|
||||
d_A1 = (double)read_navigation_signed(subframe_bits, A_1);
|
||||
d_A1 = static_cast<double>(read_navigation_signed(subframe_bits, A_1));
|
||||
d_A1 = d_A1 * A_1_LSB;
|
||||
d_A0 = (double)read_navigation_signed(subframe_bits, A_0);
|
||||
d_A0 = static_cast<double>(read_navigation_signed(subframe_bits, A_0));
|
||||
d_A0 = d_A0 * A_0_LSB;
|
||||
d_t_OT = (double)read_navigation_unsigned(subframe_bits, T_OT);
|
||||
d_t_OT = static_cast<double>(read_navigation_unsigned(subframe_bits, T_OT));
|
||||
d_t_OT = d_t_OT * T_OT_LSB;
|
||||
i_WN_T = (int)read_navigation_unsigned(subframe_bits, WN_T);
|
||||
d_DeltaT_LS = (double)read_navigation_signed(subframe_bits, DELTAT_LS);
|
||||
i_WN_LSF = (int)read_navigation_unsigned(subframe_bits, WN_LSF);
|
||||
i_DN = (int)read_navigation_unsigned(subframe_bits, DN); // Right-justified ?
|
||||
d_DeltaT_LSF = (double)read_navigation_signed(subframe_bits, DELTAT_LSF);
|
||||
i_WN_T = static_cast<int>(read_navigation_unsigned(subframe_bits, WN_T));
|
||||
d_DeltaT_LS = static_cast<double>(read_navigation_signed(subframe_bits, DELTAT_LS));
|
||||
i_WN_LSF = static_cast<int>(read_navigation_unsigned(subframe_bits, WN_LSF));
|
||||
i_DN = static_cast<int>(read_navigation_unsigned(subframe_bits, DN)); // Right-justified ?
|
||||
d_DeltaT_LSF = static_cast<double>(read_navigation_signed(subframe_bits, DELTAT_LSF));
|
||||
flag_iono_valid = true;
|
||||
flag_utc_model_valid = true;
|
||||
}
|
||||
@ -599,60 +599,60 @@ int Gps_Navigation_Message::subframe_decoder(char *subframe)
|
||||
{
|
||||
// Page 25 Anti-Spoofing, SV config and almanac health (PRN: 25-32)
|
||||
//! \TODO Read Anti-Spoofing, SV config
|
||||
almanacHealth[25] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV25);
|
||||
almanacHealth[26] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV26);
|
||||
almanacHealth[27] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV27);
|
||||
almanacHealth[28] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV28);
|
||||
almanacHealth[29] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV29);
|
||||
almanacHealth[30] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV30);
|
||||
almanacHealth[31] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV31);
|
||||
almanacHealth[32] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV32);
|
||||
almanacHealth[25] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV25));
|
||||
almanacHealth[26] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV26));
|
||||
almanacHealth[27] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV27));
|
||||
almanacHealth[28] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV28));
|
||||
almanacHealth[29] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV29));
|
||||
almanacHealth[30] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV30));
|
||||
almanacHealth[31] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV31));
|
||||
almanacHealth[32] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV32));
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case 5://--- It is subframe 5 -----------------almanac health (PRN: 1-24) and Almanac reference week number and time.
|
||||
d_TOW_SF5 = (double)read_navigation_unsigned(subframe_bits, TOW);
|
||||
d_TOW_SF5 = d_TOW_SF5*6;
|
||||
d_TOW_SF5 = static_cast<double>(read_navigation_unsigned(subframe_bits, TOW));
|
||||
d_TOW_SF5 = d_TOW_SF5 * 6;
|
||||
d_TOW = d_TOW_SF5 - 6; // Set transmission time
|
||||
b_integrity_status_flag = read_navigation_bool(subframe_bits, INTEGRITY_STATUS_FLAG);
|
||||
b_alert_flag = read_navigation_bool(subframe_bits, ALERT_FLAG);
|
||||
b_antispoofing_flag = read_navigation_bool(subframe_bits, ANTI_SPOOFING_FLAG);
|
||||
SV_data_ID = (int)read_navigation_unsigned(subframe_bits, SV_DATA_ID);
|
||||
SV_page = (int)read_navigation_unsigned(subframe_bits, SV_PAGE);
|
||||
SV_data_ID = static_cast<int>(read_navigation_unsigned(subframe_bits, SV_DATA_ID));
|
||||
SV_page = static_cast<int>(read_navigation_unsigned(subframe_bits, SV_PAGE));
|
||||
if (SV_page < 25)
|
||||
{
|
||||
//! \TODO read almanac
|
||||
}
|
||||
if (SV_page == 25)
|
||||
{
|
||||
d_Toa = (double)read_navigation_unsigned(subframe_bits, T_OA);
|
||||
d_Toa = static_cast<double>(read_navigation_unsigned(subframe_bits, T_OA));
|
||||
d_Toa = d_Toa * T_OA_LSB;
|
||||
i_WN_A = (int)read_navigation_unsigned(subframe_bits, WN_A);
|
||||
almanacHealth[1] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV1);
|
||||
almanacHealth[2] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV2);
|
||||
almanacHealth[3] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV3);
|
||||
almanacHealth[4] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV4);
|
||||
almanacHealth[5] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV5);
|
||||
almanacHealth[6] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV6);
|
||||
almanacHealth[7] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV7);
|
||||
almanacHealth[8] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV8);
|
||||
almanacHealth[9] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV9);
|
||||
almanacHealth[10] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV10);
|
||||
almanacHealth[11] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV11);
|
||||
almanacHealth[12] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV12);
|
||||
almanacHealth[13] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV13);
|
||||
almanacHealth[14] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV14);
|
||||
almanacHealth[15] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV15);
|
||||
almanacHealth[16] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV16);
|
||||
almanacHealth[17] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV17);
|
||||
almanacHealth[18] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV18);
|
||||
almanacHealth[19] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV19);
|
||||
almanacHealth[20] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV20);
|
||||
almanacHealth[21] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV21);
|
||||
almanacHealth[22] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV22);
|
||||
almanacHealth[23] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV23);
|
||||
almanacHealth[24] = (int)read_navigation_unsigned(subframe_bits, HEALTH_SV24);
|
||||
i_WN_A = static_cast<int>(read_navigation_unsigned(subframe_bits, WN_A));
|
||||
almanacHealth[1] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV1));
|
||||
almanacHealth[2] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV2));
|
||||
almanacHealth[3] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV3));
|
||||
almanacHealth[4] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV4));
|
||||
almanacHealth[5] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV5));
|
||||
almanacHealth[6] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV6));
|
||||
almanacHealth[7] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV7));
|
||||
almanacHealth[8] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV8));
|
||||
almanacHealth[9] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV9));
|
||||
almanacHealth[10] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV10));
|
||||
almanacHealth[11] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV11));
|
||||
almanacHealth[12] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV12));
|
||||
almanacHealth[13] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV13));
|
||||
almanacHealth[14] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV14));
|
||||
almanacHealth[15] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV15));
|
||||
almanacHealth[16] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV16));
|
||||
almanacHealth[17] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV17));
|
||||
almanacHealth[18] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV18));
|
||||
almanacHealth[19] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV19));
|
||||
almanacHealth[20] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV20));
|
||||
almanacHealth[21] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV21));
|
||||
almanacHealth[22] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV22));
|
||||
almanacHealth[23] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV23));
|
||||
almanacHealth[24] = static_cast<int>(read_navigation_unsigned(subframe_bits, HEALTH_SV24));
|
||||
}
|
||||
break;
|
||||
|
||||
@ -670,7 +670,7 @@ double Gps_Navigation_Message::utc_time(double gpstime_corrected)
|
||||
{
|
||||
double t_utc;
|
||||
double t_utc_daytime;
|
||||
double Delta_t_UTC = d_DeltaT_LS + d_A0 + d_A1 * (gpstime_corrected - d_t_OT + 604800 * (double)(i_GPS_week - i_WN_T));
|
||||
double Delta_t_UTC = d_DeltaT_LS + d_A0 + d_A1 * (gpstime_corrected - d_t_OT + 604800 * static_cast<double>((i_GPS_week - i_WN_T)));
|
||||
|
||||
// Determine if the effectivity time of the leap second event is in the past
|
||||
int weeksToLeapSecondEvent = i_WN_LSF - i_GPS_week;
|
||||
@ -710,7 +710,7 @@ double Gps_Navigation_Message::utc_time(double gpstime_corrected)
|
||||
}
|
||||
if ( (gpstime_corrected - secondOfLeapSecondEvent) > 21600)
|
||||
{
|
||||
Delta_t_UTC = d_DeltaT_LSF + d_A0 + d_A1 * (gpstime_corrected - d_t_OT + 604800*(double)(i_GPS_week - i_WN_T));
|
||||
Delta_t_UTC = d_DeltaT_LSF + d_A0 + d_A1 * (gpstime_corrected - d_t_OT + 604800 * static_cast<double>((i_GPS_week - i_WN_T)));
|
||||
t_utc_daytime = fmod(gpstime_corrected - Delta_t_UTC, 86400);
|
||||
}
|
||||
}
|
||||
@ -722,7 +722,7 @@ double Gps_Navigation_Message::utc_time(double gpstime_corrected)
|
||||
* WNLSF and DN values, is in the "past" (relative to the user's current time),
|
||||
* and the user<EFBFBD>s current time does not fall in the time span as given above
|
||||
* in 20.3.3.5.2.4b,*/
|
||||
Delta_t_UTC = d_DeltaT_LSF + d_A0 + d_A1 * (gpstime_corrected - d_t_OT + 604800 * (double)(i_GPS_week - i_WN_T));
|
||||
Delta_t_UTC = d_DeltaT_LSF + d_A0 + d_A1 * (gpstime_corrected - d_t_OT + 604800 * static_cast<double>((i_GPS_week - i_WN_T)));
|
||||
t_utc_daytime = fmod(gpstime_corrected - Delta_t_UTC, 86400);
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user