2017-04-20 14:10:12 +00:00
/*!
2019-03-02 01:21:03 +00:00
* \ file rtklib_pvt_gs . cc
2017-04-20 14:10:12 +00:00
* \ brief Interface of a Position Velocity and Time computation block
* \ author Javier Arribas , 2017. jarribas ( at ) cttc . es
*
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
*
2019-07-26 10:38:20 +00:00
* Copyright ( C ) 2010 - 2019 ( see AUTHORS file for a list of contributors )
2017-04-20 14:10:12 +00:00
*
* 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
2018-05-13 20:49:11 +00:00
* along with GNSS - SDR . If not , see < https : //www.gnu.org/licenses/>.
2017-04-20 14:10:12 +00:00
*
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
*/
2019-11-24 12:06:32 +00:00
# include "rtklib_pvt_gs.h"
2019-07-31 16:16:09 +00:00
# include "MATH_CONSTANTS.h"
2019-03-05 07:59:04 +00:00
# include "beidou_dnav_almanac.h"
# include "beidou_dnav_ephemeris.h"
2019-03-05 18:31:41 +00:00
# include "beidou_dnav_iono.h"
# include "beidou_dnav_utc_model.h"
2018-12-02 04:29:11 +00:00
# include "display.h"
2019-03-05 07:59:04 +00:00
# include "galileo_almanac.h"
2018-10-24 15:28:12 +00:00
# include "galileo_almanac_helper.h"
2019-03-05 07:59:04 +00:00
# include "galileo_ephemeris.h"
2019-03-05 18:31:41 +00:00
# include "galileo_iono.h"
# include "galileo_utc_model.h"
2019-03-05 07:59:04 +00:00
# include "geojson_printer.h"
2019-03-05 18:31:41 +00:00
# include "glonass_gnav_almanac.h"
# include "glonass_gnav_ephemeris.h"
# include "glonass_gnav_utc_model.h"
2019-07-31 16:16:09 +00:00
# include "gnss_frequencies.h"
2018-10-30 10:41:15 +00:00
# include "gnss_sdr_create_directory.h"
2019-03-05 07:59:04 +00:00
# include "gps_almanac.h"
2019-03-05 18:31:41 +00:00
# include "gps_cnav_ephemeris.h"
# include "gps_cnav_iono.h"
# include "gps_cnav_utc_model.h"
2019-03-05 07:59:04 +00:00
# include "gps_ephemeris.h"
2019-03-05 18:31:41 +00:00
# include "gps_iono.h"
# include "gps_utc_model.h"
2019-03-05 07:59:04 +00:00
# include "gpx_printer.h"
# include "kml_printer.h"
2019-03-05 18:31:41 +00:00
# include "monitor_pvt.h"
2019-03-05 07:59:04 +00:00
# include "monitor_pvt_udp_sink.h"
# include "nmea_printer.h"
2018-12-02 04:29:11 +00:00
# include "pvt_conf.h"
2019-03-05 07:59:04 +00:00
# include "rinex_printer.h"
# include "rtcm_printer.h"
# include "rtklib_solver.h"
2019-03-05 18:31:41 +00:00
# include <boost/any.hpp> // for any_cast, any
# include <boost/archive/xml_iarchive.hpp> // for xml_iarchive
# include <boost/archive/xml_oarchive.hpp> // for xml_oarchive
# include <boost/bind/bind.hpp> // for bind_t, bind
2019-03-05 07:59:04 +00:00
# include <boost/exception/diagnostic_information.hpp>
# include <boost/exception/exception.hpp>
2018-07-21 11:40:52 +00:00
# include <boost/serialization/map.hpp>
2019-03-05 07:59:04 +00:00
# include <boost/serialization/nvp.hpp> // for nvp, make_nvp
# include <glog/logging.h> // for LOG
# include <gnuradio/io_signature.h> // for io_signature
# include <pmt/pmt_sugar.h> // for mp
2019-03-05 18:31:41 +00:00
# include <algorithm> // for sort, unique
# include <exception> // for exception
# include <fstream> // for ofstream
2019-03-15 12:31:18 +00:00
# include <iomanip> // for put_time, setprecision
2019-03-05 18:31:41 +00:00
# include <iostream> // for operator<<
2019-03-15 12:31:18 +00:00
# include <locale> // for locale
# include <sstream> // for ostringstream
2019-03-05 18:31:41 +00:00
# include <stdexcept> // for length_error
# include <sys/ipc.h> // for IPC_CREAT
# include <sys/msg.h> // for msgctl
2019-06-10 19:41:13 +00:00
# if HAS_STD_FILESYSTEM
# include <system_error>
namespace errorlib = std ;
2019-06-12 18:39:29 +00:00
# if HAS_STD_FILESYSTEM_EXPERIMENTAL
# include <experimental/filesystem>
namespace fs = std : : experimental : : filesystem ;
# else
# include <filesystem>
namespace fs = std : : filesystem ;
# endif
2019-06-10 19:41:13 +00:00
# else
# include <boost/filesystem/path.hpp>
# include <boost/system/error_code.hpp> // for error_code
namespace fs = boost : : filesystem ;
namespace errorlib = boost : : system ;
# endif
2018-07-21 11:57:14 +00:00
# if OLD_BOOST
# include <boost/math/common_factor_rt.hpp>
namespace bc = boost : : math ;
# else
# include <boost/integer/common_factor_rt.hpp>
namespace bc = boost : : integer ;
# endif
2018-02-26 02:15:53 +00:00
2017-04-20 14:10:12 +00:00
2019-03-02 01:21:03 +00:00
rtklib_pvt_gs_sptr rtklib_make_pvt_gs ( uint32_t nchannels ,
2018-10-27 22:42:28 +00:00
const Pvt_Conf & conf_ ,
2018-12-02 04:29:11 +00:00
const rtk_t & rtk )
2017-04-20 14:10:12 +00:00
{
2019-03-02 01:21:03 +00:00
return rtklib_pvt_gs_sptr ( new rtklib_pvt_gs ( nchannels ,
2018-10-27 22:42:28 +00:00
conf_ ,
2018-03-03 01:03:39 +00:00
rtk ) ) ;
2017-04-20 14:10:12 +00:00
}
2019-03-02 01:21:03 +00:00
rtklib_pvt_gs : : rtklib_pvt_gs ( uint32_t nchannels ,
2018-10-27 22:42:28 +00:00
const Pvt_Conf & conf_ ,
2019-03-02 01:21:03 +00:00
const rtk_t & rtk ) : gr : : sync_block ( " rtklib_pvt_gs " ,
2019-01-28 01:29:43 +00:00
gr : : io_signature : : make ( nchannels , nchannels , sizeof ( Gnss_Synchro ) ) ,
gr : : io_signature : : make ( 0 , 0 , 0 ) )
2017-04-20 14:10:12 +00:00
{
2019-04-23 15:31:26 +00:00
// Send feedback message to observables block with the receiver clock offset
this - > message_port_register_out ( pmt : : mp ( " pvt_to_observables " ) ) ;
2019-07-11 16:39:28 +00:00
// Send PVT status to gnss_flowgraph
this - > message_port_register_out ( pmt : : mp ( " status " ) ) ;
2019-04-23 15:31:26 +00:00
2019-07-31 16:16:09 +00:00
mapStringValues_ [ " 1C " ] = evGPS_1C ;
mapStringValues_ [ " 2S " ] = evGPS_2S ;
mapStringValues_ [ " L5 " ] = evGPS_L5 ;
mapStringValues_ [ " 1B " ] = evGAL_1B ;
mapStringValues_ [ " 5X " ] = evGAL_5X ;
mapStringValues_ [ " 1G " ] = evGLO_1G ;
mapStringValues_ [ " 2G " ] = evGLO_2G ;
mapStringValues_ [ " B1 " ] = evBDS_B1 ;
mapStringValues_ [ " B2 " ] = evBDS_B2 ;
mapStringValues_ [ " B3 " ] = evBDS_B3 ;
2019-08-01 16:11:36 +00:00
max_obs_block_rx_clock_offset_ms = conf_ . max_obs_block_rx_clock_offset_ms ;
2018-10-27 22:42:28 +00:00
d_output_rate_ms = conf_ . output_rate_ms ;
d_display_rate_ms = conf_ . display_rate_ms ;
2019-08-01 18:09:35 +00:00
d_report_rate_ms = 1000 ; // report every second PVT to gnss_synchro
2018-10-27 22:42:28 +00:00
d_dump = conf_ . dump ;
2018-10-31 13:56:59 +00:00
d_dump_mat = conf_ . dump_mat and d_dump ;
2018-10-27 22:42:28 +00:00
d_dump_filename = conf_ . dump_filename ;
std : : string dump_ls_pvt_filename = conf_ . dump_filename ;
2018-10-30 10:41:15 +00:00
if ( d_dump )
{
std : : string dump_path ;
// Get path
2019-02-05 00:31:09 +00:00
if ( d_dump_filename . find_last_of ( ' / ' ) ! = std : : string : : npos )
2018-10-30 10:41:15 +00:00
{
2019-02-05 00:31:09 +00:00
std : : string dump_filename_ = d_dump_filename . substr ( d_dump_filename . find_last_of ( ' / ' ) + 1 ) ;
dump_path = d_dump_filename . substr ( 0 , d_dump_filename . find_last_of ( ' / ' ) ) ;
2018-10-30 10:41:15 +00:00
d_dump_filename = dump_filename_ ;
}
else
{
dump_path = std : : string ( " . " ) ;
}
if ( d_dump_filename . empty ( ) )
{
d_dump_filename = " pvt " ;
}
// remove extension if any
2019-02-05 00:31:09 +00:00
if ( d_dump_filename . substr ( 1 ) . find_last_of ( ' . ' ) ! = std : : string : : npos )
2018-10-30 10:41:15 +00:00
{
2019-02-05 00:31:09 +00:00
d_dump_filename = d_dump_filename . substr ( 0 , d_dump_filename . find_last_of ( ' . ' ) ) ;
2018-10-30 10:41:15 +00:00
}
2019-06-10 19:41:13 +00:00
dump_ls_pvt_filename = dump_path + fs : : path : : preferred_separator + d_dump_filename ;
2018-10-30 10:41:15 +00:00
dump_ls_pvt_filename . append ( " .dat " ) ;
// create directory
if ( ! gnss_sdr_create_directory ( dump_path ) )
{
std : : cerr < < " GNSS-SDR cannot create dump file for the PVT block. Wrong permissions? " < < std : : endl ;
d_dump = false ;
}
}
2017-04-20 14:10:12 +00:00
d_nchannels = nchannels ;
2018-10-30 10:41:15 +00:00
2018-10-27 22:42:28 +00:00
type_of_rx = conf_ . type_of_receiver ;
2017-04-20 14:10:12 +00:00
// GPS Ephemeris data message port in
this - > message_port_register_in ( pmt : : mp ( " telemetry " ) ) ;
2019-03-02 01:21:03 +00:00
this - > set_msg_handler ( pmt : : mp ( " telemetry " ) , boost : : bind ( & rtklib_pvt_gs : : msg_handler_telemetry , this , _1 ) ) ;
2017-04-20 14:10:12 +00:00
2018-06-05 19:41:13 +00:00
// initialize kml_printer
2017-04-20 14:10:12 +00:00
std : : string kml_dump_filename ;
kml_dump_filename = d_dump_filename ;
2018-10-27 22:42:28 +00:00
d_kml_output_enabled = conf_ . kml_output_enabled ;
2019-06-16 18:27:00 +00:00
d_kml_rate_ms = conf_ . kml_rate_ms ;
if ( d_kml_rate_ms = = 0 )
{
d_kml_output_enabled = false ;
}
2018-10-27 22:42:28 +00:00
if ( d_kml_output_enabled )
2017-05-14 17:59:55 +00:00
{
2018-10-27 22:42:28 +00:00
d_kml_dump = std : : make_shared < Kml_Printer > ( conf_ . kml_output_path ) ;
d_kml_dump - > set_headers ( kml_dump_filename ) ;
2017-05-14 17:59:55 +00:00
}
2017-04-20 14:10:12 +00:00
else
2017-05-14 17:59:55 +00:00
{
2018-10-27 22:42:28 +00:00
d_kml_dump = nullptr ;
2017-05-14 17:59:55 +00:00
}
2017-04-20 14:10:12 +00:00
2018-06-05 19:41:13 +00:00
// initialize gpx_printer
2018-05-05 05:47:42 +00:00
std : : string gpx_dump_filename ;
gpx_dump_filename = d_dump_filename ;
2018-10-27 22:42:28 +00:00
d_gpx_output_enabled = conf_ . gpx_output_enabled ;
2019-06-16 18:27:00 +00:00
d_gpx_rate_ms = conf_ . gpx_rate_ms ;
if ( d_gpx_rate_ms = = 0 )
{
d_gpx_output_enabled = false ;
}
2018-10-27 22:42:28 +00:00
if ( d_gpx_output_enabled )
2017-08-17 04:40:05 +00:00
{
2018-10-27 22:42:28 +00:00
d_gpx_dump = std : : make_shared < Gpx_Printer > ( conf_ . gpx_output_path ) ;
d_gpx_dump - > set_headers ( gpx_dump_filename ) ;
2017-08-17 04:40:05 +00:00
}
else
{
2018-10-27 22:42:28 +00:00
d_gpx_dump = nullptr ;
2017-08-17 04:40:05 +00:00
}
2018-05-05 05:47:42 +00:00
2018-06-05 19:41:13 +00:00
// initialize geojson_printer
2017-04-20 14:10:12 +00:00
std : : string geojson_dump_filename ;
geojson_dump_filename = d_dump_filename ;
2018-10-27 22:42:28 +00:00
d_geojson_output_enabled = conf_ . geojson_output_enabled ;
2019-06-16 18:27:00 +00:00
d_geojson_rate_ms = conf_ . geojson_rate_ms ;
if ( d_geojson_rate_ms = = 0 )
{
d_geojson_output_enabled = false ;
}
2018-10-27 22:42:28 +00:00
if ( d_geojson_output_enabled )
2017-05-14 17:59:55 +00:00
{
2018-10-27 22:42:28 +00:00
d_geojson_printer = std : : make_shared < GeoJSON_Printer > ( conf_ . geojson_output_path ) ;
d_geojson_printer - > set_headers ( geojson_dump_filename ) ;
2017-05-14 17:59:55 +00:00
}
2017-04-20 14:10:12 +00:00
else
2017-05-14 17:59:55 +00:00
{
2018-10-27 22:42:28 +00:00
d_geojson_printer = nullptr ;
2017-05-14 17:59:55 +00:00
}
2017-04-20 14:10:12 +00:00
2018-06-05 19:41:13 +00:00
// initialize nmea_printer
2018-11-08 09:02:52 +00:00
d_nmea_output_file_enabled = ( conf_ . nmea_output_file_enabled or conf_ . flag_nmea_tty_port ) ;
2019-06-16 18:27:00 +00:00
d_nmea_rate_ms = conf_ . nmea_rate_ms ;
if ( d_nmea_rate_ms = = 0 )
{
d_nmea_output_file_enabled = false ;
}
2018-11-08 09:02:52 +00:00
if ( d_nmea_output_file_enabled )
2017-05-14 17:59:55 +00:00
{
2018-11-08 09:02:52 +00:00
d_nmea_printer = std : : make_shared < Nmea_Printer > ( conf_ . nmea_dump_filename , conf_ . nmea_output_file_enabled , conf_ . flag_nmea_tty_port , conf_ . nmea_dump_devname , conf_ . nmea_output_file_path ) ;
2017-05-14 17:59:55 +00:00
}
2017-04-20 14:10:12 +00:00
else
2017-05-14 17:59:55 +00:00
{
2018-11-08 09:02:52 +00:00
d_nmea_printer = nullptr ;
2017-05-14 17:59:55 +00:00
}
2017-04-20 14:10:12 +00:00
2018-06-05 19:41:13 +00:00
// initialize rtcm_printer
2017-04-20 14:10:12 +00:00
std : : string rtcm_dump_filename ;
rtcm_dump_filename = d_dump_filename ;
2018-11-02 13:12:31 +00:00
if ( conf_ . flag_rtcm_server or conf_ . flag_rtcm_tty_port or conf_ . rtcm_output_file_enabled )
2017-08-17 04:40:05 +00:00
{
2018-11-02 13:12:31 +00:00
d_rtcm_printer = std : : make_shared < Rtcm_Printer > ( rtcm_dump_filename , conf_ . rtcm_output_file_enabled , conf_ . flag_rtcm_server , conf_ . flag_rtcm_tty_port , conf_ . rtcm_tcp_port , conf_ . rtcm_station_id , conf_ . rtcm_dump_devname , true , conf_ . rtcm_output_file_path ) ;
std : : map < int , int > rtcm_msg_rate_ms = conf_ . rtcm_msg_rate_ms ;
if ( rtcm_msg_rate_ms . find ( 1019 ) ! = rtcm_msg_rate_ms . end ( ) )
{
d_rtcm_MT1019_rate_ms = rtcm_msg_rate_ms [ 1019 ] ;
}
else
{
d_rtcm_MT1019_rate_ms = bc : : lcm ( 5000 , d_output_rate_ms ) ; // default value if not set
}
if ( rtcm_msg_rate_ms . find ( 1020 ) ! = rtcm_msg_rate_ms . end ( ) )
{
d_rtcm_MT1020_rate_ms = rtcm_msg_rate_ms [ 1020 ] ;
}
else
{
d_rtcm_MT1020_rate_ms = bc : : lcm ( 5000 , d_output_rate_ms ) ; // default value if not set
}
if ( rtcm_msg_rate_ms . find ( 1045 ) ! = rtcm_msg_rate_ms . end ( ) )
{
d_rtcm_MT1045_rate_ms = rtcm_msg_rate_ms [ 1045 ] ;
}
else
{
d_rtcm_MT1045_rate_ms = bc : : lcm ( 5000 , d_output_rate_ms ) ; // default value if not set
}
if ( rtcm_msg_rate_ms . find ( 1077 ) ! = rtcm_msg_rate_ms . end ( ) ) // whatever between 1071 and 1077
{
d_rtcm_MT1077_rate_ms = rtcm_msg_rate_ms [ 1077 ] ;
}
else
{
d_rtcm_MT1077_rate_ms = bc : : lcm ( 1000 , d_output_rate_ms ) ; // default value if not set
}
if ( rtcm_msg_rate_ms . find ( 1087 ) ! = rtcm_msg_rate_ms . end ( ) ) // whatever between 1081 and 1087
{
d_rtcm_MT1087_rate_ms = rtcm_msg_rate_ms [ 1087 ] ;
}
else
{
d_rtcm_MT1087_rate_ms = bc : : lcm ( 1000 , d_output_rate_ms ) ; // default value if not set
}
if ( rtcm_msg_rate_ms . find ( 1097 ) ! = rtcm_msg_rate_ms . end ( ) ) // whatever between 1091 and 1097
{
d_rtcm_MT1097_rate_ms = rtcm_msg_rate_ms [ 1097 ] ;
d_rtcm_MSM_rate_ms = rtcm_msg_rate_ms [ 1097 ] ;
}
else
{
d_rtcm_MT1097_rate_ms = bc : : lcm ( 1000 , d_output_rate_ms ) ; // default value if not set
d_rtcm_MSM_rate_ms = bc : : lcm ( 1000 , d_output_rate_ms ) ; // default value if not set
}
b_rtcm_writing_started = false ;
b_rtcm_enabled = true ;
2017-08-17 04:40:05 +00:00
}
else
{
2018-11-03 09:50:19 +00:00
d_rtcm_MT1019_rate_ms = 0 ;
d_rtcm_MT1045_rate_ms = 0 ;
d_rtcm_MT1020_rate_ms = 0 ;
d_rtcm_MT1077_rate_ms = 0 ;
d_rtcm_MT1087_rate_ms = 0 ;
d_rtcm_MT1097_rate_ms = 0 ;
d_rtcm_MSM_rate_ms = 0 ;
2018-11-02 13:12:31 +00:00
b_rtcm_enabled = false ;
b_rtcm_writing_started = false ;
d_rtcm_printer = nullptr ;
2017-08-17 04:40:05 +00:00
}
2017-04-20 14:10:12 +00:00
2018-06-05 19:41:13 +00:00
// initialize RINEX printer
b_rinex_header_written = false ;
b_rinex_header_updated = false ;
2018-10-27 22:42:28 +00:00
b_rinex_output_enabled = conf_ . rinex_output_enabled ;
d_rinex_version = conf_ . rinex_version ;
if ( b_rinex_output_enabled )
2017-05-14 17:59:55 +00:00
{
2018-10-27 22:42:28 +00:00
rp = std : : make_shared < Rinex_Printer > ( d_rinex_version , conf_ . rinex_output_path ) ;
2019-09-18 16:25:07 +00:00
rp - > set_pre_2009_file ( conf_ . pre_2009_file ) ;
2017-05-14 17:59:55 +00:00
}
2017-04-20 14:10:12 +00:00
else
2017-05-14 17:59:55 +00:00
{
2018-10-27 22:42:28 +00:00
rp = nullptr ;
2017-05-14 17:59:55 +00:00
}
2018-10-27 22:42:28 +00:00
d_rinexobs_rate_ms = conf_ . rinexobs_rate_ms ;
2017-04-20 14:10:12 +00:00
2018-10-27 22:42:28 +00:00
// XML printer
d_xml_storage = conf_ . xml_output_enabled ;
if ( d_xml_storage )
{
xml_base_path = conf_ . xml_output_path ;
2019-06-10 19:41:13 +00:00
fs : : path full_path ( fs : : current_path ( ) ) ;
const fs : : path p ( xml_base_path ) ;
if ( ! fs : : exists ( p ) )
2018-10-27 22:42:28 +00:00
{
std : : string new_folder ;
2019-06-10 19:41:13 +00:00
for ( auto & folder : fs : : path ( xml_base_path ) )
2018-10-27 22:42:28 +00:00
{
new_folder + = folder . string ( ) ;
2019-06-10 19:41:13 +00:00
errorlib : : error_code ec ;
if ( ! fs : : exists ( new_folder ) )
2018-10-27 22:42:28 +00:00
{
2019-06-10 19:41:13 +00:00
if ( ! fs : : create_directory ( new_folder , ec ) )
2018-10-27 22:42:28 +00:00
{
std : : cout < < " Could not create the " < < new_folder < < " folder. " < < std : : endl ;
xml_base_path = full_path . string ( ) ;
}
}
2019-06-10 19:41:13 +00:00
new_folder + = fs : : path : : preferred_separator ;
2018-10-27 22:42:28 +00:00
}
}
else
{
xml_base_path = p . string ( ) ;
}
2018-12-02 14:52:32 +00:00
if ( xml_base_path ! = " . " )
2018-10-27 22:42:28 +00:00
{
std : : cout < < " XML files will be stored at " < < xml_base_path < < std : : endl ;
}
2018-06-05 19:41:13 +00:00
2019-06-10 19:41:13 +00:00
xml_base_path = xml_base_path + fs : : path : : preferred_separator ;
2018-10-27 22:42:28 +00:00
}
2017-04-20 14:10:12 +00:00
2017-04-28 13:38:31 +00:00
d_rx_time = 0.0 ;
2017-04-20 14:10:12 +00:00
d_last_status_print_seg = 0 ;
2019-01-21 10:59:29 +00:00
// PVT MONITOR
flag_monitor_pvt_enabled = conf_ . monitor_enabled ;
if ( flag_monitor_pvt_enabled )
{
std : : string address_string = conf_ . udp_addresses ;
std : : vector < std : : string > udp_addr_vec = split_string ( address_string , ' _ ' ) ;
std : : sort ( udp_addr_vec . begin ( ) , udp_addr_vec . end ( ) ) ;
udp_addr_vec . erase ( std : : unique ( udp_addr_vec . begin ( ) , udp_addr_vec . end ( ) ) , udp_addr_vec . end ( ) ) ;
2019-04-21 11:30:59 +00:00
udp_sink_ptr = std : : unique_ptr < Monitor_Pvt_Udp_Sink > ( new Monitor_Pvt_Udp_Sink ( udp_addr_vec , conf_ . udp_port , conf_ . protobuf_enabled ) ) ;
2019-01-21 10:59:29 +00:00
}
2019-02-18 20:44:19 +00:00
else
{
udp_sink_ptr = nullptr ;
}
2019-01-21 10:59:29 +00:00
2017-04-20 14:10:12 +00:00
// Create Sys V message queue
first_fix = true ;
sysv_msg_key = 1101 ;
int msgflg = IPC_CREAT | 0666 ;
2018-03-03 01:03:39 +00:00
if ( ( sysv_msqid = msgget ( sysv_msg_key , msgflg ) ) = = - 1 )
2017-05-14 17:59:55 +00:00
{
std : : cout < < " GNSS-SDR can not create message queues! " < < std : : endl ;
2018-12-08 17:49:31 +00:00
throw std : : exception ( ) ;
2017-05-14 17:59:55 +00:00
}
2019-02-18 20:44:19 +00:00
2019-03-15 12:31:18 +00:00
// Display time in local time zone
2019-03-16 11:47:36 +00:00
d_show_local_time_zone = conf_ . show_local_time_zone ;
2019-03-15 12:31:18 +00:00
std : : ostringstream os ;
2019-03-16 19:30:38 +00:00
# ifdef HAS_PUT_TIME
2019-03-19 20:11:21 +00:00
time_t when = std : : time ( nullptr ) ;
auto const tm = * std : : localtime ( & when ) ;
2019-03-15 12:31:18 +00:00
os < < std : : put_time ( & tm , " %z " ) ;
2019-03-16 19:30:38 +00:00
# endif
2019-03-16 11:47:36 +00:00
std : : string utc_diff_str = os . str ( ) ; // in ISO 8601 format: "+HHMM" or "-HHMM"
if ( utc_diff_str . empty ( ) )
{
utc_diff_str = " +0000 " ;
}
int h = std : : stoi ( utc_diff_str . substr ( 0 , 3 ) , nullptr , 10 ) ;
int m = std : : stoi ( utc_diff_str [ 0 ] + utc_diff_str . substr ( 3 ) , nullptr , 10 ) ;
2019-03-15 12:31:18 +00:00
d_utc_diff_time = boost : : posix_time : : hours ( h ) + boost : : posix_time : : minutes ( m ) ;
2019-03-16 11:47:36 +00:00
std : : ostringstream os2 ;
2019-03-16 19:30:38 +00:00
# ifdef HAS_PUT_TIME
2019-03-16 11:47:36 +00:00
os2 < < std : : put_time ( & tm , " %Z " ) ;
2019-03-16 19:30:38 +00:00
# endif
2019-03-16 11:47:36 +00:00
std : : string time_zone_abrv = os2 . str ( ) ;
if ( time_zone_abrv . empty ( ) )
{
if ( utc_diff_str = = " +0000 " )
{
d_local_time_str = " UTC " ;
}
else
{
d_local_time_str = " (UTC " + utc_diff_str . substr ( 0 , 3 ) + " : " + utc_diff_str . substr ( 3 , 2 ) + " ) " ;
}
}
else
{
d_local_time_str = std : : string ( " " ) + time_zone_abrv + " (UTC " + utc_diff_str . substr ( 0 , 3 ) + " : " + utc_diff_str . substr ( 3 , 2 ) + " ) " ;
}
2019-08-01 16:11:36 +00:00
d_waiting_obs_block_rx_clock_offset_correction_msg = false ;
2019-09-06 16:02:40 +00:00
d_enable_rx_clock_correction = conf_ . enable_rx_clock_correction ;
if ( d_enable_rx_clock_correction = = true )
{
2019-09-06 16:39:03 +00:00
// setup two PVT solvers: internal solver for rx clock and user solver
2019-09-06 16:02:40 +00:00
// user PVT solver
d_user_pvt_solver = std : : make_shared < Rtklib_Solver > ( static_cast < int32_t > ( nchannels ) , dump_ls_pvt_filename , d_dump , d_dump_mat , rtk ) ;
d_user_pvt_solver - > set_averaging_depth ( 1 ) ;
2019-09-18 16:25:07 +00:00
d_user_pvt_solver - > set_pre_2009_file ( conf_ . pre_2009_file ) ;
2019-09-06 16:02:40 +00:00
// internal PVT solver, mainly used to estimate the receiver clock
rtk_t internal_rtk = rtk ;
internal_rtk . opt . mode = PMODE_SINGLE ; // use single positioning mode in internal PVT solver
d_internal_pvt_solver = std : : make_shared < Rtklib_Solver > ( static_cast < int32_t > ( nchannels ) , dump_ls_pvt_filename , false , false , internal_rtk ) ;
d_internal_pvt_solver - > set_averaging_depth ( 1 ) ;
2019-09-18 16:25:07 +00:00
d_internal_pvt_solver - > set_pre_2009_file ( conf_ . pre_2009_file ) ;
2019-09-06 16:02:40 +00:00
}
else
{
2019-09-06 16:39:03 +00:00
// only one solver, customized by the user options
2019-09-06 16:02:40 +00:00
d_internal_pvt_solver = std : : make_shared < Rtklib_Solver > ( static_cast < int32_t > ( nchannels ) , dump_ls_pvt_filename , d_dump , d_dump_mat , rtk ) ;
d_internal_pvt_solver - > set_averaging_depth ( 1 ) ;
2019-09-18 16:25:07 +00:00
d_internal_pvt_solver - > set_pre_2009_file ( conf_ . pre_2009_file ) ;
2019-09-06 16:02:40 +00:00
d_user_pvt_solver = d_internal_pvt_solver ;
}
2017-08-11 03:18:38 +00:00
start = std : : chrono : : system_clock : : now ( ) ;
2017-04-20 14:10:12 +00:00
}
2019-03-02 01:21:03 +00:00
rtklib_pvt_gs : : ~ rtklib_pvt_gs ( )
2017-04-20 14:10:12 +00:00
{
2019-02-05 00:31:09 +00:00
msgctl ( sysv_msqid , IPC_RMID , nullptr ) ;
2019-02-10 20:55:51 +00:00
try
2017-04-20 14:10:12 +00:00
{
2019-02-10 20:55:51 +00:00
if ( d_xml_storage )
2018-03-03 01:03:39 +00:00
{
2019-02-10 20:55:51 +00:00
// save GPS L2CM ephemeris to XML file
std : : string file_name = xml_base_path + " gps_cnav_ephemeris.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_cnav_ephemeris_map . empty ( ) = = false )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_cnav_ephemeris_map " , d_internal_pvt_solver - > gps_cnav_ephemeris_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GPS L2CM or L5 Ephemeris map data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GPS L2CM or L5 Ephemeris, map is empty " ;
2018-10-27 22:42:28 +00:00
}
2017-04-20 14:10:12 +00:00
2019-02-10 20:55:51 +00:00
// save GPS L1 CA ephemeris to XML file
file_name = xml_base_path + " gps_ephemeris.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_ephemeris_map . empty ( ) = = false )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_ephemeris_map " , d_internal_pvt_solver - > gps_ephemeris_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GPS L1 CA Ephemeris map data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : exception & e )
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GPS L1 CA Ephemeris, map is empty " ;
2018-10-27 22:42:28 +00:00
}
2017-04-20 14:10:12 +00:00
2019-02-10 20:55:51 +00:00
// save Galileo E1 ephemeris to XML file
file_name = xml_base_path + " gal_ephemeris.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > galileo_ephemeris_map . empty ( ) = = false )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gal_ephemeris_map " , d_internal_pvt_solver - > galileo_ephemeris_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved Galileo E1 Ephemeris map data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
catch ( const std : : exception & e )
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save Galileo E1 Ephemeris, map is empty " ;
2018-10-27 22:42:28 +00:00
}
2017-04-20 14:10:12 +00:00
2019-02-10 20:55:51 +00:00
// save GLONASS GNAV ephemeris to XML file
file_name = xml_base_path + " eph_GLONASS_GNAV.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > glonass_gnav_ephemeris_map . empty ( ) = = false )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gnav_ephemeris_map " , d_internal_pvt_solver - > glonass_gnav_ephemeris_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GLONASS GNAV Ephemeris map data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GLONASS GNAV Ephemeris, map is empty " ;
2018-10-27 22:42:28 +00:00
}
2018-08-09 18:36:11 +00:00
2019-02-10 20:55:51 +00:00
// Save GPS UTC model parameters
file_name = xml_base_path + " gps_utc_model.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_utc_model . valid )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_utc_model " , d_internal_pvt_solver - > gps_utc_model ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GPS UTC model parameters " ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GPS UTC model parameters, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2018-10-19 11:48:21 +00:00
2019-02-10 20:55:51 +00:00
// Save Galileo UTC model parameters
file_name = xml_base_path + " gal_utc_model.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > galileo_utc_model . Delta_tLS_6 ! = 0.0 )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gal_utc_model " , d_internal_pvt_solver - > galileo_utc_model ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved Galileo UTC model parameters " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save Galileo UTC model parameters, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2018-10-19 11:48:21 +00:00
2019-02-10 20:55:51 +00:00
// Save GPS iono parameters
file_name = xml_base_path + " gps_iono.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_iono . valid = = true )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_iono_model " , d_internal_pvt_solver - > gps_iono ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GPS ionospheric model parameters " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GPS ionospheric model parameters, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2018-10-19 12:48:41 +00:00
2019-02-10 20:55:51 +00:00
// Save GPS CNAV iono parameters
file_name = xml_base_path + " gps_cnav_iono.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_cnav_iono . valid = = true )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_cnav_iono_model " , d_internal_pvt_solver - > gps_cnav_iono ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GPS CNAV ionospheric model parameters " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GPS CNAV ionospheric model parameters, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2018-10-20 17:30:32 +00:00
2019-02-10 20:55:51 +00:00
// Save Galileo iono parameters
file_name = xml_base_path + " gal_iono.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > galileo_iono . ai0_5 ! = 0.0 )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gal_iono_model " , d_internal_pvt_solver - > galileo_iono ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved Galileo ionospheric model parameters " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save Galileo ionospheric model parameters, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2018-10-20 17:30:32 +00:00
2019-02-10 20:55:51 +00:00
// save GPS almanac to XML file
file_name = xml_base_path + " gps_almanac.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_almanac_map . empty ( ) = = false )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gps_almanac_map " , d_internal_pvt_solver - > gps_almanac_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GPS almanac map data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
catch ( const std : : exception & e )
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GPS almanac, map is empty " ;
2018-10-27 22:42:28 +00:00
}
2018-10-20 17:30:32 +00:00
2019-02-10 20:55:51 +00:00
// Save Galileo almanac
file_name = xml_base_path + " gal_almanac.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > galileo_almanac_map . empty ( ) = = false )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gal_almanac_map " , d_internal_pvt_solver - > galileo_almanac_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved Galileo almanac data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save Galileo almanac, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
// Save GPS CNAV UTC model parameters
file_name = xml_base_path + " gps_cnav_utc_model.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_cnav_utc_model . valid )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_cnav_utc_model " , d_internal_pvt_solver - > gps_cnav_utc_model ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GPS CNAV UTC model parameters " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GPS CNAV UTC model parameters, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
// save GLONASS GNAV ephemeris to XML file
file_name = xml_base_path + " glo_gnav_ephemeris.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > glonass_gnav_ephemeris_map . empty ( ) = = false )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gnav_ephemeris_map " , d_internal_pvt_solver - > glonass_gnav_ephemeris_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GLONASS GNAV ephemeris map data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GLONASS GNAV ephemeris, map is empty " ;
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
// save GLONASS UTC model parameters to XML file
file_name = xml_base_path + " glo_utc_model.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > glonass_gnav_utc_model . valid )
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gnav_utc_model " , d_internal_pvt_solver - > glonass_gnav_utc_model ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved GLONASS UTC model parameters " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save GLONASS GNAV ephemeris, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2018-11-29 15:53:40 +00:00
2019-02-10 20:55:51 +00:00
// save BeiDou DNAV ephemeris to XML file
file_name = xml_base_path + " bds_dnav_ephemeris.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > beidou_dnav_ephemeris_map . empty ( ) = = false )
2018-11-29 15:53:40 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_bds_dnav_ephemeris_map " , d_internal_pvt_solver - > beidou_dnav_ephemeris_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved BeiDou DNAV Ephemeris map data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
catch ( const std : : exception & e )
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-10-27 22:42:28 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-10-27 22:42:28 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save BeiDou DNAV Ephemeris, map is empty " ;
2018-11-29 15:53:40 +00:00
}
2019-02-10 20:55:51 +00:00
// Save BeiDou DNAV iono parameters
file_name = xml_base_path + " bds_dnav_iono.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > beidou_dnav_iono . valid )
2018-11-29 15:53:40 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_bds_dnav_iono_model " , d_internal_pvt_solver - > beidou_dnav_iono ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved BeiDou DNAV ionospheric model parameters " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-11-29 15:53:40 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-11-29 15:53:40 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save BeiDou DNAV ionospheric model parameters, not valid data " ;
2018-11-29 15:53:40 +00:00
}
2019-02-10 20:55:51 +00:00
// save BeiDou DNAV almanac to XML file
file_name = xml_base_path + " bds_dnav_almanac.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > beidou_dnav_almanac_map . empty ( ) = = false )
2018-11-29 15:53:40 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_bds_dnav_almanac_map " , d_internal_pvt_solver - > beidou_dnav_almanac_map ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved BeiDou DNAV almanac map data " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
catch ( const std : : exception & e )
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-11-29 15:53:40 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-11-29 15:53:40 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save BeiDou DNAV almanac, map is empty " ;
2018-11-29 15:53:40 +00:00
}
2019-02-10 20:55:51 +00:00
// Save BeiDou UTC model parameters
file_name = xml_base_path + " bds_dnav_utc_model.xml " ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > beidou_dnav_utc_model . valid )
2018-11-29 15:53:40 +00:00
{
2019-02-10 20:55:51 +00:00
std : : ofstream ofs ;
try
{
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
boost : : archive : : xml_oarchive xml ( ofs ) ;
2019-08-01 16:11:36 +00:00
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_bds_dnav_utc_model " , d_internal_pvt_solver - > beidou_dnav_utc_model ) ;
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Saved BeiDou DNAV UTC model parameters " ;
}
2019-02-11 21:00:48 +00:00
catch ( const boost : : archive : : archive_exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
catch ( const std : : ofstream : : failure & e )
{
LOG ( WARNING ) < < " Problem opening output XML file " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2019-02-10 20:55:51 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
}
2018-11-29 15:53:40 +00:00
}
2019-02-10 20:55:51 +00:00
else
2018-11-29 15:53:40 +00:00
{
2019-02-10 20:55:51 +00:00
LOG ( INFO ) < < " Failed to save BeiDou DNAV UTC model parameters, not valid data " ;
2018-10-27 22:42:28 +00:00
}
2018-10-20 17:30:32 +00:00
}
2019-02-10 20:55:51 +00:00
}
catch ( std : : length_error & e )
{
LOG ( WARNING ) < < e . what ( ) ;
2018-10-20 17:30:32 +00:00
}
2017-04-20 14:10:12 +00:00
}
2019-03-02 01:21:03 +00:00
void rtklib_pvt_gs : : msg_handler_telemetry ( const pmt : : pmt_t & msg )
2019-02-26 00:38:48 +00:00
{
try
{
// ************* GPS telemetry *****************
if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Gps_Ephemeris > ) )
{
// ### GPS EPHEMERIS ###
std : : shared_ptr < Gps_Ephemeris > gps_eph ;
gps_eph = boost : : any_cast < std : : shared_ptr < Gps_Ephemeris > > ( pmt : : any_ref ( msg ) ) ;
DLOG ( INFO ) < < " Ephemeris record has arrived from SAT ID "
< < gps_eph - > i_satellite_PRN < < " (Block "
< < gps_eph - > satelliteBlock [ gps_eph - > i_satellite_PRN ] < < " ) "
< < " inserted with Toe= " < < gps_eph - > d_Toe < < " and GPS Week= "
< < gps_eph - > i_GPS_week ;
// update/insert new ephemeris record to the global ephemeris map
2019-05-07 14:39:06 +00:00
if ( b_rinex_header_written ) // The header is already written, we can now log the navigation message data
{
bool new_annotation = false ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_ephemeris_map . find ( gps_eph - > i_satellite_PRN ) = = d_internal_pvt_solver - > gps_ephemeris_map . cend ( ) )
2019-05-07 14:39:06 +00:00
{
new_annotation = true ;
}
else
{
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_ephemeris_map [ gps_eph - > i_satellite_PRN ] . d_Toe ! = gps_eph - > d_Toe )
2019-05-07 14:39:06 +00:00
{
new_annotation = true ;
}
}
if ( new_annotation = = true )
{
// New record!
std : : map < int32_t , Gps_Ephemeris > new_eph ;
std : : map < int32_t , Galileo_Ephemeris > new_gal_eph ;
std : : map < int32_t , Glonass_Gnav_Ephemeris > new_glo_eph ;
new_eph [ gps_eph - > i_satellite_PRN ] = * gps_eph ;
switch ( type_of_rx )
{
case 1 : // GPS L1 C/A only
rp - > log_rinex_nav ( rp - > navFile , new_eph ) ;
break ;
case 8 : // L1+L5
rp - > log_rinex_nav ( rp - > navFile , new_eph ) ;
break ;
2019-09-14 09:57:08 +00:00
case 9 : // GPS L1 C/A + Galileo E1B
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
case 10 : // GPS L1 C/A + Galileo E5a
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
2019-05-07 14:39:06 +00:00
case 11 : // GPS L1 C/A + Galileo E5b
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
case 26 : // GPS L1 C/A + GLONASS L1 C/A
if ( d_rinex_version = = 3 )
{
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_glo_eph ) ;
}
if ( d_rinex_version = = 2 )
{
rp - > log_rinex_nav ( rp - > navFile , new_glo_eph ) ;
}
break ;
2019-11-02 11:23:28 +00:00
case 29 : // GPS L1 C/A + GLONASS L2 C/A
2019-05-07 14:39:06 +00:00
if ( d_rinex_version = = 3 )
{
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_glo_eph ) ;
}
if ( d_rinex_version = = 2 )
{
rp - > log_rinex_nav ( rp - > navFile , new_eph ) ;
}
break ;
case 32 : // L1+E1+L5+E5a
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
case 33 : // L1+E1+E5a
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
2019-09-13 15:49:22 +00:00
case 1000 : // L1+L2+L5
rp - > log_rinex_nav ( rp - > navFile , new_eph ) ;
break ;
2019-09-13 14:30:00 +00:00
case 1001 : // L1+E1+L2+L5+E5a
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
2019-05-07 14:39:06 +00:00
default :
break ;
}
}
}
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > gps_ephemeris_map [ gps_eph - > i_satellite_PRN ] = * gps_eph ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > gps_ephemeris_map [ gps_eph - > i_satellite_PRN ] = * gps_eph ;
}
2019-02-26 00:38:48 +00:00
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Gps_Iono > ) )
{
// ### GPS IONO ###
std : : shared_ptr < Gps_Iono > gps_iono ;
gps_iono = boost : : any_cast < std : : shared_ptr < Gps_Iono > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > gps_iono = * gps_iono ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > gps_iono = * gps_iono ;
}
2019-02-26 00:38:48 +00:00
DLOG ( INFO ) < < " New IONO record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Gps_Utc_Model > ) )
{
// ### GPS UTC MODEL ###
std : : shared_ptr < Gps_Utc_Model > gps_utc_model ;
gps_utc_model = boost : : any_cast < std : : shared_ptr < Gps_Utc_Model > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > gps_utc_model = * gps_utc_model ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > gps_utc_model = * gps_utc_model ;
}
2019-02-26 00:38:48 +00:00
DLOG ( INFO ) < < " New UTC record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Gps_CNAV_Ephemeris > ) )
{
// ### GPS CNAV message ###
std : : shared_ptr < Gps_CNAV_Ephemeris > gps_cnav_ephemeris ;
gps_cnav_ephemeris = boost : : any_cast < std : : shared_ptr < Gps_CNAV_Ephemeris > > ( pmt : : any_ref ( msg ) ) ;
// update/insert new ephemeris record to the global ephemeris map
2019-05-07 14:39:06 +00:00
if ( b_rinex_header_written ) // The header is already written, we can now log the navigation message data
{
bool new_annotation = false ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_cnav_ephemeris_map . find ( gps_cnav_ephemeris - > i_satellite_PRN ) = = d_internal_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) )
2019-05-07 14:39:06 +00:00
{
new_annotation = true ;
}
else
{
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_cnav_ephemeris_map [ gps_cnav_ephemeris - > i_satellite_PRN ] . d_Toe1 ! = gps_cnav_ephemeris - > d_Toe1 )
2019-05-07 14:39:06 +00:00
{
new_annotation = true ;
}
}
if ( new_annotation = = true )
{
// New record!
std : : map < int32_t , Galileo_Ephemeris > new_gal_eph ;
std : : map < int32_t , Gps_CNAV_Ephemeris > new_cnav_eph ;
std : : map < int32_t , Glonass_Gnav_Ephemeris > new_glo_eph ;
new_cnav_eph [ gps_cnav_ephemeris - > i_satellite_PRN ] = * gps_cnav_ephemeris ;
switch ( type_of_rx )
{
case 2 : // GPS L2C only
rp - > log_rinex_nav ( rp - > navFile , new_cnav_eph ) ;
break ;
case 3 : // GPS L5 only
rp - > log_rinex_nav ( rp - > navFile , new_cnav_eph ) ;
break ;
case 7 : // GPS L1 C/A + GPS L2C
rp - > log_rinex_nav ( rp - > navFile , new_cnav_eph ) ;
break ;
2019-11-02 11:23:28 +00:00
case 13 : // L5+E5a
2019-09-15 16:10:05 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_cnav_eph , new_gal_eph ) ;
2019-05-07 14:39:06 +00:00
break ;
2019-11-02 11:23:28 +00:00
case 28 : // GPS L2C + GLONASS L1 C/A
2019-05-07 14:39:06 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_cnav_eph , new_glo_eph ) ;
break ;
2019-11-02 11:23:28 +00:00
case 31 : // GPS L2C + GLONASS L2 C/A
2019-05-07 14:39:06 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_cnav_eph , new_glo_eph ) ;
break ;
default :
break ;
}
}
}
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > gps_cnav_ephemeris_map [ gps_cnav_ephemeris - > i_satellite_PRN ] = * gps_cnav_ephemeris ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > gps_cnav_ephemeris_map [ gps_cnav_ephemeris - > i_satellite_PRN ] = * gps_cnav_ephemeris ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New GPS CNAV ephemeris record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Gps_CNAV_Iono > ) )
{
// ### GPS CNAV IONO ###
std : : shared_ptr < Gps_CNAV_Iono > gps_cnav_iono ;
gps_cnav_iono = boost : : any_cast < std : : shared_ptr < Gps_CNAV_Iono > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > gps_cnav_iono = * gps_cnav_iono ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > gps_cnav_iono = * gps_cnav_iono ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New CNAV IONO record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Gps_CNAV_Utc_Model > ) )
{
// ### GPS CNAV UTC MODEL ###
std : : shared_ptr < Gps_CNAV_Utc_Model > gps_cnav_utc_model ;
gps_cnav_utc_model = boost : : any_cast < std : : shared_ptr < Gps_CNAV_Utc_Model > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > gps_cnav_utc_model = * gps_cnav_utc_model ;
2019-09-06 16:02:40 +00:00
{
d_user_pvt_solver - > gps_cnav_utc_model = * gps_cnav_utc_model ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New CNAV UTC record has arrived " ;
}
2018-10-20 17:30:32 +00:00
2019-05-07 16:52:08 +00:00
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Gps_Almanac > ) )
{
// ### GPS ALMANAC ###
std : : shared_ptr < Gps_Almanac > gps_almanac ;
gps_almanac = boost : : any_cast < std : : shared_ptr < Gps_Almanac > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > gps_almanac_map [ gps_almanac - > i_satellite_PRN ] = * gps_almanac ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > gps_almanac_map [ gps_almanac - > i_satellite_PRN ] = * gps_almanac ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New GPS almanac record has arrived " ;
}
2018-10-27 22:42:28 +00:00
2019-05-07 16:52:08 +00:00
// **************** Galileo telemetry ********************
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Galileo_Ephemeris > ) )
{
// ### Galileo EPHEMERIS ###
std : : shared_ptr < Galileo_Ephemeris > galileo_eph ;
galileo_eph = boost : : any_cast < std : : shared_ptr < Galileo_Ephemeris > > ( pmt : : any_ref ( msg ) ) ;
// insert new ephemeris record
DLOG ( INFO ) < < " Galileo New Ephemeris record inserted in global map with TOW = " < < galileo_eph - > TOW_5
< < " , GALILEO Week Number = " < < galileo_eph - > WN_5
< < " and Ephemeris IOD = " < < galileo_eph - > IOD_ephemeris ;
// update/insert new ephemeris record to the global ephemeris map
if ( b_rinex_header_written ) // The header is already written, we can now log the navigation message data
2019-05-07 14:39:06 +00:00
{
2019-05-07 16:52:08 +00:00
bool new_annotation = false ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > galileo_ephemeris_map . find ( galileo_eph - > i_satellite_PRN ) = = d_internal_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2019-05-07 16:52:08 +00:00
{
new_annotation = true ;
}
else
{
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > galileo_ephemeris_map [ galileo_eph - > i_satellite_PRN ] . t0e_1 ! = galileo_eph - > t0e_1 )
2019-05-07 14:39:06 +00:00
{
new_annotation = true ;
}
2019-05-07 16:52:08 +00:00
}
if ( new_annotation = = true )
{
// New record!
std : : map < int32_t , Galileo_Ephemeris > new_gal_eph ;
std : : map < int32_t , Gps_CNAV_Ephemeris > new_cnav_eph ;
std : : map < int32_t , Gps_Ephemeris > new_eph ;
std : : map < int32_t , Glonass_Gnav_Ephemeris > new_glo_eph ;
new_gal_eph [ galileo_eph - > i_satellite_PRN ] = * galileo_eph ;
switch ( type_of_rx )
2019-05-07 14:39:06 +00:00
{
2019-09-14 09:57:08 +00:00
case 4 : // Galileo E1B only
rp - > log_rinex_nav ( rp - > navGalFile , new_gal_eph ) ;
break ;
case 5 : // Galileo E5a only
rp - > log_rinex_nav ( rp - > navGalFile , new_gal_eph ) ;
break ;
2019-05-07 16:52:08 +00:00
case 6 : // Galileo E5b only
rp - > log_rinex_nav ( rp - > navGalFile , new_gal_eph ) ;
break ;
2019-09-14 09:57:08 +00:00
case 9 : // GPS L1 C/A + Galileo E1B
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
2019-09-14 09:57:08 +00:00
case 10 : // GPS L1 C/A + Galileo E5a
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
case 11 : // GPS L1 C/A + Galileo E5b
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
case 13 : // L5+E5a
2019-09-14 17:25:33 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_cnav_eph , new_gal_eph ) ;
2019-05-07 16:52:08 +00:00
break ;
2019-09-14 09:57:08 +00:00
case 15 : // Galileo E1B + Galileo E5b
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navGalFile , new_gal_eph ) ;
break ;
2019-09-14 09:57:08 +00:00
case 27 : // Galileo E1B + GLONASS L1 C/A
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_gal_eph , new_glo_eph ) ;
break ;
2019-09-14 09:57:08 +00:00
case 30 : // Galileo E1B + GLONASS L2 C/A
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_gal_eph , new_glo_eph ) ;
break ;
case 32 : // L1+E1+L5+E5a
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
case 33 : // L1+E1+E5a
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
2019-09-13 14:30:00 +00:00
case 1001 : // L1+E1+L2+L5+E5a
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_gal_eph ) ;
break ;
2019-05-08 06:24:13 +00:00
default :
break ;
2019-05-07 14:39:06 +00:00
}
}
}
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > galileo_ephemeris_map [ galileo_eph - > i_satellite_PRN ] = * galileo_eph ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > galileo_ephemeris_map [ galileo_eph - > i_satellite_PRN ] = * galileo_eph ;
}
2019-05-07 16:52:08 +00:00
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Galileo_Iono > ) )
{
// ### Galileo IONO ###
std : : shared_ptr < Galileo_Iono > galileo_iono ;
galileo_iono = boost : : any_cast < std : : shared_ptr < Galileo_Iono > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > galileo_iono = * galileo_iono ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > galileo_iono = * galileo_iono ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New IONO record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Galileo_Utc_Model > ) )
{
// ### Galileo UTC MODEL ###
std : : shared_ptr < Galileo_Utc_Model > galileo_utc_model ;
galileo_utc_model = boost : : any_cast < std : : shared_ptr < Galileo_Utc_Model > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > galileo_utc_model = * galileo_utc_model ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > galileo_utc_model = * galileo_utc_model ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New UTC record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Galileo_Almanac_Helper > ) )
{
// ### Galileo Almanac ###
std : : shared_ptr < Galileo_Almanac_Helper > galileo_almanac_helper ;
galileo_almanac_helper = boost : : any_cast < std : : shared_ptr < Galileo_Almanac_Helper > > ( pmt : : any_ref ( msg ) ) ;
Galileo_Almanac sv1 = galileo_almanac_helper - > get_almanac ( 1 ) ;
Galileo_Almanac sv2 = galileo_almanac_helper - > get_almanac ( 2 ) ;
Galileo_Almanac sv3 = galileo_almanac_helper - > get_almanac ( 3 ) ;
if ( sv1 . i_satellite_PRN ! = 0 )
2018-10-27 22:42:28 +00:00
{
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > galileo_almanac_map [ sv1 . i_satellite_PRN ] = sv1 ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > galileo_almanac_map [ sv1 . i_satellite_PRN ] = sv1 ;
}
2018-10-27 22:42:28 +00:00
}
2019-05-07 16:52:08 +00:00
if ( sv2 . i_satellite_PRN ! = 0 )
2018-10-27 22:42:28 +00:00
{
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > galileo_almanac_map [ sv2 . i_satellite_PRN ] = sv2 ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > galileo_almanac_map [ sv2 . i_satellite_PRN ] = sv2 ;
}
2018-10-27 22:42:28 +00:00
}
2019-05-07 16:52:08 +00:00
if ( sv3 . i_satellite_PRN ! = 0 )
2018-10-27 22:42:28 +00:00
{
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > galileo_almanac_map [ sv3 . i_satellite_PRN ] = sv3 ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > galileo_almanac_map [ sv3 . i_satellite_PRN ] = sv3 ;
}
2019-05-07 16:52:08 +00:00
}
DLOG ( INFO ) < < " New Galileo Almanac data have arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Galileo_Almanac > ) )
{
// ### Galileo Almanac ###
std : : shared_ptr < Galileo_Almanac > galileo_alm ;
galileo_alm = boost : : any_cast < std : : shared_ptr < Galileo_Almanac > > ( pmt : : any_ref ( msg ) ) ;
// update/insert new almanac record to the global almanac map
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > galileo_almanac_map [ galileo_alm - > i_satellite_PRN ] = * galileo_alm ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > galileo_almanac_map [ galileo_alm - > i_satellite_PRN ] = * galileo_alm ;
}
2019-05-07 16:52:08 +00:00
}
2019-05-07 14:39:06 +00:00
2019-05-07 16:52:08 +00:00
// **************** GLONASS GNAV Telemetry **************************
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Glonass_Gnav_Ephemeris > ) )
{
// ### GLONASS GNAV EPHEMERIS ###
std : : shared_ptr < Glonass_Gnav_Ephemeris > glonass_gnav_eph ;
glonass_gnav_eph = boost : : any_cast < std : : shared_ptr < Glonass_Gnav_Ephemeris > > ( pmt : : any_ref ( msg ) ) ;
// TODO Add GLONASS with gps week number and tow,
// insert new ephemeris record
DLOG ( INFO ) < < " GLONASS GNAV New Ephemeris record inserted in global map with TOW = " < < glonass_gnav_eph - > d_TOW
< < " , Week Number = " < < glonass_gnav_eph - > d_WN
< < " and Ephemeris IOD in UTC = " < < glonass_gnav_eph - > compute_GLONASS_time ( glonass_gnav_eph - > d_t_b )
< < " from SV = " < < glonass_gnav_eph - > i_satellite_slot_number ;
// update/insert new ephemeris record to the global ephemeris map
if ( b_rinex_header_written ) // The header is already written, we can now log the navigation message data
{
bool new_annotation = false ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > glonass_gnav_ephemeris_map . find ( glonass_gnav_eph - > i_satellite_PRN ) = = d_internal_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2019-05-07 14:39:06 +00:00
{
2019-05-07 16:52:08 +00:00
new_annotation = true ;
2019-05-07 14:39:06 +00:00
}
2019-05-07 16:52:08 +00:00
else
2019-05-07 14:39:06 +00:00
{
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > glonass_gnav_ephemeris_map [ glonass_gnav_eph - > i_satellite_PRN ] . d_t_b ! = glonass_gnav_eph - > d_t_b )
2019-05-07 14:39:06 +00:00
{
new_annotation = true ;
}
2019-05-07 16:52:08 +00:00
}
if ( new_annotation = = true )
{
// New record!
std : : map < int32_t , Galileo_Ephemeris > new_gal_eph ;
std : : map < int32_t , Gps_CNAV_Ephemeris > new_cnav_eph ;
std : : map < int32_t , Gps_Ephemeris > new_eph ;
std : : map < int32_t , Glonass_Gnav_Ephemeris > new_glo_eph ;
new_glo_eph [ glonass_gnav_eph - > i_satellite_PRN ] = * glonass_gnav_eph ;
switch ( type_of_rx )
2019-05-07 14:39:06 +00:00
{
2019-09-15 16:10:05 +00:00
case 23 : // GLONASS L1 C/A
rp - > log_rinex_nav ( rp - > navGloFile , new_glo_eph ) ;
break ;
case 24 : // GLONASS L2 C/A
rp - > log_rinex_nav ( rp - > navGloFile , new_glo_eph ) ;
break ;
2019-05-07 16:52:08 +00:00
case 25 : // GLONASS L1 C/A + GLONASS L2 C/A
rp - > log_rinex_nav ( rp - > navGloFile , new_glo_eph ) ;
break ;
2019-11-02 11:23:28 +00:00
case 26 : // GPS L1 C/A + GLONASS L1 C/A
2019-05-07 16:52:08 +00:00
if ( d_rinex_version = = 3 )
2019-05-07 14:39:06 +00:00
{
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_glo_eph ) ;
2019-05-07 14:39:06 +00:00
}
2019-05-07 16:52:08 +00:00
if ( d_rinex_version = = 2 )
2019-05-07 14:39:06 +00:00
{
rp - > log_rinex_nav ( rp - > navGloFile , new_glo_eph ) ;
}
2019-05-07 16:52:08 +00:00
break ;
2019-11-02 11:23:28 +00:00
case 27 : // Galileo E1B + GLONASS L1 C/A
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_gal_eph , new_glo_eph ) ;
break ;
2019-11-02 11:23:28 +00:00
case 28 : // GPS L2C + GLONASS L1 C/A
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_cnav_eph , new_glo_eph ) ;
break ;
2019-11-02 11:23:28 +00:00
case 29 : // GPS L1 C/A + GLONASS L2 C/A
2019-05-07 16:52:08 +00:00
if ( d_rinex_version = = 3 )
{
rp - > log_rinex_nav ( rp - > navMixFile , new_eph , new_glo_eph ) ;
}
if ( d_rinex_version = = 2 )
{
rp - > log_rinex_nav ( rp - > navGloFile , new_glo_eph ) ;
}
break ;
2019-11-02 11:23:28 +00:00
case 30 : // Galileo E1B + GLONASS L2 C/A
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_gal_eph , new_glo_eph ) ;
break ;
2019-11-02 11:23:28 +00:00
case 31 : // GPS L2C + GLONASS L2 C/A
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , new_cnav_eph , new_glo_eph ) ;
break ;
default :
break ;
2019-05-07 14:39:06 +00:00
}
}
}
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > glonass_gnav_ephemeris_map [ glonass_gnav_eph - > i_satellite_PRN ] = * glonass_gnav_eph ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > glonass_gnav_ephemeris_map [ glonass_gnav_eph - > i_satellite_PRN ] = * glonass_gnav_eph ;
}
2019-05-07 16:52:08 +00:00
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Glonass_Gnav_Utc_Model > ) )
{
// ### GLONASS GNAV UTC MODEL ###
std : : shared_ptr < Glonass_Gnav_Utc_Model > glonass_gnav_utc_model ;
glonass_gnav_utc_model = boost : : any_cast < std : : shared_ptr < Glonass_Gnav_Utc_Model > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > glonass_gnav_utc_model = * glonass_gnav_utc_model ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > glonass_gnav_utc_model = * glonass_gnav_utc_model ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New GLONASS GNAV UTC record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Glonass_Gnav_Almanac > ) )
{
// ### GLONASS GNAV Almanac ###
std : : shared_ptr < Glonass_Gnav_Almanac > glonass_gnav_almanac ;
glonass_gnav_almanac = boost : : any_cast < std : : shared_ptr < Glonass_Gnav_Almanac > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > glonass_gnav_almanac = * glonass_gnav_almanac ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > glonass_gnav_almanac = * glonass_gnav_almanac ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New GLONASS GNAV Almanac has arrived "
< < " , GLONASS GNAV Slot Number = " < < glonass_gnav_almanac - > d_n_A ;
}
2019-02-26 00:38:48 +00:00
2019-05-07 16:52:08 +00:00
// ************* BeiDou telemetry *****************
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Beidou_Dnav_Ephemeris > ) )
{
// ### Beidou EPHEMERIS ###
std : : shared_ptr < Beidou_Dnav_Ephemeris > bds_dnav_eph ;
bds_dnav_eph = boost : : any_cast < std : : shared_ptr < Beidou_Dnav_Ephemeris > > ( pmt : : any_ref ( msg ) ) ;
DLOG ( INFO ) < < " Ephemeris record has arrived from SAT ID "
< < bds_dnav_eph - > i_satellite_PRN < < " (Block "
< < bds_dnav_eph - > satelliteBlock [ bds_dnav_eph - > i_satellite_PRN ] < < " ) "
< < " inserted with Toe= " < < bds_dnav_eph - > d_Toe < < " and BDS Week= "
< < bds_dnav_eph - > i_BEIDOU_week ;
// update/insert new ephemeris record to the global ephemeris map
if ( b_rinex_header_written ) // The header is already written, we can now log the navigation message data
2019-05-07 14:39:06 +00:00
{
2019-05-07 16:52:08 +00:00
bool new_annotation = false ;
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > beidou_dnav_ephemeris_map . find ( bds_dnav_eph - > i_satellite_PRN ) = = d_internal_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
2019-05-07 16:52:08 +00:00
{
new_annotation = true ;
}
else
{
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > beidou_dnav_ephemeris_map [ bds_dnav_eph - > i_satellite_PRN ] . d_Toc ! = bds_dnav_eph - > d_Toc )
2019-05-07 14:39:06 +00:00
{
new_annotation = true ;
}
2019-05-07 16:52:08 +00:00
}
if ( new_annotation = = true )
{
// New record!
std : : map < int32_t , Beidou_Dnav_Ephemeris > new_bds_eph ;
new_bds_eph [ bds_dnav_eph - > i_satellite_PRN ] = * bds_dnav_eph ;
switch ( type_of_rx )
2019-05-07 14:39:06 +00:00
{
2019-07-12 09:35:01 +00:00
case 500 : // BDS B1I only
2019-05-07 16:52:08 +00:00
rp - > log_rinex_nav ( rp - > navFile , new_bds_eph ) ;
break ;
2019-09-15 16:10:05 +00:00
case 600 : // BDS B3I only
rp - > log_rinex_nav ( rp - > navFile , new_bds_eph ) ;
break ;
2019-05-07 16:52:08 +00:00
default :
break ;
2019-05-07 14:39:06 +00:00
}
}
}
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > beidou_dnav_ephemeris_map [ bds_dnav_eph - > i_satellite_PRN ] = * bds_dnav_eph ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > beidou_dnav_ephemeris_map [ bds_dnav_eph - > i_satellite_PRN ] = * bds_dnav_eph ;
}
2019-05-07 16:52:08 +00:00
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Beidou_Dnav_Iono > ) )
{
// ### BeiDou IONO ###
std : : shared_ptr < Beidou_Dnav_Iono > bds_dnav_iono ;
bds_dnav_iono = boost : : any_cast < std : : shared_ptr < Beidou_Dnav_Iono > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > beidou_dnav_iono = * bds_dnav_iono ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > beidou_dnav_iono = * bds_dnav_iono ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New BeiDou DNAV IONO record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Beidou_Dnav_Utc_Model > ) )
{
// ### BeiDou UTC MODEL ###
std : : shared_ptr < Beidou_Dnav_Utc_Model > bds_dnav_utc_model ;
bds_dnav_utc_model = boost : : any_cast < std : : shared_ptr < Beidou_Dnav_Utc_Model > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > beidou_dnav_utc_model = * bds_dnav_utc_model ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > beidou_dnav_utc_model = * bds_dnav_utc_model ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New BeiDou DNAV UTC record has arrived " ;
}
else if ( pmt : : any_ref ( msg ) . type ( ) = = typeid ( std : : shared_ptr < Beidou_Dnav_Almanac > ) )
{
// ### BeiDou ALMANAC ###
std : : shared_ptr < Beidou_Dnav_Almanac > bds_dnav_almanac ;
bds_dnav_almanac = boost : : any_cast < std : : shared_ptr < Beidou_Dnav_Almanac > > ( pmt : : any_ref ( msg ) ) ;
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > beidou_dnav_almanac_map [ bds_dnav_almanac - > i_satellite_PRN ] = * bds_dnav_almanac ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > beidou_dnav_almanac_map [ bds_dnav_almanac - > i_satellite_PRN ] = * bds_dnav_almanac ;
}
2019-05-07 16:52:08 +00:00
DLOG ( INFO ) < < " New BeiDou DNAV almanac record has arrived " ;
}
else
{
LOG ( WARNING ) < < " msg_handler_telemetry unknown object type! " ;
2018-10-20 17:30:32 +00:00
}
}
2019-02-26 00:38:48 +00:00
catch ( boost : : bad_any_cast & e )
{
LOG ( WARNING ) < < " msg_handler_telemetry Bad any cast! " ;
}
}
2019-03-02 01:21:03 +00:00
std : : map < int , Gps_Ephemeris > rtklib_pvt_gs : : get_gps_ephemeris_map ( ) const
2019-02-26 00:38:48 +00:00
{
2019-08-01 16:11:36 +00:00
return d_internal_pvt_solver - > gps_ephemeris_map ;
2019-02-26 00:38:48 +00:00
}
2019-03-02 01:21:03 +00:00
std : : map < int , Gps_Almanac > rtklib_pvt_gs : : get_gps_almanac_map ( ) const
2019-02-26 00:38:48 +00:00
{
2019-08-01 16:11:36 +00:00
return d_internal_pvt_solver - > gps_almanac_map ;
2019-02-26 00:38:48 +00:00
}
2019-03-02 01:21:03 +00:00
std : : map < int , Galileo_Ephemeris > rtklib_pvt_gs : : get_galileo_ephemeris_map ( ) const
2019-02-26 00:38:48 +00:00
{
2019-08-01 16:11:36 +00:00
return d_internal_pvt_solver - > galileo_ephemeris_map ;
2019-02-26 00:38:48 +00:00
}
2019-03-02 01:21:03 +00:00
std : : map < int , Galileo_Almanac > rtklib_pvt_gs : : get_galileo_almanac_map ( ) const
2019-02-26 00:38:48 +00:00
{
2019-08-01 16:11:36 +00:00
return d_internal_pvt_solver - > galileo_almanac_map ;
2019-02-26 00:38:48 +00:00
}
2019-03-02 01:21:03 +00:00
std : : map < int , Beidou_Dnav_Ephemeris > rtklib_pvt_gs : : get_beidou_dnav_ephemeris_map ( ) const
2019-02-26 00:38:48 +00:00
{
2019-08-01 16:11:36 +00:00
return d_internal_pvt_solver - > beidou_dnav_ephemeris_map ;
2019-02-26 00:38:48 +00:00
}
2019-03-02 01:21:03 +00:00
std : : map < int , Beidou_Dnav_Almanac > rtklib_pvt_gs : : get_beidou_dnav_almanac_map ( ) const
2019-02-26 00:38:48 +00:00
{
2019-08-01 16:11:36 +00:00
return d_internal_pvt_solver - > beidou_dnav_almanac_map ;
2019-02-26 00:38:48 +00:00
}
2019-03-02 01:21:03 +00:00
void rtklib_pvt_gs : : clear_ephemeris ( )
2019-02-26 00:38:48 +00:00
{
2019-08-01 16:11:36 +00:00
d_internal_pvt_solver - > gps_ephemeris_map . clear ( ) ;
d_internal_pvt_solver - > gps_almanac_map . clear ( ) ;
d_internal_pvt_solver - > galileo_ephemeris_map . clear ( ) ;
d_internal_pvt_solver - > galileo_almanac_map . clear ( ) ;
d_internal_pvt_solver - > beidou_dnav_ephemeris_map . clear ( ) ;
d_internal_pvt_solver - > beidou_dnav_almanac_map . clear ( ) ;
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
{
d_user_pvt_solver - > gps_ephemeris_map . clear ( ) ;
d_user_pvt_solver - > gps_almanac_map . clear ( ) ;
d_user_pvt_solver - > galileo_ephemeris_map . clear ( ) ;
d_user_pvt_solver - > galileo_almanac_map . clear ( ) ;
d_user_pvt_solver - > beidou_dnav_ephemeris_map . clear ( ) ;
d_user_pvt_solver - > beidou_dnav_almanac_map . clear ( ) ;
}
2017-04-20 14:10:12 +00:00
}
2019-03-02 01:21:03 +00:00
bool rtklib_pvt_gs : : send_sys_v_ttff_msg ( ttff_msgbuf ttff )
2017-04-20 14:10:12 +00:00
{
2018-06-05 19:41:13 +00:00
// Fill Sys V message structures
2017-04-20 14:10:12 +00:00
int msgsend_size ;
ttff_msgbuf msg ;
msg . ttff = ttff . ttff ;
msgsend_size = sizeof ( msg . ttff ) ;
2019-11-02 11:23:28 +00:00
msg . mtype = 1 ; // default message ID
2017-04-20 14:10:12 +00:00
2018-06-05 19:41:13 +00:00
// SEND SOLUTION OVER A MESSAGE QUEUE
// non-blocking Sys V message send
2017-04-20 14:10:12 +00:00
msgsnd ( sysv_msqid , & msg , msgsend_size , IPC_NOWAIT ) ;
return true ;
}
2019-03-02 01:21:03 +00:00
bool rtklib_pvt_gs : : save_gnss_synchro_map_xml ( const std : : string & file_name )
2018-10-05 09:49:11 +00:00
{
if ( gnss_observables_map . empty ( ) = = false )
{
2018-10-06 18:10:16 +00:00
std : : ofstream ofs ;
2018-10-05 09:49:11 +00:00
try
{
2018-10-06 18:10:16 +00:00
ofs . open ( file_name . c_str ( ) , std : : ofstream : : trunc | std : : ofstream : : out ) ;
2018-10-05 09:49:11 +00:00
boost : : archive : : xml_oarchive xml ( ofs ) ;
xml < < boost : : serialization : : make_nvp ( " GNSS-SDR_gnss_synchro_map " , gnss_observables_map ) ;
LOG ( INFO ) < < " Saved gnss_sychro map data " ;
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2018-10-05 09:49:11 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
return false ;
}
return true ;
}
2018-12-03 21:08:19 +00:00
2019-01-28 01:29:43 +00:00
LOG ( WARNING ) < < " Failed to save gnss_synchro, map is empty " ;
return false ;
2018-10-05 09:49:11 +00:00
}
2018-10-06 18:10:16 +00:00
2019-03-02 01:21:03 +00:00
bool rtklib_pvt_gs : : load_gnss_synchro_map_xml ( const std : : string & file_name )
2018-10-05 09:49:11 +00:00
{
2018-10-06 18:10:16 +00:00
// load from xml (boost serialize)
std : : ifstream ifs ;
2018-10-05 09:49:11 +00:00
try
{
2018-10-06 18:10:16 +00:00
ifs . open ( file_name . c_str ( ) , std : : ifstream : : binary | std : : ifstream : : in ) ;
2018-10-05 09:49:11 +00:00
boost : : archive : : xml_iarchive xml ( ifs ) ;
gnss_observables_map . clear ( ) ;
xml > > boost : : serialization : : make_nvp ( " GNSS-SDR_gnss_synchro_map " , gnss_observables_map ) ;
2019-08-01 18:09:35 +00:00
// std::cout << "Loaded gnss_synchro map data with " << gnss_synchro_map.size() << " pseudoranges" << std::endl;
2018-10-05 09:49:11 +00:00
}
2019-02-14 11:51:43 +00:00
catch ( const std : : exception & e )
2018-10-05 09:49:11 +00:00
{
std : : cout < < e . what ( ) < < " File: " < < file_name ;
return false ;
}
2018-10-06 18:10:16 +00:00
return true ;
2018-10-05 09:49:11 +00:00
}
2019-03-02 01:21:03 +00:00
std : : vector < std : : string > rtklib_pvt_gs : : split_string ( const std : : string & s , char delim ) const
2019-02-18 20:44:19 +00:00
{
std : : vector < std : : string > v ;
std : : stringstream ss ( s ) ;
std : : string item ;
while ( std : : getline ( ss , item , delim ) )
{
* ( std : : back_inserter ( v ) + + ) = item ;
}
return v ;
}
2019-03-02 01:21:03 +00:00
bool rtklib_pvt_gs : : get_latest_PVT ( double * longitude_deg ,
2018-11-06 13:39:57 +00:00
double * latitude_deg ,
double * height_m ,
double * ground_speed_kmh ,
double * course_over_ground_deg ,
2019-02-18 20:44:19 +00:00
time_t * UTC_time ) const
2018-11-06 13:39:57 +00:00
{
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
2018-11-06 13:39:57 +00:00
{
2019-09-06 16:02:40 +00:00
if ( d_user_pvt_solver - > is_valid_position ( ) )
{
* latitude_deg = d_user_pvt_solver - > get_latitude ( ) ;
* longitude_deg = d_user_pvt_solver - > get_longitude ( ) ;
* height_m = d_user_pvt_solver - > get_height ( ) ;
* ground_speed_kmh = d_user_pvt_solver - > get_speed_over_ground ( ) * 3600.0 / 1000.0 ;
* course_over_ground_deg = d_user_pvt_solver - > get_course_over_ground ( ) ;
* UTC_time = convert_to_time_t ( d_user_pvt_solver - > get_position_UTC_time ( ) ) ;
return true ;
}
}
else
{
if ( d_internal_pvt_solver - > is_valid_position ( ) )
{
* latitude_deg = d_internal_pvt_solver - > get_latitude ( ) ;
* longitude_deg = d_internal_pvt_solver - > get_longitude ( ) ;
* height_m = d_internal_pvt_solver - > get_height ( ) ;
* ground_speed_kmh = d_internal_pvt_solver - > get_speed_over_ground ( ) * 3600.0 / 1000.0 ;
* course_over_ground_deg = d_internal_pvt_solver - > get_course_over_ground ( ) ;
* UTC_time = convert_to_time_t ( d_internal_pvt_solver - > get_position_UTC_time ( ) ) ;
return true ;
}
2018-11-06 13:39:57 +00:00
}
2018-12-03 21:08:19 +00:00
2019-01-28 01:29:43 +00:00
return false ;
2018-11-06 13:39:57 +00:00
}
2018-11-07 18:27:26 +00:00
2019-07-31 16:16:09 +00:00
void rtklib_pvt_gs : : apply_rx_clock_offset ( std : : map < int , Gnss_Synchro > & observables_map ,
double rx_clock_offset_s )
{
2019-08-01 18:09:35 +00:00
// apply corrections according to Rinex 3.04, Table 1: Observation Corrections for Receiver Clock Offset
2019-07-31 16:16:09 +00:00
std : : map < int , Gnss_Synchro > : : iterator observables_iter ;
for ( observables_iter = observables_map . begin ( ) ; observables_iter ! = observables_map . end ( ) ; observables_iter + + )
{
2019-08-01 18:09:35 +00:00
// all observables in the map are valid
2019-07-31 16:16:09 +00:00
observables_iter - > second . RX_time - = rx_clock_offset_s ;
observables_iter - > second . Pseudorange_m - = rx_clock_offset_s * SPEED_OF_LIGHT ;
switch ( mapStringValues_ [ observables_iter - > second . Signal ] )
{
case evGPS_1C :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ1 * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evGPS_L5 :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ5 * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evSBAS_1C :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ1 * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evGAL_1B :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ1 * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evGAL_5X :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ5 * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evGPS_2S :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ2 * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evBDS_B3 :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ3_BDS * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evGLO_1G :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ1_GLO * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evGLO_2G :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ2_GLO * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evBDS_B1 :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ1_BDS * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
case evBDS_B2 :
2019-11-08 12:40:46 +00:00
observables_iter - > second . Carrier_phase_rads - = rx_clock_offset_s * FREQ2_BDS * PI_2 ;
2019-07-31 16:16:09 +00:00
break ;
default :
break ;
}
}
}
2019-08-01 18:09:35 +00:00
2019-07-31 16:16:09 +00:00
std : : map < int , Gnss_Synchro > rtklib_pvt_gs : : interpolate_observables ( std : : map < int , Gnss_Synchro > & observables_map_t0 ,
std : : map < int , Gnss_Synchro > & observables_map_t1 ,
double rx_time_s )
{
std : : map < int , Gnss_Synchro > interp_observables_map ;
2019-08-01 18:09:35 +00:00
// Linear interpolation: y(t) = y(t0) + (y(t1) - y(t0)) * (t - t0) / (t1 - t0)
2019-08-01 16:11:36 +00:00
// check TOW rollover
double time_factor ;
if ( ( observables_map_t1 . cbegin ( ) - > second . RX_time -
observables_map_t0 . cbegin ( ) - > second . RX_time ) > 0 )
{
time_factor = ( rx_time_s - observables_map_t0 . cbegin ( ) - > second . RX_time ) /
( observables_map_t1 . cbegin ( ) - > second . RX_time -
observables_map_t0 . cbegin ( ) - > second . RX_time ) ;
}
else
{
// TOW rollover situation
time_factor = ( 604800000.0 + rx_time_s - observables_map_t0 . cbegin ( ) - > second . RX_time ) /
( 604800000.0 + observables_map_t1 . cbegin ( ) - > second . RX_time -
observables_map_t0 . cbegin ( ) - > second . RX_time ) ;
}
2019-07-31 16:16:09 +00:00
std : : map < int , Gnss_Synchro > : : const_iterator observables_iter ;
for ( observables_iter = observables_map_t0 . cbegin ( ) ; observables_iter ! = observables_map_t0 . cend ( ) ; observables_iter + + )
{
2019-08-01 18:09:35 +00:00
// 1. Check if the observable exist in t0 and t1
// the map key is the channel ID (see work())
2019-07-31 16:16:09 +00:00
try
{
if ( observables_map_t1 . at ( observables_iter - > first ) . PRN = = observables_iter - > second . PRN )
{
interp_observables_map . insert ( std : : pair < int , Gnss_Synchro > ( observables_iter - > first , observables_iter - > second ) ) ;
2019-08-01 18:09:35 +00:00
interp_observables_map . at ( observables_iter - > first ) . RX_time = rx_time_s ; // interpolation point
2019-07-31 16:16:09 +00:00
interp_observables_map . at ( observables_iter - > first ) . Pseudorange_m + = ( observables_map_t1 . at ( observables_iter - > first ) . Pseudorange_m - observables_iter - > second . Pseudorange_m ) * time_factor ;
interp_observables_map . at ( observables_iter - > first ) . Carrier_phase_rads + = ( observables_map_t1 . at ( observables_iter - > first ) . Carrier_phase_rads - observables_iter - > second . Carrier_phase_rads ) * time_factor ;
interp_observables_map . at ( observables_iter - > first ) . Carrier_Doppler_hz + = ( observables_map_t1 . at ( observables_iter - > first ) . Carrier_Doppler_hz - observables_iter - > second . Carrier_Doppler_hz ) * time_factor ;
}
}
catch ( const std : : out_of_range & oor )
{
2019-08-01 18:09:35 +00:00
// observable does not exist in t1
2019-07-31 16:16:09 +00:00
}
}
return interp_observables_map ;
}
2019-08-01 18:09:35 +00:00
2019-03-02 01:21:03 +00:00
int rtklib_pvt_gs : : work ( int noutput_items , gr_vector_const_void_star & input_items ,
2018-03-03 01:03:39 +00:00
gr_vector_void_star & output_items __attribute__ ( ( unused ) ) )
2017-04-20 14:10:12 +00:00
{
2018-08-11 21:03:41 +00:00
for ( int32_t epoch = 0 ; epoch < noutput_items ; epoch + + )
2017-04-20 14:10:12 +00:00
{
2017-05-14 17:59:55 +00:00
bool flag_display_pvt = false ;
bool flag_compute_pvt_output = false ;
bool flag_write_RTCM_1019_output = false ;
2017-08-17 04:40:05 +00:00
bool flag_write_RTCM_1020_output = false ;
2017-05-14 17:59:55 +00:00
bool flag_write_RTCM_1045_output = false ;
bool flag_write_RTCM_MSM_output = false ;
bool flag_write_RINEX_obs_output = false ;
gnss_observables_map . clear ( ) ;
2019-02-05 00:31:09 +00:00
const auto * * in = reinterpret_cast < const Gnss_Synchro * * > ( & input_items [ 0 ] ) ; // Get the input buffer pointer
2017-05-14 17:59:55 +00:00
// ############ 1. READ PSEUDORANGES ####
2018-08-11 21:03:41 +00:00
for ( uint32_t i = 0 ; i < d_nchannels ; i + + )
2017-04-20 14:10:12 +00:00
{
2018-03-08 17:32:55 +00:00
if ( in [ i ] [ epoch ] . Flag_valid_pseudorange )
2017-04-28 13:38:31 +00:00
{
2019-11-24 12:06:32 +00:00
auto tmp_eph_iter_gps = d_internal_pvt_solver - > gps_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) ;
auto tmp_eph_iter_gal = d_internal_pvt_solver - > galileo_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) ;
auto tmp_eph_iter_cnav = d_internal_pvt_solver - > gps_cnav_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) ;
auto tmp_eph_iter_glo_gnav = d_internal_pvt_solver - > glonass_gnav_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) ;
auto tmp_eph_iter_bds_dnav = d_internal_pvt_solver - > beidou_dnav_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) ;
2018-11-29 15:53:40 +00:00
2019-08-01 17:23:38 +00:00
bool store_valid_observable = false ;
2019-08-01 18:09:35 +00:00
if ( tmp_eph_iter_gps ! = d_internal_pvt_solver - > gps_ephemeris_map . cend ( ) )
2019-08-01 17:23:38 +00:00
{
uint32_t prn_aux = tmp_eph_iter_gps - > second . i_satellite_PRN ;
if ( ( prn_aux = = in [ i ] [ epoch ] . PRN ) and ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " 1C " ) )
{
store_valid_observable = true ;
}
}
2019-08-01 18:09:35 +00:00
if ( tmp_eph_iter_gal ! = d_internal_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2019-08-01 17:23:38 +00:00
{
uint32_t prn_aux = tmp_eph_iter_gal - > second . i_satellite_PRN ;
if ( ( prn_aux = = in [ i ] [ epoch ] . PRN ) and ( ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " 1B " ) or ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " 5X " ) ) )
{
store_valid_observable = true ;
}
}
2019-08-01 18:09:35 +00:00
if ( tmp_eph_iter_cnav ! = d_internal_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) )
2019-08-01 17:23:38 +00:00
{
uint32_t prn_aux = tmp_eph_iter_cnav - > second . i_satellite_PRN ;
if ( ( prn_aux = = in [ i ] [ epoch ] . PRN ) and ( ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " 2S " ) or ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " L5 " ) ) )
{
store_valid_observable = true ;
}
}
2019-08-01 18:09:35 +00:00
if ( tmp_eph_iter_glo_gnav ! = d_internal_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2019-08-01 17:23:38 +00:00
{
uint32_t prn_aux = tmp_eph_iter_glo_gnav - > second . i_satellite_PRN ;
if ( ( prn_aux = = in [ i ] [ epoch ] . PRN ) and ( ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " 1G " ) or ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " 2G " ) ) )
{
store_valid_observable = true ;
}
}
2019-08-01 18:09:35 +00:00
if ( tmp_eph_iter_bds_dnav ! = d_internal_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
2019-08-01 17:23:38 +00:00
{
uint32_t prn_aux = tmp_eph_iter_bds_dnav - > second . i_satellite_PRN ;
if ( ( prn_aux = = in [ i ] [ epoch ] . PRN ) and ( ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " B1 " ) or ( std : : string ( in [ i ] [ epoch ] . Signal ) = = " B3 " ) ) )
{
store_valid_observable = true ;
}
}
if ( store_valid_observable )
2017-05-12 15:58:04 +00:00
{
2017-05-14 17:59:55 +00:00
// store valid observables in a map.
2018-03-03 01:03:39 +00:00
gnss_observables_map . insert ( std : : pair < int , Gnss_Synchro > ( i , in [ i ] [ epoch ] ) ) ;
2017-04-20 14:10:12 +00:00
}
2019-08-01 17:23:38 +00:00
2018-11-03 09:50:19 +00:00
if ( b_rtcm_enabled )
2017-05-12 15:58:04 +00:00
{
2018-11-03 09:50:19 +00:00
try
2017-05-14 17:59:55 +00:00
{
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_ephemeris_map . empty ( ) = = false )
2018-03-13 10:16:30 +00:00
{
2019-08-01 16:11:36 +00:00
if ( tmp_eph_iter_gps ! = d_internal_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-11-03 09:50:19 +00:00
{
2019-08-01 16:11:36 +00:00
d_rtcm_printer - > lock_time ( d_internal_pvt_solver - > gps_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) - > second , in [ i ] [ epoch ] . RX_time , in [ i ] [ epoch ] ) ; // keep track of locking time
2018-11-03 09:50:19 +00:00
}
2018-03-13 10:16:30 +00:00
}
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > galileo_ephemeris_map . empty ( ) = = false )
2018-03-13 10:16:30 +00:00
{
2019-08-01 16:11:36 +00:00
if ( tmp_eph_iter_gal ! = d_internal_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-11-03 09:50:19 +00:00
{
2019-08-01 16:11:36 +00:00
d_rtcm_printer - > lock_time ( d_internal_pvt_solver - > galileo_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) - > second , in [ i ] [ epoch ] . RX_time , in [ i ] [ epoch ] ) ; // keep track of locking time
2018-11-03 09:50:19 +00:00
}
2018-03-13 10:16:30 +00:00
}
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > gps_cnav_ephemeris_map . empty ( ) = = false )
2018-03-13 10:16:30 +00:00
{
2019-08-01 16:11:36 +00:00
if ( tmp_eph_iter_cnav ! = d_internal_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) )
2018-11-03 09:50:19 +00:00
{
2019-08-01 16:11:36 +00:00
d_rtcm_printer - > lock_time ( d_internal_pvt_solver - > gps_cnav_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) - > second , in [ i ] [ epoch ] . RX_time , in [ i ] [ epoch ] ) ; // keep track of locking time
2018-11-03 09:50:19 +00:00
}
2018-03-13 10:16:30 +00:00
}
2019-08-01 16:11:36 +00:00
if ( d_internal_pvt_solver - > glonass_gnav_ephemeris_map . empty ( ) = = false )
2018-03-13 10:16:30 +00:00
{
2019-08-01 16:11:36 +00:00
if ( tmp_eph_iter_glo_gnav ! = d_internal_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-11-03 09:50:19 +00:00
{
2019-08-01 16:11:36 +00:00
d_rtcm_printer - > lock_time ( d_internal_pvt_solver - > glonass_gnav_ephemeris_map . find ( in [ i ] [ epoch ] . PRN ) - > second , in [ i ] [ epoch ] . RX_time , in [ i ] [ epoch ] ) ; // keep track of locking time
2018-11-03 09:50:19 +00:00
}
2018-03-13 10:16:30 +00:00
}
2017-07-18 03:09:10 +00:00
}
2018-11-03 09:50:19 +00:00
catch ( const boost : : exception & ex )
2018-08-09 18:36:11 +00:00
{
2018-11-03 09:50:19 +00:00
std : : cout < < " RTCM boost exception: " < < boost : : diagnostic_information ( ex ) < < std : : endl ;
LOG ( ERROR ) < < " RTCM boost exception: " < < boost : : diagnostic_information ( ex ) ;
}
catch ( const std : : exception & ex )
{
std : : cout < < " RTCM std exception: " < < ex . what ( ) < < std : : endl ;
LOG ( ERROR ) < < " RTCM std exception: " < < ex . what ( ) ;
2018-08-09 18:36:11 +00:00
}
2018-03-13 10:16:30 +00:00
}
2017-04-20 14:10:12 +00:00
}
2017-05-14 17:59:55 +00:00
}
2017-04-29 07:25:05 +00:00
2017-05-14 17:59:55 +00:00
// ############ 2 COMPUTE THE PVT ################################
2019-09-06 16:02:40 +00:00
bool flag_pvt_valid = false ;
2018-08-16 08:20:03 +00:00
if ( gnss_observables_map . empty ( ) = = false )
2017-05-14 17:59:55 +00:00
{
2019-08-01 18:09:35 +00:00
// LOG(INFO) << "diff raw obs time: " << gnss_observables_map.cbegin()->second.RX_time * 1000.0 - old_time_debug;
// old_time_debug = gnss_observables_map.cbegin()->second.RX_time * 1000.0;
2019-08-01 16:11:36 +00:00
uint32_t current_RX_time_ms = 0 ;
// #### solve PVT and store the corrected observable set
if ( d_internal_pvt_solver - > get_PVT ( gnss_observables_map , false ) )
2017-04-20 14:10:12 +00:00
{
2019-08-01 16:11:36 +00:00
double Rx_clock_offset_s = d_internal_pvt_solver - > get_time_offset_s ( ) ;
if ( fabs ( Rx_clock_offset_s ) * 1000.0 > max_obs_block_rx_clock_offset_ms )
2019-07-31 16:16:09 +00:00
{
2019-08-01 16:11:36 +00:00
if ( ! d_waiting_obs_block_rx_clock_offset_correction_msg )
2019-07-31 16:16:09 +00:00
{
this - > message_port_pub ( pmt : : mp ( " pvt_to_observables " ) , pmt : : make_any ( Rx_clock_offset_s ) ) ;
2019-08-01 16:11:36 +00:00
d_waiting_obs_block_rx_clock_offset_correction_msg = true ;
2019-07-31 16:16:09 +00:00
LOG ( INFO ) < < " Sent clock offset correction to observables: " < < Rx_clock_offset_s < < " [s] " ;
}
2019-08-01 16:11:36 +00:00
}
else
{
2019-09-06 16:02:40 +00:00
if ( d_enable_rx_clock_correction = = true )
2019-07-31 16:16:09 +00:00
{
2019-09-06 16:02:40 +00:00
d_waiting_obs_block_rx_clock_offset_correction_msg = false ;
gnss_observables_map_t0 = gnss_observables_map_t1 ;
apply_rx_clock_offset ( gnss_observables_map , Rx_clock_offset_s ) ;
gnss_observables_map_t1 = gnss_observables_map ;
2019-08-01 16:11:36 +00:00
2019-09-06 16:02:40 +00:00
// ### select the rx_time and interpolate observables at that time
if ( ! gnss_observables_map_t0 . empty ( ) )
2019-07-31 16:16:09 +00:00
{
2019-09-06 16:02:40 +00:00
uint32_t t0_int_ms = static_cast < uint32_t > ( gnss_observables_map_t0 . cbegin ( ) - > second . RX_time * 1000.0 ) ;
uint32_t adjust_next_20ms = 20 - t0_int_ms % 20 ;
current_RX_time_ms = t0_int_ms + adjust_next_20ms ;
if ( current_RX_time_ms % d_output_rate_ms = = 0 )
{
d_rx_time = static_cast < double > ( current_RX_time_ms ) / 1000.0 ;
// std::cout << " obs time t0: " << gnss_observables_map_t0.cbegin()->second.RX_time
// << " t1: " << gnss_observables_map_t1.cbegin()->second.RX_time
// << " interp time: " << d_rx_time << std::endl;
gnss_observables_map = interpolate_observables ( gnss_observables_map_t0 ,
gnss_observables_map_t1 ,
d_rx_time ) ;
flag_compute_pvt_output = true ;
// d_rx_time = current_RX_time;
// std::cout.precision(17);
// std::cout << "current_RX_time: " << current_RX_time << " map time: " << gnss_observables_map.begin()->second.RX_time << std::endl;
}
2019-07-31 16:16:09 +00:00
}
}
2019-09-06 16:02:40 +00:00
else
{
2019-09-06 16:19:40 +00:00
d_rx_time = gnss_observables_map . begin ( ) - > second . RX_time ;
current_RX_time_ms = static_cast < uint32_t > ( d_rx_time * 1000.0 ) ;
if ( current_RX_time_ms % d_output_rate_ms = = 0 )
{
flag_compute_pvt_output = true ;
// std::cout.precision(17);
// std::cout << "current_RX_time: " << current_RX_time << " map time: " << gnss_observables_map.begin()->second.RX_time << std::endl;
}
2019-09-06 16:02:40 +00:00
flag_pvt_valid = true ;
}
2019-07-31 16:16:09 +00:00
}
2017-05-12 15:58:04 +00:00
}
2019-08-01 18:09:35 +00:00
// debug code
2019-08-17 13:47:20 +00:00
// else
// {
// DLOG(INFO) << "Internal PVT solver error";
// }
2017-05-14 17:59:55 +00:00
// compute on the fly PVT solution
if ( flag_compute_pvt_output = = true )
2017-05-12 15:58:04 +00:00
{
2019-09-06 16:02:40 +00:00
flag_pvt_valid = d_user_pvt_solver - > get_PVT ( gnss_observables_map , false ) ;
}
if ( flag_pvt_valid = = true )
{
double Rx_clock_offset_s = d_user_pvt_solver - > get_time_offset_s ( ) ;
if ( d_enable_rx_clock_correction = = true and fabs ( Rx_clock_offset_s ) > 0.000001 ) // 1us !!
{
LOG ( INFO ) < < " Warning: Rx clock offset at interpolated RX time: " < < Rx_clock_offset_s * 1000.0 < < " [ms] "
< < " at RX time: " < < static_cast < uint32_t > ( d_rx_time * 1000.0 ) < < " [ms] " ;
}
else
2017-05-12 15:58:04 +00:00
{
2019-09-06 16:02:40 +00:00
DLOG ( INFO ) < < " Rx clock offset at interpolated RX time: " < < Rx_clock_offset_s * 1000.0 < < " [s] "
< < " at RX time: " < < static_cast < uint32_t > ( d_rx_time * 1000.0 ) < < " [ms] " ;
// Optional debug code: export observables snapshot for rtklib unit testing
// std::cout << "step 1: save gnss_synchro map" << std::endl;
// save_gnss_synchro_map_xml("./gnss_synchro_map.xml");
// getchar(); // stop the execution
// end debug
if ( d_display_rate_ms ! = 0 )
2019-04-23 15:31:26 +00:00
{
2019-09-06 16:02:40 +00:00
if ( current_RX_time_ms % d_display_rate_ms = = 0 )
{
flag_display_pvt = true ;
}
2019-04-23 15:31:26 +00:00
}
2019-09-06 16:02:40 +00:00
if ( d_rtcm_MT1019_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
2017-04-20 14:10:12 +00:00
{
2019-09-06 16:02:40 +00:00
if ( current_RX_time_ms % d_rtcm_MT1019_rate_ms = = 0 )
2018-11-08 09:02:52 +00:00
{
2019-09-06 16:02:40 +00:00
flag_write_RTCM_1019_output = true ;
2018-11-08 09:02:52 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MT1020_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
if ( current_RX_time_ms % d_rtcm_MT1020_rate_ms = = 0 )
2018-11-03 09:50:19 +00:00
{
2019-09-06 16:02:40 +00:00
flag_write_RTCM_1020_output = true ;
2018-11-03 09:50:19 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MT1045_rate_ms ! = 0 )
{
if ( current_RX_time_ms % d_rtcm_MT1045_rate_ms = = 0 )
2018-11-03 09:50:19 +00:00
{
2019-09-06 16:02:40 +00:00
flag_write_RTCM_1045_output = true ;
2018-11-03 09:50:19 +00:00
}
2019-09-06 16:02:40 +00:00
}
// TODO: RTCM 1077, 1087 and 1097 are not used, so, disable the output rates
// if (current_RX_time_ms % d_rtcm_MT1077_rate_ms==0 and d_rtcm_MT1077_rate_ms != 0)
// {
// last_RTCM_1077_output_time = current_RX_time;
// }
// if (current_RX_time_ms % d_rtcm_MT1087_rate_ms==0 and d_rtcm_MT1087_rate_ms != 0)
// {
// last_RTCM_1087_output_time = current_RX_time;
// }
// if (current_RX_time_ms % d_rtcm_MT1097_rate_ms==0 and d_rtcm_MT1097_rate_ms != 0)
// {
// last_RTCM_1097_output_time = current_RX_time;
// }
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
if ( current_RX_time_ms % d_rtcm_MSM_rate_ms = = 0 )
2018-11-03 09:50:19 +00:00
{
2019-09-06 16:02:40 +00:00
flag_write_RTCM_MSM_output = true ;
2018-11-03 09:50:19 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rinexobs_rate_ms ! = 0 )
{
if ( current_RX_time_ms % static_cast < uint32_t > ( d_rinexobs_rate_ms ) = = 0 )
2018-11-03 09:50:19 +00:00
{
2019-09-06 16:02:40 +00:00
flag_write_RINEX_obs_output = true ;
2018-11-03 09:50:19 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( first_fix = = true )
{
if ( d_show_local_time_zone )
2018-11-03 09:50:19 +00:00
{
2019-09-06 16:02:40 +00:00
boost : : posix_time : : ptime time_first_solution = d_user_pvt_solver - > get_position_UTC_time ( ) + d_utc_diff_time ;
std : : cout < < " First position fix at " < < time_first_solution < < d_local_time_str ;
2018-11-03 09:50:19 +00:00
}
2019-09-06 16:02:40 +00:00
else
2019-04-23 15:31:26 +00:00
{
2019-09-06 16:02:40 +00:00
std : : cout < < " First position fix at " < < d_user_pvt_solver - > get_position_UTC_time ( ) < < " UTC " ;
2019-04-23 15:31:26 +00:00
}
2019-09-06 16:02:40 +00:00
std : : cout < < " is Lat = " < < d_user_pvt_solver - > get_latitude ( ) < < " [deg], Long = " < < d_user_pvt_solver - > get_longitude ( )
< < " [deg], Height= " < < d_user_pvt_solver - > get_height ( ) < < " [m] " < < std : : endl ;
ttff_msgbuf ttff ;
ttff . mtype = 1 ;
end = std : : chrono : : system_clock : : now ( ) ;
std : : chrono : : duration < double > elapsed_seconds = end - start ;
ttff . ttff = elapsed_seconds . count ( ) ;
send_sys_v_ttff_msg ( ttff ) ;
first_fix = false ;
}
if ( d_kml_output_enabled )
{
if ( current_RX_time_ms % d_kml_rate_ms = = 0 )
2019-03-15 12:31:18 +00:00
{
2019-09-06 16:02:40 +00:00
d_kml_dump - > print_position ( d_user_pvt_solver , false ) ;
2019-03-15 12:31:18 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_gpx_output_enabled )
{
if ( current_RX_time_ms % d_gpx_rate_ms = = 0 )
2019-03-15 12:31:18 +00:00
{
2019-09-06 16:02:40 +00:00
d_gpx_dump - > print_position ( d_user_pvt_solver , false ) ;
2019-04-23 15:31:26 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_geojson_output_enabled )
{
if ( current_RX_time_ms % d_geojson_rate_ms = = 0 )
2019-04-23 15:31:26 +00:00
{
2019-09-06 16:02:40 +00:00
d_geojson_printer - > print_position ( d_user_pvt_solver , false ) ;
2019-04-23 15:31:26 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_nmea_output_file_enabled )
{
if ( current_RX_time_ms % d_nmea_rate_ms = = 0 )
2019-04-23 15:31:26 +00:00
{
2019-09-06 16:02:40 +00:00
d_nmea_printer - > Print_Nmea_Line ( d_user_pvt_solver , false ) ;
2019-03-15 12:31:18 +00:00
}
2019-09-06 16:02:40 +00:00
}
2017-05-14 17:59:55 +00:00
2019-09-06 16:02:40 +00:00
/*
2019-09-06 16:39:03 +00:00
* TYPE | RECEIVER
* 0 | Unknown
* 1 | GPS L1 C / A
* 2 | GPS L2C
* 3 | GPS L5
* 4 | Galileo E1B
* 5 | Galileo E5a
* 6 | Galileo E5b
* 7 | GPS L1 C / A + GPS L2C
* 8 | GPS L1 C / A + GPS L5
* 9 | GPS L1 C / A + Galileo E1B
* 10 | GPS L1 C / A + Galileo E5a
* 11 | GPS L1 C / A + Galileo E5b
* 12 | Galileo E1B + GPS L2C
* 13 | Galileo E5a + GPS L5
* 14 | Galileo E1B + Galileo E5a
* 15 | Galileo E1B + Galileo E5b
* 16 | GPS L2C + GPS L5
* 17 | GPS L2C + Galileo E5a
* 18 | GPS L2C + Galileo E5b
* 21 | GPS L1 C / A + Galileo E1B + GPS L2C
* 22 | GPS L1 C / A + Galileo E1B + GPS L5
* 23 | GLONASS L1 C / A
* 24 | GLONASS L2 C / A
* 25 | GLONASS L1 C / A + GLONASS L2 C / A
* 26 | GPS L1 C / A + GLONASS L1 C / A
* 27 | Galileo E1B + GLONASS L1 C / A
* 28 | GPS L2C + GLONASS L1 C / A
* 29 | GPS L1 C / A + GLONASS L2 C / A
* 30 | Galileo E1B + GLONASS L2 C / A
* 31 | GPS L2C + GLONASS L2 C / A
* 32 | GPS L1 C / A + Galileo E1B + GPS L5 + Galileo E5a
* 500 | BeiDou B1I
* 501 | BeiDou B1I + GPS L1 C / A
* 502 | BeiDou B1I + Galileo E1B
* 503 | BeiDou B1I + GLONASS L1 C / A
* 504 | BeiDou B1I + GPS L1 C / A + Galileo E1B
* 505 | BeiDou B1I + GPS L1 C / A + GLONASS L1 C / A + Galileo E1B
* 506 | BeiDou B1I + Beidou B3I
* 600 | BeiDou B3I
* 601 | BeiDou B3I + GPS L2C
* 602 | BeiDou B3I + GLONASS L2 C / A
* 603 | BeiDou B3I + GPS L2C + GLONASS L2 C / A
* 604 | BeiDou B3I + GPS L1 C / A
* 605 | BeiDou B3I + Galileo E1B
* 606 | BeiDou B3I + GLONASS L1 C / A
* 607 | BeiDou B3I + GPS L1 C / A + Galileo E1B
* 608 | BeiDou B3I + GPS L1 C / A + Galileo E1B + BeiDou B1I
* 609 | BeiDou B3I + GPS L1 C / A + Galileo E1B + GLONASS L1 C / A
* 610 | BeiDou B3I + GPS L1 C / A + Galileo E1B + GLONASS L1 C / A + BeiDou B1I
2019-09-13 14:30:00 +00:00
* 1000 | GPS L1 C / A + GPS L2C + GPS L5
* 1001 | GPS L1 C / A + Galileo E1B + GPS L2C + GPS L5 + Galileo E5a
2019-09-06 16:39:03 +00:00
*/
2017-05-14 17:59:55 +00:00
2019-09-06 16:02:40 +00:00
// ####################### RINEX FILES #################
if ( b_rinex_output_enabled )
{
std : : map < int , Galileo_Ephemeris > : : const_iterator galileo_ephemeris_iter ;
std : : map < int , Gps_Ephemeris > : : const_iterator gps_ephemeris_iter ;
std : : map < int , Gps_CNAV_Ephemeris > : : const_iterator gps_cnav_ephemeris_iter ;
std : : map < int , Glonass_Gnav_Ephemeris > : : const_iterator glonass_gnav_ephemeris_iter ;
std : : map < int , Beidou_Dnav_Ephemeris > : : const_iterator beidou_dnav_ephemeris_iter ;
2019-11-02 11:23:28 +00:00
if ( ! b_rinex_header_written ) // & we have utc data in nav message!
2019-09-06 16:02:40 +00:00
{
galileo_ephemeris_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
gps_ephemeris_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
gps_cnav_ephemeris_iter = d_user_pvt_solver - > gps_cnav_ephemeris_map . cbegin ( ) ;
glonass_gnav_ephemeris_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
beidou_dnav_ephemeris_iter = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cbegin ( ) ;
switch ( type_of_rx )
{
case 1 : // GPS L1 C/A only
if ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
{
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , d_rx_time ) ;
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second ) ;
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > gps_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 2 : // GPS L2C only
if ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) )
{
std : : string signal ( " 2S " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > gps_cnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 3 : // GPS L5 only
if ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) )
{
std : : string signal ( " L5 " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > gps_cnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 4 : // Galileo E1B only
if ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
{
rp - > rinex_obs_header ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time ) ;
rp - > rinex_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
2019-09-13 16:40:41 +00:00
rp - > log_rinex_nav ( rp - > navGalFile , d_user_pvt_solver - > galileo_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 5 : // Galileo E5a only
if ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
{
std : : string signal ( " 5X " ) ;
rp - > rinex_obs_header ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
2019-09-13 16:40:41 +00:00
rp - > log_rinex_nav ( rp - > navGalFile , d_user_pvt_solver - > galileo_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 6 : // Galileo E5b only
if ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
{
std : : string signal ( " 7X " ) ;
rp - > rinex_obs_header ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > log_rinex_nav ( rp - > navGalFile , d_user_pvt_solver - > galileo_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 7 : // GPS L1 C/A + GPS L2C
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
std : : string signal ( " 1C 2S " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second ) ;
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > gps_cnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 8 : // GPS L1 + GPS L5
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
std : : string signal ( " 1C L5 " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second ) ;
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > gps_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 9 : // GPS L1 C/A + Galileo E1B
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) and ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 1B " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
2019-09-14 08:40:29 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_ephemeris_map , d_user_pvt_solver - > galileo_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-11-02 11:23:28 +00:00
case 10 : // GPS L1 C/A + Galileo E5a
2019-09-06 16:02:40 +00:00
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) and ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 5X " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
2019-09-14 08:40:29 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_ephemeris_map , d_user_pvt_solver - > galileo_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-11-02 11:23:28 +00:00
case 11 : // GPS L1 C/A + Galileo E5b
2019-09-06 16:02:40 +00:00
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) and ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 7X " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_ephemeris_map , d_user_pvt_solver - > galileo_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 13 : // L5+E5a
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 5X " ) ;
std : : string gps_signal ( " L5 " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gps_signal , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
2019-09-14 17:25:33 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_ephemeris_map , d_user_pvt_solver - > galileo_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-11-02 11:23:28 +00:00
case 14 : // Galileo E1B + Galileo E5a
2019-09-06 16:02:40 +00:00
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 1B 5X " ) ;
rp - > rinex_obs_header ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
2019-09-13 16:40:41 +00:00
rp - > log_rinex_nav ( rp - > navGalFile , d_user_pvt_solver - > galileo_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-11-02 11:23:28 +00:00
case 15 : // Galileo E1B + Galileo E5b
2019-09-06 16:02:40 +00:00
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 1B 7X " ) ;
rp - > rinex_obs_header ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > log_rinex_nav ( rp - > navGalFile , d_user_pvt_solver - > galileo_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 23 : // GLONASS L1 C/A only
if ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
{
std : : string signal ( " 1G " ) ;
rp - > rinex_obs_header ( rp - > obsFile , glonass_gnav_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_utc_model , glonass_gnav_ephemeris_iter - > second ) ;
2019-09-14 08:40:29 +00:00
rp - > log_rinex_nav ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 24 : // GLONASS L2 C/A only
if ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
{
std : : string signal ( " 2G " ) ;
rp - > rinex_obs_header ( rp - > obsFile , glonass_gnav_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_utc_model , glonass_gnav_ephemeris_iter - > second ) ;
2019-09-14 08:40:29 +00:00
rp - > log_rinex_nav ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 25 : // GLONASS L1 C/A + GLONASS L2 C/A
if ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
{
std : : string signal ( " 1G 2G " ) ;
rp - > rinex_obs_header ( rp - > obsFile , glonass_gnav_ephemeris_iter - > second , d_rx_time , signal ) ;
rp - > rinex_nav_header ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_utc_model , glonass_gnav_ephemeris_iter - > second ) ;
rp - > log_rinex_nav ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 26 : // GPS L1 C/A + GLONASS L1 C/A
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) )
{
std : : string glo_signal ( " 1G " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , glo_signal ) ;
if ( d_rinex_version = = 3 )
{
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_ephemeris_map , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
}
if ( d_rinex_version = = 2 )
{
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second ) ;
rp - > rinex_nav_header ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_utc_model , glonass_gnav_ephemeris_iter - > second ) ;
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > gps_ephemeris_map ) ;
rp - > log_rinex_nav ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
}
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-11-02 11:23:28 +00:00
case 27 : // Galileo E1B + GLONASS L1 C/A
2019-09-06 16:02:40 +00:00
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
{
std : : string glo_signal ( " 1G " ) ;
std : : string gal_signal ( " 1B " ) ;
rp - > rinex_obs_header ( rp - > obsFile , galileo_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , glo_signal , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > galileo_ephemeris_map , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 28 : // GPS L2C + GLONASS L1 C/A
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
std : : string glo_signal ( " 1G " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , glo_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_ephemeris_map , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 29 : // GPS L1 C/A + GLONASS L2 C/A
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) )
{
std : : string glo_signal ( " 2G " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , glo_signal ) ;
if ( d_rinex_version = = 3 )
{
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_ephemeris_map , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
}
if ( d_rinex_version = = 2 )
{
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second ) ;
rp - > rinex_nav_header ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_utc_model , glonass_gnav_ephemeris_iter - > second ) ;
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > gps_ephemeris_map ) ;
rp - > log_rinex_nav ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
}
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-11-02 11:23:28 +00:00
case 30 : // Galileo E1B + GLONASS L2 C/A
2019-09-06 16:02:40 +00:00
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
{
std : : string glo_signal ( " 2G " ) ;
std : : string gal_signal ( " 1B " ) ;
rp - > rinex_obs_header ( rp - > obsFile , galileo_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , glo_signal , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > galileo_ephemeris_map , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 31 : // GPS L2C + GLONASS L2 C/A
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
std : : string glo_signal ( " 2G " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , glo_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_ephemeris_map , d_user_pvt_solver - > glonass_gnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 32 : // L1+E1+L5+E5a
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and
( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) and
( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 1B 5X " ) ;
std : : string gps_signal ( " 1C L5 " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gps_signal , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_ephemeris_map , d_user_pvt_solver - > galileo_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 33 : // L1+E1+E5a
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and
( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 1B 5X " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_ephemeris_map , d_user_pvt_solver - > galileo_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 500 : // BDS B1I only
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
rp - > rinex_obs_header ( rp - > obsFile , beidou_dnav_ephemeris_iter - > second , d_rx_time , " B1 " ) ;
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > beidou_dnav_iono , d_user_pvt_solver - > beidou_dnav_utc_model ) ;
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > beidou_dnav_ephemeris_map ) ;
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 501 : // BeiDou B1I + GPS L1 C/A
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) ) )
{
std : : string bds_signal ( " B1 " ) ;
// rp->rinex_obs_header(rp->obsFile, gps_ephemeris_iter->second, beidou_dnav_ephemeris_iter->second, d_rx_time, bds_signal);
// rp->rinex_nav_header(rp->navMixFile, d_user_pvt_solver->gps_iono, d_user_pvt_solver->gps_utc_model, gps_ephemeris_iter->second, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 502 : // BeiDou B1I + Galileo E1B
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) and ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) ) )
{
std : : string bds_signal ( " B1 " ) ;
std : : string gal_signal ( " 1B " ) ;
// rp->rinex_obs_header(rp->obsFile, galileo_ephemeris_iter->second, beidou_dnav_ephemeris_iter->second, d_rx_time, gal_signal, bds_signal);
// rp->rinex_nav_header(rp->navMixFile, d_user_pvt_solver->galileo_iono, d_user_pvt_solver->galileo_utc_model, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 503 : // BeiDou B1I + GLONASS L1 C/A
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
// rp->rinex_obs_header(rp->obsFile, beidou_dnav_ephemeris_iter->second, d_rx_time, "B1");
// rp->rinex_nav_header(rp->navFile, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
// rp->log_rinex_nav(rp->navFile, d_user_pvt_solver->beidou_dnav_ephemeris_map);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 504 : // BeiDou B1I + GPS L1 C/A + Galileo E1B
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
// rp->rinex_obs_header(rp->obsFile, beidou_dnav_ephemeris_iter->second, d_rx_time, "B1");
// rp->rinex_nav_header(rp->navFile, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
// rp->log_rinex_nav(rp->navFile, d_user_pvt_solver->beidou_dnav_ephemeris_map);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 505 : // BeiDou B1I + GPS L1 C/A + GLONASS L1 C/A + Galileo E1B
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
// rp->rinex_obs_header(rp->obsFile, beidou_dnav_ephemeris_iter->second, d_rx_time, "B1");
// rp->rinex_nav_header(rp->navFile, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
// rp->log_rinex_nav(rp->navFile, d_user_pvt_solver->beidou_dnav_ephemeris_map);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 506 : // BeiDou B1I + Beidou B3I
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
// rp->rinex_obs_header(rp->obsFile, beidou_dnav_ephemeris_iter->second, d_rx_time, "B1");
// rp->rinex_nav_header(rp->navFile, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
// rp->log_rinex_nav(rp->navFile, d_user_pvt_solver->beidou_dnav_ephemeris_map);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 600 : // BDS B3I only
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
rp - > rinex_obs_header ( rp - > obsFile , beidou_dnav_ephemeris_iter - > second , d_rx_time , " B3 " ) ;
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > beidou_dnav_iono , d_user_pvt_solver - > beidou_dnav_utc_model ) ;
2019-09-15 16:10:05 +00:00
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > beidou_dnav_ephemeris_map ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 601 : // BeiDou B3I + GPS L2C
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
rp - > rinex_obs_header ( rp - > obsFile , beidou_dnav_ephemeris_iter - > second , d_rx_time , " B3 " ) ;
// rp->rinex_nav_header(rp->navFile, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 602 : // BeiDou B3I + GLONASS L2 C/A
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
rp - > rinex_obs_header ( rp - > obsFile , beidou_dnav_ephemeris_iter - > second , d_rx_time , " B3 " ) ;
// rp->rinex_nav_header(rp->navFile, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
case 603 : // BeiDou B3I + GPS L2C + GLONASS L2 C/A
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
rp - > rinex_obs_header ( rp - > obsFile , beidou_dnav_ephemeris_iter - > second , d_rx_time , " B3 " ) ;
// rp->rinex_nav_header(rp->navFile, d_user_pvt_solver->beidou_dnav_iono, d_user_pvt_solver->beidou_dnav_utc_model);
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-09-13 15:49:22 +00:00
case 1000 : // GPS L1 C/A + GPS L2C + GPS L5
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and
( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
std : : string gps_signal ( " 1C 2S L5 " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , d_rx_time , gps_signal ) ;
rp - > rinex_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second ) ;
2019-09-13 16:40:41 +00:00
rp - > log_rinex_nav ( rp - > navFile , d_user_pvt_solver - > gps_ephemeris_map ) ;
2019-09-13 15:49:22 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-09-13 14:30:00 +00:00
case 1001 : // GPS L1 C/A + Galileo E1B + GPS L2C + GPS L5 + Galileo E5a
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) and
( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and
( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
std : : string gal_signal ( " 1B 5X " ) ;
std : : string gps_signal ( " 1C 2S L5 " ) ;
rp - > rinex_obs_header ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gps_signal , gal_signal ) ;
rp - > rinex_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
2019-09-13 16:40:41 +00:00
rp - > log_rinex_nav ( rp - > navMixFile , d_user_pvt_solver - > gps_ephemeris_map , d_user_pvt_solver - > galileo_ephemeris_map ) ;
2019-09-13 14:30:00 +00:00
b_rinex_header_written = true ; // do not write header anymore
}
break ;
2019-09-06 16:02:40 +00:00
default :
break ;
}
}
if ( b_rinex_header_written ) // The header is already written, we can now log the navigation message data
2017-07-18 03:09:10 +00:00
{
2019-09-06 16:02:40 +00:00
galileo_ephemeris_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
gps_ephemeris_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
gps_cnav_ephemeris_iter = d_user_pvt_solver - > gps_cnav_ephemeris_map . cbegin ( ) ;
glonass_gnav_ephemeris_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
beidou_dnav_ephemeris_iter = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cbegin ( ) ;
// Log observables into the RINEX file
if ( flag_write_RINEX_obs_output )
2017-05-14 17:59:55 +00:00
{
2018-11-07 22:53:16 +00:00
switch ( type_of_rx )
2017-05-14 17:59:55 +00:00
{
2018-11-07 22:53:16 +00:00
case 1 : // GPS L1 C/A only
2019-08-01 16:11:36 +00:00
if ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_utc_model , d_user_pvt_solver - > gps_iono , gps_ephemeris_iter - > second ) ;
b_rinex_header_updated = true ;
}
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 2 : // GPS L2C only
2019-08-01 16:11:36 +00:00
if ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > gps_cnav_iono ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
2019-09-06 16:02:40 +00:00
case 3 : // GPS L5
2019-08-01 16:11:36 +00:00
if ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > gps_cnav_iono ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 4 : // Galileo E1B only
2019-08-01 16:11:36 +00:00
if ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " 1B " ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
{
rp - > update_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 5 : // Galileo E5a only
2019-08-01 16:11:36 +00:00
if ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " 5X " ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
{
rp - > update_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 6 : // Galileo E5b only
2019-08-01 16:11:36 +00:00
if ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " 7X " ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
{
rp - > update_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 7 : // GPS L1 C/A + GPS L2C
2019-08-01 16:11:36 +00:00
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_utc_model , d_user_pvt_solver - > gps_iono , gps_ephemeris_iter - > second ) ;
b_rinex_header_updated = true ;
}
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
2019-09-06 16:02:40 +00:00
case 8 : // L1+L5
2019-08-01 16:11:36 +00:00
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
2018-11-01 16:50:06 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
if ( ! b_rinex_header_updated and ( ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 ) or ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) ) )
{
if ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > gps_cnav_iono ) ;
}
else
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_utc_model , d_user_pvt_solver - > gps_iono , gps_ephemeris_iter - > second ) ;
}
b_rinex_header_updated = true ;
}
2018-11-01 16:50:06 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 9 : // GPS L1 C/A + Galileo E1B
2019-08-01 16:11:36 +00:00
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) and ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ;
}
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
2019-09-06 16:02:40 +00:00
case 13 : // L5+E5a
if ( ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) and ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
2018-11-01 16:50:06 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
2018-11-01 16:50:06 +00:00
}
2019-09-06 16:02:40 +00:00
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 ) and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ; // do not write header anymore
2018-10-27 22:42:28 +00:00
}
2019-04-23 15:31:26 +00:00
break ;
2019-09-06 16:02:40 +00:00
case 14 : // Galileo E1B + Galileo E5a
if ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " 1B 5X " ) ;
2018-10-27 22:42:28 +00:00
}
2019-09-06 16:02:40 +00:00
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > update_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2019-04-23 15:31:26 +00:00
break ;
2019-09-06 16:02:40 +00:00
case 15 : // Galileo E1B + Galileo E5b
if ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
{
rp - > log_rinex_obs ( rp - > obsFile , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " 1B 7X " ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > update_nav_header ( rp - > navGalFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 23 : // GLONASS L1 C/A only
2019-08-01 16:11:36 +00:00
if ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " 1C " ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > glonass_gnav_utc_model . d_tau_c ! = 0 ) )
{
rp - > update_nav_header ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 24 : // GLONASS L2 C/A only
2019-08-01 16:11:36 +00:00
if ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " 2C " ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > glonass_gnav_utc_model . d_tau_c ! = 0 ) )
{
rp - > update_nav_header ( rp - > navGloFile , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 25 : // GLONASS L1 C/A + GLONASS L2 C/A
2019-08-01 16:11:36 +00:00
if ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " 1C 2C " ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > glonass_gnav_utc_model . d_tau_c ! = 0 ) )
{
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
b_rinex_header_updated = true ;
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 26 : // GPS L1 C/A + GLONASS L1 C/A
2019-08-01 16:11:36 +00:00
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) )
2019-04-23 15:31:26 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
b_rinex_header_updated = true ; // do not write header anymore
2019-04-23 15:31:26 +00:00
}
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
2019-09-06 16:02:40 +00:00
case 27 : // Galileo E1B + GLONASS L1 C/A
2019-08-01 16:11:36 +00:00
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , galileo_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
b_rinex_header_updated = true ; // do not write header anymore
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 28 : // GPS L2C + GLONASS L1 C/A
2019-08-01 16:11:36 +00:00
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
b_rinex_header_updated = true ; // do not write header anymore
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 29 : // GPS L1 C/A + GLONASS L2 C/A
2019-08-01 16:11:36 +00:00
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) )
2019-04-23 15:31:26 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
b_rinex_header_updated = true ; // do not write header anymore
2019-04-23 15:31:26 +00:00
}
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
2019-09-06 16:02:40 +00:00
case 30 : // Galileo E1B + GLONASS L2 C/A
2019-08-01 16:11:36 +00:00
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , galileo_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > galileo_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
b_rinex_header_updated = true ; // do not write header anymore
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
case 31 : // GPS L2C + GLONASS L2 C/A
2019-08-01 16:11:36 +00:00
if ( ( glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_cnav_ephemeris_iter - > second , glonass_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > glonass_gnav_utc_model , d_user_pvt_solver - > glonass_gnav_almanac ) ;
b_rinex_header_updated = true ; // do not write header anymore
2018-10-27 22:42:28 +00:00
}
2019-04-23 15:31:26 +00:00
break ;
case 32 : // L1+E1+L5+E5a
2019-09-06 16:02:40 +00:00
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) and ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
2018-10-27 22:42:28 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
if ( ! b_rinex_header_updated and ( ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 ) or ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) ) and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
{
if ( d_user_pvt_solver - > gps_cnav_utc_model . d_A0 ! = 0 )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_cnav_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_cnav_utc_model , d_user_pvt_solver - > gps_cnav_iono , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
}
else
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
}
b_rinex_header_updated = true ; // do not write header anymore
}
2018-10-27 22:42:28 +00:00
}
2018-11-07 22:53:16 +00:00
break ;
2019-04-23 15:31:26 +00:00
case 33 : // L1+E1+E5a
2019-09-06 16:02:40 +00:00
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) )
2018-11-01 16:50:06 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map ) ;
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ; // do not write header anymore
}
2018-11-01 16:50:06 +00:00
}
2019-04-23 15:31:26 +00:00
break ;
2019-06-28 16:25:39 +00:00
case 500 : // BDS B1I only
2019-08-01 16:11:36 +00:00
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
2018-11-01 16:50:06 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > log_rinex_obs ( rp - > obsFile , beidou_dnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " B1 " ) ;
2018-11-13 11:51:14 +00:00
}
2019-09-06 16:02:40 +00:00
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > beidou_dnav_utc_model . d_A0_UTC ! = 0 ) )
2019-06-28 16:25:39 +00:00
{
2019-09-06 16:02:40 +00:00
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > beidou_dnav_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > beidou_dnav_utc_model , d_user_pvt_solver - > beidou_dnav_iono ) ;
2019-09-15 16:10:05 +00:00
b_rinex_header_updated = true ;
}
break ;
case 600 : // BDS B3I only
if ( beidou_dnav_ephemeris_iter ! = d_user_pvt_solver - > beidou_dnav_ephemeris_map . cend ( ) )
{
rp - > log_rinex_obs ( rp - > obsFile , beidou_dnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map , " B3 " ) ;
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > beidou_dnav_utc_model . d_A0_UTC ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > beidou_dnav_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > beidou_dnav_utc_model , d_user_pvt_solver - > beidou_dnav_iono ) ;
2019-09-06 16:02:40 +00:00
b_rinex_header_updated = true ;
2019-06-28 16:25:39 +00:00
}
2018-11-29 15:53:40 +00:00
break ;
2019-09-13 15:49:22 +00:00
case 1000 : // GPS L1 C/A + GPS L2C + GPS L5
if ( ( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and
( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
2019-09-17 14:43:08 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map , true ) ;
2019-09-13 15:49:22 +00:00
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navFile , d_user_pvt_solver - > gps_utc_model , d_user_pvt_solver - > gps_iono , gps_ephemeris_iter - > second ) ;
b_rinex_header_updated = true ;
}
break ;
2019-09-13 14:30:00 +00:00
case 1001 : // GPS L1 C/A + Galileo E1B + GPS L2C + GPS L5 + Galileo E5a
if ( ( galileo_ephemeris_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) ) and
( gps_ephemeris_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and
( gps_cnav_ephemeris_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
{
2019-09-17 14:43:08 +00:00
rp - > log_rinex_obs ( rp - > obsFile , gps_ephemeris_iter - > second , gps_cnav_ephemeris_iter - > second , galileo_ephemeris_iter - > second , d_rx_time , gnss_observables_map , true ) ;
2019-09-13 14:30:00 +00:00
}
if ( ! b_rinex_header_updated and ( d_user_pvt_solver - > gps_utc_model . d_A0 ! = 0 ) and ( d_user_pvt_solver - > galileo_utc_model . A0_6 ! = 0 ) )
{
rp - > update_obs_header ( rp - > obsFile , d_user_pvt_solver - > gps_utc_model ) ;
rp - > update_nav_header ( rp - > navMixFile , d_user_pvt_solver - > gps_iono , d_user_pvt_solver - > gps_utc_model , gps_ephemeris_iter - > second , d_user_pvt_solver - > galileo_iono , d_user_pvt_solver - > galileo_utc_model ) ;
b_rinex_header_updated = true ;
}
break ;
2018-11-13 11:51:14 +00:00
default :
break ;
2018-08-09 18:36:11 +00:00
}
}
2017-05-14 17:59:55 +00:00
}
2019-09-06 16:02:40 +00:00
}
2017-05-12 15:58:04 +00:00
2019-09-06 16:02:40 +00:00
// ####################### RTCM MESSAGES #################
try
{
if ( b_rtcm_writing_started and b_rtcm_enabled )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
switch ( type_of_rx )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
case 1 : // GPS L1 C/A
if ( flag_write_RTCM_1019_output = = true )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
break ;
case 4 :
case 5 :
case 6 :
if ( flag_write_RTCM_1045_output = = true )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
break ;
case 7 : // GPS L1 C/A + GPS L2C
if ( flag_write_RTCM_1019_output = = true )
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
auto gps_cnav_eph_iter = d_user_pvt_solver - > gps_cnav_ephemeris_map . cbegin ( ) ;
if ( ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_eph_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , gps_cnav_eph_iter - > second , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
break ;
case 8 : // L1+L5
if ( flag_write_RTCM_1019_output = = true )
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
auto gps_cnav_eph_iter = d_user_pvt_solver - > gps_cnav_ephemeris_map . cbegin ( ) ;
if ( ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_eph_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , gps_cnav_eph_iter - > second , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
break ;
case 9 : // GPS L1 C/A + Galileo E1B
if ( flag_write_RTCM_1019_output = = true )
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_1045_output = = true )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
int gps_channel = 0 ;
int gal_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gps_channel = = 0 )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " G " )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2018-03-13 10:16:30 +00:00
}
2017-05-14 17:59:55 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( gal_channel = = 0 )
{
if ( system = = " E " )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-03-13 10:16:30 +00:00
}
2017-05-14 17:59:55 +00:00
}
}
}
2019-09-06 16:02:40 +00:00
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
}
break ;
case 13 : // L5+E5a
if ( flag_write_RTCM_1045_output = = true )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
{
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
2017-08-17 04:40:05 +00:00
2019-09-06 16:02:40 +00:00
if ( flag_write_RTCM_MSM_output and d_rtcm_MSM_rate_ms ! = 0 )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
auto gps_cnav_eph_iter = d_user_pvt_solver - > gps_cnav_ephemeris_map . cbegin ( ) ;
int gal_channel = 0 ;
int gps_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gps_channel = = 0 )
2018-12-13 11:57:11 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " G " )
2018-12-13 11:57:11 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gps_cnav_eph_iter = d_user_pvt_solver - > gps_cnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_cnav_eph_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) )
2019-01-28 01:29:43 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2019-01-28 01:29:43 +00:00
}
2018-12-13 11:57:11 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( gal_channel = = 0 )
{
if ( system = = " E " )
2018-12-13 11:57:11 +00:00
{
2019-09-06 16:02:40 +00:00
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2019-01-28 01:29:43 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-12-13 11:57:11 +00:00
}
}
}
2019-09-06 16:02:40 +00:00
}
2018-12-13 11:57:11 +00:00
2019-09-06 16:02:40 +00:00
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) and ( d_rtcm_MT1097_rate_ms ! = 0 ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-12-13 11:57:11 +00:00
}
2019-09-06 16:02:40 +00:00
if ( gps_cnav_eph_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) and ( d_rtcm_MT1077_rate_ms ! = 0 ) )
2018-11-07 22:53:16 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , gps_cnav_eph_iter - > second , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-07 22:53:16 +00:00
}
2019-09-06 16:02:40 +00:00
}
break ;
case 14 :
case 15 :
if ( flag_write_RTCM_1045_output = = true )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-11-07 22:53:16 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-11-07 22:53:16 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
break ;
case 23 :
case 24 :
case 25 :
if ( flag_write_RTCM_1020_output = = true )
{
for ( auto glonass_gnav_ephemeris_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_ephemeris_iter + + )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_ephemeris_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
auto glo_gnav_ephemeris_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
if ( glo_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glo_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 26 : // GPS L1 C/A + GLONASS L1 C/A
if ( flag_write_RTCM_1019_output = = true )
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
}
}
if ( flag_write_RTCM_1020_output = = true )
{
for ( auto glonass_gnav_ephemeris_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_ephemeris_iter + + )
{
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_ephemeris_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
int gps_channel = 0 ;
int glo_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gps_channel = = 0 )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " G " )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2018-03-13 10:16:30 +00:00
}
2017-08-17 04:40:05 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glo_channel = = 0 )
{
if ( system = = " R " )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
glo_channel = 1 ;
2018-03-13 10:16:30 +00:00
}
2017-08-17 04:40:05 +00:00
}
}
2019-09-06 16:02:40 +00:00
}
2018-11-02 11:15:28 +00:00
2019-09-06 16:02:40 +00:00
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glonass_gnav_eph_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2017-08-17 04:40:05 +00:00
}
2019-09-06 16:02:40 +00:00
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
break ;
case 27 : // GLONASS L1 C/A + Galileo E1B
if ( flag_write_RTCM_1020_output = = true )
{
for ( auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_eph_iter + + )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_eph_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_1045_output = = true )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
}
}
if ( flag_write_RTCM_MSM_output = = true )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
int gal_channel = 0 ;
int glo_channel = 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 )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " E " )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-03-13 10:16:30 +00:00
}
2017-08-17 04:40:05 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glo_channel = = 0 )
{
if ( system = = " R " )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
glo_channel = 1 ;
2018-03-13 10:16:30 +00:00
}
2017-08-17 04:40:05 +00:00
}
2018-03-13 10:16:30 +00:00
}
2017-08-17 04:40:05 +00:00
}
2019-09-06 16:02:40 +00:00
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2017-08-17 04:40:05 +00:00
}
2019-09-06 16:02:40 +00:00
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glonass_gnav_eph_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
}
break ;
case 29 : // GPS L1 C/A + GLONASS L2 C/A
if ( flag_write_RTCM_1019_output = = true )
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
{
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
}
}
if ( flag_write_RTCM_1020_output = = true )
{
for ( auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_eph_iter + + )
{
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_eph_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
int gps_channel = 0 ;
int glo_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gps_channel = = 0 )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " G " )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2018-03-13 10:16:30 +00:00
}
2017-08-17 04:40:05 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glo_channel = = 0 )
{
if ( system = = " R " )
2017-08-17 04:40:05 +00:00
{
2019-09-06 16:02:40 +00:00
glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
glo_channel = 1 ;
2018-03-13 10:16:30 +00:00
}
2017-08-17 04:40:05 +00:00
}
}
}
2019-09-06 16:02:40 +00:00
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glonass_gnav_eph_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
}
break ;
case 30 : // GLONASS L2 C/A + Galileo E1B
if ( flag_write_RTCM_1020_output = = true )
{
for ( auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_eph_iter + + )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_eph_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_1045_output = = true )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
int gal_channel = 0 ;
int glo_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gal_channel = = 0 )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " E " )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-03-29 10:54:03 +00:00
}
2018-03-24 18:42:04 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glo_channel = = 0 )
{
if ( system = = " R " )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
glo_channel = 1 ;
2018-03-29 10:54:03 +00:00
}
2018-03-24 18:42:04 +00:00
}
}
}
2019-09-06 16:02:40 +00:00
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glonass_gnav_eph_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
}
break ;
case 32 : // L1+E1+L5+E5a
if ( flag_write_RTCM_1019_output = = true )
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
{
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
}
}
if ( flag_write_RTCM_1045_output = = true )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
{
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( flag_write_RTCM_MSM_output = = true )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
int gal_channel = 0 ;
int gps_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gal_channel = = 0 )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " E " )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-03-29 10:54:03 +00:00
}
2018-03-24 18:42:04 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( gps_channel = = 0 )
{
if ( system = = " G " )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2018-03-29 10:54:03 +00:00
}
2018-03-24 18:42:04 +00:00
}
}
}
2019-09-06 16:02:40 +00:00
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
2018-03-24 18:42:04 +00:00
}
2019-09-06 16:02:40 +00:00
break ;
default :
break ;
2018-03-24 18:42:04 +00:00
}
2019-09-06 16:02:40 +00:00
}
2017-05-14 17:59:55 +00:00
2019-09-06 16:02:40 +00:00
if ( ! b_rtcm_writing_started and b_rtcm_enabled ) // the first time
{
switch ( type_of_rx )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
case 1 : // GPS L1 C/A
if ( d_rtcm_MT1019_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
2019-04-23 15:31:26 +00:00
2019-09-06 16:02:40 +00:00
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 4 :
case 5 :
case 6 :
if ( d_rtcm_MT1045_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 7 : // GPS L1 C/A + GPS L2C
if ( d_rtcm_MT1019_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
auto gps_cnav_eph_iter = d_user_pvt_solver - > gps_cnav_ephemeris_map . cbegin ( ) ;
if ( ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_eph_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , gps_cnav_eph_iter - > second , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 8 : // L1+L5
if ( d_rtcm_MT1019_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
auto gps_cnav_eph_iter = d_user_pvt_solver - > gps_cnav_ephemeris_map . cbegin ( ) ;
if ( ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) ) and ( gps_cnav_eph_iter ! = d_user_pvt_solver - > gps_cnav_ephemeris_map . cend ( ) ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , gps_cnav_eph_iter - > second , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 9 : // GPS L1 C/A + Galileo E1B
if ( d_rtcm_MT1019_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MT1045_rate_ms ! = 0 )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
int gps_channel = 0 ;
int gal_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gps_channel = = 0 )
2017-05-14 17:59:55 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " G " )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( gal_channel = = 0 )
{
if ( system = = " E " )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-13 10:16:30 +00:00
}
2017-05-14 17:59:55 +00:00
}
}
2019-09-06 16:02:40 +00:00
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
}
b_rtcm_writing_started = true ;
break ;
2017-05-14 17:59:55 +00:00
2019-09-06 16:02:40 +00:00
case 13 : // L5+E5a
if ( d_rtcm_MT1045_rate_ms ! = 0 )
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
int gal_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-12-11 12:59:57 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gal_channel = = 0 )
2018-12-11 12:59:57 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " E " )
2018-12-11 12:59:57 +00:00
{
2019-09-06 16:02:40 +00:00
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-12-11 12:59:57 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-12-11 12:59:57 +00:00
}
}
}
2019-09-06 16:02:40 +00:00
}
2018-12-11 12:59:57 +00:00
2019-09-06 16:02:40 +00:00
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) and ( d_rtcm_MT1097_rate_ms ! = 0 ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 14 :
case 15 :
if ( d_rtcm_MT1045_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 23 :
case 24 :
case 25 :
if ( d_rtcm_MT1020_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_eph_iter + + )
2018-11-07 22:53:16 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_eph_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-11-07 22:53:16 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
auto glo_gnav_ephemeris_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
if ( glo_gnav_ephemeris_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-11-07 22:53:16 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glo_gnav_ephemeris_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-07 22:53:16 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 26 : // GPS L1 C/A + GLONASS L1 C/A
if ( d_rtcm_MT1019_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MT1020_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_eph_iter + + )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_eph_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
int gps_channel = 0 ;
int glo_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-01-23 23:52:09 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gps_channel = = 0 )
2018-01-23 23:52:09 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " G " )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glo_channel = = 0 )
{
if ( system = = " R " )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
glo_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-13 10:16:30 +00:00
}
2018-01-23 23:52:09 +00:00
}
}
2019-09-06 16:02:40 +00:00
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glonass_gnav_eph_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
}
b_rtcm_writing_started = true ;
break ;
case 27 : // GLONASS L1 C/A + Galileo E1B
if ( d_rtcm_MT1020_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_eph_iter + + )
{
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_eph_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MT1045_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
{
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
}
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
int gal_channel = 0 ;
int glo_channel = 0 ;
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-01-23 23:52:09 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gal_channel = = 0 )
2018-01-23 23:52:09 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " E " )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-13 10:16:30 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glo_channel = = 0 )
{
if ( system = = " R " )
2018-03-13 10:16:30 +00:00
{
2019-09-06 16:02:40 +00:00
glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
glo_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-13 10:16:30 +00:00
}
2018-01-23 23:52:09 +00:00
}
}
2019-09-06 16:02:40 +00:00
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glonass_gnav_eph_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
}
b_rtcm_writing_started = true ;
break ;
case 29 : // GPS L1 C/A + GLONASS L2 C/A
if ( d_rtcm_MT1019_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
{
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
}
}
if ( d_rtcm_MT1020_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_eph_iter + + )
{
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_eph_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
int gps_channel = 0 ;
int glo_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gps_channel = = 0 )
2018-03-24 18:42:04 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " G " )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glo_channel = = 0 )
{
if ( system = = " R " )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
glo_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-29 10:54:03 +00:00
}
2018-03-24 18:42:04 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glonass_gnav_eph_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
2018-03-24 18:42:04 +00:00
2019-09-06 16:02:40 +00:00
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
b_rtcm_writing_started = true ;
break ;
case 30 : // GLONASS L2 C/A + Galileo E1B
if ( d_rtcm_MT1020_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ; glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) ; glonass_gnav_eph_iter + + )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1020 ( glonass_gnav_eph_iter - > second , d_user_pvt_solver - > glonass_gnav_utc_model ) ;
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MT1045_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
int gal_channel = 0 ;
int glo_channel = 0 ;
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
auto glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cbegin ( ) ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-01-23 23:52:09 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gal_channel = = 0 )
2018-01-23 23:52:09 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " E " )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-29 10:54:03 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( glo_channel = = 0 )
{
if ( system = = " R " )
2018-03-29 10:54:03 +00:00
{
2019-09-06 16:02:40 +00:00
glonass_gnav_eph_iter = d_user_pvt_solver - > glonass_gnav_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
glo_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
2018-03-29 10:54:03 +00:00
}
2018-01-23 23:52:09 +00:00
}
}
2019-09-06 16:02:40 +00:00
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
if ( glonass_gnav_eph_iter ! = d_user_pvt_solver - > glonass_gnav_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , { } , glonass_gnav_eph_iter - > second , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
}
b_rtcm_writing_started = true ;
break ;
case 32 : // L1+E1+L5+E5a
if ( d_rtcm_MT1019_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gps_eph_iter : d_user_pvt_solver - > gps_ephemeris_map )
{
d_rtcm_printer - > Print_Rtcm_MT1019 ( gps_eph_iter . second ) ;
}
}
if ( d_rtcm_MT1045_rate_ms ! = 0 ) // allows deactivating messages by setting rate = 0
{
for ( const auto & gal_eph_iter : d_user_pvt_solver - > galileo_ephemeris_map )
{
d_rtcm_printer - > Print_Rtcm_MT1045 ( gal_eph_iter . second ) ;
2018-11-02 11:15:28 +00:00
}
2019-09-06 16:02:40 +00:00
}
if ( d_rtcm_MSM_rate_ms ! = 0 )
{
std : : map < int , Gnss_Synchro > : : const_iterator gnss_observables_iter ;
auto gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . cbegin ( ) ;
auto gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . cbegin ( ) ;
int gps_channel = 0 ;
int gal_channel = 0 ;
for ( gnss_observables_iter = gnss_observables_map . cbegin ( ) ; gnss_observables_iter ! = gnss_observables_map . cend ( ) ; gnss_observables_iter + + )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
std : : string system ( & gnss_observables_iter - > second . System , 1 ) ;
if ( gps_channel = = 0 )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
if ( system = = " G " )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
// This is a channel with valid GPS signal
gps_eph_iter = d_user_pvt_solver - > gps_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gps_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
}
2019-09-06 16:02:40 +00:00
}
if ( gal_channel = = 0 )
{
if ( system = = " E " )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gal_eph_iter = d_user_pvt_solver - > galileo_ephemeris_map . find ( gnss_observables_iter - > second . PRN ) ;
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
2018-11-02 11:15:28 +00:00
{
2019-09-06 16:02:40 +00:00
gal_channel = 1 ;
2018-11-02 11:15:28 +00:00
}
}
}
}
2019-09-06 16:02:40 +00:00
if ( gps_eph_iter ! = d_user_pvt_solver - > gps_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , gps_eph_iter - > second , { } , { } , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
if ( gal_eph_iter ! = d_user_pvt_solver - > galileo_ephemeris_map . cend ( ) )
{
d_rtcm_printer - > Print_Rtcm_MSM ( 7 , { } , { } , gal_eph_iter - > second , { } , d_rx_time , gnss_observables_map , 0 , 0 , 0 , false , false ) ;
}
2018-01-23 23:52:09 +00:00
}
2019-09-06 16:02:40 +00:00
b_rtcm_writing_started = true ;
break ;
default :
break ;
2018-01-23 23:52:09 +00:00
}
}
2019-09-06 16:02:40 +00:00
}
catch ( const boost : : exception & ex )
{
std : : cout < < " RTCM boost exception: " < < boost : : diagnostic_information ( ex ) < < std : : endl ;
LOG ( ERROR ) < < " RTCM boost exception: " < < boost : : diagnostic_information ( ex ) ;
}
catch ( const std : : exception & ex )
{
std : : cout < < " RTCM std exception: " < < ex . what ( ) < < std : : endl ;
LOG ( ERROR ) < < " RTCM std exception: " < < ex . what ( ) ;
2018-03-13 10:16:30 +00:00
}
2017-05-14 17:59:55 +00:00
}
2017-04-29 07:25:05 +00:00
}
2017-05-14 17:59:55 +00:00
// DEBUG MESSAGE: Display position in console output
2019-08-01 16:11:36 +00:00
if ( d_user_pvt_solver - > is_valid_position ( ) and flag_display_pvt )
2017-05-14 17:59:55 +00:00
{
2019-03-15 12:31:18 +00:00
boost : : posix_time : : ptime time_solution ;
std : : string UTC_solution_str ;
if ( d_show_local_time_zone )
{
2019-08-01 16:11:36 +00:00
time_solution = d_user_pvt_solver - > get_position_UTC_time ( ) + d_utc_diff_time ;
2019-03-16 11:47:36 +00:00
UTC_solution_str = d_local_time_str ;
2019-03-15 12:31:18 +00:00
}
else
{
2019-08-01 16:11:36 +00:00
time_solution = d_user_pvt_solver - > get_position_UTC_time ( ) ;
2019-03-15 12:31:18 +00:00
UTC_solution_str = " UTC " ;
}
2018-06-05 19:41:13 +00:00
std : : streamsize ss = std : : cout . precision ( ) ; // save current precision
2018-06-07 10:23:26 +00:00
std : : cout . setf ( std : : ios : : fixed , std : : ios : : floatfield ) ;
auto facet = new boost : : posix_time : : time_facet ( " %Y-%b-%d %H:%M:%S.%f %z " ) ;
std : : cout . imbue ( std : : locale ( std : : cout . getloc ( ) , facet ) ) ;
2019-03-15 12:31:18 +00:00
std : : cout
< < TEXT_BOLD_GREEN
< < " Position at " < < time_solution < < UTC_solution_str
2019-08-01 16:11:36 +00:00
< < " using " < < d_user_pvt_solver - > get_num_valid_observations ( )
2019-03-15 12:31:18 +00:00
< < std : : fixed < < std : : setprecision ( 9 )
2019-08-01 16:11:36 +00:00
< < " observations is Lat = " < < d_user_pvt_solver - > get_latitude ( ) < < " [deg], Long = " < < d_user_pvt_solver - > get_longitude ( )
2019-03-15 12:31:18 +00:00
< < std : : fixed < < std : : setprecision ( 3 )
2019-08-01 16:11:36 +00:00
< < " [deg], Height = " < < d_user_pvt_solver - > get_height ( ) < < " [m] " < < TEXT_RESET < < std : : endl ;
2018-06-07 10:23:26 +00:00
2018-06-05 16:20:55 +00:00
std : : cout < < std : : setprecision ( ss ) ;
2019-08-01 16:11:36 +00:00
DLOG ( INFO ) < < " RX clock offset: " < < d_user_pvt_solver - > get_time_offset_s ( ) < < " [s] " ;
2018-05-18 19:07:12 +00:00
2019-11-04 12:04:46 +00:00
std : : cout
< < TEXT_BOLD_GREEN
< < " Velocity: " < < std : : fixed < < std : : setprecision ( 3 )
< < " East: " < < d_user_pvt_solver - > get_rx_vel ( ) [ 0 ] < < " [m/s], North: " < < d_user_pvt_solver - > get_rx_vel ( ) [ 1 ]
< < " [m/s], Up = " < < d_user_pvt_solver - > get_rx_vel ( ) [ 2 ] < < " [m/s] " < < TEXT_RESET < < std : : endl ;
std : : cout < < std : : setprecision ( ss ) ;
DLOG ( INFO ) < < " RX clock drift: " < < d_user_pvt_solver - > get_clock_drift_ppm ( ) < < " [ppm] " ;
2018-06-05 19:41:13 +00:00
// boost::posix_time::ptime p_time;
2019-08-01 16:11:36 +00:00
// gtime_t rtklib_utc_time = gpst2time(adjgpsweek(d_user_pvt_solver->gps_ephemeris_map.cbegin()->second.i_GPS_week), d_rx_time);
2018-06-05 19:41:13 +00:00
// p_time = boost::posix_time::from_time_t(rtklib_utc_time.time);
// p_time += boost::posix_time::microseconds(round(rtklib_utc_time.sec * 1e6));
// std::cout << TEXT_MAGENTA << "Observable RX time (GPST) " << boost::posix_time::to_simple_string(p_time) << TEXT_RESET << std::endl;
2018-05-18 19:07:12 +00:00
2019-08-01 16:11:36 +00:00
DLOG ( INFO ) < < " Position at " < < boost : : posix_time : : to_simple_string ( d_user_pvt_solver - > get_position_UTC_time ( ) )
< < " UTC using " < < d_user_pvt_solver - > get_num_valid_observations ( ) < < " observations is Lat = " < < d_user_pvt_solver - > get_latitude ( ) < < " [deg], Long = " < < d_user_pvt_solver - > get_longitude ( )
< < " [deg], Height = " < < d_user_pvt_solver - > get_height ( ) < < " [m] " ;
2017-08-16 10:45:00 +00:00
2019-08-01 16:11:36 +00:00
/* std::cout << "Dilution of Precision at " << boost::posix_time::to_simple_string(d_user_pvt_solver->get_position_UTC_time())
< < " UTC using " < < d_user_pvt_solver - > get_num_valid_observations ( ) < < " observations is HDOP = " < < d_user_pvt_solver - > get_hdop ( ) < < " VDOP = "
< < d_user_pvt_solver - > get_vdop ( )
< < " GDOP = " < < d_user_pvt_solver - > get_gdop ( ) < < std : : endl ; */
2017-05-14 17:59:55 +00:00
}
2019-01-21 10:59:29 +00:00
// PVT MONITOR
2019-08-01 16:11:36 +00:00
if ( d_user_pvt_solver - > is_valid_position ( ) )
2019-01-21 10:59:29 +00:00
{
2019-08-01 16:11:36 +00:00
std : : shared_ptr < Monitor_Pvt > monitor_pvt = std : : make_shared < Monitor_Pvt > ( d_user_pvt_solver - > get_monitor_pvt ( ) ) ;
2019-07-11 16:39:28 +00:00
2019-08-01 18:09:35 +00:00
// publish new position to the gnss_flowgraph channel status monitor
2019-07-11 16:39:28 +00:00
if ( current_RX_time_ms % d_report_rate_ms = = 0 )
{
this - > message_port_pub ( pmt : : mp ( " status " ) , pmt : : make_any ( monitor_pvt ) ) ;
}
if ( flag_monitor_pvt_enabled )
{
udp_sink_ptr - > write_monitor_pvt ( monitor_pvt ) ;
}
2019-01-21 10:59:29 +00:00
}
2017-04-28 13:38:31 +00:00
}
2017-04-20 14:10:12 +00:00
}
2017-04-28 13:38:31 +00:00
2017-04-29 07:25:05 +00:00
return noutput_items ;
2017-04-20 14:10:12 +00:00
}