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

src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc

@@ -36,11 +36,16 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition(
     const ConfigurationInterface* configuration,
     const std::string& role,
     unsigned int in_streams,
-    unsigned int out_streams) : role_(role),
+    unsigned int out_streams)
-                                in_streams_(in_streams),
+    : configuration_(configuration),
-                                out_streams_(out_streams)
+      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";

src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc

@@ -28,11 +28,16 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition
     const ConfigurationInterface* configuration,
     const std::string& role,
     unsigned int in_streams,
-    unsigned int out_streams) : role_(role),
+    unsigned int out_streams)
-                                in_streams_(in_streams),
+    : configuration_(configuration),
-                                out_streams_(out_streams)
+      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";

src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc

@@ -36,11 +36,16 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui
     const ConfigurationInterface* configuration,
     const std::string& role,
     unsigned int in_streams,
-    unsigned int out_streams) : role_(role),
+    unsigned int out_streams)
-                                in_streams_(in_streams),
+    : configuration_(configuration),
-                                out_streams_(out_streams)
+      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";

src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc

@@ -36,11 +36,16 @@ GalileoE1PcpsTongAmbiguousAcquisition::GalileoE1PcpsTongAmbiguousAcquisition(
     const ConfigurationInterface* configuration,
     const std::string& role,
     unsigned int in_streams,
-    unsigned int out_streams) : role_(role),
+    unsigned int out_streams)
-                                in_streams_(in_streams),
+    : configuration_(configuration),
-                                out_streams_(out_streams)
+      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";

src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc

@@ -42,11 +42,16 @@ GalileoE5aNoncoherentIQAcquisitionCaf::GalileoE5aNoncoherentIQAcquisitionCaf(
     const ConfigurationInterface* configuration,
     const std::string& role,
     unsigned int in_streams,
-    unsigned int out_streams) : role_(role),
+    unsigned int out_streams)
-                                in_streams_(in_streams),
+    : configuration_(configuration),
-                                out_streams_(out_streams)
+      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";

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc

@@ -37,11 +37,16 @@ GpsL1CaPcpsQuickSyncAcquisition::GpsL1CaPcpsQuickSyncAcquisition(
     const ConfigurationInterface* configuration,
     const std::string& role,
     unsigned int in_streams,
-    unsigned int out_streams) : role_(role),
+    unsigned int out_streams)
-                                in_streams_(in_streams),
+    : configuration_(configuration),
-                                out_streams_(out_streams)
+      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";

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc

@@ -36,11 +36,16 @@ GpsL1CaPcpsTongAcquisition::GpsL1CaPcpsTongAcquisition(
     const ConfigurationInterface* configuration,
     const std::string& role,
     unsigned int in_streams,
-    unsigned int out_streams) : role_(role),
+    unsigned int out_streams)
-                                in_streams_(in_streams),
+    : configuration_(configuration),
-                                out_streams_(out_streams)
+      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";

src/algorithms/channel/libs/channel_fsm.cc

@@ -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;
 }
 
 

src/algorithms/conditioner/adapters/array_signal_conditioner.cc

@@ -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;
 }
 
 

src/algorithms/conditioner/adapters/signal_conditioner.cc

@@ -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;
 }
 
 

src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc

@@ -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;

src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.h

@@ -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;

src/algorithms/signal_source/adapters/custom_udp_signal_source.cc

@@ -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,

src/algorithms/signal_source/adapters/gen_signal_source.cc

@@ -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)),
+    Concurrent_Queue<pmt::pmt_t> *queue __attribute__((unused)))
-                                                                   filter_(std::move(filter)),
+    : signal_generator_(std::move(signal_generator)),
-                                                                   role_(std::move(role))
+      filter_(std::move(filter)),
+      role_(std::move(role)),
+      connected_(false)
 {
-    connected_ = false;
 }
 
 

src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.cc

@@ -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;
 

src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.cc

@@ -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";
+    memset(reinterpret_cast<char *>(&si_me), 0, sizeof(si_me));
-    std::cout << "Overflow events will be indicated by o's\n";
-
-    d_n_baseband_channels = n_baseband_channels;
     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";
 }
 

src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.h

@@ -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;
 };
 
 

src/algorithms/signal_source/gnuradio_blocks/labsat23_source.cc

@@ -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();

src/algorithms/signal_source/gnuradio_blocks/unpack_spir_gss6450_samples.cc

@@ -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",
+unpack_spir_gss6450_samples::unpack_spir_gss6450_samples(int adc_nbit)
-                                                                             gr::io_signature::make(1, 1, sizeof(int32_t)),
+    : gr::sync_interpolator("unpack_spir_gss6450_samples",
-                                                                             gr::io_signature::make(1, 1, sizeof(gr_complex)), 16 / adc_nbit)
+          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;
 }
 
 

src/algorithms/signal_source/libs/fpga_buffer_monitor.cc

@@ -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;

src/algorithms/signal_source/libs/fpga_buffer_monitor.h

@@ -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;
 };
 
 

src/algorithms/signal_source/libs/gnss_sdr_timestamp.cc

@@ -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";
+                    // 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";
-                    get_next_timetag = true;
+                    d_get_next_timetag = true;
                 }
         }
 

src/algorithms/signal_source/libs/gnss_sdr_timestamp.h

@@ -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;
+    double d_integer_ms_offset;
-    bool get_next_timetag;
+    uint64_t d_next_timetag_samplecount;
+    bool d_get_next_timetag;
 };
 
 

src/algorithms/signal_source/libs/gnss_sdr_valve.cc

@@ -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;
 }
 
 

src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc

@@ -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 PMT_USES_BOOST_ANY
-#if HAS_STD_FILESYSTEM_EXPERIMENTAL
+#include <boost/any.hpp>
-#include <experimental/filesystem>
+namespace wht = boost;
-namespace fs = std::experimental::filesystem;
 #else
-#include <filesystem>
+#include <any>
-namespace fs = std::filesystem;
+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::block("kf_vtl_tracking",
-          gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
+          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));
+                    const auto cmd = wht::any_cast<const std::shared_ptr<TrackingCmd>>(pmt::any_ref(msg));
-                    //                    std::cout << "RX pvt-to-trk cmd with delay: "
+                    // 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";
+                    //           << 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);
+    d_code_error_kf_chips = d_x_new_new(0);
-    x_new_new(0) = 0;  // reset error estimation because the NCO corrects the code phase
+    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);
+    d_carrier_doppler_rate_kf_hz_s = d_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';
 
     // 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);

src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.h

@@ -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;

src/core/libs/INIReader.cc

@@ -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);
 }
 
 

src/core/libs/channel_event.cc

@@ -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_;
 }

src/core/libs/command_event.cc

@@ -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_;
 }

src/core/libs/gnss_sdr_fpga_sample_counter.cc

@@ -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",
+    int32_t _interval_ms)
-                                gr::io_signature::make(0, 0, 0),
+    : gr::block("fpga_fpga_sample_counter",
-                                gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
+          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
+    open_device();
-    flag_m = false;
-    flag_h = false;
-    flag_days = false;
 }
 
 

src/core/libs/gnss_sdr_sample_counter.cc

@@ -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",
+    size_t _size)
-                        gr::io_signature::make(1, 1, _size),
+    : gr::sync_decimator("sample_counter",
-                        gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
+          gr::io_signature::make(1, 1, _size),
-                        static_cast<uint32_t>(std::round(_fs * static_cast<double>(_interval_ms) / 1e3)))
+          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()
 }
 

src/core/libs/gnss_sdr_supl_client.cc

@@ -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;
 }
 
 

src/core/libs/gnss_sdr_time_counter.cc

@@ -21,20 +21,21 @@
 #include <iostream>
 #include <string>
 
-gnss_sdr_time_counter::gnss_sdr_time_counter() : gr::block("time_counter",
+gnss_sdr_time_counter::gnss_sdr_time_counter()
-                                                     gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
+    : gr::block("time_counter",
-                                                     gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
+          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;
 }
 
 

src/core/monitor/gnss_synchro_monitor.cc

@@ -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",
+    bool enable_protobuf)
-                                gr::io_signature::make(n_channels, n_channels, sizeof(Gnss_Synchro)),
+    : gr::block("gnss_synchro_monitor",
-                                gr::io_signature::make(0, 0, 0))
+          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);
 }
 

src/core/monitor/gnss_synchro_udp_sink.cc

@@ -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();

src/core/receiver/control_thread.cc

@@ -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();
 }
 

src/core/receiver/file_configuration.cc

@@ -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();
 }
 

src/core/receiver/gnss_flowgraph.cc

@@ -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();
 }

src/core/receiver/tcp_cmd_interface.cc

@@ -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;
 }
 
 

src/core/system_parameters/galileo_inav_message.cc

@@ -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

src/core/system_parameters/gnss_signal.cc

@@ -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_;
 }