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

Merge branch 'unify_tracking' into observables_and_display_color

Browse Source
This commit is contained in:
Antonio Ramos
2018-03-19 14:50:00 +01:00
parent a797bfb641 59a991b884
commit cc887402b1
30 changed files with 2694 additions and 544 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -34,6 +34,7 @@
#include <boost/archive/xml_oarchive.hpp> #include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp> #include <boost/archive/xml_iarchive.hpp>
#include <boost/serialization/map.hpp> #include <boost/serialization/map.hpp>
#include <boost/exception/all.hpp>
#include <glog/logging.h> #include <glog/logging.h>
#include <gnuradio/gr_complex.h> #include <gnuradio/gr_complex.h>
#include <gnuradio/io_signature.h> #include <gnuradio/io_signature.h>
@@ -41,6 +42,7 @@
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
#include <map> #include <map>
#include <exception>
using google::LogMessage; using google::LogMessage;
@@ -545,34 +547,46 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
// store valid observables in a map. // store valid observables in a map.
gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(i, in[i][epoch])); gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(i, in[i][epoch]));
} }
try
if (d_ls_pvt->gps_ephemeris_map.size() > 0)
{ {
if (tmp_eph_iter_gps != d_ls_pvt->gps_ephemeris_map.end()) if (d_ls_pvt->gps_ephemeris_map.size() > 0)
{ {
d_rtcm_printer->lock_time(d_ls_pvt->gps_ephemeris_map.find(in[i][epoch].PRN)->second, in[i][epoch].RX_time, in[i][epoch]); // keep track of locking time if (tmp_eph_iter_gps != d_ls_pvt->gps_ephemeris_map.end())
{
d_rtcm_printer->lock_time(d_ls_pvt->gps_ephemeris_map.find(in[i][epoch].PRN)->second, in[i][epoch].RX_time, in[i][epoch]); // keep track of locking time
}
}
if (d_ls_pvt->galileo_ephemeris_map.size() > 0)
{
if (tmp_eph_iter_gal != d_ls_pvt->galileo_ephemeris_map.end())
{
d_rtcm_printer->lock_time(d_ls_pvt->galileo_ephemeris_map.find(in[i][epoch].PRN)->second, in[i][epoch].RX_time, in[i][epoch]); // keep track of locking time
}
}
if (d_ls_pvt->gps_cnav_ephemeris_map.size() > 0)
{
if (tmp_eph_iter_cnav != d_ls_pvt->gps_cnav_ephemeris_map.end())
{
d_rtcm_printer->lock_time(d_ls_pvt->gps_cnav_ephemeris_map.find(in[i][epoch].PRN)->second, in[i][epoch].RX_time, in[i][epoch]); // keep track of locking time
}
}
if (d_ls_pvt->glonass_gnav_ephemeris_map.size() > 0)
{
if (tmp_eph_iter_glo_gnav != d_ls_pvt->glonass_gnav_ephemeris_map.end())
{
d_rtcm_printer->lock_time(d_ls_pvt->glonass_gnav_ephemeris_map.find(in[i][epoch].PRN)->second, in[i][epoch].RX_time, in[i][epoch]); // keep track of locking time
}
} }
} }
if (d_ls_pvt->galileo_ephemeris_map.size() > 0) catch (const boost::exception& ex)
{ {
if (tmp_eph_iter_gal != d_ls_pvt->galileo_ephemeris_map.end()) std::cout << "RTCM boost exception: " << boost::diagnostic_information(ex) << std::endl;
{ LOG(ERROR) << "RTCM boost exception: " << boost::diagnostic_information(ex);
d_rtcm_printer->lock_time(d_ls_pvt->galileo_ephemeris_map.find(in[i][epoch].PRN)->second, in[i][epoch].RX_time, in[i][epoch]); // keep track of locking time
}
} }
if (d_ls_pvt->gps_cnav_ephemeris_map.size() > 0) catch (const std::exception& ex)
{ {
if (tmp_eph_iter_cnav != d_ls_pvt->gps_cnav_ephemeris_map.end()) std::cout << "RTCM std exception: " << ex.what() << std::endl;
{ LOG(ERROR) << "RTCM std exception: " << ex.what();
d_rtcm_printer->lock_time(d_ls_pvt->gps_cnav_ephemeris_map.find(in[i][epoch].PRN)->second, in[i][epoch].RX_time, in[i][epoch]); // keep track of locking time
}
}
if (d_ls_pvt->glonass_gnav_ephemeris_map.size() > 0)
{
if (tmp_eph_iter_glo_gnav != d_ls_pvt->glonass_gnav_ephemeris_map.end())
{
d_rtcm_printer->lock_time(d_ls_pvt->glonass_gnav_ephemeris_map.find(in[i][epoch].PRN)->second, in[i][epoch].RX_time, in[i][epoch]); // keep track of locking time
}
} }
} }
} }
@@ -591,10 +605,7 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
// compute on the fly PVT solution // compute on the fly PVT solution
if (flag_compute_pvt_output == true) if (flag_compute_pvt_output == true)
{ {
bool pvt_result; if (d_ls_pvt->get_PVT(gnss_observables_map, d_rx_time, false))
pvt_result = d_ls_pvt->get_PVT(gnss_observables_map, d_rx_time, false);
if (pvt_result == true)
{ {
if (std::fabs(current_RX_time - last_pvt_display_T_rx_s) * 1000.0 >= static_cast<double>(d_display_rate_ms)) if (std::fabs(current_RX_time - last_pvt_display_T_rx_s) * 1000.0 >= static_cast<double>(d_display_rate_ms))
{ {
@@ -1178,88 +1189,350 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
} }
// ####################### RTCM MESSAGES ################# // ####################### RTCM MESSAGES #################
if (b_rtcm_writing_started) try
{ {
if (type_of_rx == 1) // GPS L1 C/A if (b_rtcm_writing_started)
{ {
if (flag_write_RTCM_1019_output == true) if (type_of_rx == 1) // GPS L1 C/A
{
if (flag_write_RTCM_1019_output == true)
{
for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
}
if (flag_write_RTCM_MSM_output == true)
{
std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter;
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin();
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
}
if ((type_of_rx == 4) || (type_of_rx == 5) || (type_of_rx == 6) || (type_of_rx == 14) || (type_of_rx == 15)) // Galileo
{
if (flag_write_RTCM_1045_output == true)
{
for (std::map<int, Galileo_Ephemeris>::const_iterator gal_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin(); gal_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend(); gal_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1045(gal_ephemeris_iter->second);
}
}
if (flag_write_RTCM_MSM_output == true)
{
std::map<int, Galileo_Ephemeris>::const_iterator gal_ephemeris_iter;
gal_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin();
if (gal_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, gal_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
}
if (type_of_rx == 7) // GPS L1 C/A + GPS L2C
{
if (flag_write_RTCM_1019_output == true)
{
for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
}
if (flag_write_RTCM_MSM_output == true)
{
std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter;
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin();
std::map<int, Gps_CNAV_Ephemeris>::const_iterator gps_cnav_ephemeris_iter;
gps_cnav_ephemeris_iter = d_ls_pvt->gps_cnav_ephemeris_map.cbegin();
if ((gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend()) && (gps_cnav_ephemeris_iter != d_ls_pvt->gps_cnav_ephemeris_map.cend()))
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, gps_cnav_ephemeris_iter->second, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
}
if (type_of_rx == 9) // GPS L1 C/A + Galileo E1B
{
if (flag_write_RTCM_1019_output == true)
{
for (gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.begin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.end(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
}
if (flag_write_RTCM_1045_output == true)
{
for (galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.begin(); galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end(); galileo_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1045(galileo_ephemeris_iter->second);
}
}
if (flag_write_RTCM_MSM_output == true)
{
//gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.end();
//galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.end();
unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++)
{
std::string system(&gnss_observables_iter->second.System, 1);
if (gps_channel == 0)
{
if (system.compare("G") == 0)
{
// This is a channel with valid GPS signal
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
gps_channel = i;
}
}
}
if (gal_channel == 0)
{
if (system.compare("E") == 0)
{
galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend())
{
gal_channel = i;
}
}
}
i++;
}
if (flag_write_RTCM_MSM_output == true)
{
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, galileo_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
if (flag_write_RTCM_MSM_output == true)
{
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
}
}
if ((type_of_rx == 23) || (type_of_rx == 24) || (type_of_rx == 25)) // GLONASS
{
if (flag_write_RTCM_1020_output == true)
{
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
}
}
std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glo_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin();
if (glo_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glo_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if (type_of_rx == 26) // GPS L1 C/A + GLONASS L1 C/A
{
if (flag_write_RTCM_1019_output == true)
{
for (gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
}
if (flag_write_RTCM_1020_output == true)
{
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
}
}
if (flag_write_RTCM_MSM_output == true)
{
//gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.end();
//galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.end();
unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.begin(); gnss_observables_iter != gnss_observables_map.end(); gnss_observables_iter++)
{
std::string system(&gnss_observables_iter->second.System, 1);
if (gps_channel == 0)
{
if (system.compare("G") == 0)
{
// This is a channel with valid GPS signal
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
gps_channel = i;
}
}
}
if (glo_channel == 0)
{
if (system.compare("R") == 0)
{
glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend())
{
glo_channel = i;
}
}
}
i++;
}
if (flag_write_RTCM_MSM_output == true)
{
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glonass_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
if (flag_write_RTCM_MSM_output == true)
{
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
}
}
if (type_of_rx == 27) // GLONASS L1 C/A + Galileo E1B
{
if (flag_write_RTCM_1020_output == true)
{
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
}
}
if (flag_write_RTCM_1045_output == true)
{
for (galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin(); galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend(); galileo_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1045(galileo_ephemeris_iter->second);
}
}
if (flag_write_RTCM_MSM_output == true)
{
//gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.end();
//galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.end();
unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++)
{
std::string system(&gnss_observables_iter->second.System, 1);
if (gal_channel == 0)
{
if (system.compare("E") == 0)
{
// This is a channel with valid GPS signal
galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend())
{
gal_channel = i;
}
}
}
if (glo_channel == 0)
{
if (system.compare("R") == 0)
{
glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.end())
{
glo_channel = i;
}
}
}
i++;
}
if (flag_write_RTCM_MSM_output == true)
{
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, galileo_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
if (flag_write_RTCM_MSM_output == true)
{
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.end())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glonass_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
}
}
}
if (!b_rtcm_writing_started) // the first time
{
if (type_of_rx == 1) // GPS L1 C/A
{ {
for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++) for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{ {
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second); d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
} }
}
if (flag_write_RTCM_MSM_output == true) std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin();
{
std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter;
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin();
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend()) if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{ {
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0); d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
} }
b_rtcm_writing_started = true;
} }
} if ((type_of_rx == 4) || (type_of_rx == 5) || (type_of_rx == 6) || (type_of_rx == 14) || (type_of_rx == 15)) // Galileo
if ((type_of_rx == 4) or (type_of_rx == 5) or (type_of_rx == 6) or (type_of_rx == 14) or (type_of_rx == 15)) // Galileo
{
if (flag_write_RTCM_1045_output == true)
{ {
for (std::map<int, Galileo_Ephemeris>::const_iterator gal_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin(); gal_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend(); gal_ephemeris_iter++) for (std::map<int, Galileo_Ephemeris>::const_iterator gal_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin(); gal_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend(); gal_ephemeris_iter++)
{ {
d_rtcm_printer->Print_Rtcm_MT1045(gal_ephemeris_iter->second); d_rtcm_printer->Print_Rtcm_MT1045(gal_ephemeris_iter->second);
} }
}
if (flag_write_RTCM_MSM_output == true) std::map<int, Galileo_Ephemeris>::const_iterator gal_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin();
{
std::map<int, Galileo_Ephemeris>::const_iterator gal_ephemeris_iter;
gal_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin();
if (gal_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend()) if (gal_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend())
{ {
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, gal_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0); d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, gal_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
} }
b_rtcm_writing_started = true;
} }
} if (type_of_rx == 7) // GPS L1 C/A + GPS L2C
if (type_of_rx == 7) // GPS L1 C/A + GPS L2C
{
if (flag_write_RTCM_1019_output == true)
{ {
for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++) for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{ {
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second); d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
} }
}
if (flag_write_RTCM_MSM_output == true) std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin();
{ std::map<int, Gps_CNAV_Ephemeris>::const_iterator gps_cnav_ephemeris_iter = d_ls_pvt->gps_cnav_ephemeris_map.cbegin();
std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter;
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); if ((gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend()) && (gps_cnav_ephemeris_iter != d_ls_pvt->gps_cnav_ephemeris_map.cend()))
std::map<int, Gps_CNAV_Ephemeris>::const_iterator gps_cnav_ephemeris_iter;
gps_cnav_ephemeris_iter = d_ls_pvt->gps_cnav_ephemeris_map.cbegin();
if ((gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend()) and (gps_cnav_ephemeris_iter != d_ls_pvt->gps_cnav_ephemeris_map.cend()))
{ {
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, gps_cnav_ephemeris_iter->second, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0); d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, gps_cnav_ephemeris_iter->second, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
} }
b_rtcm_writing_started = true;
} }
} if (type_of_rx == 9) // GPS L1 C/A + Galileo E1B
if (type_of_rx == 9) // GPS L1 C/A + Galileo E1B
{
if (flag_write_RTCM_1019_output == true)
{ {
for (gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.begin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.end(); gps_ephemeris_iter++) if (d_rtcm_MT1019_rate_ms != 0) // allows deactivating messages by setting rate = 0
{ {
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second); for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
} }
} if (d_rtcm_MT1045_rate_ms != 0)
if (flag_write_RTCM_1045_output == true)
{
for (galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.begin(); galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end(); galileo_ephemeris_iter++)
{ {
d_rtcm_printer->Print_Rtcm_MT1045(galileo_ephemeris_iter->second); for (galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.begin(); galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end(); galileo_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1045(galileo_ephemeris_iter->second);
}
} }
}
if (flag_write_RTCM_MSM_output == true)
{
//gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.end();
//galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.end();
unsigned int i = 0; unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++) for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++)
{ {
@@ -1270,7 +1543,7 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
{ {
// This is a channel with valid GPS signal // This is a channel with valid GPS signal
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.find(gnss_observables_iter->second.PRN); gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend()) if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.end())
{ {
gps_channel = i; gps_channel = i;
} }
@@ -1281,7 +1554,7 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
if (system.compare("E") == 0) if (system.compare("E") == 0)
{ {
galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.find(gnss_observables_iter->second.PRN); galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend()) if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end())
{ {
gal_channel = i; gal_channel = i;
} }
@@ -1289,62 +1562,54 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
} }
i++; i++;
} }
if (flag_write_RTCM_MSM_output == true)
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.end() && (d_rtcm_MT1077_rate_ms != 0))
{ {
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend()) d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, galileo_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
} }
if (flag_write_RTCM_MSM_output == true)
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end() && (d_rtcm_MT1097_rate_ms != 0))
{ {
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend()) d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, galileo_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
} }
b_rtcm_writing_started = true;
} }
} if ((type_of_rx == 23) || (type_of_rx == 24) || (type_of_rx == 25)) // GLONASS
if ((type_of_rx == 23) or (type_of_rx == 24) or (type_of_rx == 25)) // GLONASS
{
if (flag_write_RTCM_1020_output == true)
{ {
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++) for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{ {
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model); d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
} }
}
std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glo_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glo_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin();
if (glo_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend()) if (glo_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glo_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if (type_of_rx == 26) // GPS L1 C/A + GLONASS L1 C/A
{
if (flag_write_RTCM_1019_output == true)
{
for (gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{ {
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second); d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glo_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
} }
b_rtcm_writing_started = true;
} }
if (flag_write_RTCM_1020_output == true) if (type_of_rx == 26) // GPS L1 C/A + GLONASS L1 C/A
{ {
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++) if (d_rtcm_MT1019_rate_ms != 0) // allows deactivating messages by setting rate = 0
{ {
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model); for (gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
} }
} if (d_rtcm_MT1020_rate_ms != 0) // allows deactivating messages by setting rate = 0
if (flag_write_RTCM_MSM_output == true) {
{ for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
}
}
//gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.end(); //gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.end();
//galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.end(); //galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.end();
unsigned int i = 0; unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.begin(); gnss_observables_iter != gnss_observables_map.end(); gnss_observables_iter++) for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++)
{ {
std::string system(&gnss_observables_iter->second.System, 1); std::string system(&gnss_observables_iter->second.System, 1);
if (gps_channel == 0) if (gps_channel == 0)
@@ -1372,42 +1637,35 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
} }
i++; i++;
} }
if (flag_write_RTCM_MSM_output == true) if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend())
{ {
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend()) d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glonass_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if (type_of_rx == 27) // GLONASS L1 C/A + Galileo E1B
{
if (d_rtcm_MT1020_rate_ms != 0) // allows deactivating messages by setting rate = 0
{
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{ {
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glonass_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0); d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
} }
} }
if (flag_write_RTCM_MSM_output == true) if (d_rtcm_MT1045_rate_ms != 0) // allows deactivating messages by setting rate = 0
{ {
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend()) for (galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin(); galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend(); galileo_ephemeris_iter++)
{ {
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0); d_rtcm_printer->Print_Rtcm_MT1045(galileo_ephemeris_iter->second);
} }
} }
}
}
if (type_of_rx == 27) // GLONASS L1 C/A + Galileo E1B
{
if (flag_write_RTCM_1020_output == true)
{
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
}
}
if (flag_write_RTCM_1045_output == true)
{
for (galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin(); galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend(); galileo_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1045(galileo_ephemeris_iter->second);
}
}
if (flag_write_RTCM_MSM_output == true)
{
//gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.end();
//galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.end();
unsigned int i = 0; unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++) for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++)
{ {
@@ -1437,266 +1695,32 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
} }
i++; i++;
} }
if (flag_write_RTCM_MSM_output == true) if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end())
{ {
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end()) d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, galileo_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, galileo_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
} }
if (flag_write_RTCM_MSM_output == true) if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.end())
{ {
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.end()) d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glonass_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glonass_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
} }
} }
} }
} }
catch (const boost::exception& ex)
if (!b_rtcm_writing_started) // the first time
{ {
if (type_of_rx == 1) // GPS L1 C/A std::cout << "RTCM boost exception: " << boost::diagnostic_information(ex) << std::endl;
{ LOG(ERROR) << "RTCM boost exception: " << boost::diagnostic_information(ex);
for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++) }
{ catch (const std::exception& ex)
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second); {
} std::cout << "RTCM std exception: " << ex.what() << std::endl;
LOG(ERROR) << "RTCM std exception: " << ex.what();
std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin();
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if ((type_of_rx == 4) or (type_of_rx == 5) or (type_of_rx == 6) or (type_of_rx == 14) or (type_of_rx == 15)) // Galileo
{
for (std::map<int, Galileo_Ephemeris>::const_iterator gal_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin(); gal_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend(); gal_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1045(gal_ephemeris_iter->second);
}
std::map<int, Galileo_Ephemeris>::const_iterator gal_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin();
if (gal_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, gal_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if (type_of_rx == 7) // GPS L1 C/A + GPS L2C
{
for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin();
std::map<int, Gps_CNAV_Ephemeris>::const_iterator gps_cnav_ephemeris_iter = d_ls_pvt->gps_cnav_ephemeris_map.cbegin();
if ((gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend()) and (gps_cnav_ephemeris_iter != d_ls_pvt->gps_cnav_ephemeris_map.cend()))
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, gps_cnav_ephemeris_iter->second, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if (type_of_rx == 9) // GPS L1 C/A + Galileo E1B
{
if (d_rtcm_MT1019_rate_ms != 0) // allows deactivating messages by setting rate = 0
{
for (std::map<int, Gps_Ephemeris>::const_iterator gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
}
if (d_rtcm_MT1045_rate_ms != 0)
{
for (galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.begin(); galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end(); galileo_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1045(galileo_ephemeris_iter->second);
}
}
unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++)
{
std::string system(&gnss_observables_iter->second.System, 1);
if (gps_channel == 0)
{
if (system.compare("G") == 0)
{
// This is a channel with valid GPS signal
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.end())
{
gps_channel = i;
}
}
}
if (gal_channel == 0)
{
if (system.compare("E") == 0)
{
galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end())
{
gal_channel = i;
}
}
}
i++;
}
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.end() and (d_rtcm_MT1077_rate_ms != 0))
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end() and (d_rtcm_MT1097_rate_ms != 0))
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, galileo_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if ((type_of_rx == 23) or (type_of_rx == 24) or (type_of_rx == 25)) // GLONASS
{
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
}
std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glo_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin();
if (glo_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glo_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if (type_of_rx == 26) // GPS L1 C/A + GLONASS L1 C/A
{
if (d_rtcm_MT1019_rate_ms != 0) // allows deactivating messages by setting rate = 0
{
for (gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.cbegin(); gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend(); gps_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1019(gps_ephemeris_iter->second);
}
}
if (d_rtcm_MT1020_rate_ms != 0) // allows deactivating messages by setting rate = 0
{
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
}
}
//gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.end();
//galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.end();
unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++)
{
std::string system(&gnss_observables_iter->second.System, 1);
if (gps_channel == 0)
{
if (system.compare("G") == 0)
{
// This is a channel with valid GPS signal
gps_ephemeris_iter = d_ls_pvt->gps_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
gps_channel = i;
}
}
}
if (glo_channel == 0)
{
if (system.compare("R") == 0)
{
glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend())
{
glo_channel = i;
}
}
}
i++;
}
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glonass_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
if (gps_ephemeris_iter != d_ls_pvt->gps_ephemeris_map.cend())
{
d_rtcm_printer->Print_Rtcm_MSM(7, gps_ephemeris_iter->second, {}, {}, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
b_rtcm_writing_started = true;
}
if (type_of_rx == 27) // GLONASS L1 C/A + Galileo E1B
{
if (d_rtcm_MT1020_rate_ms != 0) // allows deactivating messages by setting rate = 0
{
for (std::map<int, Glonass_Gnav_Ephemeris>::const_iterator glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.cbegin(); glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.cend(); glonass_gnav_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1020(glonass_gnav_ephemeris_iter->second, d_ls_pvt->glonass_gnav_utc_model);
}
}
if (d_rtcm_MT1045_rate_ms != 0) // allows deactivating messages by setting rate = 0
{
for (galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.cbegin(); galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend(); galileo_ephemeris_iter++)
{
d_rtcm_printer->Print_Rtcm_MT1045(galileo_ephemeris_iter->second);
}
}
unsigned int i = 0;
for (gnss_observables_iter = gnss_observables_map.cbegin(); gnss_observables_iter != gnss_observables_map.cend(); gnss_observables_iter++)
{
std::string system(&gnss_observables_iter->second.System, 1);
if (gal_channel == 0)
{
if (system.compare("E") == 0)
{
// This is a channel with valid GPS signal
galileo_ephemeris_iter = d_ls_pvt->galileo_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.cend())
{
gal_channel = i;
}
}
}
if (glo_channel == 0)
{
if (system.compare("R") == 0)
{
glonass_gnav_ephemeris_iter = d_ls_pvt->glonass_gnav_ephemeris_map.find(gnss_observables_iter->second.PRN);
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.end())
{
glo_channel = i;
}
}
}
i++;
}
if (galileo_ephemeris_iter != d_ls_pvt->galileo_ephemeris_map.end())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, galileo_ephemeris_iter->second, {}, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
if (glonass_gnav_ephemeris_iter != d_ls_pvt->glonass_gnav_ephemeris_map.end())
{
d_rtcm_printer->Print_Rtcm_MSM(7, {}, {}, {}, glonass_gnav_ephemeris_iter->second, d_rx_time, gnss_observables_map, 0, 0, 0, 0, 0);
}
}
} }
} }
} }
// DEBUG MESSAGE: Display position in console output // DEBUG MESSAGE: Display position in console output
if ((d_ls_pvt->is_valid_position() == true) and (flag_display_pvt == true)) if (d_ls_pvt->is_valid_position() and flag_display_pvt)
{ {
std::cout << TEXT_BOLD_GREEN << "Position at " << boost::posix_time::to_simple_string(d_ls_pvt->get_position_UTC_time()) std::cout << TEXT_BOLD_GREEN << "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() << " UTC using " << d_ls_pvt->get_num_valid_observations() << " observations is Lat = " << d_ls_pvt->get_latitude() << " [deg], Long = " << d_ls_pvt->get_longitude()

22
src/algorithms/libs/galileo_e1_signal_processing.cc
View File

@@ -53,7 +53,7 @@ void galileo_e1_code_gen_int(int* _dest, char _Signal[3], signed int _prn)
for (size_t i = 0; i < Galileo_E1_B_PRIMARY_CODE[prn].length(); i++) for (size_t i = 0; i < Galileo_E1_B_PRIMARY_CODE[prn].length(); i++)
{ {
hex_to_binary_converter(&_dest[index], Galileo_E1_B_PRIMARY_CODE[prn].at(i)); hex_to_binary_converter(&_dest[index], Galileo_E1_B_PRIMARY_CODE[prn].at(i));
index = index + 4; index += 4;
} }
} }
else if (_galileo_signal.rfind("1C") != std::string::npos && _galileo_signal.length() >= 2) else if (_galileo_signal.rfind("1C") != std::string::npos && _galileo_signal.length() >= 2)
@@ -61,13 +61,9 @@ void galileo_e1_code_gen_int(int* _dest, char _Signal[3], signed int _prn)
for (size_t i = 0; i < Galileo_E1_C_PRIMARY_CODE[prn].length(); i++) for (size_t i = 0; i < Galileo_E1_C_PRIMARY_CODE[prn].length(); i++)
{ {
hex_to_binary_converter(&_dest[index], Galileo_E1_C_PRIMARY_CODE[prn].at(i)); hex_to_binary_converter(&_dest[index], Galileo_E1_C_PRIMARY_CODE[prn].at(i));
index = index + 4; index += 4;
} }
} }
else
{
return;
}
} }
@@ -107,6 +103,18 @@ void galileo_e1_sinboc_61_gen_int(int* _dest, int* _prn, unsigned int _length_ou
} }
} }
void galileo_e1_code_gen_sinboc11_float(float* _dest, char _Signal[3], unsigned int _prn)
{
std::string _galileo_signal = _Signal;
unsigned int _codeLength = static_cast<unsigned int>(Galileo_E1_B_CODE_LENGTH_CHIPS);
int primary_code_E1_chips[4092]; // _codeLength not accepted by Clang
galileo_e1_code_gen_int(primary_code_E1_chips, _Signal, _prn); //generate Galileo E1 code, 1 sample per chip
for (unsigned int i = 0; i < _codeLength; i++)
{
_dest[2 * i] = static_cast<float>(primary_code_E1_chips[i]);
_dest[2 * i + 1] = -_dest[2 * i];
}
}
void galileo_e1_gen_float(float* _dest, int* _prn, char _Signal[3]) void galileo_e1_gen_float(float* _dest, int* _prn, char _Signal[3])
{ {
@@ -137,8 +145,6 @@ void galileo_e1_gen_float(float* _dest, int* _prn, char _Signal[3])
beta * static_cast<float>(sinboc_61[i]); beta * static_cast<float>(sinboc_61[i]);
} }
} }
else
return;
} }

5
src/algorithms/libs/galileo_e1_signal_processing.h
View File

@@ -34,6 +34,11 @@
#include <complex> #include <complex>
/*!
* \brief This function generates Galileo E1 code (can select E1B or E1C sinboc).
*
*/
void galileo_e1_code_gen_sinboc11_float(float* _dest, char _Signal[3], unsigned int _prn);
/*! /*!
* \brief This function generates Galileo E1 code (can select E1B or E1C, cboc or sinboc * \brief This function generates Galileo E1 code (can select E1B or E1C, cboc or sinboc

17
src/algorithms/libs/gps_l2c_signal.cc
View File

@@ -71,6 +71,23 @@ void gps_l2c_m_code_gen_complex(std::complex<float>* _dest, unsigned int _prn)
delete[] _code; delete[] _code;
} }
void gps_l2c_m_code_gen_float(float* _dest, unsigned int _prn)
{
int32_t* _code = new int32_t[GPS_L2_M_CODE_LENGTH_CHIPS];
if (_prn > 0 and _prn < 51)
{
gps_l2c_m_code(_code, _prn);
}
for (signed int i = 0; i < GPS_L2_M_CODE_LENGTH_CHIPS; i++)
{
_dest[i] = 1.0 - 2.0 * static_cast<float>(_code[i]);
}
delete[] _code;
}
/* /*
* Generates complex GPS L2C M code for the desired SV ID and sampled to specific sampling frequency * Generates complex GPS L2C M code for the desired SV ID and sampled to specific sampling frequency

2
src/algorithms/libs/gps_l2c_signal.h
View File

@@ -38,7 +38,7 @@
//!Generates complex GPS L2C M code for the desired SV ID //!Generates complex GPS L2C M code for the desired SV ID
void gps_l2c_m_code_gen_complex(std::complex<float>* _dest, unsigned int _prn); void gps_l2c_m_code_gen_complex(std::complex<float>* _dest, unsigned int _prn);
void gps_l2c_m_code_gen_float(float* _dest, unsigned int _prn);
//! Generates complex GPS L2C M code for the desired SV ID, and sampled to specific sampling frequency //! Generates complex GPS L2C M code for the desired SV ID, and sampled to specific sampling frequency
void gps_l2c_m_code_gen_complex_sampled(std::complex<float>* _dest, unsigned int _prn, signed int _fs); void gps_l2c_m_code_gen_complex_sampled(std::complex<float>* _dest, unsigned int _prn, signed int _fs);

31
src/algorithms/libs/gps_l5_signal.cc
View File

@@ -197,6 +197,22 @@ void gps_l5i_code_gen_complex(std::complex<float>* _dest, unsigned int _prn)
delete[] _code; delete[] _code;
} }
void gps_l5i_code_gen_float(float* _dest, unsigned int _prn)
{
int32_t* _code = new int32_t[GPS_L5i_CODE_LENGTH_CHIPS];
if (_prn > 0 and _prn < 51)
{
make_l5i(_code, _prn - 1);
}
for (signed int i = 0; i < GPS_L5i_CODE_LENGTH_CHIPS; i++)
{
_dest[i] = 1.0 - 2.0 * static_cast<float>(_code[i]);
}
delete[] _code;
}
/* /*
* Generates complex GPS L5i code for the desired SV ID and sampled to specific sampling frequency * Generates complex GPS L5i code for the desired SV ID and sampled to specific sampling frequency
@@ -264,7 +280,22 @@ void gps_l5q_code_gen_complex(std::complex<float>* _dest, unsigned int _prn)
delete[] _code; delete[] _code;
} }
void gps_l5q_code_gen_float(float* _dest, unsigned int _prn)
{
int32_t* _code = new int32_t[GPS_L5q_CODE_LENGTH_CHIPS];
if (_prn > 0 and _prn < 51)
{
make_l5q(_code, _prn - 1);
}
for (signed int i = 0; i < GPS_L5q_CODE_LENGTH_CHIPS; i++)
{
_dest[i] = 1.0 - 2.0 * static_cast<float>(_code[i]);
}
delete[] _code;
}
/* /*
* Generates complex GPS L5i code for the desired SV ID and sampled to specific sampling frequency * Generates complex GPS L5i code for the desired SV ID and sampled to specific sampling frequency
*/ */

2
src/algorithms/libs/gps_l5_signal.h
View File

@@ -38,9 +38,11 @@
//!Generates complex GPS L5i M code for the desired SV ID //!Generates complex GPS L5i M code for the desired SV ID
void gps_l5i_code_gen_complex(std::complex<float>* _dest, unsigned int _prn); void gps_l5i_code_gen_complex(std::complex<float>* _dest, unsigned int _prn);
void gps_l5i_code_gen_float(float* _dest, unsigned int _prn);
//!Generates complex GPS L5q M code for the desired SV ID //!Generates complex GPS L5q M code for the desired SV ID
void gps_l5q_code_gen_complex(std::complex<float>* _dest, unsigned int _prn); void gps_l5q_code_gen_complex(std::complex<float>* _dest, unsigned int _prn);
void gps_l5q_code_gen_float(float* _dest, unsigned int _prn);
//! Generates complex GPS L5i M code for the desired SV ID, and sampled to specific sampling frequency //! Generates complex GPS L5i M code for the desired SV ID, and sampled to specific sampling frequency
void gps_l5i_code_gen_complex_sampled(std::complex<float>* _dest, unsigned int _prn, signed int _fs); void gps_l5i_code_gen_complex_sampled(std::complex<float>* _dest, unsigned int _prn, signed int _fs);

10
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l5_telemetry_decoder_cc.cc
View File

@@ -70,9 +70,9 @@ gps_l5_telemetry_decoder_cc::gps_l5_telemetry_decoder_cc(
d_TOW_at_Preamble = 0.0; d_TOW_at_Preamble = 0.0;
//initialize the CNAV frame decoder (libswiftcnav) //initialize the CNAV frame decoder (libswiftcnav)
cnav_msg_decoder_init(&d_cnav_decoder); cnav_msg_decoder_init(&d_cnav_decoder);
for (int aux = 0; aux < GPS_L5_NH_CODE_LENGTH; aux++) for (int aux = 0; aux < GPS_L5i_NH_CODE_LENGTH; aux++)
{ {
if (GPS_L5_NH_CODE[aux] == 0) if (GPS_L5i_NH_CODE[aux] == 0)
{ {
bits_NH[aux] = -1.0; bits_NH[aux] = -1.0;
} }
@@ -119,9 +119,9 @@ int gps_l5_telemetry_decoder_cc::general_work(int noutput_items __attribute__((u
int symbol_value = 0; int symbol_value = 0;
//Search correlation with Neuman-Hofman Code (see IS-GPS-705D) //Search correlation with Neuman-Hofman Code (see IS-GPS-705D)
if (sym_hist.size() == GPS_L5_NH_CODE_LENGTH) if (sym_hist.size() == GPS_L5i_NH_CODE_LENGTH)
{ {
for (int i = 0; i < GPS_L5_NH_CODE_LENGTH; i++) for (int i = 0; i < GPS_L5i_NH_CODE_LENGTH; i++)
{ {
if ((bits_NH[i] * sym_hist.at(i)) > 0.0) if ((bits_NH[i] * sym_hist.at(i)) > 0.0)
{ {
@@ -132,7 +132,7 @@ int gps_l5_telemetry_decoder_cc::general_work(int noutput_items __attribute__((u
corr_NH -= 1; corr_NH -= 1;
} }
} }
if (abs(corr_NH) == GPS_L5_NH_CODE_LENGTH) if (abs(corr_NH) == GPS_L5i_NH_CODE_LENGTH)
{ {
sync_NH = true; sync_NH = true;
if (corr_NH > 0) if (corr_NH > 0)

5
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l5_telemetry_decoder_cc.h
View File

@@ -42,8 +42,7 @@
#include <utility> #include <utility>
#include <vector> #include <vector>
extern "C" extern "C" {
{
#include "cnav_msg.h" #include "cnav_msg.h"
#include "edc.h" #include "edc.h"
#include "bits.h" #include "bits.h"
@@ -91,7 +90,7 @@ private:
bool d_flag_valid_word; bool d_flag_valid_word;
Gps_CNAV_Navigation_Message d_CNAV_Message; Gps_CNAV_Navigation_Message d_CNAV_Message;
double bits_NH[GPS_L5_NH_CODE_LENGTH]; double bits_NH[GPS_L5i_NH_CODE_LENGTH];
std::deque<double> sym_hist; std::deque<double> sym_hist;
bool sync_NH; bool sync_NH;
bool new_sym; bool new_sym;

85
src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc
View File

@@ -51,7 +51,6 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
//################# CONFIGURATION PARAMETERS ######################## //################# CONFIGURATION PARAMETERS ########################
int fs_in; int fs_in;
int vector_length; int vector_length;
int f_if;
bool dump; bool dump;
std::string dump_filename; std::string dump_filename;
std::string item_type; std::string item_type;
@@ -64,11 +63,10 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
float very_early_late_space_chips; float very_early_late_space_chips;
float early_late_space_narrow_chips; float early_late_space_narrow_chips;
float very_early_late_space_narrow_chips; float very_early_late_space_narrow_chips;
unified_ = configuration->property(role + ".unified", false);
item_type = configuration->property(role + ".item_type", default_item_type); item_type = configuration->property(role + ".item_type", default_item_type);
int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
f_if = configuration->property(role + ".if", 0);
dump = configuration->property(role + ".dump", false); dump = configuration->property(role + ".dump", false);
pll_bw_hz = configuration->property(role + ".pll_bw_hz", 5.0); pll_bw_hz = configuration->property(role + ".pll_bw_hz", 5.0);
if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz);
@@ -93,23 +91,45 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
//################# MAKE TRACKING GNURadio object ################### //################# MAKE TRACKING GNURadio object ###################
if (item_type.compare("gr_complex") == 0) if (item_type.compare("gr_complex") == 0)
{ {
item_size_ = sizeof(gr_complex); if (unified_)
tracking_ = galileo_e1_dll_pll_veml_make_tracking_cc( {
f_if, char sig_[3] = "1B";
fs_in, item_size_ = sizeof(gr_complex);
vector_length, tracking_unified_ = dll_pll_veml_make_tracking(
dump, fs_in,
dump_filename, vector_length,
pll_bw_hz, dump,
dll_bw_hz, dump_filename,
pll_bw_narrow_hz, pll_bw_hz,
dll_bw_narrow_hz, dll_bw_hz,
early_late_space_chips, pll_bw_narrow_hz,
very_early_late_space_chips, dll_bw_narrow_hz,
early_late_space_narrow_chips, early_late_space_chips,
very_early_late_space_narrow_chips, very_early_late_space_chips,
extend_correlation_symbols, early_late_space_narrow_chips,
track_pilot); very_early_late_space_narrow_chips,
extend_correlation_symbols,
track_pilot, 'E', sig_);
}
else
{
tracking_ = galileo_e1_dll_pll_veml_make_tracking_cc(
0,
fs_in,
vector_length,
dump,
dump_filename,
pll_bw_hz,
dll_bw_hz,
pll_bw_narrow_hz,
dll_bw_narrow_hz,
early_late_space_chips,
very_early_late_space_chips,
early_late_space_narrow_chips,
very_early_late_space_narrow_chips,
extend_correlation_symbols,
track_pilot);
}
} }
else else
{ {
@@ -130,7 +150,10 @@ GalileoE1DllPllVemlTracking::~GalileoE1DllPllVemlTracking()
void GalileoE1DllPllVemlTracking::start_tracking() void GalileoE1DllPllVemlTracking::start_tracking()
{ {
tracking_->start_tracking(); if (unified_)
tracking_unified_->start_tracking();
else
tracking_->start_tracking();
} }
@@ -140,13 +163,19 @@ void GalileoE1DllPllVemlTracking::start_tracking()
void GalileoE1DllPllVemlTracking::set_channel(unsigned int channel) void GalileoE1DllPllVemlTracking::set_channel(unsigned int channel)
{ {
channel_ = channel; channel_ = channel;
tracking_->set_channel(channel); if (unified_)
tracking_unified_->set_channel(channel);
else
tracking_->set_channel(channel);
} }
void GalileoE1DllPllVemlTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) void GalileoE1DllPllVemlTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
{ {
tracking_->set_gnss_synchro(p_gnss_synchro); if (unified_)
tracking_unified_->set_gnss_synchro(p_gnss_synchro);
else
tracking_->set_gnss_synchro(p_gnss_synchro);
} }
@@ -170,11 +199,17 @@ void GalileoE1DllPllVemlTracking::disconnect(gr::top_block_sptr top_block)
gr::basic_block_sptr GalileoE1DllPllVemlTracking::get_left_block() gr::basic_block_sptr GalileoE1DllPllVemlTracking::get_left_block()
{ {
return tracking_; if (unified_)
return tracking_unified_;
else
return tracking_;
} }
gr::basic_block_sptr GalileoE1DllPllVemlTracking::get_right_block() gr::basic_block_sptr GalileoE1DllPllVemlTracking::get_right_block()
{ {
return tracking_; if (unified_)
return tracking_unified_;
else
return tracking_;
} }

3
src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.h
View File

@@ -39,6 +39,7 @@
#include "tracking_interface.h" #include "tracking_interface.h"
#include "galileo_e1_dll_pll_veml_tracking_cc.h" #include "galileo_e1_dll_pll_veml_tracking_cc.h"
#include "dll_pll_veml_tracking.h"
#include <string> #include <string>
@@ -95,11 +96,13 @@ public:
private: private:
galileo_e1_dll_pll_veml_tracking_cc_sptr tracking_; galileo_e1_dll_pll_veml_tracking_cc_sptr tracking_;
dll_pll_veml_tracking_sptr tracking_unified_;
size_t item_size_; size_t item_size_;
unsigned int channel_; unsigned int channel_;
std::string role_; std::string role_;
unsigned int in_streams_; unsigned int in_streams_;
unsigned int out_streams_; unsigned int out_streams_;
bool unified_;
}; };
#endif // GNSS_SDR_GALILEO_E1_DLL_PLL_VEML_TRACKING_H_ #endif // GNSS_SDR_GALILEO_E1_DLL_PLL_VEML_TRACKING_H_

86
src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc
View File

@@ -52,41 +52,64 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking(
//################# CONFIGURATION PARAMETERS ######################## //################# CONFIGURATION PARAMETERS ########################
int fs_in; int fs_in;
int vector_length; int vector_length;
int f_if;
bool dump; bool dump;
std::string dump_filename; std::string dump_filename;
std::string item_type; std::string item_type;
std::string default_item_type = "gr_complex"; std::string default_item_type = "gr_complex";
float pll_bw_hz;
float dll_bw_hz;
float early_late_space_chips;
item_type = configuration->property(role + ".item_type", default_item_type); item_type = configuration->property(role + ".item_type", default_item_type);
int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
f_if = configuration->property(role + ".if", 0);
dump = configuration->property(role + ".dump", false); dump = configuration->property(role + ".dump", false);
pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0); unified_ = configuration->property(role + ".unified", false);
float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0);
if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz); if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz);
dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0); float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 20.0);
float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 2.0);
float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0);
if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast<float>(FLAGS_dll_bw_hz); if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast<float>(FLAGS_dll_bw_hz);
early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5); float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5);
float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.5);
std::string default_dump_filename = "./track_ch"; std::string default_dump_filename = "./track_ch";
dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); //unused! dump_filename = configuration->property(role + ".dump_filename", default_dump_filename); //unused!
vector_length = std::round(fs_in / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS)); vector_length = std::round(fs_in / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS));
int symbols_extended_correlator = configuration->property(role + ".extend_correlation_symbols", 1);
if (symbols_extended_correlator < 1) symbols_extended_correlator = 1;
//################# MAKE TRACKING GNURadio object ################### //################# MAKE TRACKING GNURadio object ###################
if (item_type.compare("gr_complex") == 0) if (item_type.compare("gr_complex") == 0)
{ {
item_size_ = sizeof(gr_complex); if (unified_)
tracking_ = gps_l1_ca_dll_pll_make_tracking_cc( {
f_if, char sig_[3] = "1C";
fs_in, item_size_ = sizeof(gr_complex);
vector_length, tracking_unified_ = dll_pll_veml_make_tracking(
dump, fs_in,
dump_filename, vector_length,
pll_bw_hz, dump,
dll_bw_hz, dump_filename,
early_late_space_chips); pll_bw_hz,
dll_bw_hz,
pll_bw_narrow_hz,
dll_bw_narrow_hz,
early_late_space_chips,
early_late_space_chips,
early_late_space_narrow_chips,
early_late_space_narrow_chips,
symbols_extended_correlator,
false,
'G', sig_);
}
else
{
tracking_ = gps_l1_ca_dll_pll_make_tracking_cc(
0,
fs_in,
vector_length,
dump,
dump_filename,
pll_bw_hz,
dll_bw_hz,
early_late_space_chips);
}
} }
else else
{ {
@@ -105,7 +128,10 @@ GpsL1CaDllPllTracking::~GpsL1CaDllPllTracking()
void GpsL1CaDllPllTracking::start_tracking() void GpsL1CaDllPllTracking::start_tracking()
{ {
tracking_->start_tracking(); if (unified_)
tracking_unified_->start_tracking();
else
tracking_->start_tracking();
} }
@@ -115,13 +141,19 @@ void GpsL1CaDllPllTracking::start_tracking()
void GpsL1CaDllPllTracking::set_channel(unsigned int channel) void GpsL1CaDllPllTracking::set_channel(unsigned int channel)
{ {
channel_ = channel; channel_ = channel;
tracking_->set_channel(channel); if (unified_)
tracking_unified_->set_channel(channel);
else
tracking_->set_channel(channel);
} }
void GpsL1CaDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) void GpsL1CaDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
{ {
tracking_->set_gnss_synchro(p_gnss_synchro); if (unified_)
tracking_unified_->set_gnss_synchro(p_gnss_synchro);
else
tracking_->set_gnss_synchro(p_gnss_synchro);
} }
@@ -145,11 +177,17 @@ void GpsL1CaDllPllTracking::disconnect(gr::top_block_sptr top_block)
gr::basic_block_sptr GpsL1CaDllPllTracking::get_left_block() gr::basic_block_sptr GpsL1CaDllPllTracking::get_left_block()
{ {
return tracking_; if (unified_)
return tracking_unified_;
else
return tracking_;
} }
gr::basic_block_sptr GpsL1CaDllPllTracking::get_right_block() gr::basic_block_sptr GpsL1CaDllPllTracking::get_right_block()
{ {
return tracking_; if (unified_)
return tracking_unified_;
else
return tracking_;
} }

3
src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.h
View File

@@ -40,6 +40,7 @@
#include "tracking_interface.h" #include "tracking_interface.h"
#include "gps_l1_ca_dll_pll_tracking_cc.h" #include "gps_l1_ca_dll_pll_tracking_cc.h"
#include "dll_pll_veml_tracking.h"
#include <string> #include <string>
class ConfigurationInterface; class ConfigurationInterface;
@@ -93,11 +94,13 @@ public:
private: private:
gps_l1_ca_dll_pll_tracking_cc_sptr tracking_; gps_l1_ca_dll_pll_tracking_cc_sptr tracking_;
dll_pll_veml_tracking_sptr tracking_unified_;
size_t item_size_; size_t item_size_;
unsigned int channel_; unsigned int channel_;
std::string role_; std::string role_;
unsigned int in_streams_; unsigned int in_streams_;
unsigned int out_streams_; unsigned int out_streams_;
bool unified_;
}; };
#endif // GNSS_SDR_GPS_L1_CA_DLL_PLL_TRACKING_H_ #endif // GNSS_SDR_GPS_L1_CA_DLL_PLL_TRACKING_H_

1
src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt
View File

@@ -39,6 +39,7 @@ set(TRACKING_GR_BLOCKS_SOURCES
glonass_l1_ca_dll_pll_tracking_cc.cc glonass_l1_ca_dll_pll_tracking_cc.cc
glonass_l1_ca_dll_pll_c_aid_tracking_cc.cc glonass_l1_ca_dll_pll_c_aid_tracking_cc.cc
glonass_l1_ca_dll_pll_c_aid_tracking_sc.cc glonass_l1_ca_dll_pll_c_aid_tracking_sc.cc
dll_pll_veml_tracking.cc
${OPT_TRACKING_BLOCKS} ${OPT_TRACKING_BLOCKS}
) )

1501
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc Executable file
View File

File diff suppressed because it is too large Load Diff

243
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h Executable file
View File

@@ -0,0 +1,243 @@
/*!
* \file dll_pll_veml_tracking.h
* \brief Implementation of a code DLL + carrier PLL VEML (Very Early
* Minus Late) tracking block for Galileo E1 signals
* \author Luis Esteve, 2012. luis(at)epsilon-formacion.com
*
* -------------------------------------------------------------------------
*
* 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 <http://www.gnu.org/licenses/>.
*
* -------------------------------------------------------------------------
*/
#ifndef GNSS_SDR_DLL_PLL_VEML_TRACKING_H
#define GNSS_SDR_DLL_PLL_VEML_TRACKING_H
#define DLL_PLL_CN0_ESTIMATION_SAMPLES 20
#define DLL_PLL_MINIMUM_VALID_CN0 25
#define DLL_PLL_MAXIMUM_LOCK_FAIL_COUNTER 50
#define DLL_PLL_CARRIER_LOCK_THRESHOLD 0.85
#include "gnss_synchro.h"
#include "tracking_2nd_DLL_filter.h"
#include "tracking_2nd_PLL_filter.h"
#include "cpu_multicorrelator_real_codes.h"
#include <fstream>
#include <string>
#include <gnuradio/block.h>
class dll_pll_veml_tracking;
typedef boost::shared_ptr<dll_pll_veml_tracking> dll_pll_veml_tracking_sptr;
dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(double fs_in, unsigned int vector_length,
bool dump, std::string dump_filename,
float pll_bw_hz, float dll_bw_hz,
float pll_bw_narrow_hz, float dll_bw_narrow_hz,
float early_late_space_chips, float very_early_late_space_chips,
float early_late_space_narrow_chips,
float very_early_late_space_narrow_chips,
int extend_correlation_symbols, bool track_pilot,
char system, char signal[3]);
/*!
* \brief This class implements a code DLL + carrier PLL VEML (Very Early
* Minus Late) tracking block for Galileo E1 signals
*/
class dll_pll_veml_tracking : public gr::block
{
public:
~dll_pll_veml_tracking();
void set_channel(unsigned int channel);
void set_gnss_synchro(Gnss_Synchro *p_gnss_synchro);
void start_tracking();
/*!
* \brief Code DLL + carrier PLL according to the algorithms described in:
* K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen,
* A Software-Defined GPS and Galileo Receiver. A Single-Frequency Approach,
* Birkhauser, 2007
*/
int general_work(int noutput_items, gr_vector_int &ninput_items,
gr_vector_const_void_star &input_items, gr_vector_void_star &output_items);
void forecast(int noutput_items, gr_vector_int &ninput_items_required);
private:
friend dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(double fs_in, unsigned int vector_length,
bool dump, std::string dump_filename,
float pll_bw_hz, float dll_bw_hz, float pll_bw_narrow_hz,
float dll_bw_narrow_hz, float early_late_space_chips,
float very_early_late_space_chips, float early_late_space_narrow_chips,
float very_early_late_space_narrow_chips,
int extend_correlation_symbols, bool track_pilot,
char system, char signal[3]);
dll_pll_veml_tracking(double fs_in, unsigned int vector_length,
bool dump,
std::string dump_filename,
float pll_bw_hz,
float dll_bw_hz,
float pll_bw_narrow_hz,
float dll_bw_narrow_hz,
float early_late_space_chips,
float very_early_late_space_chips,
float early_late_space_narrow_chips,
float very_early_late_space_narrow_chips,
int extend_correlation_symbols,
bool track_pilot,
char system, char signal[3]);
bool cn0_and_tracking_lock_status();
bool acquire_secondary();
void do_correlation_step(const gr_complex *input_samples);
void run_dll_pll();
void update_tracking_vars();
void clear_tracking_vars();
void save_correlation_results();
void log_data(bool integrating);
int save_matfile();
// tracking configuration vars
bool d_dump;
bool d_veml;
bool d_cloop;
unsigned int d_vector_length;
unsigned int d_channel;
double d_fs_in;
Gnss_Synchro *d_acquisition_gnss_synchro;
//Signal parameters
bool d_secondary;
bool interchange_iq;
double d_signal_carrier_freq;
double d_code_period;
double d_code_chip_rate;
unsigned int d_secondary_code_length;
unsigned int d_code_length_chips;
unsigned int d_code_samples_per_chip; // All signals have 1 sample per chip code except Gal. E1 which has 2 (CBOC disabled) or 12 (CBOC enabled)
int d_symbols_per_bit;
std::string systemName;
std::string signal_type;
std::string *d_secondary_code_string;
//tracking state machine
int d_state;
bool d_synchonizing;
//Integration period in samples
int d_correlation_length_ms;
int d_n_correlator_taps;
float d_early_late_spc_chips;
float d_very_early_late_spc_chips;
float d_early_late_spc_narrow_chips;
float d_very_early_late_spc_narrow_chips;
float *d_tracking_code;
float *d_data_code;
float *d_local_code_shift_chips;
float *d_prompt_data_shift;
cpu_multicorrelator_real_codes multicorrelator_cpu;
cpu_multicorrelator_real_codes correlator_data_cpu; //for data channel
/* TODO: currently the multicorrelator does not support adding extra correlator
with different local code, thus we need extra multicorrelator instance.
Implement this functionality inside multicorrelator class
as an enhancement to increase the performance
*/
gr_complex *d_correlator_outs;
gr_complex *d_Very_Early;
gr_complex *d_Early;
gr_complex *d_Prompt;
gr_complex *d_Late;
gr_complex *d_Very_Late;
bool d_enable_extended_integration;
int d_extend_correlation_symbols;
int d_extend_correlation_symbols_count;
int d_current_symbol;
gr_complex d_VE_accu;
gr_complex d_E_accu;
gr_complex d_P_accu;
gr_complex d_L_accu;
gr_complex d_VL_accu;
gr_complex d_last_prompt;
bool d_track_pilot;
gr_complex *d_Prompt_Data;
double d_code_phase_step_chips;
double d_carrier_phase_step_rad;
// remaining code phase and carrier phase between tracking loops
double d_rem_code_phase_samples;
double d_rem_carr_phase_rad;
// PLL and DLL filter library
Tracking_2nd_DLL_filter d_code_loop_filter;
Tracking_2nd_PLL_filter d_carrier_loop_filter;
// acquisition
double d_acq_code_phase_samples;
double d_acq_carrier_doppler_hz;
// tracking parameters
float d_dll_bw_hz;
float d_pll_bw_hz;
float d_dll_bw_narrow_hz;
float d_pll_bw_narrow_hz;
// tracking vars
double d_carr_error_hz;
double d_carr_error_filt_hz;
double d_code_error_chips;
double d_code_error_filt_chips;
double d_K_blk_samples;
double d_code_freq_chips;
double d_carrier_doppler_hz;
double d_acc_carrier_phase_rad;
double d_rem_code_phase_chips;
double d_code_phase_samples;
double T_chip_seconds;
double T_prn_seconds;
double T_prn_samples;
double K_blk_samples;
//PRN period in samples
int d_current_prn_length_samples;
//processing samples counters
unsigned long int d_sample_counter;
unsigned long int d_acq_sample_stamp;
// CN0 estimation and lock detector
int d_cn0_estimation_counter;
int d_carrier_lock_fail_counter;
double d_carrier_lock_test;
double d_CN0_SNV_dB_Hz;
double d_carrier_lock_threshold;
std::deque<gr_complex> d_Prompt_buffer_deque;
gr_complex *d_Prompt_buffer;
// file dump
std::string d_dump_filename;
std::ofstream d_dump_file;
};
#endif //GNSS_SDR_DLL_PLL_VEML_TRACKING_H

2
src/algorithms/tracking/libs/cpu_multicorrelator_real_codes.cc
View File

@@ -122,7 +122,7 @@ bool cpu_multicorrelator_real_codes::Carrier_wipeoff_multicorrelator_resampler(
lv_32fc_t phase_offset_as_complex[1]; lv_32fc_t phase_offset_as_complex[1];
phase_offset_as_complex[0] = lv_cmake(std::cos(rem_carrier_phase_in_rad), -std::sin(rem_carrier_phase_in_rad)); phase_offset_as_complex[0] = lv_cmake(std::cos(rem_carrier_phase_in_rad), -std::sin(rem_carrier_phase_in_rad));
// call VOLK_GNSSSDR kernel // call VOLK_GNSSSDR kernel
volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn(d_corr_out, d_sig_in, std::exp(lv_32fc_t(0, -phase_step_rad)), phase_offset_as_complex, (const float**)d_local_codes_resampled, d_n_correlators, signal_length_samples); volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn(d_corr_out, d_sig_in, std::exp(lv_32fc_t(0.0, -phase_step_rad)), phase_offset_as_complex, const_cast<const float**>(d_local_codes_resampled), d_n_correlators, signal_length_samples);
return true; return true;
} }

22
src/algorithms/tracking/libs/lock_detectors.cc
View File

@@ -67,20 +67,20 @@
*/ */
float cn0_svn_estimator(gr_complex* Prompt_buffer, int length, long fs_in, double code_length) float cn0_svn_estimator(gr_complex* Prompt_buffer, int length, long fs_in, double code_length)
{ {
double SNR = 0; double SNR = 0.0;
double SNR_dB_Hz = 0; double SNR_dB_Hz = 0.0;
double Psig = 0; double Psig = 0.0;
double Ptot = 0; double Ptot = 0.0;
for (int i = 0; i < length; i++) for (int i = 0; i < length; i++)
{ {
Psig += std::abs(static_cast<double>(Prompt_buffer[i].real())); Psig += std::abs(static_cast<double>(Prompt_buffer[i].real()));
Ptot += static_cast<double>(Prompt_buffer[i].imag()) * static_cast<double>(Prompt_buffer[i].imag()) + static_cast<double>(Prompt_buffer[i].real()) * static_cast<double>(Prompt_buffer[i].real()); Ptot += static_cast<double>(Prompt_buffer[i].imag()) * static_cast<double>(Prompt_buffer[i].imag()) + static_cast<double>(Prompt_buffer[i].real()) * static_cast<double>(Prompt_buffer[i].real());
} }
Psig = Psig / static_cast<double>(length); Psig /= static_cast<double>(length);
Psig = Psig * Psig; Psig = Psig * Psig;
Ptot = Ptot / static_cast<double>(length); Ptot /= static_cast<double>(length);
SNR = Psig / (Ptot - Psig); SNR = Psig / (Ptot - Psig);
SNR_dB_Hz = 10 * log10(SNR) + 10 * log10(static_cast<double>(fs_in) / 2) - 10 * log10(code_length); SNR_dB_Hz = 10.0 * log10(SNR) + 10.0 * log10(static_cast<double>(fs_in) / 2.0) - 10.0 * log10(code_length);
return static_cast<float>(SNR_dB_Hz); return static_cast<float>(SNR_dB_Hz);
} }
@@ -96,10 +96,10 @@ float cn0_svn_estimator(gr_complex* Prompt_buffer, int length, long fs_in, doubl
*/ */
float carrier_lock_detector(gr_complex* Prompt_buffer, int length) float carrier_lock_detector(gr_complex* Prompt_buffer, int length)
{ {
float tmp_sum_I = 0; float tmp_sum_I = 0.0;
float tmp_sum_Q = 0; float tmp_sum_Q = 0.0;
float NBD = 0; float NBD = 0.0;
float NBP = 0; float NBP = 0.0;
for (int i = 0; i < length; i++) for (int i = 0; i < length; i++)
{ {
tmp_sum_I += Prompt_buffer[i].real(); tmp_sum_I += Prompt_buffer[i].real();

9
src/algorithms/tracking/libs/tracking_2nd_DLL_filter.cc
View File

@@ -41,11 +41,10 @@
void Tracking_2nd_DLL_filter::calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k) void Tracking_2nd_DLL_filter::calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k)
{ {
// Solve natural frequency // Solve natural frequency
float Wn; float Wn = lbw * 8.0 * zeta / (4.0 * zeta * zeta + 1.0);
Wn = lbw * 8 * zeta / (4 * zeta * zeta + 1);
// solve for t1 & t2 // solve for t1 & t2
*tau1 = k / (Wn * Wn); *tau1 = k / (Wn * Wn);
*tau2 = (2.0 * zeta) / Wn; *tau2 = 2.0 * zeta / Wn;
} }
@@ -67,9 +66,7 @@ void Tracking_2nd_DLL_filter::initialize()
float Tracking_2nd_DLL_filter::get_code_nco(float DLL_discriminator) float Tracking_2nd_DLL_filter::get_code_nco(float DLL_discriminator)
{ {
float code_nco; float code_nco = d_old_code_nco + (d_tau2_code / d_tau1_code) * (DLL_discriminator - d_old_code_error) + (DLL_discriminator + d_old_code_error) * (d_pdi_code / (2.0 * d_tau1_code));
code_nco = d_old_code_nco + (d_tau2_code / d_tau1_code) * (DLL_discriminator - d_old_code_error) + (DLL_discriminator + d_old_code_error) * (d_pdi_code / (2 * d_tau1_code));
//code_nco = d_old_code_nco + (d_tau2_code/d_tau1_code)*(DLL_discriminator - d_old_code_error) + DLL_discriminator * (d_pdi_code/d_tau1_code);
d_old_code_nco = code_nco; d_old_code_nco = code_nco;
d_old_code_error = DLL_discriminator; //[chips] d_old_code_error = DLL_discriminator; //[chips]
return code_nco; return code_nco;

14
src/algorithms/tracking/libs/tracking_2nd_DLL_filter.h
View File

@@ -49,13 +49,13 @@ class Tracking_2nd_DLL_filter
{ {
private: private:
// PLL filter parameters // PLL filter parameters
float d_tau1_code = 0; float d_tau1_code = 0.0;
float d_tau2_code = 0; float d_tau2_code = 0.0;
float d_pdi_code = 0; float d_pdi_code = 0.0;
float d_dllnoisebandwidth = 0; float d_dllnoisebandwidth = 0.0;
float d_dlldampingratio = 0; float d_dlldampingratio = 0.0;
float d_old_code_error = 0; float d_old_code_error = 0.0;
float d_old_code_nco = 0; float d_old_code_nco = 0.0;
void calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k); void calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k);
public: public:

8
src/algorithms/tracking/libs/tracking_2nd_PLL_filter.cc
View File

@@ -40,11 +40,10 @@
void Tracking_2nd_PLL_filter::calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k) void Tracking_2nd_PLL_filter::calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k)
{ {
// Solve natural frequency // Solve natural frequency
float Wn; float Wn = lbw * 8.0 * zeta / (4.0 * zeta * zeta + 1.0);
Wn = lbw * 8 * zeta / (4 * zeta * zeta + 1);
// solve for t1 & t2 // solve for t1 & t2
*tau1 = k / (Wn * Wn); *tau1 = k / (Wn * Wn);
*tau2 = (2.0 * zeta) / Wn; *tau2 = 2.0 * zeta / Wn;
} }
@@ -71,8 +70,7 @@ void Tracking_2nd_PLL_filter::initialize()
*/ */
float Tracking_2nd_PLL_filter::get_carrier_nco(float PLL_discriminator) float Tracking_2nd_PLL_filter::get_carrier_nco(float PLL_discriminator)
{ {
float carr_nco; float carr_nco = d_old_carr_nco + (d_tau2_carr / d_tau1_carr) * (PLL_discriminator - d_old_carr_error) + (PLL_discriminator + d_old_carr_error) * (d_pdi_carr / (2.0 * d_tau1_carr));
carr_nco = d_old_carr_nco + (d_tau2_carr / d_tau1_carr) * (PLL_discriminator - d_old_carr_error) + (PLL_discriminator + d_old_carr_error) * (d_pdi_carr / (2 * d_tau1_carr));
//carr_nco = d_old_carr_nco + (d_tau2_carr/d_tau1_carr)*(PLL_discriminator - d_old_carr_error) + PLL_discriminator * (d_pdi_carr/d_tau1_carr); //carr_nco = d_old_carr_nco + (d_tau2_carr/d_tau1_carr)*(PLL_discriminator - d_old_carr_error) + PLL_discriminator * (d_pdi_carr/d_tau1_carr);
d_old_carr_nco = carr_nco; d_old_carr_nco = carr_nco;
d_old_carr_error = PLL_discriminator; d_old_carr_error = PLL_discriminator;

14
src/algorithms/tracking/libs/tracking_2nd_PLL_filter.h
View File

@@ -48,15 +48,15 @@ class Tracking_2nd_PLL_filter
{ {
private: private:
// PLL filter parameters // PLL filter parameters
float d_tau1_carr = 0; float d_tau1_carr = 0.0;
float d_tau2_carr = 0; float d_tau2_carr = 0.0;
float d_pdi_carr = 0; float d_pdi_carr = 0.0;
float d_pllnoisebandwidth = 0; float d_pllnoisebandwidth = 0.0;
float d_plldampingratio = 0; float d_plldampingratio = 0.0;
float d_old_carr_error = 0; float d_old_carr_error = 0.0;
float d_old_carr_nco = 0; float d_old_carr_nco = 0.0;
void calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k); void calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k);

6
src/algorithms/tracking/libs/tracking_discriminators.cc
View File

@@ -83,7 +83,7 @@ double pll_cloop_two_quadrant_atan(gr_complex prompt_s1)
} }
else else
{ {
return 0; return 0.0;
} }
} }
@@ -107,7 +107,7 @@ double dll_nc_e_minus_l_normalized(gr_complex early_s1, gr_complex late_s1)
} }
else else
{ {
return 0.5 * (P_early - P_late) / ((P_early + P_late)); return 0.5 * (P_early - P_late) / (P_early + P_late);
} }
} }
@@ -131,6 +131,6 @@ double dll_nc_vemlp_normalized(gr_complex very_early_s1, gr_complex early_s1, gr
} }
else else
{ {
return (P_early - P_late) / ((P_early + P_late)); return (P_early - P_late) / (P_early + P_late);
} }
} }

73
src/algorithms/tracking/libs/tracking_loop_filter.cc
View File

@@ -37,9 +37,6 @@
#include <glog/logging.h> #include <glog/logging.h>
#define MAX_LOOP_ORDER 3
#define MAX_HISTORY_LENGTH 4
Tracking_loop_filter::Tracking_loop_filter(float update_interval, Tracking_loop_filter::Tracking_loop_filter(float update_interval,
float noise_bandwidth, float noise_bandwidth,
int loop_order, int loop_order,
@@ -50,8 +47,8 @@ Tracking_loop_filter::Tracking_loop_filter(float update_interval,
d_noise_bandwidth(noise_bandwidth), d_noise_bandwidth(noise_bandwidth),
d_update_interval(update_interval) d_update_interval(update_interval)
{ {
d_inputs.resize(MAX_HISTORY_LENGTH, 0.0); d_inputs.resize(MAX_LOOP_HISTORY_LENGTH, 0.0);
d_outputs.resize(MAX_HISTORY_LENGTH, 0.0); d_outputs.resize(MAX_LOOP_HISTORY_LENGTH, 0.0);
update_coefficients(); update_coefficients();
} }
@@ -62,8 +59,8 @@ Tracking_loop_filter::Tracking_loop_filter()
d_noise_bandwidth(15.0), d_noise_bandwidth(15.0),
d_update_interval(0.001) d_update_interval(0.001)
{ {
d_inputs.resize(MAX_HISTORY_LENGTH, 0.0); d_inputs.resize(MAX_LOOP_HISTORY_LENGTH, 0.0);
d_outputs.resize(MAX_HISTORY_LENGTH, 0.0); d_outputs.resize(MAX_LOOP_HISTORY_LENGTH, 0.0);
update_coefficients(); update_coefficients();
} }
@@ -75,12 +72,12 @@ Tracking_loop_filter::~Tracking_loop_filter()
float Tracking_loop_filter::apply(float current_input) float Tracking_loop_filter::apply(float current_input)
{ {
// Now apply the filter coefficients: // Now apply the filter coefficients:
float result = 0; float result = 0.0;
// Hanlde the old outputs first: // Hanlde the old outputs first:
for (unsigned int ii = 0; ii < d_output_coefficients.size(); ++ii) for (unsigned int ii = 0; ii < d_output_coefficients.size(); ++ii)
{ {
result += d_output_coefficients[ii] * d_outputs[(d_current_index + ii) % MAX_HISTORY_LENGTH]; result += d_output_coefficients[ii] * d_outputs[(d_current_index + ii) % MAX_LOOP_HISTORY_LENGTH];
} }
// Now update the index to handle the inputs. // Now update the index to handle the inputs.
@@ -93,7 +90,7 @@ float Tracking_loop_filter::apply(float current_input)
d_current_index--; d_current_index--;
if (d_current_index < 0) if (d_current_index < 0)
{ {
d_current_index += MAX_HISTORY_LENGTH; d_current_index += MAX_LOOP_HISTORY_LENGTH;
} }
d_inputs[d_current_index] = current_input; d_inputs[d_current_index] = current_input;
@@ -101,7 +98,7 @@ float Tracking_loop_filter::apply(float current_input)
for (unsigned int ii = 0; ii < d_input_coefficients.size(); ++ii) for (unsigned int ii = 0; ii < d_input_coefficients.size(); ++ii)
{ {
result += d_input_coefficients[ii] * d_inputs[(d_current_index + ii) % MAX_HISTORY_LENGTH]; result += d_input_coefficients[ii] * d_inputs[(d_current_index + ii) % MAX_LOOP_HISTORY_LENGTH];
} }
@@ -122,7 +119,7 @@ void Tracking_loop_filter::update_coefficients(void)
float wn; float wn;
float T = d_update_interval; float T = d_update_interval;
float zeta = 1 / std::sqrt(2); float zeta = 1.0 / std::sqrt(2.0);
// The following is based on the bilinear transform approximation of // The following is based on the bilinear transform approximation of
// the analog integrator. The loop format is from Kaplan & Hegarty // the analog integrator. The loop format is from Kaplan & Hegarty
@@ -146,7 +143,7 @@ void Tracking_loop_filter::update_coefficients(void)
d_input_coefficients[1] = g1 * T / 2.0; d_input_coefficients[1] = g1 * T / 2.0;
d_output_coefficients.resize(1); d_output_coefficients.resize(1);
d_output_coefficients[0] = 1; d_output_coefficients[0] = 1.0;
} }
else else
{ {
@@ -157,28 +154,28 @@ void Tracking_loop_filter::update_coefficients(void)
} }
break; break;
case 2: case 2:
wn = d_noise_bandwidth * (8 * zeta) / (4 * zeta * zeta + 1); wn = d_noise_bandwidth * (8.0 * zeta) / (4.0 * zeta * zeta + 1.0);
g1 = wn * wn; g1 = wn * wn;
g2 = wn * 2 * zeta; g2 = wn * 2.0 * zeta;
if (d_include_last_integrator) if (d_include_last_integrator)
{ {
d_input_coefficients.resize(3); d_input_coefficients.resize(3);
d_input_coefficients[0] = T / 2 * (g1 * T / 2 + g2); d_input_coefficients[0] = T / 2.0 * (g1 * T / 2.0 + g2);
d_input_coefficients[1] = T * T / 2 * g1; d_input_coefficients[1] = T * T / 2.0 * g1;
d_input_coefficients[2] = T / 2 * (g1 * T / 2 - g2); d_input_coefficients[2] = T / 2.0 * (g1 * T / 2.0 - g2);
d_output_coefficients.resize(2); d_output_coefficients.resize(2);
d_output_coefficients[0] = 2; d_output_coefficients[0] = 2.0;
d_output_coefficients[1] = -1; d_output_coefficients[1] = -1.0;
} }
else else
{ {
d_input_coefficients.resize(2); d_input_coefficients.resize(2);
d_input_coefficients[0] = (g1 * T / 2.0 + g2); d_input_coefficients[0] = (g1 * T / 2.0 + g2);
d_input_coefficients[1] = g1 * T / 2 - g2; d_input_coefficients[1] = g1 * T / 2.0 - g2;
d_output_coefficients.resize(1); d_output_coefficients.resize(1);
d_output_coefficients[0] = 1; d_output_coefficients[0] = 1.0;
} }
break; break;
@@ -193,27 +190,27 @@ void Tracking_loop_filter::update_coefficients(void)
if (d_include_last_integrator) if (d_include_last_integrator)
{ {
d_input_coefficients.resize(4); d_input_coefficients.resize(4);
d_input_coefficients[0] = T / 2 * (g3 + T / 2 * (g2 + T / 2 * g1)); d_input_coefficients[0] = T / 2.0 * (g3 + T / 2.0 * (g2 + T / 2.0 * g1));
d_input_coefficients[1] = T / 2 * (-g3 + T / 2 * (g2 + 3 * T / 2 * g1)); d_input_coefficients[1] = T / 2.0 * (-g3 + T / 2.0 * (g2 + 3.0 * T / 2.0 * g1));
d_input_coefficients[2] = T / 2 * (-g3 - T / 2 * (g2 - 3 * T / 2 * g1)); d_input_coefficients[2] = T / 2.0 * (-g3 - T / 2.0 * (g2 - 3.0 * T / 2.0 * g1));
d_input_coefficients[3] = T / 2 * (g3 - T / 2 * (g2 - T / 2 * g1)); d_input_coefficients[3] = T / 2.0 * (g3 - T / 2.0 * (g2 - T / 2.0 * g1));
d_output_coefficients.resize(3); d_output_coefficients.resize(3);
d_output_coefficients[0] = 3; d_output_coefficients[0] = 3.0;
d_output_coefficients[1] = -3; d_output_coefficients[1] = -3.0;
d_output_coefficients[2] = 1; d_output_coefficients[2] = 1.0;
} }
else else
{ {
d_input_coefficients.resize(3); d_input_coefficients.resize(3);
d_input_coefficients[0] = g3 + T / 2 * (g2 + T / 2 * g1); d_input_coefficients[0] = g3 + T / 2.0 * (g2 + T / 2.0 * g1);
d_input_coefficients[1] = g1 * T * T / 2 - 2 * g3; d_input_coefficients[1] = g1 * T * T / 2.0 - 2.0 * g3;
d_input_coefficients[2] = g3 + T / 2 * (-g2 + T / 2 * g1); d_input_coefficients[2] = g3 + T / 2.0 * (-g2 + T / 2.0 * g1);
d_output_coefficients.resize(2); d_output_coefficients.resize(2);
d_output_coefficients[0] = 2; d_output_coefficients[0] = 2.0;
d_output_coefficients[1] = -1; d_output_coefficients[1] = -1.0;
} }
break; break;
}; };
@@ -254,7 +251,7 @@ bool Tracking_loop_filter::get_include_last_integrator(void) const
void Tracking_loop_filter::set_order(int loop_order) void Tracking_loop_filter::set_order(int loop_order)
{ {
if (loop_order < 1 || loop_order > MAX_LOOP_ORDER) if (loop_order < 1 or loop_order > MAX_LOOP_ORDER)
{ {
LOG(ERROR) << "Ignoring attempt to set loop order to " << loop_order LOG(ERROR) << "Ignoring attempt to set loop order to " << loop_order
<< ". Maximum allowed order is: " << MAX_LOOP_ORDER << ". Maximum allowed order is: " << MAX_LOOP_ORDER
@@ -274,7 +271,7 @@ int Tracking_loop_filter::get_order(void) const
void Tracking_loop_filter::initialize(float initial_output) void Tracking_loop_filter::initialize(float initial_output)
{ {
d_inputs.assign(MAX_HISTORY_LENGTH, 0.0); d_inputs.assign(MAX_LOOP_HISTORY_LENGTH, 0.0);
d_outputs.assign(MAX_HISTORY_LENGTH, initial_output); d_outputs.assign(MAX_LOOP_HISTORY_LENGTH, initial_output);
d_current_index = MAX_HISTORY_LENGTH - 1; d_current_index = MAX_LOOP_HISTORY_LENGTH - 1;
} }

2
src/algorithms/tracking/libs/tracking_loop_filter.h
View File

@@ -33,6 +33,8 @@
#ifndef GNSS_SDR_TRACKING_LOOP_FILTER_H_ #ifndef GNSS_SDR_TRACKING_LOOP_FILTER_H_
#define GNSS_SDR_TRACKING_LOOP_FILTER_H_ #define GNSS_SDR_TRACKING_LOOP_FILTER_H_
#define MAX_LOOP_ORDER 3
#define MAX_LOOP_HISTORY_LENGTH 4
#include <vector> #include <vector>

9
src/core/system_parameters/GPS_L5.h
View File

@@ -36,6 +36,7 @@
#include "GPS_CNAV.h" #include "GPS_CNAV.h"
#include "MATH_CONSTANTS.h" #include "MATH_CONSTANTS.h"
#include <cstdint> #include <cstdint>
#include <string>
// Physical constants // Physical constants
@@ -181,7 +182,11 @@ const int GPS_L5_SYMBOLS_PER_BIT = 2;
const int GPS_L5_SAMPLES_PER_SYMBOL = 10; const int GPS_L5_SAMPLES_PER_SYMBOL = 10;
const int GPS_L5_CNAV_DATA_PAGE_SYMBOLS = 600; const int GPS_L5_CNAV_DATA_PAGE_SYMBOLS = 600;
const int GPS_L5_CNAV_DATA_PAGE_DURATION_S = 6; const int GPS_L5_CNAV_DATA_PAGE_DURATION_S = 6;
const int GPS_L5_NH_CODE_LENGTH = 10; const int GPS_L5i_NH_CODE_LENGTH = 10;
const int GPS_L5_NH_CODE[10] = {0, 0, 0, 0, 1, 1, 0, 1, 0, 1}; const int GPS_L5i_NH_CODE[10] = {0, 0, 0, 0, 1, 1, 0, 1, 0, 1};
const std::string GPS_L5i_NH_CODE_STR = "0000110101";
const int GPS_L5q_NH_CODE_LENGTH = 20;
const int GPS_L5q_NH_CODE[20] = {0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0};
const std::string GPS_L5q_NH_CODE_STR = "00000100110101001110";
#endif /* GNSS_SDR_GPS_L5_H_ */ #endif /* GNSS_SDR_GPS_L5_H_ */

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

@@ -50,7 +50,7 @@ public:
double Acq_delay_samples; //!< Set by Acquisition processing block double Acq_delay_samples; //!< Set by Acquisition processing block
double Acq_doppler_hz; //!< Set by Acquisition processing block double Acq_doppler_hz; //!< Set by Acquisition processing block
unsigned long int Acq_samplestamp_samples; //!< Set by Acquisition processing block unsigned long int Acq_samplestamp_samples; //!< Set by Acquisition processing block
bool Flag_valid_acquisition; //!< Set by Acquisition processing block bool Flag_valid_acquisition = false; //!< Set by Acquisition processing block
//Tracking //Tracking
long int fs; //!< Set by Tracking processing block long int fs; //!< Set by Tracking processing block
double Prompt_I; //!< Set by Tracking processing block double Prompt_I; //!< Set by Tracking processing block
@@ -61,17 +61,17 @@ public:
double Code_phase_samples; //!< Set by Tracking processing block double Code_phase_samples; //!< Set by Tracking processing block
unsigned long int Tracking_sample_counter; //!< Set by Tracking processing block unsigned long int Tracking_sample_counter; //!< Set by Tracking processing block
bool Flag_valid_symbol_output; //!< Set by Tracking processing block bool Flag_valid_symbol_output = false; //!< Set by Tracking processing block
int correlation_length_ms; //!< Set by Tracking processing block int correlation_length_ms; //!< Set by Tracking processing block
//Telemetry Decoder //Telemetry Decoder
bool Flag_valid_word; //!< Set by Telemetry Decoder processing block bool Flag_valid_word = false; //!< Set by Telemetry Decoder processing block
double TOW_at_current_symbol_s; //!< Set by Telemetry Decoder processing block double TOW_at_current_symbol_s; //!< Set by Telemetry Decoder processing block
// Observables // Observables
double Pseudorange_m; //!< Set by Observables processing block double Pseudorange_m; //!< Set by Observables processing block
double RX_time; //!< Set by Observables processing block double RX_time; //!< Set by Observables processing block
bool Flag_valid_pseudorange; //!< Set by Observables processing block bool Flag_valid_pseudorange = false; //!< Set by Observables processing block
}; };
#endif #endif

84
src/utils/matlab/dll_pll_veml_plot_sample.m Normal file
View File

@@ -0,0 +1,84 @@
% /*!
% * \file dll_pll_vml_plot_sample.m
% * \brief Read GNSS-SDR Tracking dump binary file using the provided
% function and plot some internal variables
% * \author Javier Arribas, 2011. jarribas(at)cttc.es
% * \author Antonio Ramos, 2018. antonio.ramos(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 <http://www.gnu.org/licenses/>.
% *
% * -------------------------------------------------------------------------
% */
close all;
clear all;
if ~exist('dll_pll_veml_read_tracking_dump.m','file')
addpath('./libs')
end
samplingFreq = 5000000; %[Hz]
coherent_integration_time_ms = 20; %[ms]
channels = 5; % Number of channels
first_channel = 0; % Number of the first channel
path = '/dump_dir/'; %% CHANGE THIS PATH
for N=1:1:channels
tracking_log_path = [path 'track_ch_' num2str(N+first_channel-1) '.dat']; %% CHANGE track_ch BY YOUR dump_filename
GNSS_tracking(N)= dll_pll_veml_read_tracking_dump(tracking_log_path);
end
% GNSS-SDR format conversion to MATLAB GPS receiver
for N=1:1:channels
trackResults(N).status = 'T'; %fake track
trackResults(N).codeFreq = GNSS_tracking(N).code_freq_hz.';
trackResults(N).carrFreq = GNSS_tracking(N).carrier_doppler_hz.';
trackResults(N).dllDiscr = GNSS_tracking(N).code_error.';
trackResults(N).dllDiscrFilt = GNSS_tracking(N).code_nco.';
trackResults(N).pllDiscr = GNSS_tracking(N).carr_error.';
trackResults(N).pllDiscrFilt = GNSS_tracking(N).carr_nco.';
trackResults(N).I_P = GNSS_tracking(N).P.';
trackResults(N).Q_P = zeros(1,length(GNSS_tracking(N).P));
trackResults(N).I_VE = GNSS_tracking(N).VE.';
trackResults(N).I_E = GNSS_tracking(N).E.';
trackResults(N).I_L = GNSS_tracking(N).L.';
trackResults(N).I_VL = GNSS_tracking(N).VL.';
trackResults(N).Q_VE = zeros(1,length(GNSS_tracking(N).VE));
trackResults(N).Q_E = zeros(1,length(GNSS_tracking(N).E));
trackResults(N).Q_L = zeros(1,length(GNSS_tracking(N).L));
trackResults(N).Q_VL = zeros(1,length(GNSS_tracking(N).VL));
trackResults(N).data_I = GNSS_tracking(N).prompt_I.';
trackResults(N).data_Q = GNSS_tracking(N).prompt_Q.';
trackResults(N).PRN = GNSS_tracking(N).PRN.';
trackResults(N).CNo = GNSS_tracking(N).CN0_SNV_dB_Hz.';
% Use original MATLAB tracking plot function
settings.numberOfChannels = channels;
settings.msToProcess = length(GNSS_tracking(N).E)*coherent_integration_time_ms;
plotVEMLTracking(N,trackResults,settings)
end

153
src/utils/matlab/libs/dll_pll_veml_read_tracking_dump.m Normal file
View File

@@ -0,0 +1,153 @@
% /*!
% * \file dll_pll_veml_read_tracking_dump.m
% * \brief Read GNSS-SDR Tracking dump binary file into MATLAB.
% * \author Luis Esteve, 2012. luis(at)epsilon-formacion.com
% * -------------------------------------------------------------------------
% *
% * Copyright (C) 2010-2012 (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 <http://www.gnu.org/licenses/>.
% *
% * -------------------------------------------------------------------------
% */
function [GNSS_tracking] = dll_pll_veml_read_tracking_dump (filename, count)
%% usage: dll_pll_veml_read_tracking_dump (filename, [count])
%%
%% open GNSS-SDR tracking binary log file .dat and return the contents
%%
m = nargchk (1,2,nargin);
num_float_vars = 17;
num_unsigned_long_int_vars = 1;
num_double_vars = 1;
num_unsigned_int_vars = 1;
if(~isempty(strfind(computer('arch'), '64')))
% 64-bit computer
double_size_bytes = 8;
unsigned_long_int_size_bytes = 8;
float_size_bytes = 4;
unsigned_int_size_bytes = 4;
else
double_size_bytes = 8;
unsigned_long_int_size_bytes = 4;
float_size_bytes = 4;
unsigned_int_size_bytes = 4;
end
skip_bytes_each_read = float_size_bytes * num_float_vars + unsigned_long_int_size_bytes * num_unsigned_long_int_vars + ...
double_size_bytes * num_double_vars + num_unsigned_int_vars*unsigned_int_size_bytes;
bytes_shift = 0;
if (m)
usage (m);
end
if (nargin < 2)
count = Inf;
end
%loops_counter = fread (f, count, 'uint32',4*12);
f = fopen (filename, 'rb');
if (f < 0)
else
v1 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v2 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v3 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v4 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v5 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v6 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v7 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved float
v8 = fread (f, count, 'long', skip_bytes_each_read - unsigned_long_int_size_bytes);
bytes_shift = bytes_shift + unsigned_long_int_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v9 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v10 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v11 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v12 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v13 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v14 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v15 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v16 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved float
v17 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next float
v18 = fread (f, count, 'float', skip_bytes_each_read-float_size_bytes);
bytes_shift = bytes_shift + float_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next double
v19 = fread (f, count, 'double', skip_bytes_each_read - double_size_bytes);
bytes_shift = bytes_shift + double_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next unsigned int
v20 = fread (f, count, 'uint', skip_bytes_each_read - unsigned_int_size_bytes);
fclose (f);
GNSS_tracking.VE = v1;
GNSS_tracking.E = v2;
GNSS_tracking.P = v3;
GNSS_tracking.L = v4;
GNSS_tracking.VL = v5;
GNSS_tracking.prompt_I = v6;
GNSS_tracking.prompt_Q = v7;
GNSS_tracking.PRN_start_sample = v8;
GNSS_tracking.acc_carrier_phase_rad = v9;
GNSS_tracking.carrier_doppler_hz = v10;
GNSS_tracking.code_freq_hz = v11;
GNSS_tracking.carr_error = v12;
GNSS_tracking.carr_nco = v13;
GNSS_tracking.code_error = v14;
GNSS_tracking.code_nco = v15;
GNSS_tracking.CN0_SNV_dB_Hz = v16;
GNSS_tracking.carrier_lock_test = v17;
GNSS_tracking.var1 = v18;
GNSS_tracking.var2 = v19;
GNSS_tracking.PRN = v20;
end

24
src/utils/matlab/libs/plotVEMLTracking.m
View File

@@ -69,8 +69,8 @@ for channelNr = channelList
timeAxisInSeconds = (1:4:settings.msToProcess)/1000; timeAxisInSeconds = (1:4:settings.msToProcess)/1000;
%----- Discrete-Time Scatter Plot --------------------------------- %----- Discrete-Time Scatter Plot ---------------------------------
plot(handles(1, 1), trackResults(channelNr).I_P,... plot(handles(1, 1), trackResults(channelNr).data_I,...
trackResults(channelNr).Q_P, ... trackResults(channelNr).data_Q, ...
'.'); '.');
grid (handles(1, 1)); grid (handles(1, 1));
@@ -80,8 +80,9 @@ for channelNr = channelList
ylabel(handles(1, 1), 'Q prompt'); ylabel(handles(1, 1), 'Q prompt');
%----- Nav bits --------------------------------------------------- %----- Nav bits ---------------------------------------------------
plot (handles(1, 2), timeAxisInSeconds, ... t = (1:length(trackResults(channelNr).data_I));
trackResults(channelNr).I_P); plot (handles(1, 2), t, ...
trackResults(channelNr).data_I);
grid (handles(1, 2)); grid (handles(1, 2));
title (handles(1, 2), 'Bits of the navigation message'); title (handles(1, 2), 'Bits of the navigation message');
@@ -89,7 +90,8 @@ for channelNr = channelList
axis (handles(1, 2), 'tight'); axis (handles(1, 2), 'tight');
%----- PLL discriminator unfiltered-------------------------------- %----- PLL discriminator unfiltered--------------------------------
plot (handles(2, 1), timeAxisInSeconds, ... t = (1:length(trackResults(channelNr).pllDiscr));
plot (handles(2, 1), t, ...
trackResults(channelNr).pllDiscr, 'r'); trackResults(channelNr).pllDiscr, 'r');
grid (handles(2, 1)); grid (handles(2, 1));
@@ -99,7 +101,8 @@ for channelNr = channelList
title (handles(2, 1), 'Raw PLL discriminator'); title (handles(2, 1), 'Raw PLL discriminator');
%----- Correlation ------------------------------------------------ %----- Correlation ------------------------------------------------
plot(handles(2, 2), timeAxisInSeconds, ... t = (1:length(trackResults(channelNr).I_VE));
plot(handles(2, 2), t, ...
[sqrt(trackResults(channelNr).I_VE.^2 + ... [sqrt(trackResults(channelNr).I_VE.^2 + ...
trackResults(channelNr).Q_VE.^2)', ... trackResults(channelNr).Q_VE.^2)', ...
sqrt(trackResults(channelNr).I_E.^2 + ... sqrt(trackResults(channelNr).I_E.^2 + ...
@@ -127,7 +130,8 @@ for channelNr = channelList
set(hLegend, 'Interpreter', 'Latex'); set(hLegend, 'Interpreter', 'Latex');
%----- PLL discriminator filtered---------------------------------- %----- PLL discriminator filtered----------------------------------
plot (handles(3, 1), timeAxisInSeconds, ... t = (1:length(trackResults(channelNr).pllDiscrFilt));
plot (handles(3, 1), t, ...
trackResults(channelNr).pllDiscrFilt, 'b'); trackResults(channelNr).pllDiscrFilt, 'b');
grid (handles(3, 1)); grid (handles(3, 1));
@@ -137,7 +141,8 @@ for channelNr = channelList
title (handles(3, 1), 'Filtered PLL discriminator'); title (handles(3, 1), 'Filtered PLL discriminator');
%----- DLL discriminator unfiltered-------------------------------- %----- DLL discriminator unfiltered--------------------------------
plot (handles(3, 2), timeAxisInSeconds, ... t = (1:length(trackResults(channelNr).dllDiscr));
plot (handles(3, 2), t, ...
trackResults(channelNr).dllDiscr, 'r'); trackResults(channelNr).dllDiscr, 'r');
grid (handles(3, 2)); grid (handles(3, 2));
@@ -147,7 +152,8 @@ for channelNr = channelList
title (handles(3, 2), 'Raw DLL discriminator'); title (handles(3, 2), 'Raw DLL discriminator');
%----- DLL discriminator filtered---------------------------------- %----- DLL discriminator filtered----------------------------------
plot (handles(3, 3), timeAxisInSeconds, ... t = (1:length(trackResults(channelNr).dllDiscrFilt));
plot (handles(3, 3), t, ...
trackResults(channelNr).dllDiscrFilt, 'b'); trackResults(channelNr).dllDiscrFilt, 'b');
grid (handles(3, 3)); grid (handles(3, 3));