2011-10-01 18:45:20 +00:00
/*!
2020-07-13 08:18:24 +00:00
* \ file gnss_block_factory . cc
* \ brief This class implements a factory that returns instances of GNSS blocks .
* \ author Carlos Aviles , 2010. carlos . avilesr ( at ) googlemail . com
* Luis Esteve , 2012. luis ( at ) epsilon - formacion . com
* Javier Arribas , 2011. jarribas ( at ) cttc . es
* Marc Majoral , 2018. mmajoral ( at ) cttc . es
* Carles Fernandez - Prades , 2014 - 2020. cfernandez ( at ) cttc . es
*
* This class encapsulates the complexity behind the instantiation
* of GNSS blocks .
*
*
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
*
2020-12-30 12:35:06 +00:00
* GNSS - SDR is a Global Navigation Satellite System software - defined receiver .
2020-07-13 08:18:24 +00:00
* This file is part of GNSS - SDR .
*
2020-12-30 12:35:06 +00:00
* Copyright ( C ) 2010 - 2020 ( see AUTHORS file for a list of contributors )
2020-07-13 08:18:24 +00:00
* SPDX - License - Identifier : GPL - 3.0 - or - later
*
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
*/
2011-10-01 18:45:20 +00:00
2014-04-11 18:18:59 +00:00
2011-10-01 18:45:20 +00:00
# include "gnss_block_factory.h"
2020-07-13 08:18:24 +00:00
# include "acquisition_interface.h"
2014-02-18 19:40:44 +00:00
# include "array_signal_conditioner.h"
2018-12-09 21:00:09 +00:00
# include "beamformer_filter.h"
2019-03-26 22:05:18 +00:00
# include "beidou_b1i_dll_pll_tracking.h"
# include "beidou_b1i_pcps_acquisition.h"
# include "beidou_b1i_telemetry_decoder.h"
# include "beidou_b3i_dll_pll_tracking.h"
# include "beidou_b3i_pcps_acquisition.h"
# include "beidou_b3i_telemetry_decoder.h"
2015-02-03 18:40:26 +00:00
# include "byte_to_short.h"
2018-12-09 21:00:09 +00:00
# include "channel.h"
# include "configuration_interface.h"
2012-02-19 17:45:51 +00:00
# include "direct_resampler_conditioner.h"
2021-04-17 12:46:48 +00:00
# include "fifo_signal_source.h"
2021-04-17 17:32:10 +00:00
# include "file_signal_source.h"
2012-02-24 16:06:14 +00:00
# include "fir_filter.h"
2012-07-18 13:29:18 +00:00
# include "freq_xlating_fir_filter.h"
2018-12-09 21:00:09 +00:00
# include "galileo_e1_dll_pll_veml_tracking.h"
2013-08-28 17:17:57 +00:00
# include "galileo_e1_pcps_8ms_ambiguous_acquisition.h"
2018-12-09 21:00:09 +00:00
# include "galileo_e1_pcps_ambiguous_acquisition.h"
2013-08-28 17:17:57 +00:00
# include "galileo_e1_pcps_cccwsr_ambiguous_acquisition.h"
2014-07-23 23:38:58 +00:00
# include "galileo_e1_pcps_quicksync_ambiguous_acquisition.h"
2018-12-09 21:00:09 +00:00
# include "galileo_e1_pcps_tong_ambiguous_acquisition.h"
# include "galileo_e1_tcp_connector_tracking.h"
# include "galileo_e1b_telemetry_decoder.h"
# include "galileo_e5a_dll_pll_tracking.h"
2014-08-05 00:01:37 +00:00
# include "galileo_e5a_noncoherent_iq_acquisition_caf.h"
2018-02-07 13:26:25 +00:00
# include "galileo_e5a_pcps_acquisition.h"
2018-12-09 21:00:09 +00:00
# include "galileo_e5a_telemetry_decoder.h"
2020-07-13 22:45:07 +00:00
# include "galileo_e5b_dll_pll_tracking.h"
2020-06-12 12:07:36 +00:00
# include "galileo_e5b_pcps_acquisition.h"
2020-07-25 22:12:48 +00:00
# include "galileo_e5b_telemetry_decoder.h"
2020-11-07 20:33:26 +00:00
# include "galileo_e6_dll_pll_tracking.h"
# include "galileo_e6_pcps_acquisition.h"
# include "galileo_e6_telemetry_decoder.h"
2018-12-09 21:00:09 +00:00
# include "glonass_l1_ca_dll_pll_c_aid_tracking.h"
# include "glonass_l1_ca_dll_pll_tracking.h"
2017-06-01 23:53:17 +00:00
# include "glonass_l1_ca_pcps_acquisition.h"
2018-12-09 21:00:09 +00:00
# include "glonass_l1_ca_telemetry_decoder.h"
# include "glonass_l2_ca_dll_pll_c_aid_tracking.h"
# include "glonass_l2_ca_dll_pll_tracking.h"
2018-03-24 18:42:04 +00:00
# include "glonass_l2_ca_pcps_acquisition.h"
2018-12-09 21:00:09 +00:00
# include "glonass_l2_ca_telemetry_decoder.h"
# include "gnss_block_interface.h"
2020-06-18 09:49:28 +00:00
# include "gnss_sdr_make_unique.h"
2021-02-16 13:27:46 +00:00
# include "gnss_sdr_string_literals.h"
2018-12-09 21:00:09 +00:00
# include "gps_l1_ca_dll_pll_tracking.h"
# include "gps_l1_ca_kf_tracking.h"
# include "gps_l1_ca_pcps_acquisition.h"
# include "gps_l1_ca_pcps_acquisition_fine_doppler.h"
# include "gps_l1_ca_pcps_assisted_acquisition.h"
# include "gps_l1_ca_pcps_quicksync_acquisition.h"
# include "gps_l1_ca_pcps_tong_acquisition.h"
2012-03-16 10:55:58 +00:00
# include "gps_l1_ca_tcp_connector_tracking.h"
2011-10-01 18:45:20 +00:00
# include "gps_l1_ca_telemetry_decoder.h"
2018-12-09 21:00:09 +00:00
# include "gps_l2_m_dll_pll_tracking.h"
# include "gps_l2_m_pcps_acquisition.h"
2016-11-03 18:33:04 +00:00
# include "gps_l2c_telemetry_decoder.h"
2018-12-09 21:00:09 +00:00
# include "gps_l5_dll_pll_tracking.h"
2017-11-29 14:51:30 +00:00
# include "gps_l5_telemetry_decoder.h"
2018-12-09 21:00:09 +00:00
# include "gps_l5i_pcps_acquisition.h"
2014-06-10 16:58:17 +00:00
# include "hybrid_observables.h"
2018-12-09 21:00:09 +00:00
# include "ibyte_to_cbyte.h"
# include "ibyte_to_complex.h"
# include "ibyte_to_cshort.h"
# include "in_memory_configuration.h"
# include "ishort_to_complex.h"
# include "ishort_to_cshort.h"
# include "labsat_signal_source.h"
# include "mmse_resampler_conditioner.h"
2019-06-17 16:13:06 +00:00
# include "multichannel_file_signal_source.h"
2018-12-09 21:00:09 +00:00
# include "notch_filter.h"
# include "notch_filter_lite.h"
# include "nsr_file_signal_source.h"
# include "pass_through.h"
# include "pulse_blanking_filter.h"
2017-04-20 14:10:12 +00:00
# include "rtklib_pvt.h"
2018-12-09 21:00:09 +00:00
# include "rtl_tcp_signal_source.h"
# include "sbas_l1_telemetry_decoder.h"
# include "signal_conditioner.h"
# include "spir_file_signal_source.h"
# include "spir_gss6450_file_signal_source.h"
2019-03-05 07:59:04 +00:00
# include "telemetry_decoder_interface.h"
# include "tracking_interface.h"
2018-12-09 21:00:09 +00:00
# include "two_bit_cpx_file_signal_source.h"
# include "two_bit_packed_file_signal_source.h"
2019-03-05 07:59:04 +00:00
# include <glog/logging.h>
# include <exception> // for exception
2021-02-27 10:05:39 +00:00
# include <iostream> // for cerr
2019-03-05 07:59:04 +00:00
# include <utility> // for move
2011-10-01 18:45:20 +00:00
2018-05-16 09:36:37 +00:00
# if RAW_UDP
# include "custom_udp_signal_source.h"
# endif
2017-05-05 14:37:29 +00:00
# if ENABLE_FPGA
2018-12-09 21:00:09 +00:00
# include "galileo_e1_dll_pll_veml_tracking_fpga.h"
2018-05-22 10:25:14 +00:00
# include "galileo_e1_pcps_ambiguous_acquisition_fpga.h"
2018-12-09 21:00:09 +00:00
# include "galileo_e5a_dll_pll_tracking_fpga.h"
2018-08-01 13:55:40 +00:00
# include "galileo_e5a_pcps_acquisition_fpga.h"
2020-06-12 12:07:36 +00:00
# include "galileo_e5b_pcps_acquisition_fpga.h"
2018-03-02 16:40:13 +00:00
# include "gps_l1_ca_dll_pll_tracking_fpga.h"
2018-12-09 21:00:09 +00:00
# include "gps_l1_ca_pcps_acquisition_fpga.h"
2018-08-01 13:55:40 +00:00
# include "gps_l2_m_dll_pll_tracking_fpga.h"
2018-12-09 21:00:09 +00:00
# include "gps_l2_m_pcps_acquisition_fpga.h"
2018-08-01 13:55:40 +00:00
# include "gps_l5_dll_pll_tracking_fpga.h"
2018-12-09 21:00:09 +00:00
# include "gps_l5i_pcps_acquisition_fpga.h"
2017-05-05 14:37:29 +00:00
# endif
2014-03-15 01:21:17 +00:00
# if OPENCL_BLOCKS
2015-05-11 19:36:39 +00:00
# include "gps_l1_ca_pcps_opencl_acquisition.h"
2013-10-01 20:32:04 +00:00
# endif
2012-07-30 15:46:07 +00:00
# if GN3S_DRIVER
2015-05-11 19:36:39 +00:00
# include "gn3s_signal_source.h"
2012-07-30 15:46:07 +00:00
# endif
2014-02-17 18:53:45 +00:00
# if RAW_ARRAY_DRIVER
2015-05-11 19:36:39 +00:00
# include "raw_array_signal_source.h"
2014-02-17 18:53:45 +00:00
# endif
2014-12-15 16:39:22 +00:00
# if OSMOSDR_DRIVER
2015-05-11 19:36:39 +00:00
# include "osmosdr_signal_source.h"
2012-08-01 13:11:02 +00:00
# endif
2014-11-14 20:42:22 +00:00
# if UHD_DRIVER
2015-05-11 19:36:39 +00:00
# include "uhd_signal_source.h"
2014-11-14 20:42:22 +00:00
# endif
2017-10-29 05:51:22 +00:00
# if PLUTOSDR_DRIVER
# include "plutosdr_signal_source.h"
# endif
# if FMCOMMS2_DRIVER
# include "fmcomms2_signal_source.h"
# endif
2018-03-02 10:30:36 +00:00
# if AD9361_DRIVER
# include "ad9361_fpga_signal_source.h"
# endif
2015-03-03 17:07:26 +00:00
# if FLEXIBAND_DRIVER
2015-05-11 19:36:39 +00:00
# include "flexiband_signal_source.h"
2015-03-03 17:07:26 +00:00
# endif
2015-08-25 15:07:36 +00:00
# if CUDA_GPU_ACCEL
# include "gps_l1_ca_dll_pll_tracking_gpu.h"
# endif
2021-02-09 22:47:34 +00:00
using namespace std : : string_literals ;
2011-12-26 05:04:27 +00:00
2021-02-09 22:47:34 +00:00
namespace
2011-10-01 18:45:20 +00:00
{
2021-02-09 22:47:34 +00:00
auto const impl_prop = " .implementation " s ; // "implementation" property; used nearly universally
auto const item_prop = " .item_type " s ; // "item_type" property
// unique_ptr dynamic cast from https://stackoverflow.com/a/26377517/9220132
template < typename To , typename From >
std : : unique_ptr < To > dynamic_unique_cast ( std : : unique_ptr < From > & & p )
{
std : : unique_ptr < To > result ;
if ( To * cast = dynamic_cast < To * > ( p . get ( ) ) )
2015-02-27 17:21:25 +00:00
{
2021-02-09 22:47:34 +00:00
result . reset ( cast ) ;
2021-02-24 14:51:05 +00:00
p . release ( ) ; // NOLINT(bugprone-unused-return-value)
2018-05-01 21:32:52 +00:00
}
2021-02-09 22:47:34 +00:00
return result ;
}
2021-02-16 04:30:50 +00:00
auto findRole ( ConfigurationInterface const * configuration , std : : string const & base , int ID ) - > std : : string
2021-02-09 22:47:34 +00:00
{
auto role = base + std : : to_string ( ID ) ;
// Legacy behavior: pass -1 for unadorned property.
// Current behavior: if there is no "Tag0" use "Tag" instead
if ( ID < 1 )
2018-05-01 21:32:52 +00:00
{
2021-02-09 22:47:34 +00:00
auto stub = configuration - > property ( role + impl_prop , " " s ) ;
2021-02-16 06:01:56 +00:00
if ( stub . empty ( ) ) role = base ; // NOLINT -- legacy format
2015-02-27 17:21:25 +00:00
}
2021-02-09 22:47:34 +00:00
return role ;
} ;
} // namespace
std : : unique_ptr < SignalSourceInterface > GNSSBlockFactory : : GetSignalSource (
const ConfigurationInterface * configuration , Concurrent_Queue < pmt : : pmt_t > * queue , int ID )
{
auto role = findRole ( configuration , " SignalSource " s , ID ) ;
auto implementation = configuration - > property ( role + impl_prop , " " s ) ;
LOG ( INFO ) < < " Getting SignalSource " < < role < < " with implementation " < < implementation ;
return dynamic_unique_cast < SignalSourceInterface > ( GetBlock ( configuration , role , 0 , 1 , queue ) ) ;
2011-10-01 18:45:20 +00:00
}
2012-11-01 17:40:26 +00:00
2014-04-11 18:18:59 +00:00
std : : unique_ptr < GNSSBlockInterface > GNSSBlockFactory : : GetSignalConditioner (
2020-06-29 07:07:41 +00:00
const ConfigurationInterface * configuration , int ID )
2011-10-01 18:45:20 +00:00
{
2020-07-13 13:44:07 +00:00
const std : : string empty_implementation ;
2020-08-05 10:58:10 +00:00
2021-02-09 22:47:34 +00:00
auto role_conditioner = findRole ( configuration , " SignalConditioner " s , ID ) ;
auto role_datatypeadapter = findRole ( configuration , " DataTypeAdapter " s , ID ) ;
auto role_inputfilter = findRole ( configuration , " InputFilter " s , ID ) ;
auto role_resampler = findRole ( configuration , " Resampler " s , ID ) ;
DLOG ( INFO ) < < " role: " < < role_conditioner < < " (ID= " < < ID < < " ) " ;
2021-02-15 21:13:54 +00:00
2021-02-09 22:47:34 +00:00
const std : : string signal_conditioner = configuration - > property ( role_conditioner + impl_prop , " " s ) ;
const std : : string data_type_adapter = configuration - > property ( role_datatypeadapter + impl_prop , " " s ) ;
const std : : string input_filter = configuration - > property ( role_inputfilter + impl_prop , " " s ) ;
const std : : string resampler = configuration - > property ( role_resampler + impl_prop , " " s ) ;
2015-02-12 17:56:05 +00:00
2018-12-02 22:54:27 +00:00
if ( signal_conditioner = = " Pass_Through " )
2012-07-18 13:29:18 +00:00
{
2020-08-05 10:58:10 +00:00
if ( ! data_type_adapter . empty ( ) and ( data_type_adapter ! = " Pass_Through " ) )
{
2021-02-09 22:47:34 +00:00
LOG ( WARNING ) < < " Configuration warning: if " < < role_conditioner < < impl_prop < < " \n "
< < " is set to Pass_Through, then the " < < role_datatypeadapter < < impl_prop < < " \n "
2020-08-05 10:58:10 +00:00
< < " parameter should be either not set or set to Pass_Through. \n "
< < role_datatypeadapter < < " configuration parameters will be ignored. " ;
}
if ( ! input_filter . empty ( ) and ( input_filter ! = " Pass_Through " ) )
{
2021-02-09 22:47:34 +00:00
LOG ( WARNING ) < < " Configuration warning: if " < < role_conditioner < < impl_prop < < " \n "
< < " is set to Pass_Through, then the " < < role_inputfilter < < impl_prop < < " \n "
2020-08-05 10:58:10 +00:00
< < " parameter should be either not set or set to Pass_Through. \n "
< < role_inputfilter < < " configuration parameters will be ignored. " ;
}
if ( ! resampler . empty ( ) and ( resampler ! = " Pass_Through " ) )
{
2021-02-09 22:47:34 +00:00
LOG ( WARNING ) < < " Configuration warning: if " < < role_conditioner < < impl_prop < < " \n "
< < " is set to Pass_Through, then the " < < role_resampler < < impl_prop < < " \n "
2020-08-05 10:58:10 +00:00
< < " parameter should be either not set or set to Pass_Through. \n "
< < role_resampler < < " configuration parameters will be ignored. " ;
}
LOG ( INFO ) < < " Getting " < < role_conditioner < < " with Pass_Through implementation " ;
std : : unique_ptr < GNSSBlockInterface > conditioner_ = std : : make_unique < Pass_Through > ( configuration , role_conditioner , 1 , 1 ) ;
return conditioner_ ;
2012-07-18 13:29:18 +00:00
}
2020-08-05 10:58:10 +00:00
LOG ( INFO ) < < " Getting " < < role_conditioner < < " with " < < role_datatypeadapter < < " implementation: "
< < data_type_adapter < < " , " < < role_inputfilter < < " implementation: "
< < input_filter < < " , and " < < role_resampler < < " implementation: "
2018-03-03 01:03:39 +00:00
< < resampler ;
2012-02-19 17:45:51 +00:00
2018-12-02 22:54:27 +00:00
if ( signal_conditioner = = " Array_Signal_Conditioner " )
2014-03-16 19:58:29 +00:00
{
2019-07-21 17:32:52 +00:00
// instantiate the array version
2020-08-03 08:46:07 +00:00
std : : unique_ptr < GNSSBlockInterface > conditioner_ = std : : make_unique < ArraySignalConditioner > (
2020-07-13 13:17:15 +00:00
GetBlock ( configuration , role_datatypeadapter , 1 , 1 ) ,
GetBlock ( configuration , role_inputfilter , 1 , 1 ) ,
GetBlock ( configuration , role_resampler , 1 , 1 ) ,
2020-08-03 08:46:07 +00:00
role_conditioner ) ;
2014-04-11 18:18:59 +00:00
return conditioner_ ;
2014-03-16 19:58:29 +00:00
}
2019-02-11 14:53:50 +00:00
2021-02-27 10:05:39 +00:00
if ( signal_conditioner ! = " Signal_Conditioner " )
{
std : : cerr < < " Error in configuration file: SignalConditioner.implementation= " < < signal_conditioner < < " is not a valid value. \n " ;
return nullptr ;
}
2019-07-21 17:32:52 +00:00
// single-antenna version
2020-08-03 08:46:07 +00:00
std : : unique_ptr < GNSSBlockInterface > conditioner_ = std : : make_unique < SignalConditioner > (
2020-07-13 13:17:15 +00:00
GetBlock ( configuration , role_datatypeadapter , 1 , 1 ) ,
GetBlock ( configuration , role_inputfilter , 1 , 1 ) ,
GetBlock ( configuration , role_resampler , 1 , 1 ) ,
2020-08-03 08:46:07 +00:00
role_conditioner ) ;
2019-02-11 14:53:50 +00:00
return conditioner_ ;
2011-10-01 18:45:20 +00:00
}
2012-11-01 17:40:26 +00:00
2020-06-29 07:07:41 +00:00
std : : unique_ptr < GNSSBlockInterface > GNSSBlockFactory : : GetObservables ( const ConfigurationInterface * configuration )
2011-10-01 18:45:20 +00:00
{
2020-07-13 13:17:15 +00:00
const std : : string empty_implementation ;
std : : string implementation = configuration - > property ( " Observables.implementation " , empty_implementation ) ;
2014-03-16 19:58:29 +00:00
LOG ( INFO ) < < " Getting Observables with implementation " < < implementation ;
2021-02-27 10:05:39 +00:00
if ( implementation . find ( " _Observables " ) = = std : : string : : npos )
2020-08-05 10:58:10 +00:00
{
2021-02-27 10:05:39 +00:00
std : : cerr < < " Error in configuration file: please set Observables.implementation=Hybrid_Observables \n " ;
return nullptr ;
2020-08-05 10:58:10 +00:00
}
2016-04-21 16:54:08 +00:00
unsigned int Galileo_channels = configuration - > property ( " Channels_1B.count " , 0 ) ;
2015-05-07 19:34:37 +00:00
Galileo_channels + = configuration - > property ( " Channels_5X.count " , 0 ) ;
2020-07-12 21:08:58 +00:00
Galileo_channels + = configuration - > property ( " Channels_7X.count " , 0 ) ;
2020-11-07 20:33:26 +00:00
Galileo_channels + = configuration - > property ( " Channels_E6.count " , 0 ) ;
2016-04-21 16:54:08 +00:00
unsigned int GPS_channels = configuration - > property ( " Channels_1C.count " , 0 ) ;
2015-05-06 23:51:34 +00:00
GPS_channels + = configuration - > property ( " Channels_2S.count " , 0 ) ;
2017-12-11 11:17:01 +00:00
GPS_channels + = configuration - > property ( " Channels_L5.count " , 0 ) ;
2017-06-05 19:58:20 +00:00
unsigned int Glonass_channels = configuration - > property ( " Channels_1G.count " , 0 ) ;
2018-12-18 21:55:36 +00:00
Glonass_channels + = configuration - > property ( " Channels_2G.count " , 0 ) ;
2018-06-15 02:19:32 +00:00
unsigned int Beidou_channels = configuration - > property ( " Channels_B1.count " , 0 ) ;
2019-01-25 21:43:00 +00:00
Beidou_channels + = configuration - > property ( " Channels_B3.count " , 0 ) ;
2018-04-28 10:33:46 +00:00
unsigned int extra_channels = 1 ; // For monitor channel sample counter
2020-07-13 13:17:15 +00:00
return GetBlock ( configuration , " Observables " ,
2018-04-28 10:33:46 +00:00
Galileo_channels +
2018-02-13 17:16:03 +00:00
GPS_channels +
Glonass_channels +
2019-03-26 22:05:18 +00:00
Beidou_channels +
2018-02-13 17:16:03 +00:00
extra_channels ,
2019-03-26 22:05:18 +00:00
Galileo_channels +
2018-02-13 17:16:03 +00:00
GPS_channels +
2018-06-15 02:19:32 +00:00
Glonass_channels +
2019-03-26 22:05:18 +00:00
Beidou_channels ) ;
2011-10-01 18:45:20 +00:00
}
2012-11-01 17:40:26 +00:00
2020-06-29 07:07:41 +00:00
std : : unique_ptr < GNSSBlockInterface > GNSSBlockFactory : : GetPVT ( const ConfigurationInterface * configuration )
2011-10-01 18:45:20 +00:00
{
2020-07-13 13:17:15 +00:00
const std : : string empty_implementation ;
std : : string implementation = configuration - > property ( " PVT.implementation " , empty_implementation ) ;
2014-03-16 19:58:29 +00:00
LOG ( INFO ) < < " Getting PVT with implementation " < < implementation ;
2021-02-27 10:05:39 +00:00
if ( implementation . find ( " _PVT " ) = = std : : string : : npos )
2020-08-05 10:58:10 +00:00
{
2021-02-27 10:05:39 +00:00
std : : cerr < < " Error in configuration file: please set PVT.implementation=RTKLIB_PVT \n " ;
return nullptr ;
2020-08-05 10:58:10 +00:00
}
2017-04-29 17:12:27 +00:00
unsigned int Galileo_channels = configuration - > property ( " Channels_1B.count " , 0 ) ;
2015-05-07 19:34:37 +00:00
Galileo_channels + = configuration - > property ( " Channels_5X.count " , 0 ) ;
2020-07-12 21:08:58 +00:00
Galileo_channels + = configuration - > property ( " Channels_7X.count " , 0 ) ;
2020-11-07 20:33:26 +00:00
Galileo_channels + = configuration - > property ( " Channels_E6.count " , 0 ) ;
2017-04-29 17:12:27 +00:00
unsigned int GPS_channels = configuration - > property ( " Channels_1C.count " , 0 ) ;
2015-05-06 23:51:34 +00:00
GPS_channels + = configuration - > property ( " Channels_2S.count " , 0 ) ;
2017-12-11 11:17:01 +00:00
GPS_channels + = configuration - > property ( " Channels_L5.count " , 0 ) ;
2017-06-05 19:58:20 +00:00
unsigned int Glonass_channels = configuration - > property ( " Channels_1G.count " , 0 ) ;
2018-12-18 21:55:36 +00:00
Glonass_channels + = configuration - > property ( " Channels_2G.count " , 0 ) ;
2018-06-15 02:19:32 +00:00
unsigned int Beidou_channels = configuration - > property ( " Channels_B1.count " , 0 ) ;
2019-01-25 21:43:00 +00:00
Beidou_channels + = configuration - > property ( " Channels_B3.count " , 0 ) ;
2020-07-13 13:17:15 +00:00
return GetBlock ( configuration , " PVT " ,
2019-03-26 22:05:18 +00:00
Galileo_channels + GPS_channels + Glonass_channels + Beidou_channels , 0 ) ;
2011-10-01 18:45:20 +00:00
}
2012-11-01 17:40:26 +00:00
2020-07-12 21:08:58 +00:00
// ************************** GNSS CHANNEL *************************************
std : : unique_ptr < GNSSBlockInterface > GNSSBlockFactory : : GetChannel (
2020-06-29 07:07:41 +00:00
const ConfigurationInterface * configuration ,
2020-07-12 21:08:58 +00:00
const std : : string & signal ,
int channel ,
2020-06-18 09:49:28 +00:00
Concurrent_Queue < pmt : : pmt_t > * queue )
2015-05-06 23:51:34 +00:00
{
2019-07-21 17:32:52 +00:00
// "appendix" is added to the "role" with the aim of Acquisition, Tracking and Telemetry Decoder adapters
2020-07-12 21:08:58 +00:00
// can find their specific configurations for channels
2021-02-09 22:47:34 +00:00
std : : string aux = configuration - > property ( " Acquisition_ " + signal + std : : to_string ( channel ) + impl_prop , std : : string ( " W " ) ) ;
2015-05-11 15:18:26 +00:00
std : : string appendix1 ;
2018-12-02 22:54:27 +00:00
if ( aux ! = " W " )
2015-05-11 15:18:26 +00:00
{
2018-05-01 21:32:52 +00:00
appendix1 = std : : to_string ( channel ) ;
2015-05-11 15:18:26 +00:00
}
2018-01-26 11:49:04 +00:00
2021-02-09 22:47:34 +00:00
aux = configuration - > property ( " Tracking_ " + signal + std : : to_string ( channel ) + impl_prop , std : : string ( " W " ) ) ;
2015-05-11 15:18:26 +00:00
std : : string appendix2 ;
2018-12-02 22:54:27 +00:00
if ( aux ! = " W " )
2015-05-11 15:18:26 +00:00
{
2018-05-01 21:32:52 +00:00
appendix2 = std : : to_string ( channel ) ;
2015-05-11 15:18:26 +00:00
}
2017-06-01 23:53:17 +00:00
2021-02-09 22:47:34 +00:00
aux = configuration - > property ( " TelemetryDecoder_ " + signal + std : : to_string ( channel ) + impl_prop , std : : string ( " W " ) ) ;
2018-03-24 18:42:04 +00:00
std : : string appendix3 ;
2018-12-02 22:54:27 +00:00
if ( aux ! = " W " )
2018-03-24 18:42:04 +00:00
{
2018-05-01 21:32:52 +00:00
appendix3 = std : : to_string ( channel ) ;
2018-03-24 18:42:04 +00:00
}
2017-11-30 16:42:19 +00:00
// Automatically detect input data type
2020-07-09 22:37:55 +00:00
const std : : string default_item_type ( " gr_complex " ) ;
2021-02-09 22:47:34 +00:00
std : : string acq_item_type = configuration - > property ( " Acquisition_ " + signal + appendix1 + item_prop , default_item_type ) ;
std : : string trk_item_type = configuration - > property ( " Tracking_ " + signal + appendix2 + item_prop , default_item_type ) ;
2018-12-02 22:54:27 +00:00
if ( acq_item_type ! = trk_item_type )
2017-11-30 16:42:19 +00:00
{
2021-02-27 10:05:39 +00:00
std : : cerr < < " Configuration error: Acquisition and Tracking blocks must have the same input data type! \n " ;
2021-01-24 00:49:16 +00:00
return nullptr ;
2017-11-30 16:42:19 +00:00
}
2020-07-12 21:08:58 +00:00
LOG ( INFO ) < < " Instantiating Channel " < < channel
< < " with Acquisition Implementation: "
2021-02-09 22:47:34 +00:00
< < configuration - > property ( " Acquisition_ " + signal + appendix1 + impl_prop , std : : string ( " W " ) )
2020-07-12 21:08:58 +00:00
< < " , Tracking Implementation: "
2021-02-09 22:47:34 +00:00
< < configuration - > property ( " Tracking_ " + signal + appendix2 + impl_prop , std : : string ( " W " ) )
2020-07-12 21:08:58 +00:00
< < " , Telemetry Decoder implementation: "
2021-02-09 22:47:34 +00:00
< < configuration - > property ( " TelemetryDecoder_ " + signal + appendix3 + impl_prop , std : : string ( " W " ) ) ;
2017-11-30 16:42:19 +00:00
2020-07-12 21:08:58 +00:00
std : : unique_ptr < AcquisitionInterface > acq_ = GetAcqBlock ( configuration , " Acquisition_ " + signal + appendix1 , 1 , 0 ) ;
std : : unique_ptr < TrackingInterface > trk_ = GetTrkBlock ( configuration , " Tracking_ " + signal + appendix2 , 1 , 1 ) ;
std : : unique_ptr < TelemetryDecoderInterface > tlm_ = GetTlmBlock ( configuration , " TelemetryDecoder_ " + signal + appendix3 , 1 , 1 ) ;
2018-06-15 02:19:32 +00:00
2021-01-24 00:49:16 +00:00
if ( acq_ = = nullptr or trk_ = = nullptr or tlm_ = = nullptr )
{
return nullptr ;
}
2021-01-26 13:01:28 +00:00
if ( trk_ - > item_size ( ) = = 0 )
{
2021-02-27 10:05:39 +00:00
std : : cerr < < " Configuration error: " < < trk_ - > role ( ) < < item_prop < < " = " < < acq_item_type < < " is not defined for implementation " < < trk_ - > implementation ( ) < < ' \n ' ;
2021-01-26 13:01:28 +00:00
return nullptr ;
}
2021-01-24 00:49:16 +00:00
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > channel_ = std : : make_unique < Channel > ( configuration , channel ,
2018-06-15 02:19:32 +00:00
std : : move ( acq_ ) ,
std : : move ( trk_ ) ,
std : : move ( tlm_ ) ,
2020-07-12 21:08:58 +00:00
" Channel " , signal , queue ) ;
2018-06-15 02:19:32 +00:00
return channel_ ;
}
2019-01-25 21:43:00 +00:00
2020-07-12 21:08:58 +00:00
std : : unique_ptr < std : : vector < std : : unique_ptr < GNSSBlockInterface > > > GNSSBlockFactory : : GetChannels (
2020-06-29 07:07:41 +00:00
const ConfigurationInterface * configuration ,
2020-06-18 09:49:28 +00:00
Concurrent_Queue < pmt : : pmt_t > * queue )
2019-01-25 21:43:00 +00:00
{
2020-07-09 22:37:55 +00:00
int channel_absolute_id = 0 ;
2015-05-08 23:48:16 +00:00
2020-07-12 21:08:58 +00:00
const unsigned int Channels_1C_count = configuration - > property ( " Channels_1C.count " , 0 ) ;
const unsigned int Channels_1B_count = configuration - > property ( " Channels_1B.count " , 0 ) ;
const unsigned int Channels_1G_count = configuration - > property ( " Channels_1G.count " , 0 ) ;
const unsigned int Channels_2G_count = configuration - > property ( " Channels_2G.count " , 0 ) ;
const unsigned int Channels_2S_count = configuration - > property ( " Channels_2S.count " , 0 ) ;
const unsigned int Channels_5X_count = configuration - > property ( " Channels_5X.count " , 0 ) ;
const unsigned int Channels_L5_count = configuration - > property ( " Channels_L5.count " , 0 ) ;
const unsigned int Channels_B1_count = configuration - > property ( " Channels_B1.count " , 0 ) ;
const unsigned int Channels_B3_count = configuration - > property ( " Channels_B3.count " , 0 ) ;
const unsigned int Channels_7X_count = configuration - > property ( " Channels_7X.count " , 0 ) ;
2020-11-07 20:33:26 +00:00
const unsigned int Channels_E6_count = configuration - > property ( " Channels_E6.count " , 0 ) ;
2020-07-12 21:08:58 +00:00
const unsigned int total_channels = Channels_1C_count +
Channels_1B_count +
Channels_1G_count +
Channels_2S_count +
Channels_2G_count +
Channels_5X_count +
Channels_L5_count +
Channels_B1_count +
Channels_B3_count +
2020-11-07 20:33:26 +00:00
Channels_7X_count +
Channels_E6_count ;
2018-01-23 23:52:09 +00:00
2020-06-18 09:49:28 +00:00
auto channels = std : : make_unique < std : : vector < std : : unique_ptr < GNSSBlockInterface > > > ( total_channels ) ;
2018-05-01 21:32:52 +00:00
try
{
2020-07-12 21:08:58 +00:00
// **************** GPS L1 C/A CHANNELS ****************************
2018-05-01 21:32:52 +00:00
LOG ( INFO ) < < " Getting " < < Channels_1C_count < < " GPS L1 C/A channels " ;
for ( unsigned int i = 0 ; i < Channels_1C_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " 1C " ) ,
2018-05-01 21:32:52 +00:00
channel_absolute_id ,
2018-06-03 12:50:22 +00:00
queue ) ;
2018-05-01 21:32:52 +00:00
channel_absolute_id + + ;
}
2020-07-12 21:08:58 +00:00
// **************** GPS L2C (M) CHANNELS ***************************
2018-05-01 21:32:52 +00:00
LOG ( INFO ) < < " Getting " < < Channels_2S_count < < " GPS L2C (M) channels " ;
2020-07-12 21:08:58 +00:00
2018-05-01 21:32:52 +00:00
for ( unsigned int i = 0 ; i < Channels_2S_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " 2S " ) ,
2018-05-01 21:32:52 +00:00
channel_absolute_id ,
2018-06-03 12:50:22 +00:00
queue ) ;
2018-05-01 21:32:52 +00:00
channel_absolute_id + + ;
}
2020-07-12 21:08:58 +00:00
// **************** GPS L5 CHANNELS ********************************
2018-05-01 21:32:52 +00:00
LOG ( INFO ) < < " Getting " < < Channels_L5_count < < " GPS L5 channels " ;
2020-07-12 21:08:58 +00:00
2018-05-01 21:32:52 +00:00
for ( unsigned int i = 0 ; i < Channels_L5_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " L5 " ) ,
2018-05-01 21:32:52 +00:00
channel_absolute_id ,
2018-06-03 12:50:22 +00:00
queue ) ;
2018-05-01 21:32:52 +00:00
channel_absolute_id + + ;
}
2020-07-12 21:08:58 +00:00
// **************** GALILEO E1 B (I/NAV OS) CHANNELS ***************
2018-05-01 21:32:52 +00:00
LOG ( INFO ) < < " Getting " < < Channels_1B_count < < " GALILEO E1 B (I/NAV OS) channels " ;
2020-07-12 21:08:58 +00:00
2018-05-01 21:32:52 +00:00
for ( unsigned int i = 0 ; i < Channels_1B_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " 1B " ) ,
2018-05-01 21:32:52 +00:00
channel_absolute_id ,
2018-06-03 12:50:22 +00:00
queue ) ;
2018-05-01 21:32:52 +00:00
channel_absolute_id + + ;
}
2020-07-12 21:08:58 +00:00
// **************** GALILEO E5a I (F/NAV OS) CHANNELS **************
2018-05-01 21:32:52 +00:00
LOG ( INFO ) < < " Getting " < < Channels_5X_count < < " GALILEO E5a I (F/NAV OS) channels " ;
2020-07-12 21:08:58 +00:00
2018-05-01 21:32:52 +00:00
for ( unsigned int i = 0 ; i < Channels_5X_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " 5X " ) ,
2018-05-01 21:32:52 +00:00
channel_absolute_id ,
2018-06-03 12:50:22 +00:00
queue ) ;
2018-05-01 21:32:52 +00:00
channel_absolute_id + + ;
}
2020-11-07 20:33:26 +00:00
// **************** GALILEO E6 (B/C HAS) CHANNELS **************
LOG ( INFO ) < < " Getting " < < Channels_E6_count < < " GALILEO E6 (B/C HAS) channels " ;
for ( unsigned int i = 0 ; i < Channels_E6_count ; i + + )
{
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " E6 " ) ,
channel_absolute_id ,
queue ) ;
channel_absolute_id + + ;
}
2020-07-12 21:08:58 +00:00
// **************** GLONASS L1 C/A CHANNELS ************************
2018-05-01 21:32:52 +00:00
LOG ( INFO ) < < " Getting " < < Channels_1G_count < < " GLONASS L1 C/A channels " ;
for ( unsigned int i = 0 ; i < Channels_1G_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " 1G " ) ,
2018-05-01 21:32:52 +00:00
channel_absolute_id ,
2018-06-03 12:50:22 +00:00
queue ) ;
2018-05-01 21:32:52 +00:00
channel_absolute_id + + ;
}
2020-07-12 21:08:58 +00:00
// **************** GLONASS L2 C/A CHANNELS ************************
2018-05-01 21:32:52 +00:00
LOG ( INFO ) < < " Getting " < < Channels_2G_count < < " GLONASS L2 C/A channels " ;
for ( unsigned int i = 0 ; i < Channels_2G_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " 2G " ) ,
2018-05-01 21:32:52 +00:00
channel_absolute_id ,
2018-06-03 12:50:22 +00:00
queue ) ;
2018-05-01 21:32:52 +00:00
channel_absolute_id + + ;
}
2018-12-18 21:55:36 +00:00
2020-07-12 21:08:58 +00:00
// **************** BEIDOU B1I CHANNELS ****************************
2018-06-15 02:40:50 +00:00
LOG ( INFO ) < < " Getting " < < Channels_B1_count < < " BEIDOU B1I channels " ;
for ( unsigned int i = 0 ; i < Channels_B1_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " B1 " ) ,
2018-06-15 02:40:50 +00:00
channel_absolute_id ,
queue ) ;
channel_absolute_id + + ;
}
2020-07-12 21:08:58 +00:00
// **************** BEIDOU B3I CHANNELS ****************************
2019-01-25 21:43:00 +00:00
LOG ( INFO ) < < " Getting " < < Channels_B3_count < < " BEIDOU B3I channels " ;
for ( unsigned int i = 0 ; i < Channels_B3_count ; i + + )
{
2020-07-12 21:08:58 +00:00
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " B3 " ) ,
channel_absolute_id ,
queue ) ;
channel_absolute_id + + ;
}
// **************** GALILEO E5b I (I/NAV OS) CHANNELS **************
LOG ( INFO ) < < " Getting " < < Channels_7X_count < < " GALILEO E5b I (I/NAV OS) channels " ;
for ( unsigned int i = 0 ; i < Channels_7X_count ; i + + )
{
// Store the channel into the vector of channels
channels - > at ( channel_absolute_id ) = GetChannel ( configuration ,
std : : string ( " 7X " ) ,
2019-01-25 21:43:00 +00:00
channel_absolute_id ,
queue ) ;
channel_absolute_id + + ;
}
2018-05-01 21:32:52 +00:00
}
2019-02-11 14:53:50 +00:00
catch ( const std : : exception & e )
2018-05-01 21:32:52 +00:00
{
LOG ( WARNING ) < < e . what ( ) ;
2018-03-24 18:42:04 +00:00
}
2011-10-01 18:45:20 +00:00
return channels ;
}
2018-01-26 11:49:04 +00:00
2014-03-16 19:58:29 +00:00
/*
* Returns the block with the required configuration and implementation
*
* PLEASE ADD YOUR NEW BLOCK HERE ! !
2014-04-23 23:53:55 +00:00
*
* IMPORTANT NOTE : Acquisition , Tracking and telemetry blocks are only included here for testing purposes .
* To be included in a channel they must be also be included in GetAcqBlock ( ) , GetTrkBlock ( ) and GetTlmBlock ( )
* ( see below )
2014-03-16 19:58:29 +00:00
*/
2014-04-11 18:18:59 +00:00
std : : unique_ptr < GNSSBlockInterface > GNSSBlockFactory : : GetBlock (
2020-06-29 07:07:41 +00:00
const ConfigurationInterface * configuration ,
2019-02-05 00:31:09 +00:00
const std : : string & role ,
2020-07-12 21:08:58 +00:00
unsigned int in_streams ,
unsigned int out_streams ,
Concurrent_Queue < pmt : : pmt_t > * queue )
2011-10-01 18:45:20 +00:00
{
2014-04-11 18:18:59 +00:00
std : : unique_ptr < GNSSBlockInterface > block ;
2021-02-09 22:47:34 +00:00
const std : : string implementation = configuration - > property ( role + impl_prop , " Pass_Through " s ) ;
2011-12-27 21:21:12 +00:00
2021-02-09 22:47:34 +00:00
try
2012-07-15 11:08:10 +00:00
{
2021-02-09 22:47:34 +00:00
// PASS THROUGH ------------------------------------------------------------
if ( implementation = = " Pass_Through " )
2018-03-03 01:03:39 +00:00
{
2021-02-09 22:47:34 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < Pass_Through > ( configuration , role , in_streams , out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
2018-03-03 01:03:39 +00:00
}
2014-04-11 18:18:59 +00:00
2021-02-09 22:47:34 +00:00
// SIGNAL SOURCES ----------------------------------------------------------
2021-04-17 12:46:48 +00:00
else if ( implementation = = " Fifo_Signal_Source " )
2021-04-17 17:32:10 +00:00
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < FifoSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
}
2021-02-09 22:47:34 +00:00
else if ( implementation = = " File_Signal_Source " )
2019-06-17 16:13:06 +00:00
{
2021-02-09 22:47:34 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < FileSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
2019-06-17 16:13:06 +00:00
}
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Multichannel_File_Signal_Source " )
2019-06-17 16:13:06 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < MultichannelFileSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2019-06-17 16:13:06 +00:00
block = std : : move ( block_ ) ;
}
2018-05-16 09:36:37 +00:00
# if RAW_UDP
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Custom_UDP_Signal_Source " )
2018-05-01 19:25:15 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < CustomUDPSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2018-05-01 19:25:15 +00:00
block = std : : move ( block_ ) ;
}
2018-05-16 09:36:37 +00:00
# endif
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Nsr_File_Signal_Source " )
2018-03-03 01:03:39 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < NsrFileSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
2018-03-03 01:03:39 +00:00
}
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Two_Bit_Cpx_File_Signal_Source " )
2018-03-03 01:03:39 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < TwoBitCpxFileSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2015-07-02 15:59:43 +00:00
block = std : : move ( block_ ) ;
2018-03-03 01:03:39 +00:00
}
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Two_Bit_Packed_File_Signal_Source " )
2018-03-03 01:03:39 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < TwoBitPackedFileSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2018-03-03 01:03:39 +00:00
block = std : : move ( block_ ) ;
}
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Spir_File_Signal_Source " )
2018-03-03 01:03:39 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < SpirFileSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2015-01-14 16:26:41 +00:00
block = std : : move ( block_ ) ;
2018-03-03 01:03:39 +00:00
}
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Spir_GSS6450_File_Signal_Source " )
2018-03-03 01:03:39 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < SpirGSS6450FileSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2018-01-16 16:20:55 +00:00
block = std : : move ( block_ ) ;
2018-03-03 01:03:39 +00:00
}
2021-02-09 22:47:34 +00:00
else if ( implementation = = " RtlTcp_Signal_Source " )
2018-03-03 01:03:39 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < RtlTcpSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2015-01-14 16:26:41 +00:00
block = std : : move ( block_ ) ;
2018-03-03 01:03:39 +00:00
}
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Labsat_Signal_Source " )
2018-03-03 01:03:39 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < LabsatSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
2018-01-23 16:31:42 +00:00
block = std : : move ( block_ ) ;
2018-03-03 01:03:39 +00:00
}
2021-02-09 22:47:34 +00:00
# if UHD_DRIVER
else if ( implementation = = " UHD_Signal_Source " )
2018-03-03 01:03:39 +00:00
{
2021-02-09 22:47:34 +00:00
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < UhdSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
2018-03-03 01:03:39 +00:00
}
2014-11-14 20:42:22 +00:00
# endif
2021-02-09 22:47:34 +00:00
2012-07-30 15:46:07 +00:00
# if GN3S_DRIVER
2021-02-09 22:47:34 +00:00
else if ( implementation = = " GN3S_Signal_Source " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < Gn3sSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
}
2012-07-30 15:46:07 +00:00
# endif
2011-12-27 21:21:12 +00:00
2014-02-17 18:53:45 +00:00
# if RAW_ARRAY_DRIVER
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Raw_Array_Signal_Source " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < RawArraySignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
}
2014-02-17 18:53:45 +00:00
# endif
2014-12-15 16:39:22 +00:00
# if OSMOSDR_DRIVER
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Osmosdr_Signal_Source " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < OsmosdrSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
}
2012-08-01 13:11:02 +00:00
# endif
2017-10-29 05:51:22 +00:00
# if PLUTOSDR_DRIVER
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Plutosdr_Signal_Source " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < PlutosdrSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
}
2017-10-29 05:51:22 +00:00
# endif
# if FMCOMMS2_DRIVER
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Fmcomms2_Signal_Source " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < Fmcomms2SignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
}
2018-03-02 10:30:36 +00:00
# endif
2015-03-03 17:07:26 +00:00
# if FLEXIBAND_DRIVER
2021-02-09 22:47:34 +00:00
else if ( implementation = = " Flexiband_Signal_Source " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < FlexibandSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
}
2015-03-03 17:07:26 +00:00
# endif
2020-07-13 13:38:29 +00:00
# if AD9361_DRIVER
2021-02-09 22:47:34 +00:00
// The AD9361_DRIVER Driver must be instantiated last. In this way, when using the FPGA, and when using the GNSS receiver
// in post-processing mode, the receiver is configured and ready when the DMA starts sending samples to the receiver.
else if ( implementation = = " Ad9361_Fpga_Signal_Source " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < Ad9361FpgaSignalSource > ( configuration , role , in_streams ,
out_streams , queue ) ;
block = std : : move ( block_ ) ;
}
2020-07-13 13:38:29 +00:00
# endif
2021-02-09 22:47:34 +00:00
// DATA TYPE ADAPTER -----------------------------------------------------------
else if ( implementation = = " Byte_To_Short " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < ByteToShort > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Ibyte_To_Cbyte " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < IbyteToCbyte > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Ibyte_To_Cshort " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < IbyteToCshort > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Ibyte_To_Complex " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < IbyteToComplex > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Ishort_To_Cshort " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < IshortToCshort > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Ishort_To_Complex " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < IshortToComplex > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2015-02-03 18:40:26 +00:00
2021-02-09 22:47:34 +00:00
// INPUT FILTER ------------------------------------------------------------
else if ( implementation = = " Fir_Filter " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < FirFilter > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Freq_Xlating_Fir_Filter " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < FreqXlatingFirFilter > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Beamformer_Filter " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < BeamformerFilter > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Pulse_Blanking_Filter " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < PulseBlankingFilter > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Notch_Filter " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < NotchFilter > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Notch_Filter_Lite " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < NotchFilterLite > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2017-02-21 10:35:18 +00:00
2021-02-09 22:47:34 +00:00
// RESAMPLER ---------------------------------------------------------------
else if ( implementation = = " Direct_Resampler " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < DirectResamplerConditioner > ( configuration , role ,
in_streams , out_streams ) ;
block = std : : move ( block_ ) ;
}
2011-12-27 21:21:12 +00:00
2021-02-09 22:47:34 +00:00
else if ( ( implementation = = " Fractional_Resampler " ) | | ( implementation = = " Mmse_Resampler " ) )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < MmseResamplerConditioner > ( configuration , role ,
in_streams , out_streams ) ;
block = std : : move ( block_ ) ;
}
2018-01-31 09:46:41 +00:00
2021-02-09 22:47:34 +00:00
// ACQUISITION BLOCKS ------------------------------------------------------
else if ( implementation = = " GPS_L1_CA_PCPS_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L1_CA_PCPS_Assisted_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaPcpsAssistedAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L1_CA_PCPS_Tong_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaPcpsTongAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L1_CA_PCPS_Acquisition_Fine_Doppler " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaPcpsAcquisitionFineDoppler > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L1_CA_PCPS_QuickSync_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaPcpsQuickSyncAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L2_M_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL2MPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L5i_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL5iPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_PCPS_Ambiguous_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1PcpsAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_PCPS_8ms_Ambiguous_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1Pcps8msAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_PCPS_Tong_Ambiguous_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1PcpsTongAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1PcpsCccwsrAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1PcpsQuickSyncAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5a_Noncoherent_IQ_Acquisition_CAF " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5aNoncoherentIQAcquisitionCaf > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5a_Pcps_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5aPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5b_PCPS_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5bPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E6_PCPS_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE6PcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L1_CA_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GlonassL1CaPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L2_CA_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GlonassL2CaPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " BEIDOU_B1I_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < BeidouB1iPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " BEIDOU_B3I_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < BeidouB3iPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2020-07-13 13:38:29 +00:00
# if OPENCL_BLOCKS
2021-02-09 22:47:34 +00:00
else if ( implementation = = " GPS_L1_CA_PCPS_OpenCl_Acquisition " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaPcpsOpenClAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2020-07-13 13:38:29 +00:00
# endif
2020-07-13 10:24:27 +00:00
# if ENABLE_FPGA
2021-02-09 22:47:34 +00:00
else if ( implementation = = " GPS_L1_CA_PCPS_Acquisition_Fpga " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaPcpsAcquisitionFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_PCPS_Ambiguous_Acquisition_Fpga " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1PcpsAmbiguousAcquisitionFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L2_M_PCPS_Acquisition_Fpga " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL2MPcpsAcquisitionFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L5i_PCPS_Acquisition_Fpga " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL5iPcpsAcquisitionFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5a_Pcps_Acquisition_Fpga " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5aPcpsAcquisitionFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5b_PCPS_Acquisition_FPGA " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE5bPcpsAcquisitionFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2018-08-01 13:55:40 +00:00
# endif
2020-07-13 10:24:27 +00:00
2021-02-09 22:47:34 +00:00
// TRACKING BLOCKS ---------------------------------------------------------
else if ( implementation = = " GPS_L1_CA_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L1_CA_KF_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaKfTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L1_CA_TCP_CONNECTOR_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaTcpConnectorTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L2_M_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL2MDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( ( implementation = = " GPS_L5i_DLL_PLL_Tracking " ) or ( implementation = = " GPS_L5_DLL_PLL_Tracking " ) )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL5DllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_DLL_PLL_VEML_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1DllPllVemlTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_TCP_CONNECTOR_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1TcpConnectorTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5a_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5aDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5b_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5bDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E6_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE6DllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L1_CA_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GlonassL1CaDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L1_CA_DLL_PLL_C_Aid_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GlonassL1CaDllPllCAidTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L2_CA_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GlonassL2CaDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L2_CA_DLL_PLL_C_Aid_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GlonassL2CaDllPllCAidTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " BEIDOU_B1I_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < BeidouB1iDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " BEIDOU_B3I_DLL_PLL_Tracking " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < BeidouB3iDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2020-07-13 13:38:29 +00:00
# if CUDA_GPU_ACCEL
2021-02-09 22:47:34 +00:00
else if ( implementation = = " GPS_L1_CA_DLL_PLL_Tracking_GPU " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaDllPllTrackingGPU > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2020-07-13 13:38:29 +00:00
# endif
2020-07-13 10:24:27 +00:00
# if ENABLE_FPGA
2021-02-09 22:47:34 +00:00
else if ( implementation = = " GPS_L1_CA_DLL_PLL_Tracking_Fpga " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL1CaDllPllTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_DLL_PLL_VEML_Tracking_Fpga " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GalileoE1DllPllVemlTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L2_M_DLL_PLL_Tracking_Fpga " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL2MDllPllTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( ( implementation = = " GPS_L5i_DLL_PLL_Tracking_Fpga " ) or ( implementation = = " GPS_L5_DLL_PLL_Tracking_Fpga " ) )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL5DllPllTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5a_DLL_PLL_Tracking_Fpga " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5aDllPllTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2020-07-13 10:24:27 +00:00
# endif
2020-07-12 21:08:58 +00:00
2021-02-09 22:47:34 +00:00
// TELEMETRY DECODERS ------------------------------------------------------
else if ( implementation = = " GPS_L1_CA_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL1CaTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L2C_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL2CTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L5_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GpsL5TelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " SBAS_L1_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < SbasL1TelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1B_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE1BTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5a_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5aTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5b_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE5bTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E6_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GalileoE6TelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L1_CA_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GlonassL1CaTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L2_CA_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < GlonassL2CaTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " BEIDOU_B1I_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < BeidouB1iTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " BEIDOU_B3I_Telemetry_Decoder " )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < BeidouB3iTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2018-07-06 12:42:13 +00:00
2021-02-09 22:47:34 +00:00
// OBSERVABLES -------------------------------------------------------------
else if ( ( implementation = = " Hybrid_Observables " ) | | ( implementation = = " GPS_L1_CA_Observables " ) | | ( implementation = = " GPS_L2C_Observables " ) | |
( implementation = = " Galileo_E5A_Observables " ) )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < HybridObservables > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2018-01-26 11:49:04 +00:00
2021-02-09 22:47:34 +00:00
// PVT ---------------------------------------------------------------------
else if ( ( implementation = = " RTKLIB_PVT " ) | | ( implementation = = " GPS_L1_CA_PVT " ) | | ( implementation = = " Galileo_E1_PVT " ) | | ( implementation = = " Hybrid_PVT " ) )
{
std : : unique_ptr < GNSSBlockInterface > block_ = std : : make_unique < Rtklib_Pvt > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2019-10-01 14:01:44 +00:00
2021-02-09 22:47:34 +00:00
else
{
2021-02-27 10:05:39 +00:00
std : : cerr < < " Configuration error in " < < role < < " block: implementation " + implementation + " is not available. \n " s ;
block = nullptr ;
2021-02-09 22:47:34 +00:00
}
}
catch ( const std : : exception & e )
2011-12-28 21:36:45 +00:00
{
2021-02-27 10:05:39 +00:00
std : : cout < < " Configuration error. GNSS-SDR program ended. \n " ;
LOG ( INFO ) < < " Exception raised while instantiating a block: " < < e . what ( ) ;
2021-02-09 22:47:34 +00:00
exit ( 1 ) ;
2011-12-28 21:36:45 +00:00
}
2018-06-03 12:50:22 +00:00
return block ;
2014-04-11 18:18:59 +00:00
}
2014-04-13 16:58:52 +00:00
/*
2014-04-23 23:53:55 +00:00
*
* PLEASE ADD YOUR NEW BLOCK HERE ! !
*
* Not very elegant , Acq , Trk and Tlm blocks must be added here , too .
* To be improved !
2014-04-13 16:58:52 +00:00
*/
2014-04-11 18:18:59 +00:00
std : : unique_ptr < AcquisitionInterface > GNSSBlockFactory : : GetAcqBlock (
2020-06-29 07:07:41 +00:00
const ConfigurationInterface * configuration ,
2019-02-05 00:31:09 +00:00
const std : : string & role ,
2020-07-12 21:08:58 +00:00
unsigned int in_streams ,
2018-03-03 01:03:39 +00:00
unsigned int out_streams )
2014-04-11 18:18:59 +00:00
{
std : : unique_ptr < AcquisitionInterface > block ;
2021-02-09 22:47:34 +00:00
const std : : string implementation = configuration - > property ( role + impl_prop , " Wrong " s ) ;
2020-07-12 21:08:58 +00:00
// ACQUISITION BLOCKS ------------------------------------------------------
2018-12-02 22:54:27 +00:00
if ( implementation = = " GPS_L1_CA_PCPS_Acquisition " )
2014-04-11 18:18:59 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL1CaPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L1_CA_PCPS_Assisted_Acquisition " )
2014-04-11 18:18:59 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL1CaPcpsAssistedAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L1_CA_PCPS_Tong_Acquisition " )
2014-04-11 18:18:59 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL1CaPcpsTongAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L1_CA_PCPS_Acquisition_Fine_Doppler " )
2014-04-11 18:18:59 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL1CaPcpsAcquisitionFineDoppler > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L1_CA_PCPS_QuickSync_Acquisition " )
2014-07-23 23:38:58 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL1CaPcpsQuickSyncAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-07-23 23:38:58 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L2_M_PCPS_Acquisition " )
2015-04-24 17:11:45 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL2MPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2015-04-24 17:11:45 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L5i_PCPS_Acquisition " )
2017-12-04 16:07:54 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL5iPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2017-12-04 16:07:54 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E1_PCPS_Ambiguous_Acquisition " )
2014-04-11 18:18:59 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE1PcpsAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E1_PCPS_8ms_Ambiguous_Acquisition " )
2014-04-11 18:18:59 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE1Pcps8msAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E1_PCPS_Tong_Ambiguous_Acquisition " )
2014-04-11 18:18:59 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE1PcpsTongAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition " )
2014-04-11 18:18:59 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE1PcpsCccwsrAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-11 18:18:59 +00:00
block = std : : move ( block_ ) ;
}
2014-09-05 16:51:08 +00:00
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition " )
2014-07-23 23:38:58 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE1PcpsQuickSyncAmbiguousAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2014-07-23 23:38:58 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E5a_Noncoherent_IQ_Acquisition_CAF " )
2014-06-05 10:00:24 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE5aNoncoherentIQAcquisitionCaf > ( configuration , role , in_streams ,
out_streams ) ;
2014-07-07 19:06:26 +00:00
block = std : : move ( block_ ) ;
2014-06-05 10:00:24 +00:00
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E5a_Pcps_Acquisition " )
2018-02-07 13:26:25 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE5aPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
2018-02-07 13:26:25 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 09:02:44 +00:00
else if ( implementation = = " Galileo_E5b_PCPS_Acquisition " )
2018-08-01 13:55:40 +00:00
{
2020-07-13 09:02:44 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE5bPcpsAcquisition > ( configuration , role , in_streams ,
2020-06-18 09:49:28 +00:00
out_streams ) ;
2020-06-12 12:07:36 +00:00
block = std : : move ( block_ ) ;
}
2020-11-07 20:33:26 +00:00
else if ( implementation = = " Galileo_E6_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE6PcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2020-07-13 10:24:27 +00:00
else if ( implementation = = " GLONASS_L1_CA_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GlonassL1CaPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GLONASS_L2_CA_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GlonassL2CaPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " BEIDOU_B1I_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < BeidouB1iPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " BEIDOU_B3I_PCPS_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < BeidouB3iPcpsAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2020-07-13 13:38:29 +00:00
# if OPENCL_BLOCKS
else if ( implementation = = " GPS_L1_CA_PCPS_OpenCl_Acquisition " )
{
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL1CaPcpsOpenClAcquisition > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
# endif
2018-08-01 13:55:40 +00:00
# if ENABLE_FPGA
2020-07-13 10:24:27 +00:00
else if ( implementation = = " GPS_L1_CA_PCPS_Acquisition_Fpga " )
2018-08-01 13:55:40 +00:00
{
2020-07-13 10:24:27 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL1CaPcpsAcquisitionFpga > ( configuration , role , in_streams ,
2020-06-18 09:49:28 +00:00
out_streams ) ;
2018-08-01 13:55:40 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 10:24:27 +00:00
else if ( implementation = = " Galileo_E1_PCPS_Ambiguous_Acquisition_Fpga " )
2020-06-12 12:07:36 +00:00
{
2020-07-13 10:24:27 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE1PcpsAmbiguousAcquisitionFpga > ( configuration , role , in_streams ,
2020-06-18 17:48:53 +00:00
out_streams ) ;
2018-08-01 13:55:40 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 10:24:27 +00:00
else if ( implementation = = " GPS_L2_M_PCPS_Acquisition_Fpga " )
2017-06-01 23:53:17 +00:00
{
2020-07-13 10:24:27 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL2MPcpsAcquisitionFpga > ( configuration , role , in_streams ,
2020-06-18 09:49:28 +00:00
out_streams ) ;
2017-06-01 23:53:17 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 10:24:27 +00:00
else if ( implementation = = " GPS_L5i_PCPS_Acquisition_Fpga " )
2018-03-24 18:42:04 +00:00
{
2020-07-13 10:24:27 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GpsL5iPcpsAcquisitionFpga > ( configuration , role , in_streams ,
2020-06-18 09:49:28 +00:00
out_streams ) ;
2018-03-24 18:42:04 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 10:24:27 +00:00
else if ( implementation = = " Galileo_E5a_Pcps_Acquisition_Fpga " )
2018-07-06 12:42:13 +00:00
{
2020-07-13 10:24:27 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE5aPcpsAcquisitionFpga > ( configuration , role , in_streams ,
2020-06-18 09:49:28 +00:00
out_streams ) ;
2018-07-06 12:42:13 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 10:24:27 +00:00
else if ( implementation = = " Galileo_E5b_PCPS_Acquisition_FPGA " )
2019-01-25 21:43:00 +00:00
{
2020-07-13 10:24:27 +00:00
std : : unique_ptr < AcquisitionInterface > block_ = std : : make_unique < GalileoE5bPcpsAcquisitionFpga > ( configuration , role , in_streams ,
2020-06-18 09:49:28 +00:00
out_streams ) ;
2019-01-25 21:43:00 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 10:24:27 +00:00
# endif
2014-04-11 18:18:59 +00:00
else
2014-04-13 16:58:52 +00:00
{
2021-02-27 10:05:39 +00:00
std : : cerr < < " Configuration error in " < < role < < " block: implementation " < < ( implementation = = " Wrong " s ? " not defined. " s : implementation + " not available. " s ) < < ' \n ' ;
block = nullptr ;
2014-04-13 16:58:52 +00:00
}
2018-06-03 12:50:22 +00:00
return block ;
2014-04-11 18:18:59 +00:00
}
std : : unique_ptr < TrackingInterface > GNSSBlockFactory : : GetTrkBlock (
2020-06-29 07:07:41 +00:00
const ConfigurationInterface * configuration ,
2019-02-05 00:31:09 +00:00
const std : : string & role ,
2020-07-12 21:08:58 +00:00
unsigned int in_streams ,
2018-03-03 01:03:39 +00:00
unsigned int out_streams )
2014-04-11 18:18:59 +00:00
{
std : : unique_ptr < TrackingInterface > block ;
2021-02-09 22:47:34 +00:00
const std : : string implementation = configuration - > property ( role + impl_prop , " Wrong " s ) ;
2014-04-11 18:18:59 +00:00
2020-07-12 21:08:58 +00:00
// TRACKING BLOCKS ---------------------------------------------------------
2018-12-02 22:54:27 +00:00
if ( implementation = = " GPS_L1_CA_DLL_PLL_Tracking " )
2014-04-13 16:58:52 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL1CaDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-13 16:58:52 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L1_CA_KF_Tracking " )
2018-03-13 09:51:33 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL1CaKfTracking > ( configuration , role , in_streams ,
out_streams ) ;
2018-03-13 09:51:33 +00:00
block = std : : move ( block_ ) ;
2014-04-13 16:58:52 +00:00
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L1_CA_TCP_CONNECTOR_Tracking " )
2014-04-13 16:58:52 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL1CaTcpConnectorTracking > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-13 16:58:52 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E1_DLL_PLL_VEML_Tracking " )
2014-04-13 16:58:52 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GalileoE1DllPllVemlTracking > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-13 16:58:52 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E1_TCP_CONNECTOR_Tracking " )
2014-04-13 16:58:52 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GalileoE1TcpConnectorTracking > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-13 16:58:52 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E5a_DLL_PLL_Tracking " )
2014-06-20 16:23:44 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GalileoE5aDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
2014-06-20 16:23:44 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 22:45:07 +00:00
else if ( implementation = = " Galileo_E5b_DLL_PLL_Tracking " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GalileoE5bDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2020-11-07 20:33:26 +00:00
else if ( implementation = = " Galileo_E6_DLL_PLL_Tracking " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GalileoE6DllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L2_M_DLL_PLL_Tracking " )
2015-04-30 15:48:21 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL2MDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
2015-04-30 15:48:21 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( ( implementation = = " GPS_L5i_DLL_PLL_Tracking " ) or ( implementation = = " GPS_L5_DLL_PLL_Tracking " ) )
2017-12-04 16:07:54 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL5DllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
2017-12-04 16:07:54 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GLONASS_L1_CA_DLL_PLL_Tracking " )
2017-07-24 01:49:15 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GlonassL1CaDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
2017-07-24 01:49:15 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GLONASS_L1_CA_DLL_PLL_C_Aid_Tracking " )
2017-08-17 14:08:12 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GlonassL1CaDllPllCAidTracking > ( configuration , role , in_streams ,
out_streams ) ;
2017-08-17 14:08:12 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GLONASS_L2_CA_DLL_PLL_Tracking " )
2018-03-24 18:42:04 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GlonassL2CaDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
2018-03-24 18:42:04 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GLONASS_L2_CA_DLL_PLL_C_Aid_Tracking " )
2018-03-24 18:42:04 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GlonassL2CaDllPllCAidTracking > ( configuration , role , in_streams ,
out_streams ) ;
2018-03-24 18:42:04 +00:00
block = std : : move ( block_ ) ;
}
2018-12-18 21:55:36 +00:00
else if ( implementation = = " BEIDOU_B1I_DLL_PLL_Tracking " )
2018-07-06 12:42:13 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < BeidouB1iDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
2018-07-06 12:42:13 +00:00
block = std : : move ( block_ ) ;
}
2019-01-25 21:43:00 +00:00
else if ( implementation = = " BEIDOU_B3I_DLL_PLL_Tracking " )
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < BeidouB3iDllPllTracking > ( configuration , role , in_streams ,
out_streams ) ;
2019-01-25 21:43:00 +00:00
block = std : : move ( block_ ) ;
}
2020-07-13 13:38:29 +00:00
# if CUDA_GPU_ACCEL
else if ( implementation = = " GPS_L1_CA_DLL_PLL_Tracking_GPU " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL1CaDllPllTrackingGPU > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
# endif
2020-07-13 10:24:27 +00:00
# if ENABLE_FPGA
else if ( implementation = = " GPS_L1_CA_DLL_PLL_Tracking_Fpga " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL1CaDllPllTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E1_DLL_PLL_VEML_Tracking_Fpga " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GalileoE1DllPllVemlTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " GPS_L2_M_DLL_PLL_Tracking_Fpga " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL2MDllPllTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( ( implementation = = " GPS_L5i_DLL_PLL_Tracking_Fpga " ) or ( implementation = = " GPS_L5_DLL_PLL_Tracking_Fpga " ) )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GpsL5DllPllTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5a_DLL_PLL_Tracking_Fpga " )
{
std : : unique_ptr < TrackingInterface > block_ = std : : make_unique < GalileoE5aDllPllTrackingFpga > ( configuration , role , in_streams ,
out_streams ) ;
block = std : : move ( block_ ) ;
}
# endif
2014-04-13 16:58:52 +00:00
else
{
2021-02-27 10:05:39 +00:00
std : : cerr < < " Configuration error in " < < role < < " block: implementation " < < ( implementation = = " Wrong " s ? " not defined. " s : implementation + " not available. " s ) < < ' \n ' ;
block = nullptr ;
2014-04-13 16:58:52 +00:00
}
2018-06-03 12:50:22 +00:00
return block ;
2014-04-11 18:18:59 +00:00
}
2014-04-12 20:02:18 +00:00
2014-04-11 18:18:59 +00:00
std : : unique_ptr < TelemetryDecoderInterface > GNSSBlockFactory : : GetTlmBlock (
2020-06-29 07:07:41 +00:00
const ConfigurationInterface * configuration ,
2019-02-05 00:31:09 +00:00
const std : : string & role ,
2020-07-12 21:08:58 +00:00
unsigned int in_streams ,
2018-03-03 01:03:39 +00:00
unsigned int out_streams )
2014-04-11 18:18:59 +00:00
{
std : : unique_ptr < TelemetryDecoderInterface > block ;
2021-02-09 22:47:34 +00:00
const std : : string implementation = configuration - > property ( role + impl_prop , " Wrong " s ) ;
2014-04-11 18:18:59 +00:00
2020-07-12 21:08:58 +00:00
// TELEMETRY DECODERS ------------------------------------------------------
2018-12-02 22:54:27 +00:00
if ( implementation = = " GPS_L1_CA_Telemetry_Decoder " )
2014-04-13 16:58:52 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GpsL1CaTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-13 16:58:52 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E1B_Telemetry_Decoder " )
2014-04-13 16:58:52 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GalileoE1BTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-13 16:58:52 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " SBAS_L1_Telemetry_Decoder " )
2014-04-13 16:58:52 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < SbasL1TelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2014-04-13 16:58:52 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " Galileo_E5a_Telemetry_Decoder " )
2014-06-05 10:00:24 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GalileoE5aTelemetryDecoder > ( configuration , role , in_streams ,
2020-07-25 22:12:48 +00:00
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E5b_Telemetry_Decoder " )
{
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GalileoE5bTelemetryDecoder > ( configuration , role , in_streams ,
2020-11-07 20:33:26 +00:00
out_streams ) ;
block = std : : move ( block_ ) ;
}
else if ( implementation = = " Galileo_E6_Telemetry_Decoder " )
{
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GalileoE6TelemetryDecoder > ( configuration , role , in_streams ,
2020-06-18 09:49:28 +00:00
out_streams ) ;
2014-06-05 10:00:24 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L2C_Telemetry_Decoder " )
2015-05-05 16:18:16 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GpsL2CTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2015-05-05 16:18:16 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GLONASS_L1_CA_Telemetry_Decoder " )
2017-08-29 07:20:38 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GlonassL1CaTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2017-08-29 07:20:38 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GLONASS_L2_CA_Telemetry_Decoder " )
2018-03-24 18:42:04 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GlonassL2CaTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2018-03-24 18:42:04 +00:00
block = std : : move ( block_ ) ;
}
2018-12-02 22:54:27 +00:00
else if ( implementation = = " GPS_L5_Telemetry_Decoder " )
2018-03-03 01:03:39 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < GpsL5TelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2018-03-03 01:03:39 +00:00
block = std : : move ( block_ ) ;
}
2018-12-18 21:55:36 +00:00
else if ( implementation = = " BEIDOU_B1I_Telemetry_Decoder " )
2018-07-06 12:42:13 +00:00
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < BeidouB1iTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2018-07-06 12:42:13 +00:00
block = std : : move ( block_ ) ;
}
2019-01-25 21:43:00 +00:00
else if ( implementation = = " BEIDOU_B3I_Telemetry_Decoder " )
{
2020-06-18 09:49:28 +00:00
std : : unique_ptr < TelemetryDecoderInterface > block_ = std : : make_unique < BeidouB3iTelemetryDecoder > ( configuration , role , in_streams ,
out_streams ) ;
2019-01-25 21:43:00 +00:00
block = std : : move ( block_ ) ;
}
2018-07-06 12:42:13 +00:00
2014-04-13 16:58:52 +00:00
else
{
2021-02-27 10:05:39 +00:00
std : : cerr < < " Configuration error in " < < role < < " block: implementation " < < ( implementation = = " Wrong " s ? " not defined. " s : implementation + " not available. " s ) < < ' \n ' ;
block = nullptr ;
2014-04-13 16:58:52 +00:00
}
2021-02-09 22:47:34 +00:00
2018-06-03 12:50:22 +00:00
return block ;
2011-10-01 18:45:20 +00:00
}