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

src/algorithms/PVT/libs/monitor_pvt_udp_sink.h

@@ -53,7 +53,6 @@ private:
     boost::asio::ip::udp::socket socket;
     boost::system::error_code error;
     std::vector<boost::asio::ip::udp::endpoint> endpoints;
-    Monitor_Pvt monitor_pvt{};
     Serdes_Monitor_Pvt serdes;
     bool use_protobuf;
 };

src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.cc

@@ -199,14 +199,14 @@ void BeidouB1iPcpsAcquisition::init()
 
 void BeidouB1iPcpsAcquisition::set_local_code()
 {
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
 
-    beidou_b1i_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
+    beidou_b1i_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
 
     gsl::span<gr_complex> code_span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < num_codes_; i++)
         {
-            std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.cc

@@ -200,14 +200,14 @@ void BeidouB3iPcpsAcquisition::init()
 
 void BeidouB3iPcpsAcquisition::set_local_code()
 {
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
 
-    beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
+    beidou_b3i_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
 
     gsl::span<gr_complex> code_span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < num_codes_; i++)
         {
-            std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc

@@ -210,19 +210,19 @@ void GalileoE1Pcps8msAmbiguousAcquisition::set_local_code()
             bool cboc = configuration_->property(
                 "Acquisition" + std::to_string(channel_) + ".cboc", false);
 
-            std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+            std::vector<std::complex<float>> code(code_length_);
             std::array<char, 3> Signal_{};
             Signal_[0] = gnss_synchro_->Signal[0];
             Signal_[1] = gnss_synchro_->Signal[1];
             Signal_[2] = '\0';
 
-            galileo_e1_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), Signal_,
+            galileo_e1_code_gen_complex_sampled(code, Signal_,
                 cboc, gnss_synchro_->PRN, fs_in_, 0, false);
 
             gsl::span<gr_complex> code_span(code_.data(), vector_length_);
             for (unsigned int i = 0; i < sampled_ms_ / 4; i++)
                 {
-                    std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+                    std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
                 }
 
             acquisition_cc_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc

@@ -245,8 +245,7 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
     bool cboc = configuration_->property(
         "Acquisition" + std::to_string(channel_) + ".cboc", false);
 
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
-    gsl::span<std::complex<float>> code_span(code.get(), code_length_);
 
     if (acquire_pilot_ == true)
         {
@@ -254,12 +253,12 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
             std::array<char, 3> pilot_signal = {{'1', 'C', '\0'}};
             if (acq_parameters_.use_automatic_resampler)
                 {
-                    galileo_e1_code_gen_complex_sampled(code_span, pilot_signal,
+                    galileo_e1_code_gen_complex_sampled(code, pilot_signal,
                         cboc, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0, false);
                 }
             else
                 {
-                    galileo_e1_code_gen_complex_sampled(code_span, pilot_signal,
+                    galileo_e1_code_gen_complex_sampled(code, pilot_signal,
                         cboc, gnss_synchro_->PRN, fs_in_, 0, false);
                 }
         }
@@ -271,12 +270,12 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
             Signal_[2] = '\0';
             if (acq_parameters_.use_automatic_resampler)
                 {
-                    galileo_e1_code_gen_complex_sampled(code_span, Signal_,
+                    galileo_e1_code_gen_complex_sampled(code, Signal_,
                         cboc, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0, false);
                 }
             else
                 {
-                    galileo_e1_code_gen_complex_sampled(code_span, Signal_,
+                    galileo_e1_code_gen_complex_sampled(code, Signal_,
                         cboc, gnss_synchro_->PRN, fs_in_, 0, false);
                 }
         }
@@ -284,7 +283,7 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
     gsl::span<gr_complex> code__span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < sampled_ms_ / 4; i++)
         {
-            std::copy_n(code.get(), code_length_, code__span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code__span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc

@@ -244,19 +244,19 @@ void GalileoE1PcpsQuickSyncAmbiguousAcquisition::set_local_code()
             bool cboc = configuration_->property(
                 "Acquisition" + std::to_string(channel_) + ".cboc", false);
 
-            std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+            std::vector<std::complex<float>> code(code_length_);
             std::array<char, 3> Signal_{};
             Signal_[0] = gnss_synchro_->Signal[0];
             Signal_[1] = gnss_synchro_->Signal[1];
             Signal_[2] = '\0';
 
-            galileo_e1_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), Signal_,
+            galileo_e1_code_gen_complex_sampled(code, Signal_,
                 cboc, gnss_synchro_->PRN, fs_in_, 0, false);
 
             gsl::span<gr_complex> code_span(code_.data(), vector_length_);
             for (unsigned int i = 0; i < (sampled_ms_ / (folding_factor_ * 4)); i++)
                 {
-                    std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+                    std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
                 }
 
             acquisition_cc_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc

@@ -214,18 +214,18 @@ void GalileoE1PcpsTongAmbiguousAcquisition::set_local_code()
             bool cboc = configuration_->property(
                 "Acquisition" + std::to_string(channel_) + ".cboc", false);
 
-            std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+            std::vector<std::complex<float>> code(code_length_);
             std::array<char, 3> Signal_{};
             Signal_[0] = gnss_synchro_->Signal[0];
             Signal_[1] = gnss_synchro_->Signal[1];
             Signal_[2] = '\0';
-            galileo_e1_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), Signal_,
+            galileo_e1_code_gen_complex_sampled(code, Signal_,
                 cboc, gnss_synchro_->PRN, fs_in_, 0, false);
 
             gsl::span<gr_complex> code_span(code_.data(), vector_length_);
             for (unsigned int i = 0; i < sampled_ms_ / 4; i++)
                 {
-                    std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+                    std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
                 }
 
             acquisition_cc_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc

@@ -209,6 +209,7 @@ void GalileoE5aPcpsAcquisition::set_doppler_step(unsigned int doppler_step)
     acquisition_->set_doppler_step(doppler_step_);
 }
 
+
 void GalileoE5aPcpsAcquisition::set_doppler_center(int doppler_center)
 {
     doppler_center_ = doppler_center;
@@ -216,6 +217,7 @@ void GalileoE5aPcpsAcquisition::set_doppler_center(int doppler_center)
     acquisition_->set_doppler_center(doppler_center_);
 }
 
+
 void GalileoE5aPcpsAcquisition::set_gnss_synchro(Gnss_Synchro* gnss_synchro)
 {
     gnss_synchro_ = gnss_synchro;
@@ -237,7 +239,7 @@ void GalileoE5aPcpsAcquisition::init()
 
 void GalileoE5aPcpsAcquisition::set_local_code()
 {
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
     std::array<char, 3> signal_{};
     signal_[0] = '5';
     signal_[2] = '\0';
@@ -257,16 +259,16 @@ void GalileoE5aPcpsAcquisition::set_local_code()
 
     if (acq_parameters_.use_automatic_resampler)
         {
-            galileo_e5_a_code_gen_complex_sampled(gsl::span<gr_complex>(code.get(), code_length_), signal_, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0);
+            galileo_e5_a_code_gen_complex_sampled(code, signal_, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0);
         }
     else
         {
-            galileo_e5_a_code_gen_complex_sampled(gsl::span<gr_complex>(code.get(), code_length_), signal_, gnss_synchro_->PRN, fs_in_, 0);
+            galileo_e5_a_code_gen_complex_sampled(code, signal_, gnss_synchro_->PRN, fs_in_, 0);
         }
     gsl::span<gr_complex> code_span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < sampled_ms_; i++)
         {
-            std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc

@@ -202,14 +202,14 @@ void GlonassL1CaPcpsAcquisition::init()
 
 void GlonassL1CaPcpsAcquisition::set_local_code()
 {
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
 
-    glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), /* gnss_synchro_->PRN,*/ fs_in_, 0);
+    glonass_l1_ca_code_gen_complex_sampled(code, fs_in_, 0);
 
     gsl::span<gr_complex> code_span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < sampled_ms_; i++)
         {
-            std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc

@@ -201,14 +201,14 @@ void GlonassL2CaPcpsAcquisition::init()
 
 void GlonassL2CaPcpsAcquisition::set_local_code()
 {
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
 
-    glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), /* gnss_synchro_->PRN,*/ fs_in_, 0);
+    glonass_l2_ca_code_gen_complex_sampled(code, fs_in_, 0);
 
     gsl::span<gr_complex> code_span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < sampled_ms_; i++)
         {
-            std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc

@@ -201,6 +201,7 @@ void GpsL1CaPcpsAcquisition::set_doppler_step(unsigned int doppler_step)
     acquisition_->set_doppler_step(doppler_step_);
 }
 
+
 void GpsL1CaPcpsAcquisition::set_doppler_center(int doppler_center)
 {
     doppler_center_ = doppler_center;
@@ -208,6 +209,7 @@ void GpsL1CaPcpsAcquisition::set_doppler_center(int doppler_center)
     acquisition_->set_doppler_center(doppler_center_);
 }
 
+
 void GpsL1CaPcpsAcquisition::set_gnss_synchro(Gnss_Synchro* gnss_synchro)
 {
     gnss_synchro_ = gnss_synchro;
@@ -230,20 +232,20 @@ void GpsL1CaPcpsAcquisition::init()
 
 void GpsL1CaPcpsAcquisition::set_local_code()
 {
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
 
     if (acq_parameters_.use_automatic_resampler)
         {
-            gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0);
+            gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0);
         }
     else
         {
-            gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
+            gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
         }
     gsl::span<gr_complex> code_span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < sampled_ms_; i++)
         {
-            std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());
@@ -264,7 +266,7 @@ void GpsL1CaPcpsAcquisition::set_state(int state)
 
 float GpsL1CaPcpsAcquisition::calculate_threshold(float pfa)
 {
-    //Calculate the threshold
+    // Calculate the threshold
     unsigned int frequency_bins = 0;
     for (int doppler = static_cast<int>(-doppler_max_); doppler <= static_cast<int>(doppler_max_); doppler += doppler_step_)
         {
@@ -355,6 +357,7 @@ gr::basic_block_sptr GpsL1CaPcpsAcquisition::get_right_block()
     return acquisition_;
 }
 
+
 void GpsL1CaPcpsAcquisition::set_resampler_latency(uint32_t latency_samples)
 {
     acquisition_->set_resampler_latency(latency_samples);

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc

@@ -206,14 +206,14 @@ void GpsL1CaPcpsOpenClAcquisition::set_local_code()
 {
     if (item_type_ == "gr_complex")
         {
-            std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+            std::vector<std::complex<float>> code(code_length_);
 
-            gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
+            gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
 
             gsl::span<gr_complex> code_span(code_.data(), vector_length_);
             for (unsigned int i = 0; i < sampled_ms_; i++)
                 {
-                    std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+                    std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
                 }
 
             acquisition_cc_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc

@@ -232,14 +232,14 @@ void GpsL1CaPcpsQuickSyncAcquisition::set_local_code()
 {
     if (item_type_ == "gr_complex")
         {
-            std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+            std::vector<std::complex<float>> code(code_length_);
 
-            gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
+            gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
 
             gsl::span<gr_complex> code_span(code_.data(), vector_length_);
             for (unsigned int i = 0; i < (sampled_ms_ / folding_factor_); i++)
                 {
-                    std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+                    std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
                 }
 
             acquisition_cc_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc

@@ -194,14 +194,14 @@ void GpsL1CaPcpsTongAcquisition::set_local_code()
 {
     if (item_type_ == "gr_complex")
         {
-            std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+            std::vector<std::complex<float>> code(code_length_);
 
-            gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
+            gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
 
             gsl::span<gr_complex> code_span(code_.data(), vector_length_);
             for (unsigned int i = 0; i < sampled_ms_; i++)
                 {
-                    std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+                    std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
                 }
 
             acquisition_cc_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc

@@ -241,21 +241,21 @@ void GpsL2MPcpsAcquisition::init()
 
 void GpsL2MPcpsAcquisition::set_local_code()
 {
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
 
     if (acq_parameters_.use_automatic_resampler)
         {
-            gps_l2c_m_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), gnss_synchro_->PRN, acq_parameters_.resampled_fs);
+            gps_l2c_m_code_gen_complex_sampled(code, gnss_synchro_->PRN, acq_parameters_.resampled_fs);
         }
     else
         {
-            gps_l2c_m_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), gnss_synchro_->PRN, fs_in_);
+            gps_l2c_m_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_);
         }
 
     gsl::span<gr_complex> code_span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < num_codes_; i++)
         {
-            std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());

src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc

@@ -235,21 +235,21 @@ void GpsL5iPcpsAcquisition::init()
 
 void GpsL5iPcpsAcquisition::set_local_code()
 {
-    std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
+    std::vector<std::complex<float>> code(code_length_);
 
     if (acq_parameters_.use_automatic_resampler)
         {
-            gps_l5i_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), gnss_synchro_->PRN, acq_parameters_.resampled_fs);
+            gps_l5i_code_gen_complex_sampled(code, gnss_synchro_->PRN, acq_parameters_.resampled_fs);
         }
     else
         {
-            gps_l5i_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), gnss_synchro_->PRN, fs_in_);
+            gps_l5i_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_);
         }
 
     gsl::span<gr_complex> code_span(code_.data(), vector_length_);
     for (unsigned int i = 0; i < num_codes_; i++)
         {
-            std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
+            std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
         }
 
     acquisition_->set_local_code(code_.data());

src/algorithms/libs/beidou_b3i_signal_processing.cc

@@ -35,11 +35,11 @@
 #include <bitset>
 #include <string>
 
-auto auxCeil = [](float x) { return static_cast<int>(static_cast<long>((x) + 1)); };
+auto auxCeil = [](float x) { return static_cast<int32_t>(static_cast<int64_t>((x) + 1)); };
 
-void beidou_b3i_code_gen_int(gsl::span<int> _dest, signed int _prn, unsigned int _chip_shift)
+void beidou_b3i_code_gen_int(gsl::span<int> _dest, int32_t _prn, uint32_t _chip_shift)
 {
-    const unsigned int _code_length = 10230;
+    const uint32_t _code_length = 10230;
     std::bitset<_code_length> G1{};
     std::bitset<_code_length> G2{};
     auto G1_register = std::bitset<13>{}.set();  // All true
@@ -175,54 +175,54 @@ void beidou_b3i_code_gen_int(gsl::span<int> _dest, signed int _prn, unsigned int
 }
 
 
-void beidou_b3i_code_gen_float(gsl::span<float> _dest, signed int _prn, unsigned int _chip_shift)
+void beidou_b3i_code_gen_float(gsl::span<float> _dest, int32_t _prn, uint32_t _chip_shift)
 {
-    const unsigned int _code_length = 10230;
+    const uint32_t _code_length = 10230;
     std::array<int, _code_length> b3i_code_int{};
 
     beidou_b3i_code_gen_int(b3i_code_int, _prn, _chip_shift);
 
-    for (unsigned int ii = 0; ii < _code_length; ++ii)
+    for (uint32_t ii = 0; ii < _code_length; ++ii)
         {
             _dest[ii] = static_cast<float>(b3i_code_int[ii]);
         }
 }
 
 
-void beidou_b3i_code_gen_complex(gsl::span<std::complex<float>> _dest, signed int _prn, unsigned int _chip_shift)
+void beidou_b3i_code_gen_complex(gsl::span<std::complex<float>> _dest, int32_t _prn, uint32_t _chip_shift)
 {
-    const unsigned int _code_length = 10230;
+    const uint32_t _code_length = 10230;
     std::array<int, _code_length> b3i_code_int{};
 
     beidou_b3i_code_gen_int(b3i_code_int, _prn, _chip_shift);
 
-    for (unsigned int ii = 0; ii < _code_length; ++ii)
+    for (uint32_t ii = 0; ii < _code_length; ++ii)
         {
             _dest[ii] = std::complex<float>(static_cast<float>(b3i_code_int[ii]), 0.0F);
         }
 }
 
 
-void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, unsigned int _prn, int _fs, unsigned int _chip_shift)
+void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift)
 {
     // This function is based on the GNU software GPS for MATLAB in the Kay Borre book
     std::array<std::complex<float>, 10230> _code{};
-    signed int _samplesPerCode, _codeValueIndex;
+    int32_t _samplesPerCode, _codeValueIndex;
     float _ts;
     float _tc;
     float aux;
-    const signed int _codeFreqBasis = 10230000;  // Hz
+    const int32_t _codeFreqBasis = 10230000;  // Hz
-    const signed int _codeLength = 10230;
+    const int32_t _codeLength = 10230;
 
     //--- Find number of samples per spreading code ----------------------------
-    _samplesPerCode = static_cast<signed int>(static_cast<double>(_fs) / static_cast<double>(_codeFreqBasis / _codeLength));
+    _samplesPerCode = static_cast<int32_t>(static_cast<double>(_fs) / static_cast<double>(_codeFreqBasis / _codeLength));
 
     //--- Find time constants --------------------------------------------------
     _ts = 1.0 / static_cast<float>(_fs);                    // Sampling period in sec
     _tc = 1.0 / static_cast<float>(_codeFreqBasis);         // C/A chip period in sec
     beidou_b3i_code_gen_complex(_code, _prn, _chip_shift);  // generate C/A code 1 sample per chip
 
-    for (signed int i = 0; i < _samplesPerCode; i++)
+    for (int32_t i = 0; i < _samplesPerCode; i++)
         {
             //=== Digitizing =======================================================
 
@@ -231,7 +231,6 @@ void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, u
             // number of samples per millisecond (because one C/A code period is one
             // millisecond).
 
-            // _codeValueIndex = ceil((_ts * ((float)i + 1)) / _tc) - 1;
             aux = (_ts * (i + 1)) / _tc;
             _codeValueIndex = auxCeil(aux) - 1;
 
@@ -245,7 +244,7 @@ void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, u
                 }
             else
                 {
-                    _dest[i] = _code[_codeValueIndex];  //repeat the chip -> upsample
+                    _dest[i] = _code[_codeValueIndex];  // repeat the chip -> upsample
                 }
         }
 }

src/algorithms/libs/beidou_b3i_signal_processing.h

@@ -34,10 +34,7 @@
 #define GNSS_SDR_BEIDOU_B3I_SIGNAL_PROCESSING_H_
 
 #include <complex>
-#include <iostream>
 #include <cstdint>
-#include <array>
-#include <algorithm>
 
 #if HAS_SPAN
 #include <span>
@@ -47,18 +44,18 @@ namespace gsl = std;
 #endif
 
 //! Generates int BeiDou B3I code for the desired SV ID and code shift
-void beidou_b3i_code_gen_int(gsl::span<int> _dest, signed int _prn, unsigned int _chip_shift);
+void beidou_b3i_code_gen_int(gsl::span<int> _dest, int32_t _prn, uint32_t _chip_shift);
 
 //! Generates float BeiDou B3I code for the desired SV ID and code shift
-void beidou_b3i_code_gen_float(gsl::span<float> _dest, signed int _prn, unsigned int _chip_shift);
+void beidou_b3i_code_gen_float(gsl::span<float> _dest, int32_t _prn, uint32_t _chip_shift);
 
 //! Generates complex BeiDou B3I code for the desired SV ID and code shift, and sampled to specific sampling frequency
-void beidou_b3i_code_gen_complex(gsl::span<std::complex<float>> _dest, signed int _prn, unsigned int _chip_shift);
+void beidou_b3i_code_gen_complex(gsl::span<std::complex<float>> _dest, int32_t _prn, uint32_t _chip_shift);
 
 //! Generates N complex BeiDou B3I codes for the desired SV ID and code shift
-void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, unsigned int _prn, int _fs, unsigned int _chip_shift, unsigned int _ncodes);
+void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift, uint32_t _ncodes);
 
 //! Generates complex BeiDou B3I code for the desired SV ID and code shift
-void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, unsigned int _prn, int _fs, unsigned int _chip_shift);
+void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift);
 
 #endif /* GNSS_SDR_BEIDOU_B3I_SIGNAL_PROCESSING_H_ */

src/algorithms/libs/galileo_e1_signal_processing.cc

@@ -33,7 +33,6 @@
 #include "galileo_e1_signal_processing.h"
 #include "Galileo_E1.h"
 #include "gnss_signal_processing.h"
-#include <array>
 #include <memory>
 #include <string>
 #include <vector>

src/algorithms/libs/galileo_e5_signal_processing.cc

@@ -35,7 +35,6 @@
 #include "Galileo_E5a.h"
 #include "gnss_signal_processing.h"
 #include <gnuradio/gr_complex.h>
-#include <array>
 #include <memory>
 
 

src/algorithms/libs/galileo_e5_signal_processing.h

@@ -34,6 +34,7 @@
 #ifndef GNSS_SDR_GALILEO_E5_SIGNAL_PROCESSING_H_
 #define GNSS_SDR_GALILEO_E5_SIGNAL_PROCESSING_H_
 
+#include <array>
 #include <complex>
 #include <cstdint>
 #if HAS_SPAN

src/algorithms/libs/geofunctions.cc

@@ -232,7 +232,7 @@ int togeod(double *dphi, double *dlambda, double *h, double a, double finv, doub
 }
 
 
-arma::mat Gravity_ECEF(const arma::vec &r_eb_e)
+arma::vec Gravity_ECEF(const arma::vec &r_eb_e)
 {
     // Parameters
     const double R_0 = 6378137.0;         // WGS84 Equatorial radius in meters

src/algorithms/libs/geofunctions.h

@@ -79,7 +79,7 @@ int topocent(double *Az, double *El, double *D, const arma::vec &x, const arma::
  */
 int togeod(double *dphi, double *dlambda, double *h, double a, double finv, double X, double Y, double Z);
 
-arma::mat Gravity_ECEF(const arma::vec &r_eb_e);  //!< Calculates acceleration due to gravity resolved about ECEF-frame
+arma::vec Gravity_ECEF(const arma::vec &r_eb_e);  //!< Calculates acceleration due to gravity resolved about ECEF-frame
 
 /*!
  * \brief Conversion of Cartesian coordinates (X,Y,Z) to geographical

src/algorithms/libs/glonass_l1_signal_processing.cc

@@ -36,7 +36,7 @@
 
 auto auxCeil = [](float x) { return static_cast<int32_t>(static_cast<int64_t>((x) + 1)); };
 
-void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /* int32_t  _prn,*/ uint32_t _chip_shift)
+void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, uint32_t _chip_shift)
 {
     const uint32_t _code_length = 511;
     std::bitset<_code_length> G1{};
@@ -101,7 +101,7 @@ void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /* int
 /*
  *  Generates complex GLONASS L1 C/A code for the desired SV ID and sampled to specific sampling frequency
  */
-void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift)
+void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift)
 {
     // This function is based on the GNU software GPS for MATLAB in the Kay Borre book
     std::array<std::complex<float>, 511> _code{};

src/algorithms/libs/glonass_l1_signal_processing.h

@@ -43,13 +43,13 @@ namespace gsl = std;
 #include <gsl/gsl>
 #endif
 
-//!Generates complex GLONASS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
+//! Generates complex GLONASS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
-void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /*int32_t  _prn,*/ uint32_t _chip_shift);
+void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, uint32_t _chip_shift);
 
 //! Generates N complex GLONASS L1 C/A codes for the desired SV ID and code shift
-void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes);
+void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes);
 
 //! Generates complex GLONASS L1 C/A code for the desired SV ID and code shift
-void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift);
+void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift);
 
 #endif /* GNSS_SDR_GLONASS_SDR_SIGNAL_PROCESSING_H_ */

src/algorithms/libs/glonass_l2_signal_processing.cc

@@ -36,7 +36,7 @@
 
 auto auxCeil = [](float x) { return static_cast<int32_t>(static_cast<int64_t>((x) + 1)); };
 
-void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /* int32_t _prn,*/ uint32_t _chip_shift)
+void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, uint32_t _chip_shift)
 {
     const uint32_t _code_length = 511;
     std::bitset<_code_length> G1{};
@@ -101,7 +101,7 @@ void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /* int
 /*
  *  Generates complex GLONASS L2 C/A code for the desired SV ID and sampled to specific sampling frequency
  */
-void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift)
+void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift)
 {
     // This function is based on the GNU software GPS for MATLAB in the Kay Borre book
     std::array<std::complex<float>, 511> _code{};

src/algorithms/libs/glonass_l2_signal_processing.h

@@ -43,13 +43,13 @@ namespace gsl = std;
 #include <gsl/gsl>
 #endif
 
-//!Generates complex GLONASS L2 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
+//! Generates complex GLONASS L2 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
-void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /*int32_t  _prn,*/ uint32_t _chip_shift);
+void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, uint32_t _chip_shift);
 
 //! Generates N complex GLONASS L2 C/A codes for the desired SV ID and code shift
-void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes);
+void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes);
 
 //! Generates complex GLONASS L2 C/A code for the desired SV ID and code shift
-void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift);
+void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift);
 
 #endif /* GNSS_SDR_GLONASS_L2_SIGNAL_PROCESSING_H_ */

src/algorithms/libs/gps_l2c_signal.cc

@@ -106,7 +106,7 @@ void gps_l2c_m_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, ui
 
     //--- Find time constants --------------------------------------------------
     _ts = 1.0 / static_cast<float>(_fs);                    // Sampling period in sec
-    _tc = 1.0 / static_cast<float>(GPS_L2_M_CODE_RATE_HZ);  // C/A chip period in sec
+    _tc = 1.0 / static_cast<float>(GPS_L2_M_CODE_RATE_HZ);  // L2C chip period in sec
 
     for (int32_t i = 0; i < _samplesPerCode; i++)
         {
@@ -123,7 +123,7 @@ void gps_l2c_m_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, ui
                 }
             else
                 {
-                    _dest[i] = std::complex<float>(1.0 - 2.0 * _code[_codeValueIndex], 0);  //repeat the chip -> upsample
+                    _dest[i] = std::complex<float>(1.0 - 2.0 * _code[_codeValueIndex], 0);  // repeat the chip -> upsample
                 }
         }
 }

src/algorithms/libs/gps_l5_signal.cc

@@ -33,6 +33,7 @@
 #include "gps_l5_signal.h"
 #include "GPS_L5.h"
 #include <array>
+#include <cmath>
 #include <deque>
 
 std::deque<bool> l5i_xa_shift(std::deque<bool> xa)  // GPS-IS-705E Figure 3-4 pp. 15
@@ -298,7 +299,6 @@ void gps_l5q_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, uint
     _ts = 1.0 / static_cast<float>(_fs);                   // Sampling period in sec
     _tc = 1.0 / static_cast<float>(GPS_L5Q_CODE_RATE_HZ);  // L5Q chip period in sec
 
-    //float aux;
     for (int32_t i = 0; i < _samplesPerCode; i++)
         {
             //=== Digitizing =======================================================

src/algorithms/libs/rtklib/rtklib_stream.cc

@@ -975,9 +975,8 @@ void discontcp(tcp_t *tcp, int tcon)
 /* open tcp server -----------------------------------------------------------*/
 tcpsvr_t *opentcpsvr(const char *path, char *msg)
 {
-    tcpsvr_t *tcpsvr, tcpsvr0;  // = {{0}};
+    tcpsvr_t *tcpsvr, tcpsvr0{};
     char port[256] = "";
-    tcpsvr0 = {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}, {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}}};
     tracet(3, "opentcpsvr: path=%s\n", path);
 
     if (!(tcpsvr = static_cast<tcpsvr_t *>(malloc(sizeof(tcpsvr_t)))))
@@ -1265,9 +1264,8 @@ int consock(tcpcli_t *tcpcli, char *msg)
 /* open tcp client -----------------------------------------------------------*/
 tcpcli_t *opentcpcli(const char *path, char *msg)
 {
-    tcpcli_t *tcpcli, tcpcli0;  // = {{0}};
+    tcpcli_t *tcpcli, tcpcli0{};
     char port[256] = "";
-    tcpcli0 = {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}, 0, 0};
 
     tracet(3, "opentcpcli: path=%s\n", path);
 

src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l1_ca_telemetry_decoder_gs.h

@@ -92,7 +92,6 @@ private:
     // Preamble decoding
     const std::array<uint16_t, GLONASS_GNAV_PREAMBLE_LENGTH_BITS> d_preambles_bits{GLONASS_GNAV_PREAMBLE};
     std::array<int32_t, GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS> d_preambles_symbols{};
-    uint32_t d_samples_per_symbol = (GLONASS_L1_CA_CODE_RATE_HZ / GLONASS_L1_CA_CODE_LENGTH_CHIPS) / GLONASS_L1_CA_SYMBOL_RATE_BPS;
     const int32_t d_symbols_per_preamble = GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS;
 
     // Storage for incoming data

src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l2_ca_telemetry_decoder_gs.h

@@ -90,7 +90,6 @@ private:
     // Preamble decoding
     const std::array<uint16_t, GLONASS_GNAV_PREAMBLE_LENGTH_BITS> d_preambles_bits{GLONASS_GNAV_PREAMBLE};
     std::array<int32_t, GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS> d_preambles_symbols{};
-    uint32_t d_samples_per_symbol = (GLONASS_L2_CA_CODE_RATE_HZ / GLONASS_L2_CA_CODE_LENGTH_CHIPS) / GLONASS_L2_CA_SYMBOL_RATE_BPS;
     const int32_t d_symbols_per_preamble = GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS;
 
     // Storage for incoming data

src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc

@@ -194,6 +194,7 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
 
 void GalileoE1DllPllVemlTracking::stop_tracking()
 {
+    tracking_->stop_tracking();
 }
 
 

src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc

@@ -190,6 +190,7 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking(
 
 void GalileoE5aDllPllTracking::stop_tracking()
 {
+    tracking_->stop_tracking();
 }
 
 

src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc

@@ -172,6 +172,7 @@ GpsL2MDllPllTracking::GpsL2MDllPllTracking(
 
 void GpsL2MDllPllTracking::stop_tracking()
 {
+    tracking_->stop_tracking();
 }
 
 

src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking_fpga.cc

@@ -158,6 +158,7 @@ void GpsL2MDllPllTrackingFpga::start_tracking()
 
 void GpsL2MDllPllTrackingFpga::stop_tracking()
 {
+    tracking_fpga_sc->stop_tracking();
 }
 
 

src/algorithms/tracking/adapters/gps_l5_dll_pll_tracking.cc

@@ -192,6 +192,7 @@ GpsL5DllPllTracking::GpsL5DllPllTracking(
 
 void GpsL5DllPllTracking::stop_tracking()
 {
+    tracking_->stop_tracking();
 }
 
 

src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_c_aid_tracking_cc.cc

@@ -676,7 +676,6 @@ int glonass_l1_ca_dll_pll_c_aid_tracking_cc::general_work(int noutput_items __at
                                     d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GLONASS_TWO_PI);
 
                                     // UPDATE ACCUMULATED CARRIER PHASE
-                                    CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
                                     d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GLONASS_TWO_PI;
 
                                     // disable tracking loop and inform telemetry decoder

src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_c_aid_tracking_sc.cc

@@ -667,7 +667,6 @@ int glonass_l1_ca_dll_pll_c_aid_tracking_sc::general_work(int noutput_items __at
                                     d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GLONASS_TWO_PI);
 
                                     // UPDATE ACCUMULATED CARRIER PHASE
-                                    CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
                                     d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GLONASS_TWO_PI;
 
                                     // disable tracking loop and inform telemetry decoder

src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_c_aid_tracking_cc.cc

@@ -674,7 +674,6 @@ int glonass_l2_ca_dll_pll_c_aid_tracking_cc::general_work(int noutput_items __at
                                     d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GLONASS_TWO_PI);
 
                                     // UPDATE ACCUMULATED CARRIER PHASE
-                                    CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
                                     d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GLONASS_TWO_PI;
 
                                     // disable tracking loop and inform telemetry decoder

src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_c_aid_tracking_sc.cc

@@ -666,7 +666,6 @@ int glonass_l2_ca_dll_pll_c_aid_tracking_sc::general_work(int noutput_items __at
                                     d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GLONASS_TWO_PI);
 
                                     // UPDATE ACCUMULATED CARRIER PHASE
-                                    CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
                                     d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GLONASS_TWO_PI;
 
                                     // disable tracking loop and inform telemetry decoder

src/algorithms/tracking/libs/exponential_smoother.cc

@@ -76,7 +76,7 @@ void Exponential_Smoother::set_samples_for_initialization(int num_samples)
         {
             ns = 1;
         }
-    samples_for_initialization_ = num_samples;
+    samples_for_initialization_ = ns;
     init_buffer_.reserve(samples_for_initialization_);
 }
 

src/core/receiver/control_thread.cc

@@ -194,6 +194,8 @@ void ControlThread::init()
                     agnss_ref_time_.valid = false;
                 }
         }
+
+    receiver_on_standby_ = false;
 }
 
 
@@ -234,11 +236,14 @@ void ControlThread::event_dispatcher(bool &valid_event, pmt::pmt_t &msg)
             processed_control_messages_++;
             if (pmt::any_ref(msg).type() == typeid(channel_event_sptr))
                 {
-                    channel_event_sptr new_event;
+                    if (receiver_on_standby_ == false)
-                    new_event = boost::any_cast<channel_event_sptr>(pmt::any_ref(msg));
+                        {
-                    DLOG(INFO) << "New channel event rx from ch id: " << new_event->channel_id
+                            channel_event_sptr new_event;
-                               << " what: " << new_event->event_type;
+                            new_event = boost::any_cast<channel_event_sptr>(pmt::any_ref(msg));
-                    flowgraph_->apply_action(new_event->channel_id, new_event->event_type);
+                            DLOG(INFO) << "New channel event rx from ch id: " << new_event->channel_id
+                                       << " what: " << new_event->event_type;
+                            flowgraph_->apply_action(new_event->channel_id, new_event->event_type);
+                        }
                 }
             else if (pmt::any_ref(msg).type() == typeid(command_event_sptr))
                 {
@@ -267,8 +272,11 @@ void ControlThread::event_dispatcher(bool &valid_event, pmt::pmt_t &msg)
         }
     else
         {
-            //perform non-priority tasks
+            if (receiver_on_standby_ == false)
-            flowgraph_->acquisition_manager(0);  //start acquisition of untracked satellites
+                {
+                    //perform non-priority tasks
+                    flowgraph_->acquisition_manager(0);  //start acquisition of untracked satellites
+                }
         }
 }
 
@@ -852,6 +860,10 @@ void ControlThread::apply_action(unsigned int what)
             stop_ = true;
             restart_ = true;
             break;
+        case 10:  // request standby mode
+            LOG(INFO) << "TC request standby mode";
+            receiver_on_standby_ = true;
+            break;
         case 11:
             LOG(INFO) << "Receiver action COLDSTART";
             // delete all ephemeris and almanac information from maps (also the PVT map queue)
@@ -859,13 +871,16 @@ void ControlThread::apply_action(unsigned int what)
             pvt_ptr->clear_ephemeris();
             // todo: reorder the satellite queues to the receiver default startup order.
             // This is required to allow repeatability. Otherwise the satellite search order will depend on the last tracked satellites
+            // start again the satellite acquisitions
+            receiver_on_standby_ = false;
             break;
         case 12:
             LOG(INFO) << "Receiver action HOTSTART";
             visible_satellites = get_visible_sats(cmd_interface_.get_utc_time(), cmd_interface_.get_LLH());
             // reorder the satellite queue to acquire first those visible satellites
             flowgraph_->priorize_satellites(visible_satellites);
-            // start again the satellite acquisitions (done in chained apply_action to flowgraph)
+            // start again the satellite acquisitions
+            receiver_on_standby_ = false;
             break;
         case 13:
             LOG(INFO) << "Receiver action WARMSTART";
@@ -879,7 +894,8 @@ void ControlThread::apply_action(unsigned int what)
             get_visible_sats(cmd_interface_.get_utc_time(), cmd_interface_.get_LLH());
             // reorder the satellite queue to acquire first those visible satellites
             flowgraph_->priorize_satellites(visible_satellites);
-            // start again the satellite acquisitions (done in chained apply_action to flowgraph)
+            // start again the satellite acquisitions
+            receiver_on_standby_ = false;
             break;
         default:
             LOG(INFO) << "Unrecognized action.";

src/core/receiver/control_thread.h

@@ -129,6 +129,7 @@ private:
     /*
      * New receiver event dispatcher
      */
+    bool receiver_on_standby_;
     void event_dispatcher(bool &valid_event, pmt::pmt_t &msg);
 
     std::thread cmd_interface_thread_;

src/core/receiver/gnss_flowgraph.cc

@@ -1288,8 +1288,8 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
 
     std::lock_guard<std::mutex> lock(signal_list_mutex);
     DLOG(INFO) << "Received " << what << " from " << who;
-    Gnss_Signal gs = channels_[who]->get_signal();
     unsigned int sat = 0;
+    Gnss_Signal gs;
     if (who < 200)
         {
             try
@@ -1304,6 +1304,7 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
     switch (what)
         {
         case 0:
+            gs = channels_[who]->get_signal();
             DLOG(INFO) << "Channel " << who << " ACQ FAILED satellite " << gs.get_satellite() << ", Signal " << gs.get_signal_str();
             channels_state_[who] = 0;
             if (acq_channels_count_ > 0)
@@ -1319,6 +1320,7 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
                 }
             break;
         case 1:
+            gs = channels_[who]->get_signal();
             DLOG(INFO) << "Channel " << who << " ACQ SUCCESS satellite " << gs.get_satellite();
             // If the satellite is in the list of available ones, remove it.
             remove_signal(gs);
@@ -1333,6 +1335,7 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
             break;
 
         case 2:
+            gs = channels_[who]->get_signal();
             DLOG(INFO) << "Channel " << who << " TRK FAILED satellite " << gs.get_satellite();
             if (acq_channels_count_ < max_acq_channels_)
                 {
@@ -1359,7 +1362,6 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
                 }
             break;
         case 10:  // request standby mode
-            LOG(INFO) << "TC request standby mode";
             for (size_t n = 0; n < channels_.size(); n++)
                 {
                     if (channels_state_[n] == 1 or channels_state_[n] == 2)  // channel in acquisition or in tracking
@@ -1372,22 +1374,7 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
                             channels_state_[n] = 0;
                         }
                 }
-            acq_channels_count_ = 0;  // all channels are in standby now
+            acq_channels_count_ = 0;  // all channels are in standby now and no new acquisition should be started
-            break;
-        case 11:  // request coldstart mode
-            LOG(INFO) << "TC request flowgraph coldstart";
-            // call the acquisition manager to assign new satellite and start next acquisition (if required)
-            acquisition_manager(who);
-            break;
-        case 12:  // request hotstart mode
-            LOG(INFO) << "TC request flowgraph hotstart";
-            // call the acquisition manager to assign new satellite and start next acquisition (if required)
-            acquisition_manager(who);
-            break;
-        case 13:  // request warmstart mode
-            LOG(INFO) << "TC request flowgraph warmstart";
-            // call the acquisition manager to assign new satellite and start next acquisition (if required)
-            acquisition_manager(who);
             break;
         default:
             break;

src/core/system_parameters/gnss_satellite.cc

@@ -124,9 +124,9 @@ Gnss_Satellite& Gnss_Satellite::operator=(Gnss_Satellite&& other) noexcept
 {
     if (this != &other)
         {
-            this->system = std::move(other.get_system());
+            this->system = other.get_system();
             this->PRN = other.get_PRN();
-            this->block = std::move(other.get_block());
+            this->block = other.get_block();
             this->rf_link = other.get_rf_link();
         }
     return *this;