mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-09-29 23:41:05 +00:00
Code Issues Releases Wiki Activity

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

Browse Source
This commit is contained in:
Carles Fernandez 2021-12-14 17:48:57 +01:00
commit 1e0a62e080
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
41 changed files with 360 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc
View File

@ -36,11 +36,16 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition(
const ConfigurationInterface* configuration,
const std::string& role,
unsigned int in_streams,
unsigned int out_streams) : role_(role),
in_streams_(in_streams),
out_streams_(out_streams)
unsigned int out_streams)
: configuration_(configuration),
gnss_synchro_(nullptr),
role_(role),
threshold_(0.0),
channel_(0),
doppler_step_(0),
in_streams_(in_streams),
out_streams_(out_streams)
{
configuration_ = configuration;
const std::string default_item_type("gr_complex");
const std::string default_dump_filename("../data/acquisition.dat");
@ -53,6 +58,7 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition(
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
dump_ = configuration_->property(role + ".dump", false);
doppler_max_ = configuration_->property(role + ".doppler_max", 5000);
if (FLAGS_doppler_max != 0)
{
doppler_max_ = FLAGS_doppler_max;
@ -102,11 +108,6 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition(
LOG(WARNING) << item_type_ << " unknown acquisition item type";
}
channel_ = 0;
threshold_ = 0.0;
doppler_step_ = 0;
gnss_synchro_ = nullptr;
if (in_streams_ > 1)
{
LOG(ERROR) << "This implementation only supports one input stream";

20
src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc
View File

@ -28,11 +28,16 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition
const ConfigurationInterface* configuration,
const std::string& role,
unsigned int in_streams,
unsigned int out_streams) : role_(role),
in_streams_(in_streams),
out_streams_(out_streams)
unsigned int out_streams)
: configuration_(configuration),
role_(role),
gnss_synchro_(nullptr),
threshold_(0.0),
channel_(0),
doppler_step_(0),
in_streams_(in_streams),
out_streams_(out_streams)
{
configuration_ = configuration;
const std::string default_item_type("gr_complex");
const std::string default_dump_filename("../data/acquisition.dat");
@ -44,6 +49,7 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
dump_ = configuration_->property(role + ".dump", false);
doppler_max_ = configuration_->property(role + ".doppler_max", 5000);
if (FLAGS_doppler_max != 0)
{
doppler_max_ = FLAGS_doppler_max;
@ -64,7 +70,6 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition
default_dump_filename);
// -- Find number of samples per spreading code (4 ms) -----------------
code_length_ = static_cast<unsigned int>(round(
fs_in_ / (GALILEO_E1_CODE_CHIP_RATE_CPS / GALILEO_E1_B_CODE_LENGTH_CHIPS)));
@ -95,11 +100,6 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition
LOG(WARNING) << item_type_ << " unknown acquisition item type";
}
channel_ = 0;
threshold_ = 0.0;
doppler_step_ = 0;
gnss_synchro_ = nullptr;
if (in_streams_ > 1)
{
LOG(ERROR) << "This implementation only supports one input stream";

19
src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc
View File

@ -36,11 +36,16 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui
const ConfigurationInterface* configuration,
const std::string& role,
unsigned int in_streams,
unsigned int out_streams) : role_(role),
in_streams_(in_streams),
out_streams_(out_streams)
unsigned int out_streams)
: configuration_(configuration),
role_(role),
gnss_synchro_(nullptr),
threshold_(0.0),
channel_(0),
doppler_step_(0),
in_streams_(in_streams),
out_streams_(out_streams)
{
configuration_ = configuration;
const std::string default_item_type("gr_complex");
const std::string default_dump_filename("../data/acquisition.dat");
@ -53,6 +58,7 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
dump_ = configuration_->property(role + ".dump", false);
doppler_max_ = configuration_->property(role + ".doppler_max", 5000);
if (FLAGS_doppler_max != 0)
{
doppler_max_ = FLAGS_doppler_max;
@ -136,11 +142,6 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui
LOG(WARNING) << item_type_ << " unknown acquisition item type";
}
channel_ = 0;
threshold_ = 0.0;
doppler_step_ = 0;
gnss_synchro_ = nullptr;
if (in_streams_ > 1)
{
LOG(ERROR) << "This implementation only supports one input stream";

18
src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc
View File

@ -36,11 +36,16 @@ GalileoE1PcpsTongAmbiguousAcquisition::GalileoE1PcpsTongAmbiguousAcquisition(
const ConfigurationInterface* configuration,
const std::string& role,
unsigned int in_streams,
unsigned int out_streams) : role_(role),
in_streams_(in_streams),
out_streams_(out_streams)
unsigned int out_streams)
: configuration_(configuration),
gnss_synchro_(nullptr),
role_(role),
threshold_(0.0),
channel_(0),
doppler_step_(0),
in_streams_(in_streams),
out_streams_(out_streams)
{
configuration_ = configuration;
const std::string default_item_type("gr_complex");
const std::string default_dump_filename("../data/acquisition.dat");
@ -106,11 +111,6 @@ GalileoE1PcpsTongAmbiguousAcquisition::GalileoE1PcpsTongAmbiguousAcquisition(
LOG(WARNING) << item_type_ << " unknown acquisition item type";
}
channel_ = 0;
threshold_ = 0.0;
doppler_step_ = 0;
gnss_synchro_ = nullptr;
if (in_streams_ > 1)
{
LOG(ERROR) << "This implementation only supports one input stream";

18
src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc
View File

@ -42,11 +42,16 @@ GalileoE5aNoncoherentIQAcquisitionCaf::GalileoE5aNoncoherentIQAcquisitionCaf(
const ConfigurationInterface* configuration,
const std::string& role,
unsigned int in_streams,
unsigned int out_streams) : role_(role),
in_streams_(in_streams),
out_streams_(out_streams)
unsigned int out_streams)
: configuration_(configuration),
role_(role),
gnss_synchro_(nullptr),
threshold_(0.0),
channel_(0),
doppler_step_(0),
in_streams_(in_streams),
out_streams_(out_streams)
{
configuration_ = configuration;
const std::string default_item_type("gr_complex");
const std::string default_dump_filename("../data/acquisition.dat");
@ -111,11 +116,6 @@ GalileoE5aNoncoherentIQAcquisitionCaf::GalileoE5aNoncoherentIQAcquisitionCaf(
LOG(WARNING) << item_type_ << " unknown acquisition item type";
}
channel_ = 0;
threshold_ = 0.0;
doppler_step_ = 0;
gnss_synchro_ = nullptr;
if (in_streams_ > 1)
{
LOG(ERROR) << "This implementation only supports one input stream";

18
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc
View File

@ -37,11 +37,16 @@ GpsL1CaPcpsQuickSyncAcquisition::GpsL1CaPcpsQuickSyncAcquisition(
const ConfigurationInterface* configuration,
const std::string& role,
unsigned int in_streams,
unsigned int out_streams) : role_(role),
in_streams_(in_streams),
out_streams_(out_streams)
unsigned int out_streams)
: configuration_(configuration),
role_(role),
gnss_synchro_(nullptr),
threshold_(0.0),
channel_(0),
doppler_step_(0),
in_streams_(in_streams),
out_streams_(out_streams)
{
configuration_ = configuration;
const std::string default_item_type("gr_complex");
std::string default_dump_filename = "./data/acquisition.dat";
@ -129,11 +134,6 @@ GpsL1CaPcpsQuickSyncAcquisition::GpsL1CaPcpsQuickSyncAcquisition(
LOG(WARNING) << item_type_ << " unknown acquisition item type";
}
channel_ = 0;
threshold_ = 0.0;
doppler_step_ = 0;
gnss_synchro_ = nullptr;
if (in_streams_ > 1)
{
LOG(ERROR) << "This implementation only supports one input stream";

18
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc
View File

@ -36,11 +36,16 @@ GpsL1CaPcpsTongAcquisition::GpsL1CaPcpsTongAcquisition(
const ConfigurationInterface* configuration,
const std::string& role,
unsigned int in_streams,
unsigned int out_streams) : role_(role),
in_streams_(in_streams),
out_streams_(out_streams)
unsigned int out_streams)
: configuration_(configuration),
gnss_synchro_(nullptr),
role_(role),
threshold_(0.0),
channel_(0),
doppler_step_(0),
in_streams_(in_streams),
out_streams_(out_streams)
{
configuration_ = configuration;
const std::string default_item_type("gr_complex");
std::string default_dump_filename = "./data/acquisition.dat";
@ -91,11 +96,6 @@ GpsL1CaPcpsTongAcquisition::GpsL1CaPcpsTongAcquisition(
LOG(WARNING) << item_type_ << " unknown acquisition item type";
}
channel_ = 0;
threshold_ = 0.0;
doppler_step_ = 0;
gnss_synchro_ = nullptr;
if (in_streams_ > 1)
{
LOG(ERROR) << "This implementation only supports one input stream";

15
src/algorithms/channel/libs/channel_fsm.cc
View File

@ -22,21 +22,22 @@
#include <utility>
ChannelFsm::ChannelFsm()
: queue_(nullptr),
channel_(0U),
state_(0U)
{
acq_ = nullptr;
trk_ = nullptr;
channel_ = 0U;
state_ = 0U;
queue_ = nullptr;
}
ChannelFsm::ChannelFsm(std::shared_ptr<AcquisitionInterface> acquisition) : acq_(std::move(acquisition))
ChannelFsm::ChannelFsm(std::shared_ptr<AcquisitionInterface> acquisition)
: acq_(std::move(acquisition)),
queue_(nullptr),
channel_(0U),
state_(0U)
{
trk_ = nullptr;
channel_ = 0U;
state_ = 0U;
queue_ = nullptr;
}

4
src/algorithms/conditioner/adapters/array_signal_conditioner.cc
View File

@ -28,9 +28,9 @@ ArraySignalConditioner::ArraySignalConditioner(std::shared_ptr<GNSSBlockInterfac
std::string role) : data_type_adapt_(std::move(data_type_adapt)),
in_filt_(std::move(in_filt)),
res_(std::move(res)),
role_(std::move(role))
role_(std::move(role)),
connected_(false)
{
connected_ = false;
}

4
src/algorithms/conditioner/adapters/signal_conditioner.cc
View File

@ -28,9 +28,9 @@ SignalConditioner::SignalConditioner(std::shared_ptr<GNSSBlockInterface> data_ty
std::string role) : data_type_adapt_(std::move(data_type_adapt)),
in_filt_(std::move(in_filt)),
res_(std::move(res)),
role_(std::move(role))
role_(std::move(role)),
connected_(false)
{
connected_ = false;
}

7
src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc
View File

@ -63,6 +63,7 @@ hybrid_observables_gs::hybrid_observables_gs(const Obs_Conf &conf_)
d_dump_filename(conf_.dump_filename),
d_smooth_filter_M(static_cast<double>(conf_.smoothing_factor)),
d_T_rx_step_s(static_cast<double>(conf_.observable_interval_ms) / 1000.0),
d_last_rx_clock_round20ms_error(0.0),
d_T_rx_TOW_ms(0U),
d_T_rx_step_ms(conf_.observable_interval_ms),
d_T_status_report_timer_ms(0),
@ -113,7 +114,7 @@ hybrid_observables_gs::hybrid_observables_gs(const Obs_Conf &conf_)
d_SourceTagTimestamps = std::vector<std::queue<GnssTime>>(d_nchannels_out);
last_rx_clock_round20ms_error = 0;
set_tag_propagation_policy(TPP_DONT); // no tag propagation, the time tag will be adjusted and regenerated in work()
// ############# ENABLE DATA FILE LOG #################
@ -216,7 +217,7 @@ void hybrid_observables_gs::msg_handler_pvt_to_observables(const pmt::pmt_t &msg
{
d_T_rx_TOW_ms += d_T_rx_step_ms - d_T_rx_TOW_ms % d_T_rx_step_ms;
}
last_rx_clock_round20ms_error = static_cast<double>(d_T_rx_TOW_ms) - old_tow_corrected;
d_last_rx_clock_round20ms_error = static_cast<double>(d_T_rx_TOW_ms) - old_tow_corrected;
// d_Rx_clock_buffer.clear(); // Clear all the elements in the buffer
for (uint32_t n = 0; n < d_nchannels_out; n++)
{
@ -659,7 +660,7 @@ void hybrid_observables_gs::set_tag_timestamp_in_sdr_timeframe(const std::vector
// << "] OBS RX TimeTag Week: " << current_tag.week
// << ", TOW: " << current_tag.tow_ms
// << " [ms], TOW fraction: " << current_tag.tow_ms_fraction
// << " [ms], DELTA TLM TOW: " << last_rx_clock_round20ms_error + delta_rxtime_to_tag * 1000.0 + static_cast<double>(current_tag.tow_ms) - static_cast<double>(d_T_rx_TOW_ms) + current_tag.tow_ms_fraction << " [ms] \n";
// << " [ms], DELTA TLM TOW: " << d_last_rx_clock_round20ms_error + delta_rxtime_to_tag * 1000.0 + static_cast<double>(current_tag.tow_ms) - static_cast<double>(d_T_rx_TOW_ms) + current_tag.tow_ms_fraction << " [ms] \n";
const std::shared_ptr<GnssTime> tmp_obj = std::make_shared<GnssTime>(GnssTime());
*tmp_obj = current_tag;
double intpart;

4
src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.h
View File

@ -118,9 +118,9 @@ private:
double d_smooth_filter_M;
double d_T_rx_step_s;
double d_last_rx_clock_round20ms_error;
uint32_t d_T_rx_TOW_ms;
double last_rx_clock_round20ms_error;
uint32_t d_T_rx_step_ms;
uint32_t d_T_status_report_timer_ms;
uint32_t d_nchannels_in;

7
src/algorithms/signal_source/adapters/custom_udp_signal_source.cc
View File

@ -27,7 +27,10 @@ using namespace std::string_literals;
CustomUDPSignalSource::CustomUDPSignalSource(const ConfigurationInterface* configuration,
const std::string& role, unsigned int in_stream, unsigned int out_stream,
Concurrent_Queue<pmt::pmt_t>* queue __attribute__((unused)))
: SignalSourceBase(configuration, role, "Custom_UDP_Signal_Source"s), in_stream_(in_stream), out_stream_(out_stream)
: SignalSourceBase(configuration, role, "Custom_UDP_Signal_Source"s),
item_size_(sizeof(gr_complex)),
in_stream_(in_stream),
out_stream_(out_stream)
{
// DUMP PARAMETERS
const std::string default_dump_file("./data/signal_source.dat");
@ -51,8 +54,6 @@ CustomUDPSignalSource::CustomUDPSignalSource(const ConfigurationInterface* confi
const std::string default_sample_type("cbyte");
const std::string sample_type = configuration->property(role + ".sample_type", default_sample_type);
item_type_ = configuration->property(role + ".item_type", default_item_type);
// output item size is always gr_complex
item_size_ = sizeof(gr_complex);
udp_gnss_rx_source_ = Gr_Complex_Ip_Packet_Source::make(capture_device,
address,

9
src/algorithms/signal_source/adapters/gen_signal_source.cc
View File

@ -29,11 +29,12 @@
GenSignalSource::GenSignalSource(std::shared_ptr<GNSSBlockInterface> signal_generator,
std::shared_ptr<GNSSBlockInterface> filter,
std::string role,
Concurrent_Queue<pmt::pmt_t> *queue __attribute__((unused))) : signal_generator_(std::move(signal_generator)),
filter_(std::move(filter)),
role_(std::move(role))
Concurrent_Queue<pmt::pmt_t> *queue __attribute__((unused)))
: signal_generator_(std::move(signal_generator)),
filter_(std::move(filter)),
role_(std::move(role)),
connected_(false)
{
connected_ = false;
}

9
src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.cc
View File

@ -30,11 +30,14 @@ using namespace std::string_literals;
SpirGSS6450FileSignalSource::SpirGSS6450FileSignalSource(const ConfigurationInterface* configuration,
const std::string& role, uint32_t in_streams, uint32_t out_streams, Concurrent_Queue<pmt::pmt_t>* queue)
: SignalSourceBase(configuration, role, "Spir_GSS6450_File_Signal_Source"s), in_streams_(in_streams), out_streams_(out_streams)
: SignalSourceBase(configuration, role, "Spir_GSS6450_File_Signal_Source"s),
item_type_("int"),
item_size_(sizeof(int32_t)),
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_filename("../data/my_capture.dat");
const std::string default_dump_filename("../data/my_capture_dump.dat");
item_type_ = "int";
samples_ = configuration->property(role + ".samples", static_cast<uint64_t>(0));
sampling_frequency_ = configuration->property(role + ".sampling_frequency", static_cast<int64_t>(0));
@ -47,7 +50,7 @@ SpirGSS6450FileSignalSource::SpirGSS6450FileSignalSource(const ConfigurationInte
adc_bits_ = configuration->property(role + ".adc_bits", 4);
n_channels_ = configuration->property(role + ".total_channels", 1);
sel_ch_ = configuration->property(role + ".sel_ch", 1);
item_size_ = sizeof(int32_t);
const int64_t bytes_seek = configuration->property(role + ".bytes_to_skip", static_cast<int64_t>(65536));
const double sample_size_byte = static_cast<double>(adc_bits_) / 4.0;

41
src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.cc
View File

@ -94,19 +94,27 @@ Gr_Complex_Ip_Packet_Source::make(std::string src_device,
Gr_Complex_Ip_Packet_Source::Gr_Complex_Ip_Packet_Source(std::string src_device,
__attribute__((unused)) const std::string &origin_address,
int udp_port,
int udp_packet_size,
int udp_packet_size __attribute__((unused)),
int n_baseband_channels,
const std::string &wire_sample_type,
size_t item_size,
bool IQ_swap_)
: gr::sync_block("gr_complex_ip_packet_source",
gr::io_signature::make(0, 0, 0),
gr::io_signature::make(1, 4, item_size)) // 1 to 4 baseband complex channels
gr::io_signature::make(1, 4, item_size)), // 1 to 4 baseband complex channels
d_pcap_thread(nullptr),
d_src_device(std::move(src_device)),
descr(nullptr),
fifo_buff(new char[FIFO_SIZE]),
fifo_read_ptr(0),
fifo_write_ptr(0),
fifo_items(0),
d_sock_raw(0),
d_udp_port(udp_port),
d_n_baseband_channels(n_baseband_channels),
d_IQ_swap(IQ_swap_)
{
std::cout << "Start Ethernet packet capture\n";
std::cout << "Overflow events will be indicated by o's\n";
d_n_baseband_channels = n_baseband_channels;
memset(reinterpret_cast<char *>(&si_me), 0, sizeof(si_me));
if (wire_sample_type == "cbyte")
{
d_wire_sample_type = 1;
@ -132,24 +140,9 @@ Gr_Complex_Ip_Packet_Source::Gr_Complex_Ip_Packet_Source(std::string src_device,
std::cout << "Unknown wire sample type\n";
exit(0);
}
std::cout << "Start Ethernet packet capture\n";
std::cout << "Overflow events will be indicated by o's\n";
std::cout << "d_wire_sample_type:" << d_wire_sample_type << '\n';
d_src_device = std::move(src_device);
d_udp_port = udp_port;
d_udp_payload_size = udp_packet_size;
d_fifo_full = false;
// allocate signal samples buffer
fifo_buff = new char[FIFO_SIZE];
fifo_read_ptr = 0;
fifo_write_ptr = 0;
fifo_items = 0;
d_item_size = item_size;
d_IQ_swap = IQ_swap_;
d_sock_raw = 0;
d_pcap_thread = nullptr;
descr = nullptr;
memset(reinterpret_cast<char *>(&si_me), 0, sizeof(si_me));
}
@ -230,7 +223,7 @@ Gr_Complex_Ip_Packet_Source::~Gr_Complex_Ip_Packet_Source()
{
delete d_pcap_thread;
}
delete fifo_buff;
delete[] fifo_buff;
std::cout << "Stop Ethernet packet capture\n";
}

3
src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.h
View File

@ -90,19 +90,16 @@ private:
std::string d_src_device;
std::string d_origin_address;
pcap_t *descr; // ethernet pcap device descriptor
size_t d_item_size;
char *fifo_buff;
int fifo_read_ptr;
int fifo_write_ptr;
int fifo_items;
int d_sock_raw;
int d_udp_port;
int d_udp_payload_size;
int d_n_baseband_channels;
int d_wire_sample_type;
int d_bytes_per_sample;
bool d_IQ_swap;
bool d_fifo_full;
};

19
src/algorithms/signal_source/gnuradio_blocks/labsat23_source.cc
View File

@ -45,18 +45,17 @@ labsat23_source::labsat23_source(const char *signal_file_basename,
bool digital_io_enabled) : gr::block("labsat23_source",
gr::io_signature::make(0, 0, 0),
gr::io_signature::make(1, 3, sizeof(gr_complex))),
d_queue(queue)
d_queue(queue),
d_channel_selector_config(channel_selector),
d_current_file_number(0),
d_labsat_version(0),
d_channel_selector(0),
d_ref_clock(0),
d_bits_per_sample(0),
d_header_parsed(false),
d_ls3w_digital_io_enabled(digital_io_enabled)
{
d_channel_selector_config = channel_selector;
d_header_parsed = false;
d_bits_per_sample = 0;
d_current_file_number = 0;
d_labsat_version = 0;
d_ref_clock = 0;
d_channel_selector = 0;
d_signal_file_basename = std::string(signal_file_basename);
d_ls3w_digital_io_enabled = digital_io_enabled;
std::string signal_file;
this->set_output_multiple(8);
signal_file = generate_filename();

11
src/algorithms/signal_source/gnuradio_blocks/unpack_spir_gss6450_samples.cc
View File

@ -26,12 +26,13 @@ unpack_spir_gss6450_samples_sptr make_unpack_spir_gss6450_samples(int adc_nbit_)
}
unpack_spir_gss6450_samples::unpack_spir_gss6450_samples(int adc_nbit) : gr::sync_interpolator("unpack_spir_gss6450_samples",
gr::io_signature::make(1, 1, sizeof(int32_t)),
gr::io_signature::make(1, 1, sizeof(gr_complex)), 16 / adc_nbit)
unpack_spir_gss6450_samples::unpack_spir_gss6450_samples(int adc_nbit)
: gr::sync_interpolator("unpack_spir_gss6450_samples",
gr::io_signature::make(1, 1, sizeof(int32_t)),
gr::io_signature::make(1, 1, sizeof(gr_complex)), 16 / adc_nbit),
adc_bits(adc_nbit),
samples_per_int(16 / adc_bits)
{
adc_bits = adc_nbit;
samples_per_int = 16 / adc_bits;
}

18
src/algorithms/signal_source/libs/fpga_buffer_monitor.cc
View File

@ -34,12 +34,16 @@
#include <utility> // for move
Fpga_buffer_monitor::Fpga_buffer_monitor(const std::string &device_name, uint32_t num_freq_bands, bool dump, std::string dump_filename)
Fpga_buffer_monitor::Fpga_buffer_monitor(const std::string &device_name,
uint32_t num_freq_bands,
bool dump,
std::string dump_filename)
: d_dump_filename(std::move(dump_filename)),
d_num_freq_bands(num_freq_bands),
d_max_buff_occ_freq_band_0(0),
d_max_buff_occ_freq_band_1(0),
d_dump(dump)
{
d_num_freq_bands = num_freq_bands;
d_dump = dump;
d_dump_filename = std::move(dump_filename);
// open device descriptor
if ((d_device_descriptor = open(device_name.c_str(), O_RDWR | O_SYNC)) == -1)
{
@ -69,10 +73,6 @@ Fpga_buffer_monitor::Fpga_buffer_monitor(const std::string &device_name, uint32_
DLOG(INFO) << "FPGA buffer monitor class created";
// initialize maximum buffer occupancy in case buffer monitoring is enabled
d_max_buff_occ_freq_band_0 = 0;
d_max_buff_occ_freq_band_1 = 0;
if (d_dump)
{
std::string dump_path;

5
src/algorithms/signal_source/libs/fpga_buffer_monitor.h
View File

@ -81,6 +81,9 @@ private:
int32_t buffer_monitor_test_register();
void close_device();
std::string d_dump_filename;
std::ofstream d_dump_file;
volatile unsigned* d_map_base; // driver memory map corresponding to the FPGA buffer monitor
int d_device_descriptor; // driver descriptor corresponding to the FPGA buffer monitor
@ -90,8 +93,6 @@ private:
uint32_t d_max_buff_occ_freq_band_1;
bool d_dump;
std::string d_dump_filename;
std::ofstream d_dump_file;
};

20
src/algorithms/signal_source/libs/gnss_sdr_timestamp.cc
View File

@ -33,11 +33,11 @@ Gnss_Sdr_Timestamp::Gnss_Sdr_Timestamp(size_t sizeof_stream_item,
gr::io_signature::make(1, 20, sizeof_stream_item),
gr::io_signature::make(1, 20, sizeof_stream_item)),
d_timefile(std::move(timestamp_file)),
d_clock_offset_ms(clock_offset_ms)
d_clock_offset_ms(clock_offset_ms),
d_fraction_ms_offset(modf(d_clock_offset_ms, &d_integer_ms_offset)), // optional clockoffset parameter to convert UTC timestamps to GPS time in some receiver's configuration
d_next_timetag_samplecount(0),
d_get_next_timetag(true)
{
d_fraction_ms_offset = modf(d_clock_offset_ms, &d_integer_ms_offset); // optional clockoffset parameter to convert UTC timestamps to GPS time in some receiver's configuration
get_next_timetag = true;
next_timetag_samplecount = 0;
}
@ -50,7 +50,7 @@ gnss_shared_ptr<Gnss_Sdr_Timestamp> gnss_sdr_make_Timestamp(size_t sizeof_stream
bool Gnss_Sdr_Timestamp::read_next_timetag()
{
d_timefilestream.read(reinterpret_cast<char*>(&next_timetag_samplecount), sizeof(uint64_t));
d_timefilestream.read(reinterpret_cast<char*>(&d_next_timetag_samplecount), sizeof(uint64_t));
if (!d_timefilestream)
{
return false;
@ -98,20 +98,20 @@ int Gnss_Sdr_Timestamp::work(int noutput_items,
gr_vector_void_star& output_items)
{
// multichannel support
if (get_next_timetag == true)
if (d_get_next_timetag == true)
{
if (read_next_timetag() == false)
{
// std::cout << "End of TimeTag file reached!\n";
// return 0; // todo: find why return -1 does not stop gnss-sdr!
}
get_next_timetag = false;
d_get_next_timetag = false;
}
for (size_t ch = 0; ch < output_items.size(); ch++)
{
std::memcpy(output_items[ch], input_items[ch], noutput_items * input_signature()->sizeof_stream_item(ch));
uint64_t bytes_to_samples = 2; // todo: improve this.. hardcoded 2 bytes -> 1 complex sample!
int64_t diff_samplecount = uint64diff(this->nitems_written(ch), next_timetag_samplecount * bytes_to_samples);
int64_t diff_samplecount = uint64diff(this->nitems_written(ch), d_next_timetag_samplecount * bytes_to_samples);
// std::cout << "diff_samplecount: " << diff_samplecount << ", noutput_items: " << noutput_items << "\n";
if (diff_samplecount <= noutput_items and std::labs(diff_samplecount) <= noutput_items)
{
@ -121,8 +121,8 @@ int Gnss_Sdr_Timestamp::work(int noutput_items,
tmp_obj->tow_ms_fraction = d_fraction_ms_offset;
tmp_obj->rx_time = 0;
add_item_tag(ch, this->nitems_written(ch) - diff_samplecount, pmt::mp("timetag"), pmt::make_any(tmp_obj));
// std::cout << "[" << this->nitems_written(ch) - diff_samplecount << "] Sent TimeTag SC: " << next_timetag_samplecount * bytes_to_samples << ", Week: " << next_timetag.week << ", TOW: " << next_timetag.tow_ms << " [ms] \n";
get_next_timetag = true;
// std::cout << "[" << this->nitems_written(ch) - diff_samplecount << "] Sent TimeTag SC: " << d_next_timetag_samplecount * bytes_to_samples << ", Week: " << next_timetag.week << ", TOW: " << next_timetag.tow_ms << " [ms] \n";
d_get_next_timetag = true;
}
}

6
src/algorithms/signal_source/libs/gnss_sdr_timestamp.h
View File

@ -66,10 +66,10 @@ private:
std::fstream d_timefilestream;
GnssTime next_timetag{};
double d_clock_offset_ms;
double d_integer_ms_offset;
double d_fraction_ms_offset;
uint64_t next_timetag_samplecount;
bool get_next_timetag;
double d_integer_ms_offset;
uint64_t d_next_timetag_samplecount;
bool d_get_next_timetag;
};

4
src/algorithms/signal_source/libs/gnss_sdr_valve.cc
View File

@ -33,9 +33,9 @@ Gnss_Sdr_Valve::Gnss_Sdr_Valve(size_t sizeof_stream_item,
d_nitems(nitems),
d_ncopied_items(0),
d_queue(queue),
d_stop_flowgraph(stop_flowgraph)
d_stop_flowgraph(stop_flowgraph),
d_open_valve(false)
{
d_open_valve = false;
}

168
src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc
View File

@ -35,6 +35,7 @@
#include "galileo_e6_signal_replica.h"
#include "gnss_satellite.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_l2c_signal_replica.h"
#include "gps_l5_signal_replica.h"
@ -62,19 +63,13 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#if PMT_USES_BOOST_ANY
#include <boost/any.hpp>
namespace wht = boost;
#else
#include <filesystem>
namespace fs = std::filesystem;
#include <any>
namespace wht = std;
#endif
#else
#include <boost/filesystem/path.hpp>
namespace fs = boost::filesystem;
#endif
kf_vtl_tracking_sptr kf_vtl_make_tracking(const Kf_Conf &conf_)
{
@ -83,12 +78,60 @@ kf_vtl_tracking_sptr kf_vtl_make_tracking(const Kf_Conf &conf_)
kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
: gr::block("kf_vtl_tracking", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
: gr::block("kf_vtl_tracking",
gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_trk_parameters(conf_),
d_acquisition_gnss_synchro(nullptr),
d_signal_type(d_trk_parameters.signal),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_current_correlation_time_s(0.0),
d_carr_phase_error_disc_hz(0.0),
d_code_error_disc_chips(0.0),
d_code_error_kf_chips(0.0),
d_code_freq_kf_chips_s(0.0),
d_carrier_phase_kf_rad(0.0),
d_carrier_doppler_kf_hz(0.0),
d_carrier_doppler_rate_kf_hz_s(0.0),
d_acc_carrier_phase_rad(0.0),
d_T_chip_seconds(0.0),
d_T_prn_seconds(0.0),
d_T_prn_samples(0.0),
d_K_blk_samples(0.0),
d_carrier_lock_test(1.0),
d_CN0_SNV_dB_Hz(0.0),
d_carrier_lock_threshold(d_trk_parameters.carrier_lock_th),
d_carrier_phase_step_rad(0.0),
d_carrier_phase_rate_step_rad(0.0),
d_code_phase_step_chips(0.0),
d_code_phase_rate_step_chips(0.0),
d_rem_code_phase_chips(0.0),
d_rem_code_phase_samples(0.0),
d_sample_counter(0ULL),
d_acq_sample_stamp(0ULL),
d_rem_carr_phase_rad(0.0),
d_channel(0U),
d_secondary_code_length(0U),
d_data_secondary_code_length(0U),
d_state(0),
d_current_prn_length_samples(static_cast<int32_t>(d_trk_parameters.vector_length)),
d_extend_correlation_symbols_count(0),
d_cn0_estimation_counter(0),
d_carrier_lock_fail_counter(0),
d_code_lock_fail_counter(0),
d_pull_in_transitory(true),
d_corrected_doppler(false),
d_interchange_iq(false),
d_veml(false),
d_cloop(true),
d_dump(d_trk_parameters.dump),
d_dump_mat(d_trk_parameters.dump_mat && d_dump),
d_acc_carrier_phase_initialized(false)
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
d_trk_parameters = conf_;
// Telemetry bit synchronization message port input
this->message_port_register_out(pmt::mp("events"));
this->set_relative_rate(1.0 / static_cast<double>(d_trk_parameters.vector_length));
@ -122,16 +165,6 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
#endif
// initialize internal vars
d_veml = false;
d_cloop = true;
d_pull_in_transitory = true;
d_code_chip_rate = 0.0;
d_secondary_code_length = 0U;
d_data_secondary_code_length = 0U;
d_preamble_length_symbols = 0;
d_interchange_iq = false;
d_signal_type = std::string(d_trk_parameters.signal);
std::map<std::string, std::string> map_signal_pretty_name;
map_signal_pretty_name["1C"] = "L1 C/A";
map_signal_pretty_name["1B"] = "E1";
@ -409,12 +442,6 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
d_code_samples_per_chip = 0U;
d_symbols_per_bit = 0;
}
d_T_chip_seconds = 0.0;
d_T_prn_seconds = 0.0;
d_T_prn_samples = 0.0;
d_K_blk_samples = 0.0;
// Initialize tracking ==========================================
// Initialization of local code replica
// Get space for a vector with the sinboc(1,1) replica sampled 2x/chip
@ -485,33 +512,13 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
// --- Initializations ---
d_Prompt_circular_buffer.set_capacity(d_secondary_code_length);
d_multicorrelator_cpu.set_high_dynamics_resampler(d_trk_parameters.high_dyn);
// Initial code frequency basis of NCO
d_code_freq_kf_chips_s = d_code_chip_rate;
// Residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// Residual carrier phase
d_rem_carr_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL;
d_acq_sample_stamp = 0ULL;
d_current_prn_length_samples = static_cast<int32_t>(d_trk_parameters.vector_length);
d_current_correlation_time_s = 0.0;
d_carr_phase_error_disc_hz = 0.0;
d_code_error_disc_chips = 0.0;
d_code_error_kf_chips = 0.0;
d_code_freq_kf_chips_s = 0.0;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer.reserve(d_trk_parameters.cn0_samples);
d_carrier_lock_test = 1.0;
d_CN0_SNV_dB_Hz = 0.0;
d_carrier_lock_fail_counter = 0;
d_code_lock_fail_counter = 0;
d_carrier_lock_threshold = d_trk_parameters.carrier_lock_th;
d_Prompt_Data.reserve(1);
d_cn0_smoother = Exponential_Smoother();
d_cn0_smoother.set_alpha(d_trk_parameters.cn0_smoother_alpha);
@ -527,26 +534,8 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
d_carrier_lock_test_smoother.set_offset(0.0);
d_carrier_lock_test_smoother.set_samples_for_initialization(d_trk_parameters.carrier_lock_test_smoother_samples);
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_phase_kf_rad = 0;
d_carrier_doppler_kf_hz = 0.0;
d_carrier_doppler_rate_kf_hz_s = 0.0;
d_acc_carrier_phase_rad = 0.0;
d_extend_correlation_symbols_count = 0;
d_code_phase_step_chips = 0.0;
d_code_phase_rate_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
d_carrier_phase_rate_step_rad = 0.0;
d_rem_code_phase_chips = 0.0;
d_state = 0; // initial state: standby
clear_tracking_vars();
d_dump = d_trk_parameters.dump;
d_dump_mat = d_trk_parameters.dump_mat and d_dump;
if (d_dump)
{
d_dump_filename = d_trk_parameters.dump_filename;
@ -580,8 +569,6 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
d_dump = false;
}
}
d_corrected_doppler = false;
d_acc_carrier_phase_initialized = false;
}
@ -601,7 +588,7 @@ void kf_vtl_tracking::msg_handler_telemetry_to_trk(const pmt::pmt_t &msg)
{
if (pmt::any_ref(msg).type().hash_code() == d_int_type_hash_code)
{
const int tlm_event = boost::any_cast<int>(pmt::any_ref(msg));
const int tlm_event = wht::any_cast<int>(pmt::any_ref(msg));
if (tlm_event == 1)
{
DLOG(INFO) << "Telemetry fault received in ch " << this->d_channel;
@ -623,9 +610,9 @@ void kf_vtl_tracking::msg_handler_pvt_to_trk(const pmt::pmt_t &msg)
{
if (pmt::any_ref(msg).type().hash_code() == typeid(const std::shared_ptr<TrackingCmd>).hash_code())
{
const auto cmd = boost::any_cast<const std::shared_ptr<TrackingCmd>>(pmt::any_ref(msg));
// std::cout << "RX pvt-to-trk cmd with delay: "
// << static_cast<double>(nitems_read(0) - cmd->sample_counter) / d_trk_parameters.fs_in << " [s]\n";
const auto cmd = wht::any_cast<const std::shared_ptr<TrackingCmd>>(pmt::any_ref(msg));
// std::cout << "RX pvt-to-trk cmd with delay: "
// << static_cast<double>(nitems_read(0) - cmd->sample_counter) / d_trk_parameters.fs_in << " [s]\n";
}
else
{
@ -1173,24 +1160,21 @@ void kf_vtl_tracking::run_Kf()
// Measurement update
arma::mat K = d_P_new_old * d_H.t() * arma::inv(d_H * d_P_new_old * d_H.t() + d_R); // Kalman gain
x_new_new = d_x_new_old + K * z;
d_x_new_new = d_x_new_old + K * z;
d_P_new_new = (arma::eye(5, 5) - K * d_H) * d_P_new_old;
// new code phase estimation
d_code_error_kf_chips = x_new_new(0);
x_new_new(0) = 0; // reset error estimation because the NCO corrects the code phase
d_code_error_kf_chips = d_x_new_new(0);
d_x_new_new(0) = 0; // reset error estimation because the NCO corrects the code phase
// new carrier phase estimation
d_carrier_phase_kf_rad = x_new_new(1);
d_carrier_phase_kf_rad = d_x_new_new(1);
// New carrier Doppler frequency estimation
d_carrier_doppler_kf_hz = x_new_new(2); // d_carrier_loop_filter.get_carrier_error(0, static_cast<float>(d_carr_phase_error_hz), static_cast<float>(d_current_correlation_time_s));
d_carrier_doppler_kf_hz = d_x_new_new(2); // d_carrier_loop_filter.get_carrier_error(0, static_cast<float>(d_carr_phase_error_hz), static_cast<float>(d_current_correlation_time_s));
d_carrier_doppler_rate_kf_hz_s = x_new_new(3);
// std::cout << "d_carrier_doppler_hz: " << d_carrier_doppler_hz << '\n';
// std::cout << "d_CN0_SNV_dB_Hz: " << this->d_CN0_SNV_dB_Hz << '\n';
d_carrier_doppler_rate_kf_hz_s = d_x_new_new(3);
// New code Doppler frequency estimation
if (d_trk_parameters.carrier_aiding)
@ -1201,9 +1185,9 @@ void kf_vtl_tracking::run_Kf()
else
{
// use its own KF code rate estimation
d_code_freq_kf_chips_s -= x_new_new(4);
d_code_freq_kf_chips_s -= d_x_new_new(4);
}
x_new_new(4) = 0;
d_x_new_new(4) = 0;
// Experimental: detect Carrier Doppler vs. Code Doppler incoherence and correct the Carrier Doppler
// if (d_trk_parameters.enable_doppler_correction == true)
// {
@ -1218,7 +1202,7 @@ void kf_vtl_tracking::run_Kf()
d_rem_carr_phase_rad = d_carrier_phase_kf_rad;
// prepare data for next KF epoch
d_x_old_old = x_new_new;
d_x_old_old = d_x_new_new;
d_P_old_old = d_P_new_new;
}
@ -1271,7 +1255,8 @@ void kf_vtl_tracking::update_tracking_vars()
// d_rem_carr_phase_rad = d_carrier_phase_kf_rad;
// remnant carrier phase to prevent overflow in the code NCO
d_rem_carr_phase_rad += static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples));
d_rem_carr_phase_rad += static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples) +
0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples));
d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, TWO_PI);
// carrier phase rate step (NCO phase increment rate per sample) [rads/sample^2]
@ -1288,7 +1273,8 @@ void kf_vtl_tracking::update_tracking_vars()
// double a = d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples);
// double b = 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples);
// std::cout << fmod(b, TWO_PI) / fmod(a, TWO_PI) << '\n';
d_acc_carrier_phase_rad -= (d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples));
d_acc_carrier_phase_rad -= (d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples) +
0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples));
// ################### DLL COMMANDS #################################################
// code phase step (Code resampler phase increment per sample) [chips/sample]
@ -1488,7 +1474,7 @@ void kf_vtl_tracking::log_data()
// Carrier estimation
tmp_float = static_cast<float>(d_carr_phase_error_disc_hz);
d_dump_file.write(reinterpret_cast<char *>(&tmp_float), sizeof(float));
tmp_float = static_cast<float>(x_new_new(2));
tmp_float = static_cast<float>(d_x_new_new(2));
d_dump_file.write(reinterpret_cast<char *>(&tmp_float), sizeof(float));
// code estimation
tmp_float = static_cast<float>(d_code_error_disc_chips);

57
src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.h
View File

@ -126,7 +126,30 @@ private:
arma::mat d_P_new_new;
arma::vec d_x_old_old;
arma::vec d_x_new_old;
arma::vec x_new_new;
arma::vec d_x_new_new;
std::string d_secondary_code_string;
std::string d_data_secondary_code_string;
std::string d_systemName;
std::string d_signal_type;
std::string d_signal_pretty_name;
std::string d_dump_filename;
std::ofstream d_dump_file;
gr_complex *d_Very_Early;
gr_complex *d_Early;
gr_complex *d_Prompt;
gr_complex *d_Late;
gr_complex *d_Very_Late;
gr_complex d_VE_accu;
gr_complex d_E_accu;
gr_complex d_P_accu;
gr_complex d_P_accu_old;
gr_complex d_L_accu;
gr_complex d_VL_accu;
gr_complex d_P_data_accu;
// nominal signal parameters
double d_signal_carrier_freq;
@ -171,37 +194,17 @@ private:
double d_rem_code_phase_chips;
double d_rem_code_phase_samples;
gr_complex *d_Very_Early;
gr_complex *d_Early;
gr_complex *d_Prompt;
gr_complex *d_Late;
gr_complex *d_Very_Late;
gr_complex d_VE_accu;
gr_complex d_E_accu;
gr_complex d_P_accu;
gr_complex d_P_accu_old;
gr_complex d_L_accu;
gr_complex d_VL_accu;
gr_complex d_P_data_accu;
std::string d_secondary_code_string;
std::string d_data_secondary_code_string;
std::string d_systemName;
std::string d_signal_type;
std::string d_signal_pretty_name;
std::string d_dump_filename;
std::ofstream d_dump_file;
uint64_t d_sample_counter;
uint64_t d_acq_sample_stamp;
float *d_prompt_data_shift;
float d_rem_carr_phase_rad;
uint32_t d_channel;
uint32_t d_secondary_code_length;
uint32_t d_data_secondary_code_length;
int32_t d_symbols_per_bit;
int32_t d_preamble_length_symbols;
int32_t d_state;
int32_t d_correlation_length_ms;
int32_t d_n_correlator_taps;
@ -215,10 +218,6 @@ private:
int32_t d_code_samples_per_chip; // All signals have 1 sample per chip code except Gal. E1 which has 2 (CBOC disabled) or 12 (CBOC enabled)
int32_t d_code_length_chips;
uint32_t d_channel;
uint32_t d_secondary_code_length;
uint32_t d_data_secondary_code_length;
bool d_pull_in_transitory;
bool d_corrected_doppler;
bool d_interchange_iq;

2
src/core/libs/INIReader.cc
View File

@ -33,8 +33,8 @@
INIReader::INIReader(const std::string& filename)
: _error(ini_parse(filename.c_str(), ValueHandler, this))
{
_error = ini_parse(filename.c_str(), ValueHandler, this);
}

4
src/core/libs/channel_event.cc
View File

@ -22,7 +22,7 @@ channel_event_sptr channel_event_make(int channel_id, int event_type)
}
Channel_Event::Channel_Event(int channel_id_, int event_type_)
: channel_id(channel_id_),
event_type(event_type_)
{
channel_id = channel_id_;
event_type = event_type_;
}

4
src/core/libs/command_event.cc
View File

@ -22,7 +22,7 @@ command_event_sptr command_event_make(int command_id, int event_type)
}
Command_Event::Command_Event(int command_id_, int event_type_)
: command_id(command_id_),
event_type(event_type_)
{
command_id = command_id_;
event_type = event_type_;
}

39
src/core/libs/gnss_sdr_fpga_sample_counter.cc
View File

@ -46,30 +46,31 @@
gnss_sdr_fpga_sample_counter::gnss_sdr_fpga_sample_counter(
double _fs,
int32_t _interval_ms) : gr::block("fpga_fpga_sample_counter",
gr::io_signature::make(0, 0, 0),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
int32_t _interval_ms)
: gr::block("fpga_fpga_sample_counter",
gr::io_signature::make(0, 0, 0),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
fs(_fs),
sample_counter(0ULL),
last_sample_counter(0ULL),
current_T_rx_ms(0),
interval_ms(_interval_ms),
current_s(0),
current_m(0),
current_h(0),
current_days(0),
report_interval_ms(1000), // default reporting 1 second
flag_enable_send_msg(false), // enable it for reporting time with asynchronous message
flag_m(false),
flag_h(false),
flag_days(false),
is_open(true)
{
message_port_register_out(pmt::mp("fpga_sample_counter"));
set_max_noutput_items(1);
interval_ms = _interval_ms;
fs = _fs;
samples_per_output = std::round(fs * static_cast<double>(interval_ms) / 1e3);
open_device();
is_open = true;
sample_counter = 0ULL;
last_sample_counter = 0ULL;
current_T_rx_ms = 0;
current_s = 0;
current_m = 0;
current_h = 0;
current_days = 0;
report_interval_ms = 1000; // default reporting 1 second
samples_per_report = std::round(fs * static_cast<double>(report_interval_ms) / 1e3);
flag_enable_send_msg = false; // enable it for reporting time with asynchronous message
flag_m = false;
flag_h = false;
flag_days = false;
open_device();
}

37
src/core/libs/gnss_sdr_sample_counter.cc
View File

@ -31,27 +31,28 @@
gnss_sdr_sample_counter::gnss_sdr_sample_counter(
double _fs,
int32_t _interval_ms,
size_t _size) : gr::sync_decimator("sample_counter",
gr::io_signature::make(1, 1, _size),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
static_cast<uint32_t>(std::round(_fs * static_cast<double>(_interval_ms) / 1e3)))
size_t _size)
: gr::sync_decimator("sample_counter",
gr::io_signature::make(1, 1, _size),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
static_cast<uint32_t>(std::round(_fs * static_cast<double>(_interval_ms) / 1e3))),
fs(_fs),
current_T_rx_ms(0),
sample_counter(0),
interval_ms(_interval_ms),
report_interval_ms(1000), // default reporting 1 second
samples_per_output(std::round(fs * static_cast<double>(interval_ms) / 1e3)),
current_s(0),
current_m(0),
current_h(0),
current_days(0),
flag_m(false),
flag_h(false),
flag_days(false),
flag_enable_send_msg(false) // enable it for reporting time with asynchronous message
{
message_port_register_out(pmt::mp("sample_counter"));
set_max_noutput_items(1);
interval_ms = _interval_ms;
fs = _fs;
samples_per_output = std::round(fs * static_cast<double>(interval_ms) / 1e3);
sample_counter = 0;
current_T_rx_ms = 0;
current_s = 0;
current_m = 0;
current_h = 0;
current_days = 0;
report_interval_ms = 1000; // default reporting 1 second
flag_enable_send_msg = false; // enable it for reporting time with asynchronous message
flag_m = false;
flag_h = false;
flag_days = false;
set_tag_propagation_policy(TPP_DONT); // no tag propagation, the time tag will be adjusted and regenerated in work()
}

7
src/core/libs/gnss_sdr_supl_client.cc
View File

@ -31,15 +31,10 @@
#include <vector>
Gnss_Sdr_Supl_Client::Gnss_Sdr_Supl_Client()
: server_port(0), request(0), mcc(0), mns(0), lac(0), ci(0)
{
mcc = 0;
mns = 0;
lac = 0;
ci = 0;
supl_ctx_new(&ctx);
assist = supl_assist_t();
server_port = 0;
request = 0;
}

25
src/core/libs/gnss_sdr_time_counter.cc
View File

@ -21,20 +21,21 @@
#include <iostream>
#include <string>
gnss_sdr_time_counter::gnss_sdr_time_counter() : gr::block("time_counter",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
gnss_sdr_time_counter::gnss_sdr_time_counter()
: gr::block("time_counter",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
current_T_rx_ms(0),
report_interval_ms(1000), // default reporting 1 second
current_s(0),
current_m(0),
current_h(0),
current_days(0),
flag_m(false),
flag_h(false),
flag_days(false)
{
set_max_noutput_items(1);
current_T_rx_ms = 0;
current_s = 0;
current_m = 0;
current_h = 0;
current_days = 0;
report_interval_ms = 1000; // default reporting 1 second
flag_m = false;
flag_h = false;
flag_days = false;
}

12
src/core/monitor/gnss_synchro_monitor.cc
View File

@ -42,13 +42,13 @@ gnss_synchro_monitor::gnss_synchro_monitor(int n_channels,
int decimation_factor,
int udp_port,
const std::vector<std::string>& udp_addresses,
bool enable_protobuf) : gr::block("gnss_synchro_monitor",
gr::io_signature::make(n_channels, n_channels, sizeof(Gnss_Synchro)),
gr::io_signature::make(0, 0, 0))
bool enable_protobuf)
: gr::block("gnss_synchro_monitor",
gr::io_signature::make(n_channels, n_channels, sizeof(Gnss_Synchro)),
gr::io_signature::make(0, 0, 0)),
d_nchannels(n_channels),
d_decimation_factor(decimation_factor)
{
d_decimation_factor = decimation_factor;
d_nchannels = n_channels;
udp_sink_ptr = std::make_unique<Gnss_Synchro_Udp_Sink>(udp_addresses, udp_port, enable_protobuf);
}

7
src/core/monitor/gnss_synchro_udp_sink.cc
View File

@ -21,9 +21,12 @@
#include <iostream>
#include <sstream>
Gnss_Synchro_Udp_Sink::Gnss_Synchro_Udp_Sink(const std::vector<std::string>& addresses, const uint16_t& port, bool enable_protobuf) : socket{io_context}
Gnss_Synchro_Udp_Sink::Gnss_Synchro_Udp_Sink(const std::vector<std::string>& addresses,
const uint16_t& port,
bool enable_protobuf)
: socket{io_context},
use_protobuf(enable_protobuf)
{
use_protobuf = enable_protobuf;
if (enable_protobuf)
{
serdes = Serdes_Gnss_Synchro();

16
src/core/receiver/control_thread.cc
View File

@ -129,15 +129,15 @@ ControlThread::ControlThread()
ControlThread::ControlThread(std::shared_ptr<ConfigurationInterface> configuration)
: configuration_(std::move(configuration)),
well_formatted_configuration_(true),
conf_file_has_section_(true),
conf_file_has_mandatory_globals_(true),
conf_has_signal_sources_(true),
conf_has_observables_(true),
conf_has_pvt_(true),
restart_(false)
{
configuration_ = std::move(configuration);
conf_file_has_section_ = true;
conf_file_has_mandatory_globals_ = true;
conf_has_signal_sources_ = true;
conf_has_observables_ = true;
conf_has_pvt_ = true;
well_formatted_configuration_ = true;
restart_ = false;
init();
}

4
src/core/receiver/file_configuration.cc
View File

@ -27,15 +27,15 @@
FileConfiguration::FileConfiguration(std::string filename)
: filename_(std::move(filename))
{
filename_ = std::move(filename);
init();
}
FileConfiguration::FileConfiguration()
: filename_("./default_config_file.txt")
{
filename_ = "./default_config_file.txt";
init();
}

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

@ -69,14 +69,15 @@
#define GNSS_SDR_ARRAY_SIGNAL_CONDITIONER_CHANNELS 8
GNSSFlowgraph::GNSSFlowgraph(std::shared_ptr<ConfigurationInterface> configuration, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue) // NOLINT(performance-unnecessary-value-param)
GNSSFlowgraph::GNSSFlowgraph(std::shared_ptr<ConfigurationInterface> configuration,
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue) // NOLINT(performance-unnecessary-value-param)
: configuration_(std::move(configuration)),
queue_(std::move(queue)),
connected_(false),
running_(false),
multiband_(GNSSFlowgraph::is_multiband()),
enable_e6_has_rx_(false)
{
connected_ = false;
running_ = false;
enable_e6_has_rx_ = false;
configuration_ = std::move(configuration);
queue_ = std::move(queue);
multiband_ = GNSSFlowgraph::is_multiband();
enable_fpga_offloading_ = configuration_->property("GNSS-SDR.enable_FPGA", false);
init();
}

10
src/core/receiver/tcp_cmd_interface.cc
View File

@ -32,14 +32,14 @@ using b_io_context = boost::asio::io_service;
#endif
TcpCmdInterface::TcpCmdInterface()
: rx_latitude_(0.0),
rx_longitude_(0.0),
rx_altitude_(0.0),
receiver_utc_time_(0),
keep_running_(true)
{
register_functions();
keep_running_ = true;
control_queue_ = nullptr;
rx_latitude_ = 0.0;
rx_longitude_ = 0.0;
rx_altitude_ = 0.0;
receiver_utc_time_ = 0;
}

2
src/core/system_parameters/galileo_inav_message.cc
View File

@ -1016,6 +1016,7 @@ int32_t Galileo_Inav_Message::page_jk_decoder(const char* data_jk)
DLOG(INFO) << "E1B_DVS_5= " << E1B_DVS_5;
// GST
WN_5 = static_cast<int32_t>(read_navigation_unsigned(data_jk_bits, WN_5_BIT));
WN_0 = WN_5;
DLOG(INFO) << "WN_5= " << WN_5;
TOW_5 = static_cast<int32_t>(read_navigation_unsigned(data_jk_bits, TOW_5_BIT));
DLOG(INFO) << "TOW_5= " << TOW_5;
@ -1358,6 +1359,7 @@ int32_t Galileo_Inav_Message::page_jk_decoder(const char* data_jk)
if (Time_0 == 2) // valid data
{
WN_0 = static_cast<int32_t>(read_navigation_unsigned(data_jk_bits, WN_0_BIT));
WN_5 = WN_0;
DLOG(INFO) << "WN_0= " << WN_0;
TOW_0 = static_cast<int32_t>(read_navigation_unsigned(data_jk_bits, TOW_0_BIT));
flag_TOW_set = true; // set to false externally

6
src/core/system_parameters/gnss_signal.cc
View File

@ -19,15 +19,15 @@
Gnss_Signal::Gnss_Signal(const std::string& signal_)
: signal(signal_)
{
this->signal = signal_;
}
Gnss_Signal::Gnss_Signal(const Gnss_Satellite& satellite_, const std::string& signal_)
: satellite(satellite_),
signal(signal_)
{
this->satellite = satellite_;
this->signal = signal_;
}