mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-15 04:30:33 +00:00
Code Issues Releases Wiki Activity

Update to Galileo HAS ICD v1.4

Browse Source
This commit is contained in:
Carles Fernandez 2021-11-19 17:50:41 +01:00
parent a4a5f777bc
commit 98a850053c
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
6 changed files with 88 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/algorithms/PVT/libs/has_simple_printer.cc
View File

@ -183,7 +183,7 @@ bool Has_Simple_Printer::print_message(const Galileo_HAS_data* const has_data)
d_has_file << indent << indent << "Code Bias Flag: " << static_cast<float>(has_data->header.code_bias_flag) << '\n';
d_has_file << indent << indent << "Phase Bias Flag: " << static_cast<float>(has_data->header.phase_bias_flag) << '\n';
d_has_file << indent << indent << "Mask ID: " << static_cast<float>(has_data->header.mask_id) << '\n';
d_has_file << indent << indent << "IOD Set ID: " << static_cast<float>(has_data->header.iod_id) << "\n\n";
d_has_file << indent << indent << "IOD Set ID: " << static_cast<float>(has_data->header.iod_set_id) << "\n\n";
d_has_file << indent << "MT1 Body\n";
d_has_file << indent << "--------\n";
@ -240,7 +240,7 @@ bool Has_Simple_Printer::print_message(const Galileo_HAS_data* const has_data)
d_has_file << indent << indent << "Validity interval: " << static_cast<float>(has_data->validity_interval_index_orbit_corrections) << '\n';
d_has_file << indent << indent << "GNSS IOD: " << print_vector(has_data->gnss_iod) << '\n';
d_has_file << indent << indent << "Delta Radial [m]: " << print_vector(has_data->delta_radial, HAS_MSG_DELTA_RADIAL_SCALE_FACTOR) << '\n';
d_has_file << indent << indent << "Delta Along Track [m]: " << print_vector(has_data->delta_along_track, HAS_MSG_DELTA_ALONG_TRACK_SCALE_FACTOR) << '\n';
d_has_file << indent << indent << "Delta In-Track [m]: " << print_vector(has_data->delta_in_track, HAS_MSG_DELTA_IN_TRACK_SCALE_FACTOR) << '\n';
d_has_file << indent << indent << "Delta Cross Track [m]: " << print_vector(has_data->delta_cross_track, HAS_MSG_DELTA_CROSS_TRACK_SCALE_FACTOR) << '\n';
}

82
src/core/libs/galileo_e6_has_msg_receiver.cc
View File

@ -103,6 +103,47 @@ void galileo_e6_has_msg_receiver::set_enable_navdata_monitor(bool enable)
}
std::shared_ptr<Galileo_HAS_data> galileo_e6_has_msg_receiver::process_test_page(const pmt::pmt_t& msg)
{
try
{
const size_t msg_type_hash_code = pmt::any_ref(msg).type().hash_code();
if (msg_type_hash_code == typeid(std::shared_ptr<Galileo_HAS_page>).hash_code())
{
const auto HAS_data_page = wht::any_cast<std::shared_ptr<Galileo_HAS_page>>(pmt::any_ref(msg));
DLOG(INFO) << "New HAS page received: "
<< "Status: " << static_cast<float>(HAS_data_page->has_status) << ", "
<< "MT: " << static_cast<float>(HAS_data_page->message_type) << ", "
<< "MID: " << static_cast<float>(HAS_data_page->message_id) << ", "
<< "MS: " << static_cast<float>(HAS_data_page->message_size) << ", "
<< "PID: " << static_cast<float>(HAS_data_page->message_page_id);
d_current_has_status = HAS_data_page->has_status;
d_current_message_id = HAS_data_page->message_id;
process_HAS_page(*HAS_data_page.get());
}
else
{
LOG(WARNING) << "galileo_e6_has_msg_receiver received an unknown object type!";
}
}
catch (const wht::bad_any_cast& e)
{
LOG(WARNING) << "galileo_e6_has_msg_receiver Bad any_cast: " << e.what();
}
// Return the resulting decoded HAS data (if available)
if (d_new_message == true)
{
d_HAS_data.has_status = d_current_has_status;
d_HAS_data.message_id = d_current_message_id;
auto has_data_ptr = std::make_shared<Galileo_HAS_data>(d_HAS_data);
d_new_message = false;
return has_data_ptr;
}
return nullptr;
}
void galileo_e6_has_msg_receiver::msg_handler_galileo_e6_has(const pmt::pmt_t& msg)
{
gr::thread::scoped_lock lock(d_setlock); // require mutex with msg_handler_galileo_e6_has function called by the scheduler
@ -338,36 +379,36 @@ int galileo_e6_has_msg_receiver::decode_message_type1(uint8_t message_id, uint8_
void galileo_e6_has_msg_receiver::read_MT1_header(const std::string& message_header)
{
// ICD v1.2 Table 6: MT1 Message Header
// ICD v1.4 Table 7: MT1 Message Header
const std::bitset<GALILEO_CNAV_MT1_HEADER_BITS> has_mt1_header(message_header);
d_HAS_data.header.toh = read_has_message_header_parameter_uint16(has_mt1_header, GALILEO_MT1_HEADER_TOH);
d_HAS_data.header.mask_id = read_has_message_header_parameter_uint8(has_mt1_header, GALILEO_MT1_HEADER_MASK_ID);
d_HAS_data.header.iod_id = read_has_message_header_parameter_uint8(has_mt1_header, GALILEO_MT1_HEADER_IOD_ID);
d_HAS_data.header.mask_flag = read_has_message_header_parameter_bool(has_mt1_header, GALILEO_MT1_HEADER_MASK_FLAG);
d_HAS_data.header.orbit_correction_flag = read_has_message_header_parameter_bool(has_mt1_header, GALILEO_MT1_HEADER_ORBIT_CORRECTION_FLAG);
d_HAS_data.header.clock_fullset_flag = read_has_message_header_parameter_bool(has_mt1_header, GALILEO_MT1_HEADER_CLOCK_FULLSET_FLAG);
d_HAS_data.header.clock_subset_flag = read_has_message_header_parameter_bool(has_mt1_header, GALILEO_MT1_HEADER_CLOCK_SUBSET_FLAG);
d_HAS_data.header.code_bias_flag = read_has_message_header_parameter_bool(has_mt1_header, GALILEO_MT1_HEADER_CODE_BIAS_FLAG);
d_HAS_data.header.phase_bias_flag = read_has_message_header_parameter_bool(has_mt1_header, GALILEO_MT1_HEADER_PHASE_BIAS_FLAG);
d_HAS_data.header.ura_flag = read_has_message_header_parameter_bool(has_mt1_header, GALILEO_MT1_HEADER_URA_FLAG);
d_HAS_data.header.reserved = read_has_message_header_parameter_uint8(has_mt1_header, GALILEO_MT1_HEADER_RESERVED);
d_HAS_data.header.mask_id = read_has_message_header_parameter_uint8(has_mt1_header, GALILEO_MT1_HEADER_MASK_ID);
d_HAS_data.header.iod_set_id = read_has_message_header_parameter_uint8(has_mt1_header, GALILEO_MT1_HEADER_IOD_SET_ID);
DLOG(INFO) << "MT1 header " << message_header << ": "
<< "TOH: " << static_cast<float>(d_HAS_data.header.toh) << ", "
<< "mask ID: " << static_cast<float>(d_HAS_data.header.mask_id) << ", "
<< "iod ID: " << static_cast<float>(d_HAS_data.header.iod_id) << ", "
<< "mask_flag: " << static_cast<float>(d_HAS_data.header.mask_flag) << ", "
<< "orbit_correction_flag: " << static_cast<float>(d_HAS_data.header.orbit_correction_flag) << ", "
<< "clock_fullset_flag: " << static_cast<float>(d_HAS_data.header.clock_fullset_flag) << ", "
<< "clock_subset_flag: " << static_cast<float>(d_HAS_data.header.clock_subset_flag) << ", "
<< "code_bias_flag: " << static_cast<float>(d_HAS_data.header.code_bias_flag) << ", "
<< "phase_bias_flag: " << static_cast<float>(d_HAS_data.header.phase_bias_flag) << ", "
<< "ura_flag: " << static_cast<float>(d_HAS_data.header.ura_flag);
<< "reserved: " << static_cast<float>(d_HAS_data.header.reserved) << ", "
<< "mask ID: " << static_cast<float>(d_HAS_data.header.mask_id) << ", "
<< "iod ID: " << static_cast<float>(d_HAS_data.header.iod_set_id);
}
void galileo_e6_has_msg_receiver::read_MT1_body(const std::string& message_body)
{
// ICD v1.2 Table 7: MT1 Message Body.
// ICD v1.4 Table 8: MT1 Message Body.
auto message = std::string(message_body);
int Nsat = 0;
bool have_mask = false;
@ -489,7 +530,7 @@ void galileo_e6_has_msg_receiver::read_MT1_body(const std::string& message_body)
message = std::string(message.begin() + HAS_MSG_VALIDITY_INDEX_LENGTH, message.end());
d_HAS_data.gnss_iod = std::vector<uint16_t>(Nsat);
d_HAS_data.delta_radial = std::vector<int16_t>(Nsat);
d_HAS_data.delta_along_track = std::vector<int16_t>(Nsat);
d_HAS_data.delta_in_track = std::vector<int16_t>(Nsat);
d_HAS_data.delta_cross_track = std::vector<int16_t>(Nsat);
for (int i = 0; i < Nsat; i++)
{
@ -520,8 +561,8 @@ void galileo_e6_has_msg_receiver::read_MT1_body(const std::string& message_body)
d_HAS_data.delta_radial[i] = read_has_message_body_int16(message.substr(0, HAS_MSG_DELTA_RADIAL_LENGTH));
message = std::string(message.begin() + HAS_MSG_DELTA_RADIAL_LENGTH, message.end());
d_HAS_data.delta_along_track[i] = read_has_message_body_int16(message.substr(0, HAS_MSG_DELTA_ALONG_TRACK_LENGTH));
message = std::string(message.begin() + HAS_MSG_DELTA_ALONG_TRACK_LENGTH, message.end());
d_HAS_data.delta_in_track[i] = read_has_message_body_int16(message.substr(0, HAS_MSG_DELTA_IN_TRACK_LENGTH));
message = std::string(message.begin() + HAS_MSG_DELTA_IN_TRACK_LENGTH, message.end());
d_HAS_data.delta_cross_track[i] = read_has_message_body_int16(message.substr(0, HAS_MSG_DELTA_CROSS_TRACK_LENGTH));
message = std::string(message.begin() + HAS_MSG_DELTA_CROSS_TRACK_LENGTH, message.end());
@ -530,7 +571,7 @@ void galileo_e6_has_msg_receiver::read_MT1_body(const std::string& message_body)
DLOG(INFO) << debug_print_vector("gnss_iod", d_HAS_data.gnss_iod);
DLOG(INFO) << debug_print_vector("delta_radial", d_HAS_data.delta_radial);
DLOG(INFO) << debug_print_vector("delta_along_track", d_HAS_data.delta_along_track);
DLOG(INFO) << debug_print_vector("delta_in_track", d_HAS_data.delta_in_track);
DLOG(INFO) << debug_print_vector("delta_cross_track", d_HAS_data.delta_cross_track);
}
@ -547,12 +588,9 @@ void galileo_e6_has_msg_receiver::read_MT1_body(const std::string& message_body)
message = std::string(message.begin() + HAS_MSG_DELTA_CLOCK_C0_MULTIPLIER_LENGTH, message.end());
}
d_HAS_data.iod_change_flag = std::vector<bool>(Nsat);
d_HAS_data.delta_clock_c0 = std::vector<int16_t>(Nsat);
for (int i = 0; i < Nsat; i++)
{
d_HAS_data.iod_change_flag[i] = (message[0] == '1' ? true : false);
message = std::string(message.begin() + 1, message.end());
d_HAS_data.delta_clock_c0[i] = read_has_message_body_int16(message.substr(0, HAS_MSG_DELTA_CLOCK_C0_LENGTH));
message = std::string(message.begin() + HAS_MSG_DELTA_CLOCK_C0_LENGTH, message.end());
}
@ -580,7 +618,6 @@ void galileo_e6_has_msg_receiver::read_MT1_body(const std::string& message_body)
d_HAS_data.gnss_id_clock_subset = std::vector<uint8_t>(d_HAS_data.Nsysprime);
d_HAS_data.delta_clock_c0_multiplier_clock_subset = std::vector<uint8_t>(d_HAS_data.Nsysprime);
d_HAS_data.satellite_submask = std::vector<uint64_t>(d_HAS_data.Nsysprime);
d_HAS_data.iod_change_flag_clock_subset = std::vector<std::vector<bool>>(d_HAS_data.Nsysprime, std::vector<bool>());
d_HAS_data.delta_clock_c0_clock_subset = std::vector<std::vector<int16_t>>(d_HAS_data.Nsysprime, std::vector<int16_t>());
for (uint8_t i = 0; i < d_HAS_data.Nsysprime; i++)
@ -785,19 +822,6 @@ void galileo_e6_has_msg_receiver::read_MT1_body(const std::string& message_body)
DLOG(INFO) << debug_print_matrix("phase bias", d_HAS_data.phase_bias);
DLOG(INFO) << debug_print_matrix("phase discontinuity indicator", d_HAS_data.phase_discontinuity_indicator);
}
// if (d_HAS_data.header.ura_flag && have_mask)
// {
// // read URA
// d_HAS_data.validity_interval_index_ura_corrections = read_has_message_body_uint8(message.substr(0, HAS_MSG_VALIDITY_INDEX_LENGTH));
// message = std::string(message.begin() + HAS_MSG_VALIDITY_INDEX_LENGTH, message.end());
// d_HAS_data.ura = std::vector<uint8_t>(Nsat);
// for (int i = 0; i < Nsat; i++)
// {
// d_HAS_data.ura[i] = read_has_message_body_uint8(message.substr(0, HAS_MSG_URA_LENGTH));
// message = std::string(message.begin() + HAS_MSG_URA_LENGTH, message.end());
// }
// }
}

1
src/core/libs/galileo_e6_has_msg_receiver.h
View File

@ -57,6 +57,7 @@ class galileo_e6_has_msg_receiver : public gr::block
public:
~galileo_e6_has_msg_receiver() = default; //!< Default destructor
void set_enable_navdata_monitor(bool enable);
std::shared_ptr<Galileo_HAS_data> process_test_page(const pmt::pmt_t& msg); //!< For testing purposes only
private:
friend galileo_e6_has_msg_receiver_sptr galileo_e6_has_msg_receiver_make();

23
src/core/system_parameters/Galileo_CNAV.h
View File

@ -1,9 +1,9 @@
/*!
* \file Galileo_CNAV.h
* \brief Galileo CNAV mesage constants. Data from:
* Galileo High Accuracy Service E6-B Signal-In-Space Message Specification v1.2
* (April 2020).
* \author Carles Fernandez-Prades, 2020. cfernandez(at)cttc.es
* Galileo High Accuracy Service E6-B Signal-In-Space Message Specification v1.4
* (February 2021).
* \author Carles Fernandez-Prades, 2020-2021. cfernandez(at)cttc.es
*
*
* -----------------------------------------------------------------------------
@ -61,11 +61,11 @@ constexpr size_t HAS_MSG_MASK_RESERVED_LENGTH = 6;
constexpr size_t HAS_MSG_VALIDITY_INDEX_LENGTH = 4;
constexpr size_t HAS_MSG_IOD_GPS_LENGTH = 8;
constexpr size_t HAS_MSG_IOD_GAL_LENGTH = 10;
constexpr size_t HAS_MSG_DELTA_RADIAL_LENGTH = 14;
constexpr size_t HAS_MSG_DELTA_ALONG_TRACK_LENGTH = 12;
constexpr size_t HAS_MSG_DELTA_RADIAL_LENGTH = 13;
constexpr size_t HAS_MSG_DELTA_IN_TRACK_LENGTH = 12;
constexpr size_t HAS_MSG_DELTA_CROSS_TRACK_LENGTH = 12;
constexpr size_t HAS_MSG_DELTA_CLOCK_C0_MULTIPLIER_LENGTH = 2;
constexpr size_t HAS_MSG_DELTA_CLOCK_C0_LENGTH = 14;
constexpr size_t HAS_MSG_DELTA_CLOCK_C0_LENGTH = 13;
constexpr size_t HAS_MSG_NSYSPRIME_LENGTH = 4;
constexpr size_t HAS_MSG_ID_CLOCK_SUBSET_LENGTH = 4;
constexpr size_t HAS_MSG_DELTA_CLOCK_MULTIPLIER_SUBSET_LENGTH = 2;
@ -73,7 +73,6 @@ constexpr size_t HAS_MSG_DELTA_CLOCK_C0_SUBSET_LENGTH = 13;
constexpr size_t HAS_MSG_CODE_BIAS_LENGTH = 11;
constexpr size_t HAS_MSG_PHASE_BIAS_LENGTH = 11;
constexpr size_t HAS_MSG_PHASE_DISCONTINUITY_INDICATOR_LENGTH = 2;
constexpr size_t HAS_MSG_URA_LENGTH = 2;
constexpr int32_t HAS_MSG_NUMBER_MASK_IDS = 32;
constexpr int32_t HAS_MSG_NUMBER_GNSS_IDS = 16;
@ -82,7 +81,7 @@ constexpr int32_t HAS_MSG_NUMBER_SATELLITE_IDS = 40;
constexpr int32_t HAS_MSG_NUMBER_SIGNAL_MASKS = 16;
constexpr float HAS_MSG_DELTA_RADIAL_SCALE_FACTOR = 0.0025;
constexpr float HAS_MSG_DELTA_ALONG_TRACK_SCALE_FACTOR = 0.008;
constexpr float HAS_MSG_DELTA_IN_TRACK_SCALE_FACTOR = 0.008;
constexpr float HAS_MSG_DELTA_CROSS_TRACK_SCALE_FACTOR = 0.008;
constexpr float HAS_MSG_DELTA_CLOCK_SCALE_FACTOR = 0.0025;
constexpr float HAS_MSG_CODE_BIAS_SCALE_FACTOR = 0.02;
@ -90,8 +89,8 @@ constexpr float HAS_MSG_PHASE_BIAS_SCALE_FACTOR = 0.01;
constexpr uint16_t HAS_MSG_NUMBER_MAX_TOH = 3599;
constexpr uint8_t HAS_MSG_GPS_SYSTEM = 0; // Table 8 ICD v1.2
constexpr uint8_t HAS_MSG_GALILEO_SYSTEM = 2; // Table 8 ICD v1.2
constexpr uint8_t HAS_MSG_GPS_SYSTEM = 0; // Table 9 ICD v1.4
constexpr uint8_t HAS_MSG_GALILEO_SYSTEM = 2; // Table 9 ICD v1.4
constexpr uint8_t HAS_MSG_WRONG_SYSTEM = 255;
const std::pair<int32_t, int32_t> GALILEO_HAS_STATUS({1, 2});
@ -108,9 +107,9 @@ const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_CLOCK_FULLSET_FLAG({15, 1})
const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_CLOCK_SUBSET_FLAG({16, 1});
const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_CODE_BIAS_FLAG({17, 1});
const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_PHASE_BIAS_FLAG({18, 1});
const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_URA_FLAG({19, 1});
const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_RESERVED({19, 4});
const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_MASK_ID({23, 5});
const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_IOD_ID({28, 5});
const std::pair<int32_t, int32_t> GALILEO_MT1_HEADER_IOD_SET_ID({28, 5});
/** \} */

28
src/core/system_parameters/galileo_has_data.cc
View File

@ -503,28 +503,28 @@ std::vector<float> Galileo_HAS_data::get_delta_radial_m(uint8_t nsys) const
}
std::vector<float> Galileo_HAS_data::get_delta_along_track_m() const
std::vector<float> Galileo_HAS_data::get_delta_in_track_m() const
{
std::vector<float> delta_along_track_m;
delta_along_track_m.reserve(this->delta_along_track.size());
for (const auto& d : this->delta_along_track)
std::vector<float> delta_in_track_m;
delta_in_track_m.reserve(this->delta_in_track.size());
for (const auto& d : this->delta_in_track)
{
delta_along_track_m.push_back(static_cast<float>(d) * HAS_MSG_DELTA_ALONG_TRACK_SCALE_FACTOR);
delta_in_track_m.push_back(static_cast<float>(d) * HAS_MSG_DELTA_IN_TRACK_SCALE_FACTOR);
}
return delta_along_track_m;
return delta_in_track_m;
}
std::vector<float> Galileo_HAS_data::get_delta_along_track_m(uint8_t nsys) const
std::vector<float> Galileo_HAS_data::get_delta_in_track_m(uint8_t nsys) const
{
std::vector<float> delta_along_track_m = this->get_delta_along_track_m();
std::vector<float> delta_in_track_m = this->get_delta_in_track_m();
if (nsys >= this->Nsys)
{
return delta_along_track_m;
return delta_in_track_m;
}
std::vector<float> delta_along_track_m_aux;
std::vector<float> delta_in_track_m_aux;
uint8_t num_sats_in_this_system = this->get_num_satellites()[nsys];
delta_along_track_m_aux.reserve(num_sats_in_this_system);
delta_in_track_m_aux.reserve(num_sats_in_this_system);
size_t index = 0;
for (uint8_t sys = 0; sys <= nsys; sys++)
@ -538,12 +538,12 @@ std::vector<float> Galileo_HAS_data::get_delta_along_track_m(uint8_t nsys) const
{
for (uint8_t sat = 0; sat < num_sats_in_system; sat++)
{
delta_along_track_m_aux.push_back(delta_along_track_m[index]);
delta_in_track_m_aux.push_back(delta_in_track_m[index]);
index++;
}
}
}
return delta_along_track_m_aux;
return delta_in_track_m_aux;
}
@ -551,7 +551,7 @@ std::vector<float> Galileo_HAS_data::get_delta_cross_track_m() const
{
std::vector<float> delta_cross_track_m;
delta_cross_track_m.reserve(this->delta_cross_track.size());
for (const auto& d : this->delta_along_track)
for (const auto& d : this->delta_cross_track)
{
delta_cross_track_m.push_back(static_cast<float>(d) * HAS_MSG_DELTA_CROSS_TRACK_SCALE_FACTOR);
}

20
src/core/system_parameters/galileo_has_data.h
View File

@ -31,14 +31,14 @@ struct mt1_header
{
uint16_t toh;
uint8_t mask_id;
uint8_t iod_id;
uint8_t iod_set_id;
uint8_t reserved;
bool mask_flag;
bool orbit_correction_flag;
bool clock_fullset_flag;
bool clock_subset_flag;
bool code_bias_flag;
bool phase_bias_flag;
bool ura_flag;
};
/*!
@ -57,10 +57,10 @@ public:
std::vector<std::vector<float>> get_phase_bias_cycle() const; //!< Get Nsat x Nphases phase biases in [cycles]
std::vector<float> get_delta_radial_m() const; //!< Get Nsat delta radial corrections in [m]
std::vector<float> get_delta_radial_m(uint8_t nsys) const; //!< Get delta radial corrections in [m] for system nsys, with 0 <= nsys < Nsys
std::vector<float> get_delta_along_track_m() const; //!< Get Nsat delta along_track corrections in [m]
std::vector<float> get_delta_along_track_m(uint8_t nsys) const; //!< Get alog-track corrections in [m] for system nsys, with 0 <= nsys < Nsys
std::vector<float> get_delta_cross_track_m() const; //!< Get Nsat delta cross_track corrections in [m]
std::vector<float> get_delta_cross_track_m(uint8_t nsys) const; //!< Get delta cross_track corrections in [m] for system nsys, with 0 <= nsys < Nsys
std::vector<float> get_delta_in_track_m() const; //!< Get Nsat delta in-track corrections in [m]
std::vector<float> get_delta_in_track_m(uint8_t nsys) const; //!< Get delta in-track corrections in [m] for system nsys, with 0 <= nsys < Nsys
std::vector<float> get_delta_cross_track_m() const; //!< Get Nsat delta cross-track corrections in [m]
std::vector<float> get_delta_cross_track_m(uint8_t nsys) const; //!< Get delta cross-track corrections in [m] for system nsys, with 0 <= nsys < Nsys
std::vector<float> get_delta_clock_c0_m() const; //!< Get Nsat delta clock C0 corrections in [m]
std::vector<float> get_delta_clock_c0_m(uint8_t nsys) const; //!< Get delta clock C0 corrections in [m] for system nsys, with 0 <= nsys < Nsys
std::vector<int> get_PRNs_in_mask(uint8_t nsys) const; //!< Get PRNs in mask for system nsys, with 0 <= nsys < Nsys
@ -83,19 +83,17 @@ public:
// Orbit corrections
std::vector<uint16_t> gnss_iod;
std::vector<int16_t> delta_radial;
std::vector<int16_t> delta_along_track;
std::vector<int16_t> delta_in_track;
std::vector<int16_t> delta_cross_track;
// Clock full-set corrections
std::vector<uint8_t> delta_clock_c0_multiplier;
std::vector<bool> iod_change_flag;
std::vector<int16_t> delta_clock_c0;
// Clock subset corrections
std::vector<uint8_t> gnss_id_clock_subset;
std::vector<uint8_t> delta_clock_c0_multiplier_clock_subset;
std::vector<uint64_t> satellite_submask;
std::vector<std::vector<bool>> iod_change_flag_clock_subset;
std::vector<std::vector<int16_t>> delta_clock_c0_clock_subset;
// Code bias
@ -105,9 +103,6 @@ public:
std::vector<std::vector<int16_t>> phase_bias;
std::vector<std::vector<uint8_t>> phase_discontinuity_indicator;
// URA
std::vector<uint8_t> ura;
mt1_header header;
uint8_t has_status;
uint8_t message_id;
@ -119,7 +114,6 @@ public:
uint8_t Nsysprime; // in Clock subset corrections
uint8_t validity_interval_index_code_bias_corrections; // in Code bias
uint8_t validity_interval_index_phase_bias_corrections; // in Phase bias
uint8_t validity_interval_index_ura_corrections; // in URA
};