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

Merge branch 'next' of https://github.com/gnss-sdr/gnss-sdr into next

Browse Source
This commit is contained in:
Carles Fernandez 2018-10-05 13:56:19 +02:00
commit 12b8b21d14
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
12 changed files with 1390 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_cc.cc
View File

@ -50,6 +50,10 @@ namespace bc = boost::math;
namespace bc = boost::integer; namespace bc = boost::integer;
#endif #endif
//includes used by the observables serializarion (export observables for rtklib unit test)
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/serialization/map.hpp>
using google::LogMessage; using google::LogMessage;
@ -507,6 +511,53 @@ bool rtklib_pvt_cc::send_sys_v_ttff_msg(ttff_msgbuf ttff)
} }
bool rtklib_pvt_cc::save_gnss_synchro_map_xml(const std::string file_name)
{
if (gnss_observables_map.empty() == false)
{
try
{
std::ofstream ofs(file_name.c_str(), std::ofstream::trunc | std::ofstream::out);
boost::archive::xml_oarchive xml(ofs);
xml << boost::serialization::make_nvp("GNSS-SDR_gnss_synchro_map", gnss_observables_map);
ofs.close();
LOG(INFO) << "Saved gnss_sychro map data";
}
catch (std::exception& e)
{
LOG(WARNING) << e.what();
return false;
}
return true;
}
else
{
LOG(WARNING) << "Failed to save gnss_synchro, map is empty";
return false;
}
}
bool rtklib_pvt_cc::load_gnss_synchro_map_xml(const std::string file_name)
{
//load from xml (boost serialize)
try
{
std::ifstream ifs(file_name.c_str(), std::ifstream::binary | std::ifstream::in);
boost::archive::xml_iarchive xml(ifs);
gnss_observables_map.clear();
xml >> boost::serialization::make_nvp("GNSS-SDR_gnss_synchro_map", gnss_observables_map);
ifs.close();
return true;
//std::cout << "Loaded gnss_synchro map data with " << gnss_synchro_map.size() << " pseudoranges" << std::endl;
}
catch (std::exception& e)
{
std::cout << e.what() << "File: " << file_name;
return false;
}
}
int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_items, int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items __attribute__((unused))) gr_vector_void_star& output_items __attribute__((unused)))
{ {
@ -526,7 +577,6 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
gnss_observables_map.clear(); gnss_observables_map.clear();
const Gnss_Synchro** in = reinterpret_cast<const Gnss_Synchro**>(&input_items[0]); // Get the input buffer pointer const Gnss_Synchro** in = reinterpret_cast<const Gnss_Synchro**>(&input_items[0]); // Get the input buffer pointer
// ############ 1. READ PSEUDORANGES #### // ############ 1. READ PSEUDORANGES ####
for (uint32_t i = 0; i < d_nchannels; i++) for (uint32_t i = 0; i < d_nchannels; i++)
{ {
@ -610,8 +660,15 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
// it->second.Pseudorange_m = it->second.Pseudorange_m - d_ls_pvt->get_time_offset_s() * GPS_C_m_s; // it->second.Pseudorange_m = it->second.Pseudorange_m - d_ls_pvt->get_time_offset_s() * GPS_C_m_s;
// } // }
if (d_ls_pvt->get_PVT(gnss_observables_map, false)) if (d_ls_pvt->get_PVT(gnss_observables_map, false))
{ {
//Optional debug code: export observables snapshot for rtklib unit testing
//std::cout << "step 1: save gnss_synchro map" << std::endl;
//save_gnss_synchro_map_xml("./gnss_synchro_map.xml");
//getchar(); //stop the execution
//end debug
if (current_RX_time_ms % d_display_rate_ms == 0) if (current_RX_time_ms % d_display_rate_ms == 0)
{ {
flag_display_pvt = true; flag_display_pvt = true;
@ -2060,7 +2117,6 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
{ {
std::streamsize ss = std::cout.precision(); // save current precision std::streamsize ss = std::cout.precision(); // save current precision
std::cout.setf(std::ios::fixed, std::ios::floatfield); std::cout.setf(std::ios::fixed, std::ios::floatfield);
auto facet = new boost::posix_time::time_facet("%Y-%b-%d %H:%M:%S.%f %z"); auto facet = new boost::posix_time::time_facet("%Y-%b-%d %H:%M:%S.%f %z");
std::cout.imbue(std::locale(std::cout.getloc(), facet)); std::cout.imbue(std::locale(std::cout.getloc(), facet));

4
src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_cc.h
View File

@ -152,6 +152,10 @@ private:
bool send_sys_v_ttff_msg(ttff_msgbuf ttff); bool send_sys_v_ttff_msg(ttff_msgbuf ttff);
std::chrono::time_point<std::chrono::system_clock> start, end; std::chrono::time_point<std::chrono::system_clock> start, end;
bool save_gnss_synchro_map_xml(const std::string file_name); //debug helper function
bool load_gnss_synchro_map_xml(const std::string file_name); //debug helper function
public: public:
rtklib_pvt_cc(uint32_t nchannels, rtklib_pvt_cc(uint32_t nchannels,
bool dump, std::string dump_filename, bool dump, std::string dump_filename,

3
src/algorithms/PVT/libs/rtklib_solver.h
View File

@ -76,12 +76,13 @@ private:
rtk_t rtk_; rtk_t rtk_;
std::string d_dump_filename; std::string d_dump_filename;
std::ofstream d_dump_file; std::ofstream d_dump_file;
sol_t pvt_sol;
bool d_flag_dump_enabled; bool d_flag_dump_enabled;
int d_nchannels; // Number of available channels for positioning int d_nchannels; // Number of available channels for positioning
double dop_[4]; double dop_[4];
public: public:
sol_t pvt_sol;
rtklib_solver(int nchannels, std::string dump_filename, bool flag_dump_to_file, rtk_t& rtk); rtklib_solver(int nchannels, std::string dump_filename, bool flag_dump_to_file, rtk_t& rtk);
~rtklib_solver(); ~rtklib_solver();

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

@ -801,8 +801,8 @@ void GNSSFlowgraph::wait()
bool GNSSFlowgraph::send_telemetry_msg(pmt::pmt_t msg) bool GNSSFlowgraph::send_telemetry_msg(pmt::pmt_t msg)
{ {
//push ephemeris to PVT telemetry msg in port using a channel out port // Push ephemeris to PVT telemetry msg in port using a channel out port
// it uses the first channel as a message produces (it is already connected to PVT) // it uses the first channel as a message producer (it is already connected to PVT)
channels_.at(0)->get_right_block()->message_port_pub(pmt::mp("telemetry"), msg); channels_.at(0)->get_right_block()->message_port_pub(pmt::mp("telemetry"), msg);
return true; return true;
} }
@ -816,6 +816,7 @@ bool GNSSFlowgraph::send_telemetry_msg(pmt::pmt_t msg)
*/ */
void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what) void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
{ {
std::lock_guard<std::mutex> lock(signal_list_mutex);
DLOG(INFO) << "Received " << what << " from " << who << ". Number of applied actions = " << applied_actions_; DLOG(INFO) << "Received " << what << " from " << who << ". Number of applied actions = " << applied_actions_;
unsigned int sat = 0; unsigned int sat = 0;
try try
@ -826,7 +827,6 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
{ {
LOG(WARNING) << e.what(); LOG(WARNING) << e.what();
} }
std::lock_guard<std::mutex> lock(signal_list_mutex);
switch (what) switch (what)
{ {
case 0: case 0:
@ -1336,8 +1336,8 @@ void GNSSFlowgraph::set_signals_list()
if (configuration_->property("Channels_1G.count", 0) > 0) if (configuration_->property("Channels_1G.count", 0) > 0)
{ {
// Loop to create the list of GLONASS L1 C/A signals // Loop to create the list of GLONASS L1 C/A signals
for (available_gnss_prn_iter = available_glonass_prn.begin(); for (available_gnss_prn_iter = available_glonass_prn.cbegin();
available_gnss_prn_iter != available_glonass_prn.end(); available_gnss_prn_iter != available_glonass_prn.cend();
available_gnss_prn_iter++) available_gnss_prn_iter++)
{ {
available_GLO_1G_signals_.push_back(Gnss_Signal( available_GLO_1G_signals_.push_back(Gnss_Signal(
@ -1349,8 +1349,8 @@ void GNSSFlowgraph::set_signals_list()
if (configuration_->property("Channels_2G.count", 0) > 0) if (configuration_->property("Channels_2G.count", 0) > 0)
{ {
// Loop to create the list of GLONASS L2 C/A signals // Loop to create the list of GLONASS L2 C/A signals
for (available_gnss_prn_iter = available_glonass_prn.begin(); for (available_gnss_prn_iter = available_glonass_prn.cbegin();
available_gnss_prn_iter != available_glonass_prn.end(); available_gnss_prn_iter != available_glonass_prn.cend();
available_gnss_prn_iter++) available_gnss_prn_iter++)
{ {
available_GLO_2G_signals_.push_back(Gnss_Signal( available_GLO_2G_signals_.push_back(Gnss_Signal(
@ -1363,6 +1363,7 @@ void GNSSFlowgraph::set_signals_list()
void GNSSFlowgraph::set_channels_state() void GNSSFlowgraph::set_channels_state()
{ {
std::lock_guard<std::mutex> lock(signal_list_mutex);
max_acq_channels_ = configuration_->property("Channels.in_acquisition", channels_count_); max_acq_channels_ = configuration_->property("Channels.in_acquisition", channels_count_);
if (max_acq_channels_ > channels_count_) if (max_acq_channels_ > channels_count_)
{ {
@ -1382,7 +1383,6 @@ void GNSSFlowgraph::set_channels_state()
} }
DLOG(INFO) << "Channel " << i << " in state " << channels_state_[i]; DLOG(INFO) << "Channel " << i << " in state " << channels_state_[i];
} }
std::lock_guard<std::mutex> lock(signal_list_mutex);
acq_channels_count_ = max_acq_channels_; acq_channels_count_ = max_acq_channels_;
DLOG(INFO) << acq_channels_count_ << " channels in acquisition state"; DLOG(INFO) << acq_channels_count_ << " channels in acquisition state";
} }
@ -1599,16 +1599,16 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(std::string searched_signal, bool
return result; return result;
} }
std::vector<std::string> GNSSFlowgraph::split_string(const std::string &s, char delim) std::vector<std::string> GNSSFlowgraph::split_string(const std::string& s, char delim)
{ {
std::vector<std::string> v; std::vector<std::string> v;
std::stringstream ss(s); std::stringstream ss(s);
std::string item; std::string item;
while (std::getline(ss, item, delim)) while (std::getline(ss, item, delim))
{ {
*(std::back_inserter(v)++) = item; *(std::back_inserter(v)++) = item;
} }
return v; return v;
} }

52
src/core/system_parameters/gnss_synchro.h
View File

@ -33,6 +33,7 @@
#ifndef GNSS_SDR_GNSS_SYNCHRO_H_ #ifndef GNSS_SDR_GNSS_SYNCHRO_H_
#define GNSS_SDR_GNSS_SYNCHRO_H_ #define GNSS_SDR_GNSS_SYNCHRO_H_
#include <boost/serialization/nvp.hpp>
#include "gnss_signal.h" #include "gnss_signal.h"
#include <cstdint> #include <cstdint>
@ -83,41 +84,42 @@ public:
* Gnss_Synchro objects from a byte stream. * Gnss_Synchro objects from a byte stream.
*/ */
template <class Archive> template <class Archive>
void serialize(Archive& ar, const unsigned int version) void serialize(Archive& ar, const unsigned int version)
{ {
if (version) if (version)
{ {
}; };
// Satellite and signal info // Satellite and signal info
ar& System; ar& BOOST_SERIALIZATION_NVP(System);
ar& Signal; ar& BOOST_SERIALIZATION_NVP(Signal);
ar& PRN; ar& BOOST_SERIALIZATION_NVP(PRN);
ar& Channel_ID; ar& BOOST_SERIALIZATION_NVP(Channel_ID);
// Acquisition // Acquisition
ar& Acq_delay_samples; ar& BOOST_SERIALIZATION_NVP(Acq_delay_samples);
ar& Acq_doppler_hz; ar& BOOST_SERIALIZATION_NVP(Acq_doppler_hz);
ar& Acq_samplestamp_samples; ar& BOOST_SERIALIZATION_NVP(Acq_samplestamp_samples);
ar& Acq_doppler_step; ar& BOOST_SERIALIZATION_NVP(Acq_doppler_step);
ar& Flag_valid_acquisition; ar& BOOST_SERIALIZATION_NVP(Flag_valid_acquisition);
// Tracking // Tracking
ar& fs; ar& BOOST_SERIALIZATION_NVP(fs);
ar& Prompt_I; ar& BOOST_SERIALIZATION_NVP(Prompt_I);
ar& Prompt_Q; ar& BOOST_SERIALIZATION_NVP(Prompt_Q);
ar& CN0_dB_hz; ar& BOOST_SERIALIZATION_NVP(CN0_dB_hz);
ar& Carrier_Doppler_hz; ar& BOOST_SERIALIZATION_NVP(Carrier_Doppler_hz);
ar& Carrier_phase_rads; ar& BOOST_SERIALIZATION_NVP(Carrier_phase_rads);
ar& Code_phase_samples; ar& BOOST_SERIALIZATION_NVP(Code_phase_samples);
ar& Tracking_sample_counter; ar& BOOST_SERIALIZATION_NVP(Tracking_sample_counter);
ar& Flag_valid_symbol_output; ar& BOOST_SERIALIZATION_NVP(Flag_valid_symbol_output);
ar& correlation_length_ms; ar& BOOST_SERIALIZATION_NVP(correlation_length_ms);
// Telemetry Decoder // Telemetry Decoder
ar& Flag_valid_word; ar& BOOST_SERIALIZATION_NVP(Flag_valid_word);
ar& TOW_at_current_symbol_ms; ar& BOOST_SERIALIZATION_NVP(TOW_at_current_symbol_ms);
// Observables // Observables
ar& Pseudorange_m; ar& BOOST_SERIALIZATION_NVP(Pseudorange_m);
ar& RX_time; ar& BOOST_SERIALIZATION_NVP(RX_time);
ar& Flag_valid_pseudorange; ar& BOOST_SERIALIZATION_NVP(Flag_valid_pseudorange);
ar& interp_TOW_ms; ar& BOOST_SERIALIZATION_NVP(interp_TOW_ms);
} }
}; };

2
src/core/system_parameters/gps_ephemeris.h
View File

@ -153,7 +153,7 @@ public:
archive& make_nvp("d_Cus", d_Cus); //!< Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad] archive& make_nvp("d_Cus", d_Cus); //!< Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad]
archive& make_nvp("d_sqrt_A", d_sqrt_A); //!< Square Root of the Semi-Major Axis [sqrt(m)] archive& make_nvp("d_sqrt_A", d_sqrt_A); //!< Square Root of the Semi-Major Axis [sqrt(m)]
archive& make_nvp("d_Toe", d_Toe); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200E) [s] archive& make_nvp("d_Toe", d_Toe); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200E) [s]
archive& make_nvp("d_Toc", d_Toe); //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200E) [s] archive& make_nvp("d_Toc", d_Toc); //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200E) [s]
archive& make_nvp("d_Cic", d_Cic); //!< Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad] archive& make_nvp("d_Cic", d_Cic); //!< Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad]
archive& make_nvp("d_OMEGA0", d_OMEGA0); //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles] archive& make_nvp("d_OMEGA0", d_OMEGA0); //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles]
archive& make_nvp("d_Cis", d_Cis); //!< Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad] archive& make_nvp("d_Cis", d_Cis); //!< Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad]

11
src/tests/CMakeLists.txt
View File

@ -179,7 +179,6 @@ endif(ENABLE_UNIT_TESTING_MINIMAL)
################################################################################ ################################################################################
# Optional generator # Optional generator
################################################################################ ################################################################################
option(ENABLE_GNSS_SIM_INSTALL "Enable the installation of gnss_sim on the fly" ON)
if(ENABLE_UNIT_TESTING_EXTRA OR ENABLE_SYSTEM_TESTING_EXTRA OR ENABLE_FPGA) if(ENABLE_UNIT_TESTING_EXTRA OR ENABLE_SYSTEM_TESTING_EXTRA OR ENABLE_FPGA)
if(ENABLE_FPGA) if(ENABLE_FPGA)
set(CROSS_INSTALL_DIR "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}") set(CROSS_INSTALL_DIR "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}")
@ -190,11 +189,11 @@ if(ENABLE_UNIT_TESTING_EXTRA OR ENABLE_SYSTEM_TESTING_EXTRA OR ENABLE_FPGA)
set(CROSS_INSTALL_DIR "") set(CROSS_INSTALL_DIR "")
endif(ENABLE_FPGA) endif(ENABLE_FPGA)
find_package(GnssSimulator QUIET) find_package(GnssSimulator QUIET)
if(GNSS-SIMULATOR_FOUND OR NOT ENABLE_GNSS_SIM_INSTALL) if(GNSS-SIMULATOR_FOUND)
add_definitions(-DSW_GENERATOR_BIN="${SW_GENERATOR_BIN}") add_definitions(-DSW_GENERATOR_BIN="${SW_GENERATOR_BIN}")
add_definitions(-DDEFAULT_RINEX_NAV="${CMAKE_INSTALL_PREFIX}/share/gnss-sim/brdc3540.14n") add_definitions(-DDEFAULT_RINEX_NAV="${CMAKE_INSTALL_PREFIX}/share/gnss-sim/brdc3540.14n")
add_definitions(-DDEFAULT_POSITION_FILE="${CMAKE_INSTALL_PREFIX}/share/gnss-sim/circle.csv") add_definitions(-DDEFAULT_POSITION_FILE="${CMAKE_INSTALL_PREFIX}/share/gnss-sim/circle.csv")
else(GNSS-SIMULATOR_FOUND OR NOT ENABLE_GNSS_SIM_INSTALL) else(GNSS-SIMULATOR_FOUND)
ExternalProject_Add( ExternalProject_Add(
gnss-sim gnss-sim
GIT_REPOSITORY https://bitbucket.org/jarribas/gnss-simulator GIT_REPOSITORY https://bitbucket.org/jarribas/gnss-simulator
@ -220,7 +219,7 @@ if(ENABLE_UNIT_TESTING_EXTRA OR ENABLE_SYSTEM_TESTING_EXTRA OR ENABLE_FPGA)
add_definitions(-DDEFAULT_RINEX_NAV="${CMAKE_CURRENT_BINARY_DIR}/../../../thirdparty/gnss-sim/brdc3540.14n") add_definitions(-DDEFAULT_RINEX_NAV="${CMAKE_CURRENT_BINARY_DIR}/../../../thirdparty/gnss-sim/brdc3540.14n")
add_definitions(-DDEFAULT_POSITION_FILE="${CMAKE_CURRENT_BINARY_DIR}/../../../thirdparty/gnss-sim/circle.csv") add_definitions(-DDEFAULT_POSITION_FILE="${CMAKE_CURRENT_BINARY_DIR}/../../../thirdparty/gnss-sim/circle.csv")
endif(ENABLE_INSTALL_TESTS) endif(ENABLE_INSTALL_TESTS)
endif(GNSS-SIMULATOR_FOUND OR NOT ENABLE_GNSS_SIM_INSTALL) endif(GNSS-SIMULATOR_FOUND)
################################################################################ ################################################################################
# Local installation of GPSTk http://www.gpstk.org/ # Local installation of GPSTk http://www.gpstk.org/
@ -313,12 +312,16 @@ if(ENABLE_INSTALL_TESTS)
install(FILES ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/Galileo_E1_ID_1_Fs_4Msps_8ms.dat DESTINATION share/gnss-sdr/signal_samples) install(FILES ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/Galileo_E1_ID_1_Fs_4Msps_8ms.dat DESTINATION share/gnss-sdr/signal_samples)
install(FILES ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/GPS_L1_CA_ID_1_Fs_4Msps_2ms.dat DESTINATION share/gnss-sdr/signal_samples) install(FILES ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/GPS_L1_CA_ID_1_Fs_4Msps_2ms.dat DESTINATION share/gnss-sdr/signal_samples)
install(FILES ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/NT1065_GLONASS_L1_20160831_fs6625e6_if0e3_4ms.bin DESTINATION share/gnss-sdr/signal_samples) install(FILES ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/NT1065_GLONASS_L1_20160831_fs6625e6_if0e3_4ms.bin DESTINATION share/gnss-sdr/signal_samples)
install(FILES ${CMAKE_SOURCE_DIR}/src/tests/data/rtklib_test/obs_test1.xml DESTINATION share/gnss-sdr/data/rtklib_test)
install(FILES ${CMAKE_SOURCE_DIR}/src/tests/data/rtklib_test/eph_GPS_L1CA_test1.xml DESTINATION share/gnss-sdr/data/rtklib_test)
add_definitions(-DTEST_PATH="${CMAKE_INSTALL_PREFIX}/share/gnss-sdr/") add_definitions(-DTEST_PATH="${CMAKE_INSTALL_PREFIX}/share/gnss-sdr/")
else(ENABLE_INSTALL_TESTS) else(ENABLE_INSTALL_TESTS)
file(COPY ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/GSoC_CTTC_capture_2012_07_26_4Msps_4ms.dat DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/signal_samples) file(COPY ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/GSoC_CTTC_capture_2012_07_26_4Msps_4ms.dat DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/signal_samples)
file(COPY ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/Galileo_E1_ID_1_Fs_4Msps_8ms.dat DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/signal_samples) file(COPY ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/Galileo_E1_ID_1_Fs_4Msps_8ms.dat DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/signal_samples)
file(COPY ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/GPS_L1_CA_ID_1_Fs_4Msps_2ms.dat DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/signal_samples) file(COPY ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/GPS_L1_CA_ID_1_Fs_4Msps_2ms.dat DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/signal_samples)
file(COPY ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/NT1065_GLONASS_L1_20160831_fs6625e6_if0e3_4ms.bin DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/signal_samples) file(COPY ${CMAKE_SOURCE_DIR}/src/tests/signal_samples/NT1065_GLONASS_L1_20160831_fs6625e6_if0e3_4ms.bin DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/signal_samples)
file(COPY ${CMAKE_SOURCE_DIR}/src/tests/data/rtklib_test/obs_test1.xml DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/data/rtklib_test)
file(COPY ${CMAKE_SOURCE_DIR}/src/tests/data/rtklib_test/eph_GPS_L1CA_test1.xml DESTINATION ${CMAKE_SOURCE_DIR}/thirdparty/data/rtklib_test)
add_definitions(-DTEST_PATH="${CMAKE_SOURCE_DIR}/thirdparty/") add_definitions(-DTEST_PATH="${CMAKE_SOURCE_DIR}/thirdparty/")
endif(ENABLE_INSTALL_TESTS) endif(ENABLE_INSTALL_TESTS)

480
src/tests/data/rtklib_test/eph_GPS_L1CA_test1.xml Normal file
View File

@ -0,0 +1,480 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="12">
<GNSS-SDR_ephemeris_map class_id="0" tracking_level="0" version="0">
<count>11</count>
<item_version>0</item_version>
<item class_id="1" tracking_level="0" version="0">
<first>1</first>
<second class_id="2" tracking_level="0" version="0">
<i_satellite_PRN>1</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>9.20000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>9.20000000000000000e+01</d_IODE_SF3>
<d_Crs>1.83125000000000000e+01</d_Crs>
<d_Delta_n>4.86413118201646669e-09</d_Delta_n>
<d_M_0>2.06468198930943725e+00</d_M_0>
<d_Cuc>9.42498445510864258e-07</d_Cuc>
<d_e_eccentricity>3.73082922305911736e-03</d_e_eccentricity>
<d_Cus>5.76488673686981201e-06</d_Cus>
<d_sqrt_A>5.15366174697875977e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>-5.40167093276977539e-08</d_Cic>
<d_OMEGA0>9.52167247599200905e-01</d_OMEGA0>
<d_Cis>1.86264514923095703e-08</d_Cis>
<d_i_0>9.61377026423456127e-01</d_i_0>
<d_Crc>2.66968750000000000e+02</d_Crc>
<d_OMEGA>4.44935333708291858e-01</d_OMEGA>
<d_OMEGA_DOT>-8.14641075927847669e-09</d_OMEGA_DOT>
<d_IDOT>4.15017287135849497e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>5.12227416038513184e-09</d_TGD>
<d_IODC>9.20000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>-1.09937973320484161e-05</d_A_f0>
<d_A_f1>3.41060513164847988e-13</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>2</first>
<second>
<i_satellite_PRN>2</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>5.50000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>5.50000000000000000e+01</d_IODE_SF3>
<d_Crs>2.22812500000000000e+01</d_Crs>
<d_Delta_n>5.12771358985317661e-09</d_Delta_n>
<d_M_0>2.75926302782053146e+00</d_M_0>
<d_Cuc>1.10082328319549561e-06</d_Cuc>
<d_e_eccentricity>1.40569622162729484e-02</d_e_eccentricity>
<d_Cus>6.26407563686370850e-06</d_Cus>
<d_sqrt_A>5.15372654151916504e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>-1.86264514923095703e-08</d_Cic>
<d_OMEGA0>9.18037446344556307e-01</d_OMEGA0>
<d_Cis>-2.16066837310791016e-07</d_Cis>
<d_i_0>9.39991586696909520e-01</d_i_0>
<d_Crc>2.45468750000000000e+02</d_Crc>
<d_OMEGA>-2.35598690357981555e+00</d_OMEGA>
<d_OMEGA_DOT>-8.07140763509730069e-09</d_OMEGA_DOT>
<d_IDOT>5.25736184736635464e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>-2.00234353542327881e-08</d_TGD>
<d_IODC>5.50000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>5.36850653588771820e-04</d_A_f0>
<d_A_f1>2.16004991671070416e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>3</first>
<second>
<i_satellite_PRN>3</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>7.00000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>7.00000000000000000e+01</d_IODE_SF3>
<d_Crs>-2.04375000000000000e+01</d_Crs>
<d_Delta_n>4.75769817722603366e-09</d_Delta_n>
<d_M_0>-1.78871492992227910e+00</d_M_0>
<d_Cuc>-1.30012631416320801e-06</d_Cuc>
<d_e_eccentricity>9.70319728367030512e-04</d_e_eccentricity>
<d_Cus>8.26455652713775635e-06</d_Cus>
<d_sqrt_A>5.15378153991699219e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>7.82310962677001953e-08</d_Cic>
<d_OMEGA0>1.99297660614955263e+00</d_OMEGA0>
<d_Cis>-1.11758708953857422e-08</d_Cis>
<d_i_0>9.59058451948379909e-01</d_i_0>
<d_Crc>2.19593750000000000e+02</d_Crc>
<d_OMEGA>-3.00536842405812843e+00</d_OMEGA>
<d_OMEGA_DOT>-8.02712007605698577e-09</d_OMEGA_DOT>
<d_IDOT>-5.17164399115929480e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>5.12227416038513184e-09</d_TGD>
<d_IODC>7.00000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>8.80691222846508026e-05</d_A_f0>
<d_A_f1>2.89901436190120811e-11</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>6</first>
<second>
<i_satellite_PRN>6</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>2.30000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>2.30000000000000000e+01</d_IODE_SF3>
<d_Crs>1.63750000000000000e+01</d_Crs>
<d_Delta_n>4.76305554323897445e-09</d_Delta_n>
<d_M_0>-1.28531071631616522e+00</d_M_0>
<d_Cuc>9.12696123123168945e-07</d_Cuc>
<d_e_eccentricity>5.50022465176880251e-04</d_e_eccentricity>
<d_Cus>6.24358654022216797e-06</d_Cus>
<d_sqrt_A>5.15365166282653809e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>-1.30385160446166992e-08</d_Cic>
<d_OMEGA0>9.43624288779246867e-01</d_OMEGA0>
<d_Cis>-1.86264514923095703e-09</d_Cis>
<d_i_0>9.61292940818096020e-01</d_i_0>
<d_Crc>2.58406250000000000e+02</d_Crc>
<d_OMEGA>2.29191014519991665e+00</d_OMEGA>
<d_OMEGA_DOT>-8.08069373618639861e-09</d_OMEGA_DOT>
<d_IDOT>4.79305679291144535e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>4.65661287307739258e-09</d_TGD>
<d_IODC>2.30000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>3.07881273329257965e-05</d_A_f0>
<d_A_f1>8.18545231595635253e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>9</first>
<second>
<i_satellite_PRN>9</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>4.70000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>4.70000000000000000e+01</d_IODE_SF3>
<d_Crs>1.12906250000000000e+02</d_Crs>
<d_Delta_n>4.37911097897818463e-09</d_Delta_n>
<d_M_0>-2.75253879947800195e+00</d_M_0>
<d_Cuc>5.85243105888366699e-06</d_Cuc>
<d_e_eccentricity>2.16206186451017829e-04</d_e_eccentricity>
<d_Cus>1.16303563117980957e-05</d_Cus>
<d_sqrt_A>5.15369471168518066e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>1.67638063430786133e-08</d_Cic>
<d_OMEGA0>3.03742251571970812e+00</d_OMEGA0>
<d_Cis>-1.11758708953857422e-08</d_Cis>
<d_i_0>9.59160503650671514e-01</d_i_0>
<d_Crc>1.56125000000000000e+02</d_Crc>
<d_OMEGA>2.60662251530764344e+00</d_OMEGA>
<d_OMEGA_DOT>-7.85854162551643464e-09</d_OMEGA_DOT>
<d_IDOT>-3.46443002170201364e-11</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>4.65661287307739258e-10</d_TGD>
<d_IODC>4.70000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>-3.18535603582859039e-05</d_A_f0>
<d_A_f1>-9.66338120633736091e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>10</first>
<second>
<i_satellite_PRN>10</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>5.80000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>5.80000000000000000e+01</d_IODE_SF3>
<d_Crs>-2.72500000000000000e+01</d_Crs>
<d_Delta_n>5.27093384126580581e-09</d_Delta_n>
<d_M_0>-8.86982818851813737e-01</d_M_0>
<d_Cuc>-1.17719173431396484e-06</d_Cuc>
<d_e_eccentricity>1.44534236751496774e-02</d_e_eccentricity>
<d_Cus>7.90506601333618164e-06</d_Cus>
<d_sqrt_A>5.15363725471496582e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>1.45286321640014648e-07</d_Cic>
<d_OMEGA0>2.00408517949479270e+00</d_OMEGA0>
<d_Cis>2.40281224250793457e-07</d_Cis>
<d_i_0>9.41160112993577269e-01</d_i_0>
<d_Crc>2.15406250000000000e+02</d_Crc>
<d_OMEGA>9.09732121011562200e-01</d_OMEGA>
<d_OMEGA_DOT>-8.42213653007785350e-09</d_OMEGA_DOT>
<d_IDOT>-5.42879755978047536e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>-2.79396772384643555e-09</d_TGD>
<d_IODC>5.80000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>-1.54968351125717163e-04</d_A_f0>
<d_A_f1>-1.59161572810262401e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>12</first>
<second>
<i_satellite_PRN>12</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>1.06000000000000000e+02</d_IODE_SF2>
<d_IODE_SF3>1.06000000000000000e+02</d_IODE_SF3>
<d_Crs>-1.17468750000000000e+02</d_Crs>
<d_Delta_n>3.94516433192994276e-09</d_Delta_n>
<d_M_0>1.11631735294997192e+00</d_M_0>
<d_Cuc>-6.15417957305908203e-06</d_Cuc>
<d_e_eccentricity>5.05860964767634782e-03</d_e_eccentricity>
<d_Cus>4.52436506748199463e-06</d_Cus>
<d_sqrt_A>5.15376680946350098e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>-5.40167093276977539e-08</d_Cic>
<d_OMEGA0>-1.10425023618040785e+00</d_OMEGA0>
<d_Cis>4.09781932830810547e-08</d_Cis>
<d_i_0>9.88803748742243305e-01</d_i_0>
<d_Crc>3.07187500000000000e+02</d_Crc>
<d_OMEGA>5.00154452274795935e-01</d_OMEGA>
<d_OMEGA_DOT>-7.97176062725659211e-09</d_OMEGA_DOT>
<d_IDOT>-4.18231706743614228e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>-1.16415321826934814e-08</d_TGD>
<d_IODC>1.06000000000000000e+02</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>2.54871323704719543e-04</d_A_f0>
<d_A_f1>2.72848410531878391e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>17</first>
<second>
<i_satellite_PRN>17</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>2.60000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>2.60000000000000000e+01</d_IODE_SF3>
<d_Crs>-5.91250000000000000e+01</d_Crs>
<d_Delta_n>3.88194741297723567e-09</d_Delta_n>
<d_M_0>-1.94252959218893162e+00</d_M_0>
<d_Cuc>-3.04728746414184570e-06</d_Cuc>
<d_e_eccentricity>9.88844956737011498e-03</d_e_eccentricity>
<d_Cus>1.18296593427658081e-05</d_Cus>
<d_sqrt_A>5.15369299888610840e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>2.03028321266174316e-07</d_Cic>
<d_OMEGA0>-5.68690999805671268e-02</d_OMEGA0>
<d_Cis>-7.63684511184692383e-08</d_Cis>
<d_i_0>9.71201777972365177e-01</d_i_0>
<d_Crc>1.56531250000000000e+02</d_Crc>
<d_OMEGA>-2.06928329237789344e+00</d_OMEGA>
<d_OMEGA_DOT>-7.44602444251995675e-09</d_OMEGA_DOT>
<d_IDOT>4.40375486263771432e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>-1.07102096080780029e-08</d_TGD>
<d_IODC>2.60000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>-1.44933816045522690e-04</d_A_f0>
<d_A_f1>-2.27373675443232019e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>20</first>
<second>
<i_satellite_PRN>20</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>1.17000000000000000e+02</d_IODE_SF2>
<d_IODE_SF3>1.17000000000000000e+02</d_IODE_SF3>
<d_Crs>-2.58437500000000000e+01</d_Crs>
<d_Delta_n>5.60380484953655626e-09</d_Delta_n>
<d_M_0>1.28625710142833249e-01</d_M_0>
<d_Cuc>-1.52923166751861572e-06</d_Cuc>
<d_e_eccentricity>5.80669869668781671e-03</d_e_eccentricity>
<d_Cus>7.51018524169921875e-06</d_Cus>
<d_sqrt_A>5.15578671264648438e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>-2.23517417907714844e-08</d_Cic>
<d_OMEGA0>1.92543994118208528e+00</d_OMEGA0>
<d_Cis>4.65661287307739258e-08</d_Cis>
<d_i_0>9.26021286652122910e-01</d_i_0>
<d_Crc>2.18031250000000000e+02</d_Crc>
<d_OMEGA>1.23365536128043107e+00</d_OMEGA>
<d_OMEGA_DOT>-8.54892752571746483e-09</d_OMEGA_DOT>
<d_IDOT>-5.16450083647537340e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>-8.38190317153930664e-09</d_TGD>
<d_IODC>1.17000000000000000e+02</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>2.69209500402212143e-04</d_A_f0>
<d_A_f1>4.20641299569979229e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>23</first>
<second>
<i_satellite_PRN>23</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>4.10000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>4.10000000000000000e+01</d_IODE_SF3>
<d_Crs>1.20250000000000000e+02</d_Crs>
<d_Delta_n>4.45161399901998963e-09</d_Delta_n>
<d_M_0>3.04794581942897569e+00</d_M_0>
<d_Cuc>6.13741576671600342e-06</d_Cuc>
<d_e_eccentricity>9.67817602213471954e-03</d_e_eccentricity>
<d_Cus>1.14180147647857666e-05</d_Cus>
<d_sqrt_A>5.15370163154602051e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>-6.14672899246215820e-08</d_Cic>
<d_OMEGA0>3.04748172476042711e+00</d_OMEGA0>
<d_Cis>-1.04308128356933594e-07</d_Cis>
<d_i_0>9.50229191282804808e-01</d_i_0>
<d_Crc>1.56000000000000000e+02</d_Crc>
<d_OMEGA>-2.71676891930177256e+00</d_OMEGA>
<d_OMEGA_DOT>-7.78032408172749087e-09</d_OMEGA_DOT>
<d_IDOT>-2.75011455330984601e-11</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>-1.95577740669250488e-08</d_TGD>
<d_IODC>4.10000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>-7.56788067519664764e-05</d_A_f0>
<d_A_f1>-2.72848410531878391e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
<item>
<first>28</first>
<second>
<i_satellite_PRN>28</i_satellite_PRN>
<d_TOW>5.18448000000000000e+05</d_TOW>
<d_IODE_SF2>3.30000000000000000e+01</d_IODE_SF2>
<d_IODE_SF3>3.30000000000000000e+01</d_IODE_SF3>
<d_Crs>-1.27750000000000000e+02</d_Crs>
<d_Delta_n>4.04302555109966970e-09</d_Delta_n>
<d_M_0>-1.16607683198628931e+00</d_M_0>
<d_Cuc>-6.37024641036987305e-06</d_Cuc>
<d_e_eccentricity>1.97223023278638686e-02</d_e_eccentricity>
<d_Cus>5.66989183425903320e-06</d_Cus>
<d_sqrt_A>5.15368548965454102e+03</d_sqrt_A>
<d_Toe>5.18400000000000000e+05</d_Toe>
<d_Toc>5.18400000000000000e+05</d_Toc>
<d_Cic>-1.37835741043090820e-07</d_Cic>
<d_OMEGA0>-1.08006546321039543e+00</d_OMEGA0>
<d_Cis>4.35858964920043945e-07</d_Cis>
<d_i_0>9.87961552655681530e-01</d_i_0>
<d_Crc>2.84718750000000000e+02</d_Crc>
<d_OMEGA>-1.69047108635756738e+00</d_OMEGA>
<d_OMEGA_DOT>-8.17855495535612472e-09</d_OMEGA_DOT>
<d_IDOT>-4.44661379074124424e-10</d_IDOT>
<i_code_on_L2>0</i_code_on_L2>
<i_GPS_week>799</i_GPS_week>
<b_L2_P_data_flag>0</b_L2_P_data_flag>
<i_SV_accuracy>2</i_SV_accuracy>
<i_SV_health>0</i_SV_health>
<d_TGD>-1.11758708953857422e-08</d_TGD>
<d_IODC>3.30000000000000000e+01</d_IODC>
<i_AODO>27900</i_AODO>
<b_fit_interval_flag>0</b_fit_interval_flag>
<d_spare1>0.00000000000000000e+00</d_spare1>
<d_spare2>0.00000000000000000e+00</d_spare2>
<d_A_f0>4.06486913561820984e-04</d_A_f0>
<d_A_f1>2.61479726759716828e-12</d_A_f1>
<d_A_f2>0.00000000000000000e+00</d_A_f2>
<b_integrity_status_flag>0</b_integrity_status_flag>
<b_alert_flag>0</b_alert_flag>
<b_antispoofing_flag>0</b_antispoofing_flag>
</second>
</item>
</GNSS-SDR_ephemeris_map>

357
src/tests/data/rtklib_test/obs_test1.xml Normal file
View File

@ -0,0 +1,357 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="12">
<GNSS-SDR_gnss_synchro_map class_id="0" tracking_level="0" version="0">
<count>10</count>
<item_version>0</item_version>
<item class_id="1" tracking_level="0" version="0">
<first>0</first>
<second class_id="2" tracking_level="0" version="0">
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>1</PRN>
<Channel_ID>0</Channel_ID>
<Acq_delay_samples>2.28200000000000000e+03</Acq_delay_samples>
<Acq_doppler_hz>-2.50000000000000000e+03</Acq_doppler_hz>
<Acq_samplestamp_samples>10791</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>-3.85959140625000000e+04</Prompt_I>
<Prompt_Q>-9.03592163085937500e+02</Prompt_Q>
<CN0_dB_hz>5.96898384094238281e+01</CN0_dB_hz>
<Carrier_Doppler_hz>-2.57914688873291016e+03</Carrier_Doppler_hz>
<Carrier_phase_rads>8.35350813421410858e+05</Carrier_phase_rads>
<Code_phase_samples>3.31084377635761484e-01</Code_phase_samples>
<Tracking_sample_counter>133923691</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451424</TOW_at_current_symbol_ms>
<Pseudorange_m>2.28178186234515086e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451423887949765e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>1</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>3</PRN>
<Channel_ID>1</Channel_ID>
<Acq_delay_samples>2.38500000000000000e+03</Acq_delay_samples>
<Acq_doppler_hz>-3.00000000000000000e+03</Acq_doppler_hz>
<Acq_samplestamp_samples>68450858</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>-4.34972734375000000e+04</Prompt_I>
<Prompt_Q>4.21364685058593750e+02</Prompt_Q>
<CN0_dB_hz>5.16798934936523438e+01</CN0_dB_hz>
<Carrier_Doppler_hz>-3.12509065246582031e+03</Carrier_Doppler_hz>
<Carrier_phase_rads>4.93910706686261110e+05</Carrier_phase_rads>
<Code_phase_samples>7.36033200862493686e-01</Code_phase_samples>
<Tracking_sample_counter>133923971</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451431</TOW_at_current_symbol_ms>
<Pseudorange_m>2.07516033774388395e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451430780101955e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>2</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>28</PRN>
<Channel_ID>2</Channel_ID>
<Acq_delay_samples>1.52700000000000000e+03</Acq_delay_samples>
<Acq_doppler_hz>-3.00000000000000000e+03</Acq_doppler_hz>
<Acq_samplestamp_samples>1350770</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>4.46268046875000000e+04</Prompt_I>
<Prompt_Q>-3.98811938476562500e+03</Prompt_Q>
<CN0_dB_hz>5.25376167297363281e+01</CN0_dB_hz>
<Carrier_Doppler_hz>-2.92984253692626953e+03</Carrier_Doppler_hz>
<Carrier_phase_rads>9.35704822809229488e+05</Carrier_phase_rads>
<Code_phase_samples>9.30327007595224131e-01</Code_phase_samples>
<Tracking_sample_counter>133923941</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451436</TOW_at_current_symbol_ms>
<Pseudorange_m>1.92492043561209217e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451435791565657e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>4</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>23</PRN>
<Channel_ID>4</Channel_ID>
<Acq_delay_samples>1.13100000000000000e+03</Acq_delay_samples>
<Acq_doppler_hz>1.00000000000000000e+03</Acq_doppler_hz>
<Acq_samplestamp_samples>994247</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>3.98655546875000000e+04</Prompt_I>
<Prompt_Q>-8.63781860351562500e+02</Prompt_Q>
<CN0_dB_hz>5.24684982299804688e+01</CN0_dB_hz>
<Carrier_Doppler_hz>1.09281750951009121e+03</Carrier_Doppler_hz>
<Carrier_phase_rads>-3.54128275530727289e+05</Carrier_phase_rads>
<Code_phase_samples>4.08304036132904002e-01</Code_phase_samples>
<Tracking_sample_counter>133922883</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451429</TOW_at_current_symbol_ms>
<Pseudorange_m>2.12256989876578376e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451429198689222e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>5</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>2</PRN>
<Channel_ID>5</Channel_ID>
<Acq_delay_samples>5.38000000000000000e+02</Acq_delay_samples>
<Acq_doppler_hz>1.75000000000000000e+03</Acq_doppler_hz>
<Acq_samplestamp_samples>4917751</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>-4.72456406250000000e+04</Prompt_I>
<Prompt_Q>-2.63723022460937500e+02</Prompt_Q>
<CN0_dB_hz>4.89446220397949219e+01</CN0_dB_hz>
<Carrier_Doppler_hz>1.83319645690917969e+03</Carrier_Doppler_hz>
<Carrier_phase_rads>-5.72184006019302527e+05</Carrier_phase_rads>
<Code_phase_samples>5.89544135488722532e-01</Code_phase_samples>
<Tracking_sample_counter>133922337</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451430</TOW_at_current_symbol_ms>
<Pseudorange_m>2.08629709015843943e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451430408619881e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>6</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>17</PRN>
<Channel_ID>6</Channel_ID>
<Acq_delay_samples>2.21000000000000000e+02</Acq_delay_samples>
<Acq_doppler_hz>2.50000000000000000e+02</Acq_doppler_hz>
<Acq_samplestamp_samples>514377</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>4.27717460937500000e+04</Prompt_I>
<Prompt_Q>-9.45822082519531250e+02</Prompt_Q>
<CN0_dB_hz>5.38986015319824219e+01</CN0_dB_hz>
<Carrier_Doppler_hz>2.73018497467041016e+02</Carrier_Doppler_hz>
<Carrier_phase_rads>-9.09813659855529113e+04</Carrier_phase_rads>
<Code_phase_samples>6.57473345280777721e-01</Code_phase_samples>
<Tracking_sample_counter>133923172</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451440</TOW_at_current_symbol_ms>
<Pseudorange_m>1.79613337841309197e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451440087439477e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>7</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>9</PRN>
<Channel_ID>7</Channel_ID>
<Acq_delay_samples>1.56900000000000000e+03</Acq_delay_samples>
<Acq_doppler_hz>2.25000000000000000e+03</Acq_doppler_hz>
<Acq_samplestamp_samples>7365787</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>-3.96159960937500000e+04</Prompt_I>
<Prompt_Q>-5.03847460937500000e+03</Prompt_Q>
<CN0_dB_hz>5.33032913208007812e+01</CN0_dB_hz>
<Carrier_Doppler_hz>2.30021731185913086e+03</Carrier_Doppler_hz>
<Carrier_phase_rads>-7.04913853936602012e+05</Carrier_phase_rads>
<Code_phase_samples>3.21518194999043772e-01</Code_phase_samples>
<Tracking_sample_counter>133922169</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451430</TOW_at_current_symbol_ms>
<Pseudorange_m>2.08435687343175523e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451430473338544e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>8</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>10</PRN>
<Channel_ID>8</Channel_ID>
<Acq_delay_samples>2.12600000000000000e+03</Acq_delay_samples>
<Acq_doppler_hz>2.75000000000000000e+03</Acq_doppler_hz>
<Acq_samplestamp_samples>2173576</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>4.00322539062500000e+04</Prompt_I>
<Prompt_Q>-3.88590087890625000e+02</Prompt_Q>
<CN0_dB_hz>4.85561523437500000e+01</CN0_dB_hz>
<Carrier_Doppler_hz>2.81225794982910156e+03</Carrier_Doppler_hz>
<Carrier_phase_rads>-8.99142229977656389e+05</Carrier_phase_rads>
<Code_phase_samples>1.02370741655249731e-01</Code_phase_samples>
<Tracking_sample_counter>133922664</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451438</TOW_at_current_symbol_ms>
<Pseudorange_m>1.85022797143675610e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451438283038080e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>9</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>12</PRN>
<Channel_ID>9</Channel_ID>
<Acq_delay_samples>2.13000000000000000e+02</Acq_delay_samples>
<Acq_doppler_hz>3.00000000000000000e+03</Acq_doppler_hz>
<Acq_samplestamp_samples>7464974</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>-4.03654140625000000e+04</Prompt_I>
<Prompt_Q>3.92351245117187500e+03</Prompt_Q>
<CN0_dB_hz>5.17314453125000000e+01</CN0_dB_hz>
<Carrier_Doppler_hz>3.03019989013671875e+03</Carrier_Doppler_hz>
<Carrier_phase_rads>-9.28340507655202877e+05</Carrier_phase_rads>
<Code_phase_samples>5.73995602361264901e-01</Code_phase_samples>
<Tracking_sample_counter>133923741</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451427</TOW_at_current_symbol_ms>
<Pseudorange_m>2.19242346189941987e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451426868625164e+08</interp_TOW_ms>
</second>
</item>
<item>
<first>10</first>
<second>
<System>71</System>
<Signal>
<count>3</count>
<item>49</item>
<item>67</item>
<item>0</item>
</Signal>
<PRN>6</PRN>
<Channel_ID>10</Channel_ID>
<Acq_delay_samples>4.70000000000000000e+01</Acq_delay_samples>
<Acq_doppler_hz>5.00000000000000000e+02</Acq_doppler_hz>
<Acq_samplestamp_samples>1859813</Acq_samplestamp_samples>
<Acq_doppler_step>0</Acq_doppler_step>
<Flag_valid_acquisition>0</Flag_valid_acquisition>
<fs>2600000</fs>
<Prompt_I>3.87814335937500000e+04</Prompt_I>
<Prompt_Q>2.13637329101562500e+03</Prompt_Q>
<CN0_dB_hz>6.00463027954101562e+01</CN0_dB_hz>
<Carrier_Doppler_hz>5.54514957427978516e+02</Carrier_Doppler_hz>
<Carrier_phase_rads>-1.78723083774703584e+05</Carrier_phase_rads>
<Code_phase_samples>3.47952294631795667e-01</Code_phase_samples>
<Tracking_sample_counter>133924211</Tracking_sample_counter>
<Flag_valid_symbol_output>1</Flag_valid_symbol_output>
<correlation_length_ms>1</correlation_length_ms>
<Flag_valid_word>1</Flag_valid_word>
<TOW_at_current_symbol_ms>518451439</TOW_at_current_symbol_ms>
<Pseudorange_m>1.83808922785463184e+07</Pseudorange_m>
<RX_time>5.18451500000000000e+05</RX_time>
<Flag_valid_pseudorange>1</Flag_valid_pseudorange>
<interp_TOW_ms>5.18451438687942982e+08</interp_TOW_ms>
</second>
</item>
</GNSS-SDR_gnss_synchro_map>

1
src/tests/system-tests/position_test.cc
View File

@ -354,6 +354,7 @@ int PositionSystemTest::configure_receiver()
config->set_property("Acquisition_1C.dump", "false"); config->set_property("Acquisition_1C.dump", "false");
config->set_property("Acquisition_1C.dump_filename", "./acquisition"); config->set_property("Acquisition_1C.dump_filename", "./acquisition");
config->set_property("Acquisition_1C.dump_channel", "1"); config->set_property("Acquisition_1C.dump_channel", "1");
config->set_property("Acquisition_1C.blocking", "true");
// Set Tracking // Set Tracking
config->set_property("Tracking_1C.implementation", "GPS_L1_CA_DLL_PLL_Tracking"); config->set_property("Tracking_1C.implementation", "GPS_L1_CA_DLL_PLL_Tracking");

1
src/tests/test_main.cc
View File

@ -161,6 +161,7 @@ DECLARE_string(log_dir);
#include "unit-tests/signal-processing-blocks/pvt/rtcm_printer_test.cc" #include "unit-tests/signal-processing-blocks/pvt/rtcm_printer_test.cc"
#include "unit-tests/signal-processing-blocks/pvt/rinex_printer_test.cc" #include "unit-tests/signal-processing-blocks/pvt/rinex_printer_test.cc"
#include "unit-tests/signal-processing-blocks/pvt/nmea_printer_test.cc" #include "unit-tests/signal-processing-blocks/pvt/nmea_printer_test.cc"
#include "unit-tests/signal-processing-blocks/pvt/rtklib_solver_test.cc"
#if EXTRA_TESTS #if EXTRA_TESTS

440
src/tests/unit-tests/signal-processing-blocks/pvt/rtklib_solver_test.cc Normal file
View File

@ -0,0 +1,440 @@
/*!
* \file rtklib_solver_test.cc
* \brief Implements Unit Test for the rtklib PVT solver class.
* \author Javier Arribas, 2018. jarribas(at)cttc.es
*
* -------------------------------------------------------------------------
*
* Copyright (C) 2010-2018 (see AUTHORS file for a list of contributors)
*
* GNSS-SDR is a software defined Global Navigation
* Satellite Systems receiver
*
* This file is part of GNSS-SDR.
*
* GNSS-SDR is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GNSS-SDR is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNSS-SDR. If not, see <https://www.gnu.org/licenses/>.
*
* -------------------------------------------------------------------------
*/
#include <gtest/gtest.h>
#include <string>
#include <iomanip>
#include <iostream>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/serialization/map.hpp>
#include "rtklib_solver.h"
#include "in_memory_configuration.h"
#include "gnss_sdr_supl_client.h"
rtk_t configure_rtklib_options()
{
std::shared_ptr<InMemoryConfiguration> configuration;
configuration = std::make_shared<InMemoryConfiguration>();
std::string role = "rtklib_solver";
// custom options
configuration->set_property("rtklib_solver.positioning_mode", "Single");
configuration->set_property("rtklib_solver.elevation_mask", "0");
configuration->set_property("rtklib_solver.iono_model", "OFF");
configuration->set_property("rtklib_solver.trop_model", "OFF");
//RTKLIB PVT solver options
// Settings 1
int positioning_mode = -1;
std::string default_pos_mode("Single");
std::string positioning_mode_str = configuration->property(role + ".positioning_mode", default_pos_mode); /* (PMODE_XXX) see src/algorithms/libs/rtklib/rtklib.h */
if (positioning_mode_str.compare("Single") == 0) positioning_mode = PMODE_SINGLE;
if (positioning_mode_str.compare("Static") == 0) positioning_mode = PMODE_STATIC;
if (positioning_mode_str.compare("Kinematic") == 0) positioning_mode = PMODE_KINEMA;
if (positioning_mode_str.compare("PPP_Static") == 0) positioning_mode = PMODE_PPP_STATIC;
if (positioning_mode_str.compare("PPP_Kinematic") == 0) positioning_mode = PMODE_PPP_KINEMA;
if (positioning_mode == -1)
{
//warn user and set the default
std::cout << "WARNING: Bad specification of positioning mode." << std::endl;
std::cout << "positioning_mode possible values: Single / Static / Kinematic / PPP_Static / PPP_Kinematic" << std::endl;
std::cout << "positioning_mode specified value: " << positioning_mode_str << std::endl;
std::cout << "Setting positioning_mode to Single" << std::endl;
positioning_mode = PMODE_SINGLE;
}
int num_bands = 1;
// if ((gps_1C_count > 0) || (gal_1B_count > 0) || (glo_1G_count > 0)) num_bands = 1;
// if (((gps_1C_count > 0) || (gal_1B_count > 0) || (glo_1G_count > 0)) && ((gps_2S_count > 0) || (glo_2G_count > 0))) num_bands = 2;
// if (((gps_1C_count > 0) || (gal_1B_count > 0) || (glo_1G_count > 0)) && ((gal_E5a_count > 0) || (gal_E5b_count > 0) || (gps_L5_count > 0))) num_bands = 2;
// if (((gps_1C_count > 0) || (gal_1B_count > 0) || (glo_1G_count > 0)) && ((gps_2S_count > 0) || (glo_2G_count > 0)) && ((gal_E5a_count > 0) || (gal_E5b_count > 0) || (gps_L5_count > 0))) num_bands = 3;
int number_of_frequencies = configuration->property(role + ".num_bands", num_bands); /* (1:L1, 2:L1+L2, 3:L1+L2+L5) */
if ((number_of_frequencies < 1) || (number_of_frequencies > 3))
{
//warn user and set the default
number_of_frequencies = num_bands;
}
double elevation_mask = configuration->property(role + ".elevation_mask", 15.0);
if ((elevation_mask < 0.0) || (elevation_mask > 90.0))
{
//warn user and set the default
LOG(WARNING) << "Erroneous Elevation Mask. Setting to default value of 15.0 degrees";
elevation_mask = 15.0;
}
int dynamics_model = configuration->property(role + ".dynamics_model", 0); /* dynamics model (0:none, 1:velocity, 2:accel) */
if ((dynamics_model < 0) || (dynamics_model > 2))
{
//warn user and set the default
LOG(WARNING) << "Erroneous Dynamics Model configuration. Setting to default value of (0:none)";
dynamics_model = 0;
}
std::string default_iono_model("OFF");
std::string iono_model_str = configuration->property(role + ".iono_model", default_iono_model); /* (IONOOPT_XXX) see src/algorithms/libs/rtklib/rtklib.h */
int iono_model = -1;
if (iono_model_str.compare("OFF") == 0) iono_model = IONOOPT_OFF;
if (iono_model_str.compare("Broadcast") == 0) iono_model = IONOOPT_BRDC;
if (iono_model_str.compare("SBAS") == 0) iono_model = IONOOPT_SBAS;
if (iono_model_str.compare("Iono-Free-LC") == 0) iono_model = IONOOPT_IFLC;
if (iono_model_str.compare("Estimate_STEC") == 0) iono_model = IONOOPT_EST;
if (iono_model_str.compare("IONEX") == 0) iono_model = IONOOPT_TEC;
if (iono_model == -1)
{
//warn user and set the default
std::cout << "WARNING: Bad specification of ionospheric model." << std::endl;
std::cout << "iono_model possible values: OFF / Broadcast / SBAS / Iono-Free-LC / Estimate_STEC / IONEX" << std::endl;
std::cout << "iono_model specified value: " << iono_model_str << std::endl;
std::cout << "Setting iono_model to OFF" << std::endl;
iono_model = IONOOPT_OFF; /* 0: ionosphere option: correction off */
}
std::string default_trop_model("OFF");
int trop_model = -1;
std::string trop_model_str = configuration->property(role + ".trop_model", default_trop_model); /* (TROPOPT_XXX) see src/algorithms/libs/rtklib/rtklib.h */
if (trop_model_str.compare("OFF") == 0) trop_model = TROPOPT_OFF;
if (trop_model_str.compare("Saastamoinen") == 0) trop_model = TROPOPT_SAAS;
if (trop_model_str.compare("SBAS") == 0) trop_model = TROPOPT_SBAS;
if (trop_model_str.compare("Estimate_ZTD") == 0) trop_model = TROPOPT_EST;
if (trop_model_str.compare("Estimate_ZTD_Grad") == 0) trop_model = TROPOPT_ESTG;
if (trop_model == -1)
{
//warn user and set the default
std::cout << "WARNING: Bad specification of tropospheric model." << std::endl;
std::cout << "trop_model possible values: OFF / Saastamoinen / SBAS / Estimate_ZTD / Estimate_ZTD_Grad" << std::endl;
std::cout << "trop_model specified value: " << trop_model_str << std::endl;
std::cout << "Setting trop_model to OFF" << std::endl;
trop_model = TROPOPT_OFF;
}
/* RTKLIB positioning options */
int sat_PCV = 0; /* Set whether the satellite antenna PCV (phase center variation) model is used or not. This feature requires a Satellite Antenna PCV File. */
int rec_PCV = 0; /* Set whether the receiver antenna PCV (phase center variation) model is used or not. This feature requires a Receiver Antenna PCV File. */
/* Set whether the phase windup correction for PPP modes is applied or not. Only applicable to PPP‐* modes.*/
int phwindup = configuration->property(role + ".phwindup", 0);
/* Set whether the GPS Block IIA satellites in eclipse are excluded or not.
The eclipsing Block IIA satellites often degrade the PPP solutions due to unpredicted behavior of yaw‐attitude. Only applicable to PPP‐* modes.*/
int reject_GPS_IIA = configuration->property(role + ".reject_GPS_IIA", 0);
/* Set whether RAIM (receiver autonomous integrity monitoring) FDE (fault detection and exclusion) feature is enabled or not.
In case of RAIM FDE enabled, a satellite is excluded if SSE (sum of squared errors) of residuals is over a threshold.
The excluded satellite is selected to indicate the minimum SSE. */
int raim_fde = configuration->property(role + ".raim_fde", 0);
int earth_tide = configuration->property(role + ".earth_tide", 0);
int nsys = SYS_GPS;
// if ((gps_1C_count > 0) || (gps_2S_count > 0) || (gps_L5_count > 0)) nsys += SYS_GPS;
// if ((gal_1B_count > 0) || (gal_E5a_count > 0) || (gal_E5b_count > 0)) nsys += SYS_GAL;
// if ((glo_1G_count > 0) || (glo_2G_count > 0)) nsys += SYS_GLO;
int navigation_system = configuration->property(role + ".navigation_system", nsys); /* (SYS_XXX) see src/algorithms/libs/rtklib/rtklib.h */
if ((navigation_system < 1) || (navigation_system > 255)) /* GPS: 1 SBAS: 2 GPS+SBAS: 3 Galileo: 8 Galileo+GPS: 9 GPS+SBAS+Galileo: 11 All: 255 */
{
//warn user and set the default
LOG(WARNING) << "Erroneous Navigation System. Setting to default value of (0:none)";
navigation_system = nsys;
}
// Settings 2
std::string default_gps_ar("Continuous");
std::string integer_ambiguity_resolution_gps_str = configuration->property(role + ".AR_GPS", default_gps_ar); /* Integer Ambiguity Resolution mode for GPS (0:off,1:continuous,2:instantaneous,3:fix and hold,4:ppp-ar) */
int integer_ambiguity_resolution_gps = -1;
if (integer_ambiguity_resolution_gps_str.compare("OFF") == 0) integer_ambiguity_resolution_gps = ARMODE_OFF;
if (integer_ambiguity_resolution_gps_str.compare("Continuous") == 0) integer_ambiguity_resolution_gps = ARMODE_CONT;
if (integer_ambiguity_resolution_gps_str.compare("Instantaneous") == 0) integer_ambiguity_resolution_gps = ARMODE_INST;
if (integer_ambiguity_resolution_gps_str.compare("Fix-and-Hold") == 0) integer_ambiguity_resolution_gps = ARMODE_FIXHOLD;
if (integer_ambiguity_resolution_gps_str.compare("PPP-AR") == 0) integer_ambiguity_resolution_gps = ARMODE_PPPAR;
if (integer_ambiguity_resolution_gps == -1)
{
//warn user and set the default
std::cout << "WARNING: Bad specification of GPS ambiguity resolution method." << std::endl;
std::cout << "AR_GPS possible values: OFF / Continuous / Instantaneous / Fix-and-Hold / PPP-AR" << std::endl;
std::cout << "AR_GPS specified value: " << integer_ambiguity_resolution_gps_str << std::endl;
std::cout << "Setting AR_GPS to OFF" << std::endl;
integer_ambiguity_resolution_gps = ARMODE_OFF;
}
int integer_ambiguity_resolution_glo = configuration->property(role + ".AR_GLO", 1); /* Integer Ambiguity Resolution mode for GLONASS (0:off,1:on,2:auto cal,3:ext cal) */
if ((integer_ambiguity_resolution_glo < 0) || (integer_ambiguity_resolution_glo > 3))
{
//warn user and set the default
LOG(WARNING) << "Erroneous Integer Ambiguity Resolution for GLONASS . Setting to default value of (1:on)";
integer_ambiguity_resolution_glo = 1;
}
int integer_ambiguity_resolution_bds = configuration->property(role + ".AR_DBS", 1); /* Integer Ambiguity Resolution mode for BEIDOU (0:off,1:on) */
if ((integer_ambiguity_resolution_bds < 0) || (integer_ambiguity_resolution_bds > 1))
{
//warn user and set the default
LOG(WARNING) << "Erroneous Integer Ambiguity Resolution for BEIDOU . Setting to default value of (1:on)";
integer_ambiguity_resolution_bds = 1;
}
double min_ratio_to_fix_ambiguity = configuration->property(role + ".min_ratio_to_fix_ambiguity", 3.0); /* Set the integer ambiguity validation threshold for ratio‐test,
which uses the ratio of squared residuals of the best integer vector to the second‐best vector. */
int min_lock_to_fix_ambiguity = configuration->property(role + ".min_lock_to_fix_ambiguity", 0); /* Set the minimum lock count to fix integer ambiguity.
If the lock count is less than the value, the ambiguity is excluded from the fixed integer vector. */
double min_elevation_to_fix_ambiguity = configuration->property(role + ".min_elevation_to_fix_ambiguity", 0.0); /* Set the minimum elevation (deg) to fix integer ambiguity.
If the elevation of the satellite is less than the value, the ambiguity is excluded from the fixed integer vector. */
int outage_reset_ambiguity = configuration->property(role + ".outage_reset_ambiguity", 5); /* Set the outage count to reset ambiguity. If the data outage count is over the value, the estimated ambiguity is reset to the initial value. */
double slip_threshold = configuration->property(role + ".slip_threshold", 0.05); /* set the cycle‐slip threshold (m) of geometry‐free LC carrier‐phase difference between epochs */
double threshold_reject_gdop = configuration->property(role + ".threshold_reject_gdop", 30.0); /* reject threshold of GDOP. If the GDOP is over the value, the observable is excluded for the estimation process as an outlier. */
double threshold_reject_innovation = configuration->property(role + ".threshold_reject_innovation", 30.0); /* reject threshold of innovation (m). If the innovation is over the value, the observable is excluded for the estimation process as an outlier. */
int number_filter_iter = configuration->property(role + ".number_filter_iter", 1); /* Set the number of iteration in the measurement update of the estimation filter.
If the baseline length is very short like 1 m, the iteration may be effective to handle
the nonlinearity of measurement equation. */
/// Statistics
double bias_0 = configuration->property(role + ".bias_0", 30.0);
double iono_0 = configuration->property(role + ".iono_0", 0.03);
double trop_0 = configuration->property(role + ".trop_0", 0.3);
double sigma_bias = configuration->property(role + ".sigma_bias", 1e-4); /* Set the process noise standard deviation of carrier‐phase
bias (ambiguity) (cycle/sqrt(s)) */
double sigma_iono = configuration->property(role + ".sigma_iono", 1e-3); /* Set the process noise standard deviation of vertical ionospheric delay per 10 km baseline (m/sqrt(s)). */
double sigma_trop = configuration->property(role + ".sigma_trop", 1e-4); /* Set the process noise standard deviation of zenith tropospheric delay (m/sqrt(s)). */
double sigma_acch = configuration->property(role + ".sigma_acch", 1e-1); /* Set the process noise standard deviation of the receiver acceleration as
the horizontal component. (m/s2/sqrt(s)). If Receiver Dynamics is set to OFF, they are not used. */
double sigma_accv = configuration->property(role + ".sigma_accv", 1e-2); /* Set the process noise standard deviation of the receiver acceleration as
the vertical component. (m/s2/sqrt(s)). If Receiver Dynamics is set to OFF, they are not used. */
double sigma_pos = configuration->property(role + ".sigma_pos", 0.0);
double code_phase_error_ratio_l1 = configuration->property(role + ".code_phase_error_ratio_l1", 100.0);
double code_phase_error_ratio_l2 = configuration->property(role + ".code_phase_error_ratio_l2", 100.0);
double code_phase_error_ratio_l5 = configuration->property(role + ".code_phase_error_ratio_l5", 100.0);
double carrier_phase_error_factor_a = configuration->property(role + ".carrier_phase_error_factor_a", 0.003);
double carrier_phase_error_factor_b = configuration->property(role + ".carrier_phase_error_factor_b", 0.003);
snrmask_t snrmask = {{}, {{}, {}}};
prcopt_t rtklib_configuration_options = {
positioning_mode, /* positioning mode (PMODE_XXX) see src/algorithms/libs/rtklib/rtklib.h */
0, /* solution type (0:forward,1:backward,2:combined) */
number_of_frequencies, /* number of frequencies (1:L1, 2:L1+L2, 3:L1+L2+L5)*/
navigation_system, /* navigation system */
elevation_mask * D2R, /* elevation mask angle (degrees) */
snrmask, /* snrmask_t snrmask SNR mask */
0, /* satellite ephemeris/clock (EPHOPT_XXX) */
integer_ambiguity_resolution_gps, /* AR mode (0:off,1:continuous,2:instantaneous,3:fix and hold,4:ppp-ar) */
integer_ambiguity_resolution_glo, /* GLONASS AR mode (0:off,1:on,2:auto cal,3:ext cal) */
integer_ambiguity_resolution_bds, /* BeiDou AR mode (0:off,1:on) */
outage_reset_ambiguity, /* obs outage count to reset bias */
min_lock_to_fix_ambiguity, /* min lock count to fix ambiguity */
10, /* min fix count to hold ambiguity */
1, /* max iteration to resolve ambiguity */
iono_model, /* ionosphere option (IONOOPT_XXX) */
trop_model, /* troposphere option (TROPOPT_XXX) */
dynamics_model, /* dynamics model (0:none, 1:velocity, 2:accel) */
earth_tide, /* earth tide correction (0:off,1:solid,2:solid+otl+pole) */
number_filter_iter, /* number of filter iteration */
0, /* code smoothing window size (0:none) */
0, /* interpolate reference obs (for post mission) */
0, /* sbssat_t sbssat SBAS correction options */
0, /* sbsion_t sbsion[MAXBAND+1] SBAS satellite selection (0:all) */
0, /* rover position for fixed mode */
0, /* base position for relative mode */
/* 0:pos in prcopt, 1:average of single pos, */
/* 2:read from file, 3:rinex header, 4:rtcm pos */
{code_phase_error_ratio_l1, code_phase_error_ratio_l2, code_phase_error_ratio_l5}, /* eratio[NFREQ] code/phase error ratio */
{100.0, carrier_phase_error_factor_a, carrier_phase_error_factor_b, 0.0, 1.0}, /* err[5]: measurement error factor [0]:reserved, [1-3]:error factor a/b/c of phase (m) , [4]:doppler frequency (hz) */
{bias_0, iono_0, trop_0}, /* std[3]: initial-state std [0]bias,[1]iono [2]trop*/
{sigma_bias, sigma_iono, sigma_trop, sigma_acch, sigma_accv, sigma_pos}, /* prn[6] process-noise std */
5e-12, /* sclkstab: satellite clock stability (sec/sec) */
{min_ratio_to_fix_ambiguity, 0.9999, 0.25, 0.1, 0.05, 0.0, 0.0, 0.0}, /* thresar[8]: AR validation threshold */
min_elevation_to_fix_ambiguity, /* elevation mask of AR for rising satellite (deg) */
0.0, /* elevation mask to hold ambiguity (deg) */
slip_threshold, /* slip threshold of geometry-free phase (m) */
30.0, /* max difference of time (sec) */
threshold_reject_innovation, /* reject threshold of innovation (m) */
threshold_reject_gdop, /* reject threshold of gdop */
{}, /* double baseline[2] baseline length constraint {const,sigma} (m) */
{}, /* double ru[3] rover position for fixed mode {x,y,z} (ecef) (m) */
{}, /* double rb[3] base position for relative mode {x,y,z} (ecef) (m) */
{"", ""}, /* char anttype[2][MAXANT] antenna types {rover,base} */
{{}, {}}, /* double antdel[2][3] antenna delta {{rov_e,rov_n,rov_u},{ref_e,ref_n,ref_u}} */
{}, /* pcv_t pcvr[2] receiver antenna parameters {rov,base} */
{}, /* unsigned char exsats[MAXSAT] excluded satellites (1:excluded, 2:included) */
0, /* max averaging epoches */
0, /* initialize by restart */
1, /* output single by dgps/float/fix/ppp outage */
{"", ""}, /* char rnxopt[2][256] rinex options {rover,base} */
{sat_PCV, rec_PCV, phwindup, reject_GPS_IIA, raim_fde}, /* posopt[6] positioning options [0]: satellite and receiver antenna PCV model; [1]: interpolate antenna parameters; [2]: apply phase wind-up correction for PPP modes; [3]: exclude measurements of GPS Block IIA satellites satellite [4]: RAIM FDE (fault detection and exclusion) [5]: handle day-boundary clock jump */
0, /* solution sync mode (0:off,1:on) */
{{}, {}}, /* odisp[2][6*11] ocean tide loading parameters {rov,base} */
{{}, {{}, {}}, {{}, {}}, {}, {}}, /* exterr_t exterr extended receiver error model */
0, /* disable L2-AR */
{} /* char pppopt[256] ppp option "-GAP_RESION=" default gap to reset iono parameters (ep) */
};
rtk_t rtk;
rtkinit(&rtk, &rtklib_configuration_options);
return rtk;
}
//todo: add test cases for Galileo E1, E5 and GPS L5
TEST(RTKLibSolverTest, test1)
{
//test case #1: GPS L1 CA simulated with gnss-sim
std::string path = std::string(TEST_PATH);
int nchannels = 8;
std::string dump_filename = ".rtklib_solver_dump.dat";
bool flag_dump_to_file = false;
rtk_t rtk = configure_rtklib_options();
std::unique_ptr<rtklib_solver> d_ls_pvt(new rtklib_solver(nchannels, dump_filename, flag_dump_to_file, rtk));
d_ls_pvt->set_averaging_depth(1);
// load ephemeris
std::string eph_xml_filename = path + "data/rtklib_test/eph_GPS_L1CA_test1.xml";
gnss_sdr_supl_client supl_client_ephemeris_;
std::cout << "SUPL: Try read GPS ephemeris from XML file " << eph_xml_filename << std::endl;
if (supl_client_ephemeris_.load_ephemeris_xml(eph_xml_filename) == true)
{
std::map<int, Gps_Ephemeris>::const_iterator gps_eph_iter;
for (gps_eph_iter = supl_client_ephemeris_.gps_ephemeris_map.cbegin();
gps_eph_iter != supl_client_ephemeris_.gps_ephemeris_map.cend();
gps_eph_iter++)
{
std::cout << "SUPL: Read XML Ephemeris for GPS SV " << gps_eph_iter->first << std::endl;
std::shared_ptr<Gps_Ephemeris> tmp_obj = std::make_shared<Gps_Ephemeris>(gps_eph_iter->second);
// update/insert new ephemeris record to the global ephemeris map
d_ls_pvt->gps_ephemeris_map[gps_eph_iter->first] = *tmp_obj;
}
}
else
{
std::cout << "ERROR: SUPL client error reading XML" << std::endl;
}
// insert observables epoch
std::map<int, Gnss_Synchro> gnss_synchro_map;
// Gnss_Synchro tmp_obs;
// tmp_obs.System = 'G';
// std::string signal = "1C";
// const char* str = signal.c_str(); // get a C style null terminated string
// std::memcpy(static_cast<void*>(tmp_obs.Signal), str, 3); // copy string into synchro char array: 2 char + null
//
// gnss_synchro_map[0] = tmp_obs;
// gnss_synchro_map[0].PRN = 1;
// gnss_synchro_map[0].RX_time = 518449.000000;
// gnss_synchro_map[0].Pseudorange_m = 22816591.664859;
// gnss_synchro_map[0].Carrier_Doppler_hz = -2579.334343;
// gnss_synchro_map[0].Carrier_phase_rads = 794858.014183;
//load from xml (boost serialize)
std::string file_name = path + "data/rtklib_test/obs_test1.xml";
try
{
std::ifstream ifs(file_name.c_str(), std::ifstream::binary | std::ifstream::in);
boost::archive::xml_iarchive xml(ifs);
gnss_synchro_map.clear();
xml >> boost::serialization::make_nvp("GNSS-SDR_gnss_synchro_map", gnss_synchro_map);
ifs.close();
std::cout << "Loaded gnss_synchro map data with " << gnss_synchro_map.size() << " pseudoranges" << std::endl;
}
catch (std::exception& e)
{
std::cout << e.what() << "File: " << file_name;
}
// solve
bool pvt_valid = false;
if (d_ls_pvt->get_PVT(gnss_synchro_map, false))
{
// DEBUG MESSAGE: Display position in console output
if (d_ls_pvt->is_valid_position())
{
std::streamsize ss = std::cout.precision(); // save current precision
std::cout.setf(std::ios::fixed, std::ios::floatfield);
auto facet = new boost::posix_time::time_facet("%Y-%b-%d %H:%M:%S.%f %z");
std::cout.imbue(std::locale(std::cout.getloc(), facet));
std::cout << "Position at " << d_ls_pvt->get_position_UTC_time()
<< " UTC using " << d_ls_pvt->get_num_valid_observations()
<< std::fixed << std::setprecision(9)
<< " observations is Lat = " << d_ls_pvt->get_latitude() << " [deg], Long = " << d_ls_pvt->get_longitude()
<< std::fixed << std::setprecision(3)
<< " [deg], Height = " << d_ls_pvt->get_height() << " [m]" << std::endl;
std::cout << std::setprecision(ss);
std::cout << "RX clock offset: " << d_ls_pvt->get_time_offset_s() << "[s]" << std::endl;
// boost::posix_time::ptime p_time;
// gtime_t rtklib_utc_time = gpst2time(adjgpsweek(d_ls_pvt->gps_ephemeris_map.cbegin()->second.i_GPS_week), d_rx_time);
// p_time = boost::posix_time::from_time_t(rtklib_utc_time.time);
// p_time += boost::posix_time::microseconds(round(rtklib_utc_time.sec * 1e6));
// std::cout << TEXT_MAGENTA << "Observable RX time (GPST) " << boost::posix_time::to_simple_string(p_time) << TEXT_RESET << std::endl;
std::cout << "Position at " << boost::posix_time::to_simple_string(d_ls_pvt->get_position_UTC_time())
<< " UTC using " << d_ls_pvt->get_num_valid_observations() << " observations is Lat = " << d_ls_pvt->get_latitude() << " [deg], Long = " << d_ls_pvt->get_longitude()
<< " [deg], Height = " << d_ls_pvt->get_height() << " [m]" << std::endl;
std::cout << "RTKLIB Position at RX TOW = " << gnss_synchro_map.begin()->second.RX_time
<< " in ECEF (X,Y,Z,t[meters]) = " << std::fixed << std::setprecision(16)
<< d_ls_pvt->pvt_sol.rr[0] << ","
<< d_ls_pvt->pvt_sol.rr[1] << ","
<< d_ls_pvt->pvt_sol.rr[2] << std::endl;
/* std::cout << "Dilution of Precision at " << boost::posix_time::to_simple_string(d_ls_pvt->get_position_UTC_time())
<< " UTC using "<< d_ls_pvt->get_num_valid_observations() <<" observations is HDOP = " << d_ls_pvt->get_hdop() << " VDOP = "
<< d_ls_pvt->get_vdop()
<< " GDOP = " << d_ls_pvt->get_gdop() << std::endl; */
//todo: check here the positioning error against the reference position generated with gnss-sim
//reference position on in WGS84: Lat (deg), Long (deg) , H (m): 30.286502,120.032669,100
pvt_valid = true;
}
}
EXPECT_EQ(true, pvt_valid);
}