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

CMakeLists.txt

@@ -360,7 +360,7 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
       endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${GNSSSDR_GCC_MIN_VERSION})
 endif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     execute_process(COMMAND
         ${CMAKE_CXX_COMPILER} -v
         RESULT_VARIABLE _res ERROR_VARIABLE _err
@@ -387,7 +387,7 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     else(${_res} STREQUAL "0")
         message(WARNING "\nCannot determine the version of the compiler selected to build GNSS-SDR (${APPLE_STR}Clang : ${CMAKE_CXX_COMPILER}). This build may or not work. We highly recommend using Apple Clang version ${APPLECLANG_MIN_VERSION} or more recent, or Clang version ${CLANG_MIN_VERSION} or more recent.")
     endif(${_res} STREQUAL "0")
-endif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 
 
 
@@ -783,7 +783,7 @@ if (NOT GLOG_FOUND OR ${LOCAL_GFLAGS})
          set(GFLAGS_LIBRARY_DIR_TO_LINK ${GFlags_LIBRARY_DIRS})
      endif(${LOCAL_GFLAGS})
 
-     if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+     if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
          file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags
 "#!/bin/sh
 export CPPFLAGS=-I${GFlags_INCLUDE_DIRS}
@@ -799,7 +799,7 @@ autoreconf -vfi
 cd ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
 ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configure")
 
-      else("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+      else(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
              file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags
 "#!/bin/sh
 export CPPFLAGS=-I${GFlags_INCLUDE_DIRS}
@@ -812,7 +812,7 @@ autoreconf -vfi
 cd ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
 ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/glog/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/configure")
 
-     endif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+     endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 
      file(COPY ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}/tmp/configure_with_gflags
           DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/glog-${GNSSSDR_GLOG_LOCAL_VERSION}
@@ -1458,37 +1458,49 @@ endif(ENABLE_GPROF)
 ########################################################################
 # Set compiler flags
 ########################################################################
-# Enable C++14 support in GCC / Fallback to C++11 when using GCC < 6.1.1
+# Support of C++17 is still not possible due to pm_remez.h (solved in GNU Radio 3.8)
+# Enable C++14 support in GCC >= 6.1.1
+# Fallback to C++11 when using GCC < 6.1.1
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
     if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1")
         set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11")
     else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1")
+        # if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0")
             set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14")
+        # else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0")
+            # set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17")
+        # endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0")
     endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1")
     set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wall -Wextra")  #Add warning flags: For "-Wall" see http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
 endif(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
 
-# Enable C++14 support in Clang from 3.5 / Fallback to C++11 if older version and use lib++ if working in macOS
+# Support of C++17 is still not possible due to pm_remez.h (solved in GNU Radio 3.8)
+# Enable C++14 support in Clang >= 3.5.0 or AppleClang >= 600
+# Fallback to C++11 if older version
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     if(OS_IS_MACOSX)
         # See https://trac.macports.org/wiki/XcodeVersionInfo for Apple Clang version equivalences
         if(CLANG_VERSION VERSION_LESS "600")
             set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11")
         else(CLANG_VERSION VERSION_LESS "600")
+            # if(CLANG_VERSION VERSION_LESS "900")
                 set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14")
+            # else(CLANG_VERSION VERSION_LESS "900")
+                # set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17")
+            # endif(CLANG_VERSION VERSION_LESS "900")
         endif(CLANG_VERSION VERSION_LESS "600")
-        set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wno-deprecated-declarations")
     else(OS_IS_MACOSX)
         if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0")
             set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11")
         else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0")
+            # if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0")
                 set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14")
+            # else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0")
+                # set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17")
+            # endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0")
         endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0")
     endif(OS_IS_MACOSX)
 
-    if(CMAKE_BUILD_TYPE MATCHES "Release")
-        set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wno-unused-private-field")
-    endif(CMAKE_BUILD_TYPE MATCHES "Release")
     if(OS_IS_MACOSX)
         set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -stdlib=libc++")
     endif(OS_IS_MACOSX)

src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc

@@ -45,6 +45,7 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    pcpsconf_t acq_parameters;
     configuration_ = configuration;
     std::string default_item_type = "gr_complex";
     std::string default_dump_filename = "./data/acquisition.dat";
@@ -55,32 +56,33 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition(
 
     long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 4000000);
     fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    acq_parameters.fs_in = fs_in_;
     if_ = configuration_->property(role + ".if", 0);
+    acq_parameters.freq = if_;
     dump_ = configuration_->property(role + ".dump", false);
+    acq_parameters.dump = dump_;
     blocking_ = configuration_->property(role + ".blocking", true);
+    acq_parameters.blocking = blocking_;
     doppler_max_ = configuration_->property(role + ".doppler_max", 5000);
     if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max;
-    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 4);
+    acq_parameters.doppler_max = doppler_max_;
-
+    sampled_ms_ = 4;
-    if (sampled_ms_ % 4 != 0)
+    acq_parameters.sampled_ms = sampled_ms_;
-        {
-            sampled_ms_ = static_cast<int>(sampled_ms_ / 4) * 4;
-            LOG(WARNING) << "coherent_integration_time should be multiple of "
-                         << "Galileo code length (4 ms). coherent_integration_time = "
-                         << sampled_ms_ << " ms will be used.";
-        }
-
     bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
+    acq_parameters.bit_transition_flag = bit_transition_flag_;
     use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true);  //will be false in future versions
+    acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_;
     acquire_pilot_ = configuration_->property(role + ".acquire_pilot", false);  //will be true in future versions
 
     max_dwells_ = configuration_->property(role + ".max_dwells", 1);
-
+    acq_parameters.max_dwells = max_dwells_;
     dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename);
-
+    acq_parameters.dump_filename = dump_filename_;
     //--- Find number of samples per spreading code (4 ms)  -----------------
-    code_length_ = round(fs_in_ / (Galileo_E1_CODE_CHIP_RATE_HZ / Galileo_E1_B_CODE_LENGTH_CHIPS));
+    code_length_ = static_cast<unsigned int>(std::round(static_cast<double>(fs_in_) / (Galileo_E1_CODE_CHIP_RATE_HZ / Galileo_E1_B_CODE_LENGTH_CHIPS)));
-    int samples_per_ms = round(code_length_ / 4.0);
+    acq_parameters.samples_per_code = code_length_;
+    int samples_per_ms = static_cast<int>(std::round(static_cast<double>(fs_in_) * 0.001));
+    acq_parameters.samples_per_ms = samples_per_ms;
     vector_length_ = sampled_ms_ * samples_per_ms;
 
     if (bit_transition_flag_)
@@ -98,10 +100,11 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition(
         {
             item_size_ = sizeof(gr_complex);
         }
-    acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_,
+    acq_parameters.it_size = item_size_;
-        doppler_max_, if_, fs_in_, samples_per_ms, code_length_,
+    acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4);
-        bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_,
+    acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0);
-        dump_filename_, item_size_);
+    acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false);
+    acquisition_ = pcps_make_acquisition(acq_parameters);
     DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")";
 
     stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);

src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc

@@ -44,6 +44,7 @@ using google::LogMessage;
 GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* configuration,
     std::string role, unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    pcpsconf_t acq_parameters;
     configuration_ = configuration;
     std::string default_item_type = "gr_complex";
     std::string default_dump_filename = "../data/acquisition.dat";
@@ -54,6 +55,8 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con
 
     long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 32000000);
     fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    acq_parameters.fs_in = fs_in_;
+    acq_parameters.freq = 0;
     acq_pilot_ = configuration_->property(role + ".acquire_pilot", false);
     acq_iq_ = configuration_->property(role + ".acquire_iq", false);
     if (acq_iq_)
@@ -61,17 +64,23 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con
             acq_pilot_ = false;
         }
     dump_ = configuration_->property(role + ".dump", false);
+    acq_parameters.dump = dump_;
     doppler_max_ = configuration_->property(role + ".doppler_max", 5000);
     if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max;
-    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1);
+    acq_parameters.doppler_max = doppler_max_;
+    sampled_ms_ = 1;
     max_dwells_ = configuration_->property(role + ".max_dwells", 1);
+    acq_parameters.max_dwells = max_dwells_;
     dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename);
+    acq_parameters.dump_filename = dump_filename_;
     bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
+    acq_parameters.bit_transition_flag = bit_transition_flag_;
     use_CFAR_ = configuration_->property(role + ".use_CFAR_algorithm", false);
+    acq_parameters.use_CFAR_algorithm_flag = use_CFAR_;
     blocking_ = configuration_->property(role + ".blocking", true);
-
+    acq_parameters.blocking = blocking_;
     //--- Find number of samples per spreading code (1ms)-------------------------
-    code_length_ = round(static_cast<double>(fs_in_) / Galileo_E5a_CODE_CHIP_RATE_HZ * static_cast<double>(Galileo_E5a_CODE_LENGTH_CHIPS));
+    code_length_ = static_cast<unsigned int>(std::round(static_cast<double>(fs_in_) / Galileo_E5a_CODE_CHIP_RATE_HZ * static_cast<double>(Galileo_E5a_CODE_LENGTH_CHIPS)));
     vector_length_ = code_length_ * sampled_ms_;
 
     code_ = new gr_complex[vector_length_];
@@ -89,10 +98,14 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con
             item_size_ = sizeof(gr_complex);
             LOG(WARNING) << item_type_ << " unknown acquisition item type";
         }
-
+    acq_parameters.it_size = item_size_;
-    acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_, doppler_max_, 0, fs_in_,
+    acq_parameters.samples_per_code = code_length_;
-        code_length_, code_length_, bit_transition_flag_, use_CFAR_, dump_, blocking_,
+    acq_parameters.samples_per_ms = code_length_;
-        dump_filename_, item_size_);
+    acq_parameters.sampled_ms = sampled_ms_;
+    acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4);
+    acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0);
+    acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false);
+    acquisition_ = pcps_make_acquisition(acq_parameters);
 
     stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);
     channel_ = 0;

src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc

@@ -46,6 +46,7 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    pcpsconf_t acq_parameters;
     configuration_ = configuration;
     std::string default_item_type = "gr_complex";
     std::string default_dump_filename = "./data/acquisition.dat";
@@ -56,22 +57,28 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition(
 
     long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000);
     fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    acq_parameters.fs_in = fs_in_;
     if_ = configuration_->property(role + ".if", 0);
+    acq_parameters.freq = if_;
     dump_ = configuration_->property(role + ".dump", false);
+    acq_parameters.dump = dump_;
     blocking_ = configuration_->property(role + ".blocking", true);
+    acq_parameters.blocking = blocking_;
     doppler_max_ = configuration_->property(role + ".doppler_max", 5000);
     if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max;
+    acq_parameters.doppler_max = doppler_max_;
     sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1);
-
+    acq_parameters.sampled_ms = sampled_ms_;
     bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
+    acq_parameters.bit_transition_flag = bit_transition_flag_;
     use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true);  //will be false in future versions
-
+    acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_;
     max_dwells_ = configuration_->property(role + ".max_dwells", 1);
-
+    acq_parameters.max_dwells = max_dwells_;
     dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename);
-
+    acq_parameters.dump_filename = dump_filename_;
     //--- Find number of samples per spreading code -------------------------
-    code_length_ = round(fs_in_ / (GLONASS_L1_CA_CODE_RATE_HZ / GLONASS_L1_CA_CODE_LENGTH_CHIPS));
+    code_length_ = static_cast<unsigned int>(std::round(static_cast<double>(fs_in_) / (GLONASS_L1_CA_CODE_RATE_HZ / GLONASS_L1_CA_CODE_LENGTH_CHIPS)));
 
     vector_length_ = code_length_ * sampled_ms_;
 
@@ -90,9 +97,14 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition(
         {
             item_size_ = sizeof(gr_complex);
         }
-    acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_,
+    acq_parameters.it_size = item_size_;
-        doppler_max_, if_, fs_in_, code_length_, code_length_,
+    acq_parameters.sampled_ms = sampled_ms_;
-        bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, dump_filename_, item_size_);
+    acq_parameters.samples_per_ms = code_length_;
+    acq_parameters.samples_per_code = code_length_;
+    acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4);
+    acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0);
+    acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false);
+    acquisition_ = pcps_make_acquisition(acq_parameters);
     DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")";
 
     stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);

src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc

@@ -45,6 +45,7 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    pcpsconf_t acq_parameters;
     configuration_ = configuration;
     std::string default_item_type = "gr_complex";
     std::string default_dump_filename = "./data/acquisition.dat";
@@ -55,22 +56,28 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition(
 
     long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000);
     fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    acq_parameters.fs_in = fs_in_;
     if_ = configuration_->property(role + ".if", 0);
+    acq_parameters.freq = if_;
     dump_ = configuration_->property(role + ".dump", false);
+    acq_parameters.dump = dump_;
     blocking_ = configuration_->property(role + ".blocking", true);
+    acq_parameters.blocking = blocking_;
     doppler_max_ = configuration_->property(role + ".doppler_max", 5000);
     if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max;
+    acq_parameters.doppler_max = doppler_max_;
     sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1);
-
     bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
+    acq_parameters.bit_transition_flag = bit_transition_flag_;
     use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true);  //will be false in future versions
-
+    acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_;
     max_dwells_ = configuration_->property(role + ".max_dwells", 1);
+    acq_parameters.max_dwells = max_dwells_;
 
     dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename);
-
+    acq_parameters.dump_filename = dump_filename_;
     //--- Find number of samples per spreading code -------------------------
-    code_length_ = round(fs_in_ / (GLONASS_L2_CA_CODE_RATE_HZ / GLONASS_L2_CA_CODE_LENGTH_CHIPS));
+    code_length_ = static_cast<unsigned int>(std::round(static_cast<double>(fs_in_) / (GLONASS_L2_CA_CODE_RATE_HZ / GLONASS_L2_CA_CODE_LENGTH_CHIPS)));
 
     vector_length_ = code_length_ * sampled_ms_;
 
@@ -89,9 +96,14 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition(
         {
             item_size_ = sizeof(gr_complex);
         }
-    acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_,
+    acq_parameters.it_size = item_size_;
-        doppler_max_, if_, fs_in_, code_length_, code_length_,
+    acq_parameters.sampled_ms = sampled_ms_;
-        bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, dump_filename_, item_size_);
+    acq_parameters.samples_per_ms = code_length_;
+    acq_parameters.samples_per_code = code_length_;
+    acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4);
+    acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0);
+    acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false);
+    acquisition_ = pcps_make_acquisition(acq_parameters);
     DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")";
 
     stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc

@@ -48,6 +48,7 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    pcpsconf_t acq_parameters;
     configuration_ = configuration;
     std::string default_item_type = "gr_complex";
     std::string default_dump_filename = "./data/acquisition.dat";
@@ -57,22 +58,31 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition(
     item_type_ = configuration_->property(role + ".item_type", default_item_type);
     long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000);
     fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    acq_parameters.fs_in = fs_in_;
     if_ = configuration_->property(role + ".if", 0);
+    acq_parameters.freq = if_;
     dump_ = configuration_->property(role + ".dump", false);
+    acq_parameters.dump = dump_;
     blocking_ = configuration_->property(role + ".blocking", true);
+    acq_parameters.blocking = blocking_;
     doppler_max_ = configuration_->property(role + ".doppler_max", 5000);
     if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max;
+    acq_parameters.doppler_max = doppler_max_;
     sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1);
-
+    acq_parameters.sampled_ms = sampled_ms_;
     bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
+    acq_parameters.bit_transition_flag = bit_transition_flag_;
     use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true);  //will be false in future versions
-
+    acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_;
     max_dwells_ = configuration_->property(role + ".max_dwells", 1);
-
+    acq_parameters.max_dwells = max_dwells_;
     dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename);
-
+    acq_parameters.dump_filename = dump_filename_;
+    acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4);
+    acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0);
+    acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false);
     //--- Find number of samples per spreading code -------------------------
-    code_length_ = round(fs_in_ / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS));
+    code_length_ = static_cast<unsigned int>(std::round(static_cast<double>(fs_in_) / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS)));
 
     vector_length_ = code_length_ * sampled_ms_;
 
@@ -91,9 +101,10 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition(
         {
             item_size_ = sizeof(gr_complex);
         }
-    acquisition_ = pcps_make_acquisition(sampled_ms_, max_dwells_,
+    acq_parameters.samples_per_ms = code_length_;
-        doppler_max_, if_, fs_in_, code_length_, code_length_,
+    acq_parameters.samples_per_code = code_length_;
-        bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_, dump_filename_, item_size_);
+    acq_parameters.it_size = item_size_;
+    acquisition_ = pcps_make_acquisition(acq_parameters);
     DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")";
 
     stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);

src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc

@@ -46,6 +46,7 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    pcpsconf_t acq_parameters;
     configuration_ = configuration;
     std::string default_item_type = "gr_complex";
     std::string default_dump_filename = "./data/acquisition.dat";
@@ -57,21 +58,26 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition(
 
     long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000);
     fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    acq_parameters.fs_in = fs_in_;
     if_ = configuration_->property(role + ".if", 0);
+    acq_parameters.freq = if_;
     dump_ = configuration_->property(role + ".dump", false);
+    acq_parameters.dump = dump_;
     blocking_ = configuration_->property(role + ".blocking", true);
+    acq_parameters.blocking = blocking_;
     doppler_max_ = configuration->property(role + ".doppler_max", 5000);
     if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max;
-
+    acq_parameters.doppler_max = doppler_max_;
     bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
+    acq_parameters.bit_transition_flag = bit_transition_flag_;
     use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true);  //will be false in future versions
-
+    acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_;
     max_dwells_ = configuration_->property(role + ".max_dwells", 1);
-
+    acq_parameters.max_dwells = max_dwells_;
     dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename);
-
+    acq_parameters.dump_filename = dump_filename_;
     //--- Find number of samples per spreading code -------------------------
-    code_length_ = round(static_cast<double>(fs_in_) / (GPS_L2_M_CODE_RATE_HZ / static_cast<double>(GPS_L2_M_CODE_LENGTH_CHIPS)));
+    code_length_ = std::round(static_cast<double>(fs_in_) / (GPS_L2_M_CODE_RATE_HZ / static_cast<double>(GPS_L2_M_CODE_LENGTH_CHIPS)));
 
     vector_length_ = code_length_;
 
@@ -90,10 +96,14 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition(
         {
             item_size_ = sizeof(gr_complex);
         }
-    acquisition_ = pcps_make_acquisition(1, max_dwells_,
+    acq_parameters.samples_per_ms = static_cast<int>(std::round(static_cast<double>(fs_in_) * 0.001));
-        doppler_max_, if_, fs_in_, code_length_, code_length_,
+    acq_parameters.samples_per_code = code_length_;
-        bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_,
+    acq_parameters.it_size = item_size_;
-        dump_filename_, item_size_);
+    acq_parameters.sampled_ms = 20;
+    acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4);
+    acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0);
+    acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", true);
+    acquisition_ = pcps_make_acquisition(acq_parameters);
     DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")";
 
     stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);

src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc

@@ -46,6 +46,7 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    pcpsconf_t acq_parameters;
     configuration_ = configuration;
     std::string default_item_type = "gr_complex";
     std::string default_dump_filename = "./data/acquisition.dat";
@@ -56,21 +57,26 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition(
 
     long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000);
     fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    acq_parameters.fs_in = fs_in_;
     if_ = configuration_->property(role + ".if", 0);
+    acq_parameters.freq = if_;
     dump_ = configuration_->property(role + ".dump", false);
+    acq_parameters.dump = dump_;
     blocking_ = configuration_->property(role + ".blocking", true);
+    acq_parameters.blocking = blocking_;
     doppler_max_ = configuration->property(role + ".doppler_max", 5000);
     if (FLAGS_doppler_max != 0) doppler_max_ = FLAGS_doppler_max;
-
+    acq_parameters.doppler_max = doppler_max_;
     bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
+    acq_parameters.bit_transition_flag = bit_transition_flag_;
     use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true);  //will be false in future versions
-
+    acq_parameters.use_CFAR_algorithm_flag = use_CFAR_algorithm_flag_;
     max_dwells_ = configuration_->property(role + ".max_dwells", 1);
-
+    acq_parameters.max_dwells = max_dwells_;
     dump_filename_ = configuration_->property(role + ".dump_filename", default_dump_filename);
-
+    acq_parameters.dump_filename = dump_filename_;
     //--- Find number of samples per spreading code -------------------------
-    code_length_ = round(static_cast<double>(fs_in_) / (GPS_L5i_CODE_RATE_HZ / static_cast<double>(GPS_L5i_CODE_LENGTH_CHIPS)));
+    code_length_ = static_cast<unsigned int>(std::round(static_cast<double>(fs_in_) / (GPS_L5i_CODE_RATE_HZ / static_cast<double>(GPS_L5i_CODE_LENGTH_CHIPS))));
 
     vector_length_ = code_length_;
 
@@ -89,10 +95,14 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition(
         {
             item_size_ = sizeof(gr_complex);
         }
-    acquisition_ = pcps_make_acquisition(1, max_dwells_,
+    acq_parameters.samples_per_code = code_length_;
-        doppler_max_, if_, fs_in_, code_length_, code_length_,
+    acq_parameters.samples_per_ms = code_length_;
-        bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, blocking_,
+    acq_parameters.it_size = item_size_;
-        dump_filename_, item_size_);
+    acq_parameters.sampled_ms = 1;
+    acq_parameters.num_doppler_bins_step2 = configuration_->property(role + ".second_nbins", 4);
+    acq_parameters.doppler_step2 = configuration_->property(role + ".second_doppler_step", 125.0);
+    acq_parameters.make_2_steps = configuration_->property(role + ".make_two_steps", false);
+    acquisition_ = pcps_make_acquisition(acq_parameters);
     DLOG(INFO) << "acquisition(" << acquisition_->unique_id() << ")";
 
     stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc

@@ -45,57 +45,34 @@
 
 using google::LogMessage;
 
-pcps_acquisition_sptr pcps_make_acquisition(
+pcps_acquisition_sptr pcps_make_acquisition(pcpsconf_t conf_)
-    unsigned int sampled_ms, unsigned int max_dwells,
-    unsigned int doppler_max, long freq, long fs_in,
-    int samples_per_ms, int samples_per_code,
-    bool bit_transition_flag, bool use_CFAR_algorithm_flag,
-    bool dump, bool blocking,
-    std::string dump_filename, size_t it_size)
 {
-    return pcps_acquisition_sptr(
+    return pcps_acquisition_sptr(new pcps_acquisition(conf_));
-        new pcps_acquisition(sampled_ms, max_dwells, doppler_max, freq, fs_in, samples_per_ms,
-            samples_per_code, bit_transition_flag, use_CFAR_algorithm_flag, dump, blocking, dump_filename, it_size));
 }
 
 
-pcps_acquisition::pcps_acquisition(
+pcps_acquisition::pcps_acquisition(pcpsconf_t conf_) : gr::block("pcps_acquisition",
-    unsigned int sampled_ms, unsigned int max_dwells,
+                                                           gr::io_signature::make(1, 1, conf_.it_size * conf_.sampled_ms * conf_.samples_per_ms * (conf_.bit_transition_flag ? 2 : 1)),
-    unsigned int doppler_max, long freq, long fs_in,
+                                                           gr::io_signature::make(0, 0, conf_.it_size * conf_.sampled_ms * conf_.samples_per_ms * (conf_.bit_transition_flag ? 2 : 1)))
-    int samples_per_ms, int samples_per_code,
-    bool bit_transition_flag, bool use_CFAR_algorithm_flag,
-    bool dump, bool blocking,
-    std::string dump_filename,
-    size_t it_size) : gr::block("pcps_acquisition",
-                          gr::io_signature::make(1, 1, it_size * sampled_ms * samples_per_ms * (bit_transition_flag ? 2 : 1)),
-                          gr::io_signature::make(0, 0, it_size * sampled_ms * samples_per_ms * (bit_transition_flag ? 2 : 1)))
 {
     this->message_port_register_out(pmt::mp("events"));
 
+    acq_parameters = conf_;
     d_sample_counter = 0;  // SAMPLE COUNTER
     d_active = false;
     d_state = 0;
-    d_freq = freq;
+    d_old_freq = conf_.freq;
-    d_old_freq = freq;
-    d_fs_in = fs_in;
-    d_samples_per_ms = samples_per_ms;
-    d_samples_per_code = samples_per_code;
-    d_sampled_ms = sampled_ms;
-    d_max_dwells = max_dwells;
     d_well_count = 0;
-    d_doppler_max = doppler_max;
+    d_fft_size = acq_parameters.sampled_ms * acq_parameters.samples_per_ms;
-    d_fft_size = d_sampled_ms * d_samples_per_ms;
     d_mag = 0;
     d_input_power = 0.0;
     d_num_doppler_bins = 0;
-    d_bit_transition_flag = bit_transition_flag;
-    d_use_CFAR_algorithm_flag = use_CFAR_algorithm_flag;
     d_threshold = 0.0;
     d_doppler_step = 0;
-    d_code_phase = 0;
+    d_doppler_center_step_two = 0.0;
     d_test_statistics = 0.0;
     d_channel = 0;
-    if (it_size == sizeof(gr_complex))
+    if (conf_.it_size == sizeof(gr_complex))
         {
             d_cshort = false;
         }
@@ -114,10 +91,10 @@ pcps_acquisition::pcps_acquisition(
     //
     // We can avoid this by doing linear correlation, effectively doubling the
     // size of the input buffer and padding the code with zeros.
-    if (d_bit_transition_flag)
+    if (acq_parameters.bit_transition_flag)
         {
             d_fft_size *= 2;
-            d_max_dwells = 1;  //Activation of d_bit_transition_flag invalidates the value of d_max_dwells
+            acq_parameters.max_dwells = 1;  //Activation of acq_parameters.bit_transition_flag invalidates the value of acq_parameters.max_dwells
         }
 
     d_fft_codes = static_cast<gr_complex*>(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
@@ -129,12 +106,9 @@ pcps_acquisition::pcps_acquisition(
     // Inverse FFT
     d_ifft = new gr::fft::fft_complex(d_fft_size, false);
 
-    // For dumping samples into a file
-    d_dump = dump;
-    d_dump_filename = dump_filename;
     d_gnss_synchro = 0;
-    d_grid_doppler_wipeoffs = 0;
+    d_grid_doppler_wipeoffs = nullptr;
-    d_blocking = blocking;
+    d_grid_doppler_wipeoffs_step_two = nullptr;
     d_worker_active = false;
     d_data_buffer = static_cast<gr_complex*>(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
     if (d_cshort)
@@ -146,6 +120,7 @@ pcps_acquisition::pcps_acquisition(
             d_data_buffer_sc = nullptr;
         }
     grid_ = arma::fmat();
+    d_step_two = false;
 }
 
 
@@ -159,6 +134,14 @@ pcps_acquisition::~pcps_acquisition()
                 }
             delete[] d_grid_doppler_wipeoffs;
         }
+    if (acq_parameters.make_2_steps)
+        {
+            for (unsigned int i = 0; i < acq_parameters.num_doppler_bins_step2; i++)
+                {
+                    volk_gnsssdr_free(d_grid_doppler_wipeoffs_step_two[i]);
+                }
+            delete[] d_grid_doppler_wipeoffs_step_two;
+        }
     volk_gnsssdr_free(d_fft_codes);
     volk_gnsssdr_free(d_magnitude);
     delete d_ifft;
@@ -174,7 +157,7 @@ pcps_acquisition::~pcps_acquisition()
 void pcps_acquisition::set_local_code(std::complex<float>* code)
 {
     // reset the intermediate frequency
-    d_freq = d_old_freq;
+    acq_parameters.freq = d_old_freq;
     // This will check if it's fdma, if yes will update the intermediate frequency and the doppler grid
     if (is_fdma())
         {
@@ -185,7 +168,7 @@ void pcps_acquisition::set_local_code(std::complex<float>* code)
     // [ 0 0 0 ... 0 c_0 c_1 ... c_L]
     // where c_i is the local code and there are L zeros and L chips
     gr::thread::scoped_lock lock(d_setlock);  // require mutex with work function called by the scheduler
-    if (d_bit_transition_flag)
+    if (acq_parameters.bit_transition_flag)
         {
             int offset = d_fft_size / 2;
             std::fill_n(d_fft_if->get_inbuf(), offset, gr_complex(0.0, 0.0));
@@ -206,14 +189,14 @@ bool pcps_acquisition::is_fdma()
     // Dealing with FDMA system
     if (strcmp(d_gnss_synchro->Signal, "1G") == 0)
         {
-            d_freq += DFRQ1_GLO * GLONASS_PRN.at(d_gnss_synchro->PRN);
+            acq_parameters.freq += DFRQ1_GLO * GLONASS_PRN.at(d_gnss_synchro->PRN);
-            LOG(INFO) << "Trying to acquire SV PRN " << d_gnss_synchro->PRN << " with freq " << d_freq << " in Glonass Channel " << GLONASS_PRN.at(d_gnss_synchro->PRN) << std::endl;
+            LOG(INFO) << "Trying to acquire SV PRN " << d_gnss_synchro->PRN << " with freq " << acq_parameters.freq << " in Glonass Channel " << GLONASS_PRN.at(d_gnss_synchro->PRN) << std::endl;
             return true;
         }
     else if (strcmp(d_gnss_synchro->Signal, "2G") == 0)
         {
-            d_freq += DFRQ2_GLO * GLONASS_PRN.at(d_gnss_synchro->PRN);
+            acq_parameters.freq += DFRQ2_GLO * GLONASS_PRN.at(d_gnss_synchro->PRN);
-            LOG(INFO) << "Trying to acquire SV PRN " << d_gnss_synchro->PRN << " with freq " << d_freq << " in Glonass Channel " << GLONASS_PRN.at(d_gnss_synchro->PRN) << std::endl;
+            LOG(INFO) << "Trying to acquire SV PRN " << d_gnss_synchro->PRN << " with freq " << acq_parameters.freq << " in Glonass Channel " << GLONASS_PRN.at(d_gnss_synchro->PRN) << std::endl;
             return true;
         }
     else
@@ -225,7 +208,7 @@ bool pcps_acquisition::is_fdma()
 
 void pcps_acquisition::update_local_carrier(gr_complex* carrier_vector, int correlator_length_samples, float freq)
 {
-    float phase_step_rad = GPS_TWO_PI * freq / static_cast<float>(d_fs_in);
+    float phase_step_rad = GPS_TWO_PI * freq / static_cast<float>(acq_parameters.fs_in);
     float _phase[1];
     _phase[0] = 0;
     volk_gnsssdr_s32f_sincos_32fc(carrier_vector, -phase_step_rad, _phase, correlator_length_samples);
@@ -245,22 +228,29 @@ void pcps_acquisition::init()
     d_mag = 0.0;
     d_input_power = 0.0;
 
-    d_num_doppler_bins = static_cast<unsigned int>(std::ceil(static_cast<double>(static_cast<int>(d_doppler_max) - static_cast<int>(-d_doppler_max)) / static_cast<double>(d_doppler_step)));
+    d_num_doppler_bins = static_cast<unsigned int>(std::ceil(static_cast<double>(static_cast<int>(acq_parameters.doppler_max) - static_cast<int>(-acq_parameters.doppler_max)) / static_cast<double>(d_doppler_step)));
 
     // Create the carrier Doppler wipeoff signals
     d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins];
-
+    if (acq_parameters.make_2_steps)
+        {
+            d_grid_doppler_wipeoffs_step_two = new gr_complex*[acq_parameters.num_doppler_bins_step2];
+            for (unsigned int doppler_index = 0; doppler_index < acq_parameters.num_doppler_bins_step2; doppler_index++)
+                {
+                    d_grid_doppler_wipeoffs_step_two[doppler_index] = static_cast<gr_complex*>(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
+                }
+        }
     for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
         {
             d_grid_doppler_wipeoffs[doppler_index] = static_cast<gr_complex*>(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-            int doppler = -static_cast<int>(d_doppler_max) + d_doppler_step * doppler_index;
+            int doppler = -static_cast<int>(acq_parameters.doppler_max) + d_doppler_step * doppler_index;
-            update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_freq + doppler);
+            update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, acq_parameters.freq + doppler);
         }
     d_worker_active = false;
 
-    if (d_dump)
+    if (acq_parameters.dump)
         {
-            unsigned int effective_fft_size = (d_bit_transition_flag ? (d_fft_size / 2) : d_fft_size);
+            unsigned int effective_fft_size = (acq_parameters.bit_transition_flag ? (d_fft_size / 2) : d_fft_size);
             grid_ = arma::fmat(effective_fft_size, d_num_doppler_bins, arma::fill::zeros);
         }
 }
@@ -270,12 +260,19 @@ void pcps_acquisition::update_grid_doppler_wipeoffs()
 {
     for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
         {
-            d_grid_doppler_wipeoffs[doppler_index] = static_cast<gr_complex*>(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
+            int doppler = -static_cast<int>(acq_parameters.doppler_max) + d_doppler_step * doppler_index;
-            int doppler = -static_cast<int>(d_doppler_max) + d_doppler_step * doppler_index;
+            update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, acq_parameters.freq + doppler);
-            update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_freq + doppler);
         }
 }
 
+void pcps_acquisition::update_grid_doppler_wipeoffs_step2()
+{
+    for (unsigned int doppler_index = 0; doppler_index < acq_parameters.num_doppler_bins_step2; doppler_index++)
+        {
+            float doppler = (static_cast<float>(doppler_index) - static_cast<float>(acq_parameters.num_doppler_bins_step2) / 2.0) * acq_parameters.doppler_step2;
+            update_local_carrier(d_grid_doppler_wipeoffs_step_two[doppler_index], d_fft_size, d_doppler_center_step_two + doppler);
+        }
+}
 
 void pcps_acquisition::set_state(int state)
 {
@@ -354,10 +351,17 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
      */
 
     gr::thread::scoped_lock lk(d_setlock);
-    if (!d_active || d_worker_active)
+    if (!d_active or d_worker_active)
         {
             d_sample_counter += d_fft_size * ninput_items[0];
             consume_each(ninput_items[0]);
+            if (d_step_two)
+                {
+                    d_doppler_center_step_two = static_cast<float>(d_gnss_synchro->Acq_doppler_hz);
+                    update_grid_doppler_wipeoffs_step2();
+                    d_state = 0;
+                    d_active = true;
+                }
             return 0;
         }
 
@@ -390,7 +394,7 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
                     {
                         memcpy(d_data_buffer, input_items[0], d_fft_size * sizeof(gr_complex));
                     }
-                if (d_blocking)
+                if (acq_parameters.blocking)
                     {
                         lk.unlock();
                         acquisition_core(d_sample_counter);
@@ -414,11 +418,10 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
     gr::thread::scoped_lock lk(d_setlock);
 
     // initialize acquisition algorithm
-    int doppler;
     uint32_t indext = 0;
     float magt = 0.0;
     const gr_complex* in = d_data_buffer;  //Get the input samples pointer
-    int effective_fft_size = (d_bit_transition_flag ? d_fft_size / 2 : d_fft_size);
+    int effective_fft_size = (acq_parameters.bit_transition_flag ? d_fft_size / 2 : d_fft_size);
     if (d_cshort)
         {
             volk_gnsssdr_16ic_convert_32fc(d_data_buffer, d_data_buffer_sc, d_fft_size);
@@ -432,12 +435,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
     DLOG(INFO) << "Channel: " << d_channel
                << " , doing acquisition of satellite: " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN
                << " ,sample stamp: " << samp_count << ", threshold: "
-               << d_threshold << ", doppler_max: " << d_doppler_max
+               << d_threshold << ", doppler_max: " << acq_parameters.doppler_max
                << ", doppler_step: " << d_doppler_step
-               << ", use_CFAR_algorithm_flag: " << (d_use_CFAR_algorithm_flag ? "true" : "false");
+               << ", use_CFAR_algorithm_flag: " << (acq_parameters.use_CFAR_algorithm_flag ? "true" : "false");
 
     lk.unlock();
-    if (d_use_CFAR_algorithm_flag)
+    if (acq_parameters.use_CFAR_algorithm_flag)
         {
             // 1- (optional) Compute the input signal power estimation
             volk_32fc_magnitude_squared_32f(d_magnitude, in, d_fft_size);
@@ -445,10 +448,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
             d_input_power /= static_cast<float>(d_fft_size);
         }
     // 2- Doppler frequency search loop
+    if (!d_step_two)
+        {
             for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
                 {
                     // doppler search steps
-            doppler = -static_cast<int>(d_doppler_max) + d_doppler_step * doppler_index;
+                    int doppler = -static_cast<int>(acq_parameters.doppler_max) + d_doppler_step * doppler_index;
 
                     volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index], d_fft_size);
 
@@ -464,12 +469,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
                     d_ifft->execute();
 
                     // Search maximum
-            size_t offset = (d_bit_transition_flag ? effective_fft_size : 0);
+                    size_t offset = (acq_parameters.bit_transition_flag ? effective_fft_size : 0);
                     volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size);
                     volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size);
                     magt = d_magnitude[indext];
 
-            if (d_use_CFAR_algorithm_flag)
+                    if (acq_parameters.use_CFAR_algorithm_flag)
                         {
                             // Normalize the maximum value to correct the scale factor introduced by FFTW
                             magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor);
@@ -479,14 +484,14 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
                         {
                             d_mag = magt;
 
-                    if (!d_use_CFAR_algorithm_flag)
+                            if (!acq_parameters.use_CFAR_algorithm_flag)
                                 {
                                     // Search grid noise floor approximation for this doppler line
                                     volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size);
                                     d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1);
                                 }
 
-                    // In case that d_bit_transition_flag = true, we compare the potentially
+                            // In case that acq_parameters.bit_transition_flag = true, we compare the potentially
                             // new maximum test statistics (d_mag/d_input_power) with the value in
                             // d_test_statistics. When the second dwell is being processed, the value
                             // of d_mag/d_input_power could be lower than d_test_statistics (i.e,
@@ -494,9 +499,9 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
                             // current d_mag/d_input_power). Note that d_test_statistics is not
                             // restarted between consecutive dwells in multidwell operation.
 
-                    if (d_test_statistics < (d_mag / d_input_power) || !d_bit_transition_flag)
+                            if (d_test_statistics < (d_mag / d_input_power) or !acq_parameters.bit_transition_flag)
                                 {
-                            d_gnss_synchro->Acq_delay_samples = static_cast<double>(indext % d_samples_per_code);
+                                    d_gnss_synchro->Acq_delay_samples = static_cast<double>(indext % acq_parameters.samples_per_code);
                                     d_gnss_synchro->Acq_doppler_hz = static_cast<double>(doppler);
                                     d_gnss_synchro->Acq_samplestamp_samples = samp_count;
 
@@ -506,12 +511,12 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
                                 }
                         }
                     // Record results to file if required
-            if (d_dump)
+                    if (acq_parameters.dump)
                         {
                             memcpy(grid_.colptr(doppler_index), d_magnitude, sizeof(float) * effective_fft_size);
                             if (doppler_index == (d_num_doppler_bins - 1))
                                 {
-                            std::string filename = d_dump_filename;
+                                    std::string filename = acq_parameters.dump_filename;
                                     filename.append("_");
                                     filename.append(1, d_gnss_synchro->System);
                                     filename.append("_");
@@ -524,7 +529,7 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
                                     if (matfp == NULL)
                                         {
                                             std::cout << "Unable to create or open Acquisition dump file" << std::endl;
-                                    d_dump = false;
+                                            acq_parameters.dump = false;
                                         }
                                     else
                                         {
@@ -535,7 +540,7 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
 
                                             dims[0] = static_cast<size_t>(1);
                                             dims[1] = static_cast<size_t>(1);
-                                    matvar = Mat_VarCreate("doppler_max", MAT_C_SINGLE, MAT_T_UINT32, 1, dims, &d_doppler_max, 0);
+                                            matvar = Mat_VarCreate("doppler_max", MAT_C_SINGLE, MAT_T_UINT32, 1, dims, &acq_parameters.doppler_max, 0);
                                             Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
                                             Mat_VarFree(matvar);
 
@@ -548,39 +553,136 @@ void pcps_acquisition::acquisition_core(unsigned long int samp_count)
                                 }
                         }
                 }
+        }
+    else
+        {
+            for (unsigned int doppler_index = 0; doppler_index < acq_parameters.num_doppler_bins_step2; doppler_index++)
+                {
+                    // doppler search steps
+                    float doppler = d_doppler_center_step_two + (static_cast<float>(doppler_index) - static_cast<float>(acq_parameters.num_doppler_bins_step2) / 2.0) * acq_parameters.doppler_step2;
+
+                    volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs_step_two[doppler_index], d_fft_size);
+
+                    // 3- Perform the FFT-based convolution  (parallel time search)
+                    // Compute the FFT of the carrier wiped--off incoming signal
+                    d_fft_if->execute();
+
+                    // Multiply carrier wiped--off, Fourier transformed incoming signal
+                    // with the local FFT'd code reference using SIMD operations with VOLK library
+                    volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
+
+                    // compute the inverse FFT
+                    d_ifft->execute();
+
+                    // Search maximum
+                    size_t offset = (acq_parameters.bit_transition_flag ? effective_fft_size : 0);
+                    volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size);
+                    volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size);
+                    magt = d_magnitude[indext];
+
+                    if (acq_parameters.use_CFAR_algorithm_flag)
+                        {
+                            // Normalize the maximum value to correct the scale factor introduced by FFTW
+                            magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor);
+                        }
+                    // 4- record the maximum peak and the associated synchronization parameters
+                    if (d_mag < magt)
+                        {
+                            d_mag = magt;
+
+                            if (!acq_parameters.use_CFAR_algorithm_flag)
+                                {
+                                    // Search grid noise floor approximation for this doppler line
+                                    volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size);
+                                    d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1);
+                                }
+
+                            // In case that acq_parameters.bit_transition_flag = true, we compare the potentially
+                            // new maximum test statistics (d_mag/d_input_power) with the value in
+                            // d_test_statistics. When the second dwell is being processed, the value
+                            // of d_mag/d_input_power could be lower than d_test_statistics (i.e,
+                            // the maximum test statistics in the previous dwell is greater than
+                            // current d_mag/d_input_power). Note that d_test_statistics is not
+                            // restarted between consecutive dwells in multidwell operation.
+
+                            if (d_test_statistics < (d_mag / d_input_power) or !acq_parameters.bit_transition_flag)
+                                {
+                                    d_gnss_synchro->Acq_delay_samples = static_cast<double>(indext % acq_parameters.samples_per_code);
+                                    d_gnss_synchro->Acq_doppler_hz = static_cast<double>(doppler);
+                                    d_gnss_synchro->Acq_samplestamp_samples = samp_count;
+
+                                    // 5- Compute the test statistics and compare to the threshold
+                                    //d_test_statistics = 2 * d_fft_size * d_mag / d_input_power;
+                                    d_test_statistics = d_mag / d_input_power;
+                                }
+                        }
+                }
+        }
     lk.lock();
-    if (!d_bit_transition_flag)
+    if (!acq_parameters.bit_transition_flag)
         {
             if (d_test_statistics > d_threshold)
                 {
-                    d_state = 0;  // Positive acquisition
                     d_active = false;
+                    if (acq_parameters.make_2_steps)
+                        {
+                            if (d_step_two)
+                                {
                                     send_positive_acquisition();
+                                    d_step_two = false;
+                                    d_state = 0;  // Positive acquisition
                                 }
-            else if (d_well_count == d_max_dwells)
+                            else
+                                {
+                                    d_step_two = true;  // Clear input buffer and make small grid acquisition
+                                    d_state = 0;
+                                }
+                        }
+                    else
+                        {
+                            send_positive_acquisition();
+                            d_state = 0;  // Positive acquisition
+                        }
+                }
+            else if (d_well_count == acq_parameters.max_dwells)
                 {
                     d_state = 0;
                     d_active = false;
+                    d_step_two = false;
                     send_negative_acquisition();
                 }
         }
     else
         {
-            if (d_well_count == d_max_dwells)  // d_max_dwells = 2
+            d_active = false;
-                {
             if (d_test_statistics > d_threshold)
                 {
-                            d_state = 0;  // Positive acquisition
+                    if (acq_parameters.make_2_steps)
-                            d_active = false;
+                        {
+                            if (d_step_two)
+                                {
                                     send_positive_acquisition();
+                                    d_step_two = false;
+                                    d_state = 0;  // Positive acquisition
+                                }
+                            else
+                                {
+                                    d_step_two = true;  // Clear input buffer and make small grid acquisition
+                                    d_state = 0;
+                                }
+                        }
+                    else
+                        {
+                            send_positive_acquisition();
+                            d_state = 0;  // Positive acquisition
+                        }
                 }
             else
                 {
                     d_state = 0;  // Negative acquisition
-                            d_active = false;
+                    d_step_two = false;
                     send_negative_acquisition();
                 }
         }
-        }
     d_worker_active = false;
 }

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h

@@ -59,18 +59,33 @@
 #include <volk_gnsssdr/volk_gnsssdr.h>
 #include <string>
 
+typedef struct
+{
+    /* pcps acquisition configuration */
+    unsigned int sampled_ms;
+    unsigned int max_dwells;
+    unsigned int doppler_max;
+    unsigned int num_doppler_bins_step2;
+    float doppler_step2;
+    long freq;
+    long fs_in;
+    int samples_per_ms;
+    int samples_per_code;
+    bool bit_transition_flag;
+    bool use_CFAR_algorithm_flag;
+    bool dump;
+    bool blocking;
+    bool make_2_steps;
+    std::string dump_filename;
+    size_t it_size;
+} pcpsconf_t;
 
 class pcps_acquisition;
 
 typedef boost::shared_ptr<pcps_acquisition> pcps_acquisition_sptr;
 
 pcps_acquisition_sptr
-pcps_make_acquisition(unsigned int sampled_ms, unsigned int max_dwells,
+pcps_make_acquisition(pcpsconf_t conf_);
-    unsigned int doppler_max, long freq, long fs_in,
-    int samples_per_ms, int samples_per_code,
-    bool bit_transition_flag, bool use_CFAR_algorithm_flag,
-    bool dump, bool blocking,
-    std::string dump_filename, size_t it_size);
 
 /*!
  * \brief This class implements a Parallel Code Phase Search Acquisition.
@@ -82,22 +97,13 @@ class pcps_acquisition : public gr::block
 {
 private:
     friend pcps_acquisition_sptr
-    pcps_make_acquisition(unsigned int sampled_ms, unsigned int max_dwells,
+    pcps_make_acquisition(pcpsconf_t conf_);
-        unsigned int doppler_max, long freq, long fs_in,
-        int samples_per_ms, int samples_per_code,
-        bool bit_transition_flag, bool use_CFAR_algorithm_flag,
-        bool dump, bool blocking,
-        std::string dump_filename, size_t it_size);
 
-    pcps_acquisition(unsigned int sampled_ms, unsigned int max_dwells,
+    pcps_acquisition(pcpsconf_t conf_);
-        unsigned int doppler_max, long freq, long fs_in,
-        int samples_per_ms, int samples_per_code,
-        bool bit_transition_flag, bool use_CFAR_algorithm_flag,
-        bool dump, bool blocking,
-        std::string dump_filename, size_t it_size);
 
     void update_local_carrier(gr_complex* carrier_vector, int correlator_length_samples, float freq);
     void update_grid_doppler_wipeoffs();
+    void update_grid_doppler_wipeoffs_step2();
     bool is_fdma();
 
     void acquisition_core(unsigned long int samp_count);
@@ -106,42 +112,33 @@ private:
 
     void send_positive_acquisition();
 
-    bool d_bit_transition_flag;
+    pcpsconf_t acq_parameters;
-    bool d_use_CFAR_algorithm_flag;
     bool d_active;
-    bool d_dump;
     bool d_worker_active;
-    bool d_blocking;
     bool d_cshort;
+    bool d_step_two;
     float d_threshold;
     float d_mag;
     float d_input_power;
     float d_test_statistics;
     float* d_magnitude;
-    long d_fs_in;
-    long d_freq;
     long d_old_freq;
-    int d_samples_per_ms;
-    int d_samples_per_code;
     int d_state;
     unsigned int d_channel;
-    unsigned int d_doppler_max;
     unsigned int d_doppler_step;
-    unsigned int d_sampled_ms;
+    float d_doppler_center_step_two;
-    unsigned int d_max_dwells;
     unsigned int d_well_count;
     unsigned int d_fft_size;
     unsigned int d_num_doppler_bins;
-    unsigned int d_code_phase;
     unsigned long int d_sample_counter;
     gr_complex** d_grid_doppler_wipeoffs;
+    gr_complex** d_grid_doppler_wipeoffs_step_two;
     gr_complex* d_fft_codes;
     gr_complex* d_data_buffer;
     lv_16sc_t* d_data_buffer_sc;
     gr::fft::fft_complex* d_fft_if;
     gr::fft::fft_complex* d_ifft;
     Gnss_Synchro* d_gnss_synchro;
-    std::string d_dump_filename;
     arma::fmat grid_;
 
 public:
@@ -223,7 +220,7 @@ public:
     inline void set_doppler_max(unsigned int doppler_max)
     {
         gr::thread::scoped_lock lock(d_setlock);  // require mutex with work function called by the scheduler
-        d_doppler_max = doppler_max;
+        acq_parameters.doppler_max = doppler_max;
     }
 
     /*!

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/CMakeLists.txt

@@ -27,9 +27,91 @@ enable_language(CXX)
 enable_language(C)
 enable_testing()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall")
+# Set compiler flags
+set(GNSSSDR_CLANG_MIN_VERSION "3.4.0")
+set(GNSSSDR_APPLECLANG_MIN_VERSION "500")
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    execute_process(COMMAND
+        ${CMAKE_CXX_COMPILER} -v
+        RESULT_VARIABLE _res ERROR_VARIABLE _err
+        ERROR_STRIP_TRAILING_WHITESPACE)
+    if(${_res} STREQUAL "0")
+        # output is in error stream
+        string(REGEX MATCH "^Apple.*" IS_APPLE ${_err})
+        if("${IS_APPLE}" STREQUAL "")
+            set(MIN_VERSION ${GNSSSDR_CLANG_MIN_VERSION})
+            set(APPLE_STR "")
+            # retrieve the compiler's version from it
+            string(REGEX MATCH "clang version [0-9.]+" CLANG_OTHER_VERSION ${_err})
+            string(REGEX MATCH "[0-9.]+" CLANG_VERSION ${CLANG_OTHER_VERSION})
+        else("${IS_APPLE}" STREQUAL "")
+            set(MIN_VERSION ${GNSSSDR_APPLECLANG_MIN_VERSION})
+            set(APPLE_STR "Apple ")
+            # retrieve the compiler's version from it
+            string(REGEX MATCH "(clang-[0-9.]+)" CLANG_APPLE_VERSION ${_err})
+            string(REGEX MATCH "[0-9.]+" CLANG_VERSION ${CLANG_APPLE_VERSION})
+        endif("${IS_APPLE}" STREQUAL "")
+        if(${CLANG_VERSION} VERSION_LESS "${MIN_VERSION}")
+            message(WARNING "\nThe compiler selected to build VOLK-GNSSSDR (${APPLE_STR}Clang version ${CLANG_VERSION} : ${CMAKE_CXX_COMPILER}) is older than that officially supported (${MIN_VERSION} minimum). This build may or not work. We highly recommend using Apple Clang version ${APPLECLANG_MIN_VERSION} or more recent, or Clang version ${CLANG_MIN_VERSION} or more recent.")
+        endif(${CLANG_VERSION} VERSION_LESS "${MIN_VERSION}")
+    else(${_res} STREQUAL "0")
+        message(WARNING "\nCannot determine the version of the compiler selected to build VOLK-GNSSSDR (${APPLE_STR}Clang : ${CMAKE_CXX_COMPILER}). This build may or not work. We highly recommend using Apple Clang version ${APPLECLANG_MIN_VERSION} or more recent, or Clang version ${CLANG_MIN_VERSION} or more recent.")
+    endif(${_res} STREQUAL "0")
+endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+
+# Enable C++17 support in GCC >= 8.0.0
+# Enable C++14 support in 8.0.0 > GCC >= 6.1.1
+# Fallback to C++11 when using GCC < 6.1.1
+if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1")
+        set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11")
+    else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1")
+        if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0")
+            set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14")
+        else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0")
+            set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17")
+        endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "8.0.0")
+    endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.1.1")
+    set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -Wall -Wextra")  #Add warning flags: For "-Wall" see http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
+endif(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
+
+# Enable C++17 support in Clang >= 6.0.0 or AppleClang >= 900
+# Enable C++14 support in 6.0.0 > Clang >= 3.5.0 or 900 > AppleClang >= 600
+# Fallback to C++11 if older version
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+        # See https://trac.macports.org/wiki/XcodeVersionInfo for Apple Clang version equivalences
+        if(CLANG_VERSION VERSION_LESS "600")
+            set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11")
+        else(CLANG_VERSION VERSION_LESS "600")
+            if(CLANG_VERSION VERSION_LESS "900")
+                set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14")
+            else(CLANG_VERSION VERSION_LESS "900")
+                set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17")
+            endif(CLANG_VERSION VERSION_LESS "900")
+        endif(CLANG_VERSION VERSION_LESS "600")
+    else(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+        if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0")
+            set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++11")
+        else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0")
+            if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0")
+                set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++14")
+            else(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0")
+                set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -std=c++17")
+            endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6.0.0")
+        endif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "3.5.0")
+    endif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+endif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+
+if(NOT (CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+    if(NOT (CMAKE_VERSION VERSION_LESS "3.1"))
+        set(CMAKE_C_STANDARD 11)
+        set(CMAKE_CXX_STANDARD 11)
+    endif(NOT (CMAKE_VERSION VERSION_LESS "3.1"))
+endif(NOT (CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32) AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MY_CXX_FLAGS} -Wall")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
-add_definitions(-D_GLIBCXX_USE_CXX11_ABI=1)
 
 if(CMAKE_VERSION VERSION_GREATER "3.0")
     cmake_policy(SET CMP0042 NEW)

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/cmake/Modules/VolkGnsssdrConfigVersion.cmake.in

@@ -29,6 +29,6 @@ if(${PACKAGE_FIND_VERSION_MAJOR} EQUAL ${MAJOR_VERSION})
     if(NOT ${PACKAGE_FIND_VERSION_PATCH} GREATER ${MAINT_VERSION})
       set(PACKAGE_VERSION_EXACT 1)    # exact match for API version
       set(PACKAGE_VERSION_COMPATIBLE 1)  # compat for minor/patch version
-    endif(NOT ${PACKAGE_FIND_VERSION_PATCH} GREATER ${MINOR_VERSION})
+    endif(NOT ${PACKAGE_FIND_VERSION_PATCH} GREATER ${MAINT_VERSION})
-  endif(${PACKAGE_FIND_VERSION_MINOR} EQUAL ${API_COMPAT})
+  endif(${PACKAGE_FIND_VERSION_MINOR} EQUAL ${MINOR_VERSION})
 endif(${PACKAGE_FIND_VERSION_MAJOR} EQUAL ${MAJOR_VERSION})

src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc

@@ -133,8 +133,8 @@ void signal_generator_c::init()
                         }
                 }
         }
-    random_ = new gr::random();
     std::default_random_engine e1(r());
+    std::default_random_engine e2(r());
     std::uniform_int_distribution<int> uniform_dist(0, RAND_MAX);
 }
 
@@ -271,7 +271,6 @@ signal_generator_c::~signal_generator_c()
                 }
         } */
     volk_gnsssdr_free(complex_phase_);
-    delete random_;
 }
 
 
@@ -433,7 +432,7 @@ int signal_generator_c::general_work(int noutput_items __attribute__((unused)),
         {
             for (out_idx = 0; out_idx < vector_length_; out_idx++)
                 {
-                    out[out_idx] += gr_complex(random_->gasdev(), random_->gasdev());
+                    out[out_idx] += gr_complex(normal_dist(e1), normal_dist(e2));
                 }
         }
 

src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h

@@ -33,7 +33,7 @@
 
 #include "gnss_signal.h"
 #include <boost/scoped_array.hpp>
-#include <gnuradio/random.h>
+//#include <gnuradio/random.h>
 #include <gnuradio/block.h>
 #include <string>
 #include <vector>
@@ -120,13 +120,15 @@ private:
 
     boost::scoped_array<gr_complex *> sampled_code_data_;
     boost::scoped_array<gr_complex *> sampled_code_pilot_;
-    gr::random *random_;
+    //gr::random *random_;
     gr_complex *complex_phase_;
 
     unsigned int work_counter_;
     std::random_device r;
     std::default_random_engine e1;
+    std::default_random_engine e2;
     std::uniform_int_distribution<int> uniform_dist;
+    std::normal_distribution<float> normal_dist;
 
 public:
     ~signal_generator_c();  // public destructor

src/algorithms/signal_source/libs/ad9361_manager.cc

@@ -86,7 +86,7 @@ bool get_ad9361_stream_dev(struct iio_context *ctx, enum iodev d, struct iio_dev
 
 
 /* finds AD9361 streaming IIO channels */
-bool get_ad9361_stream_ch(struct iio_context *ctx, enum iodev d, struct iio_device *dev, int chid, struct iio_channel **chn)
+bool get_ad9361_stream_ch(struct iio_context *ctx __attribute__((unused)), enum iodev d, struct iio_device *dev, int chid, struct iio_channel **chn)
 {
     std::stringstream name;
     name.str("");

src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc

@@ -48,24 +48,35 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    dllpllconf_t trk_param;
     DLOG(INFO) << "role " << role;
     //################# CONFIGURATION PARAMETERS ########################
     std::string default_item_type = "gr_complex";
     std::string item_type = configuration->property(role + ".item_type", default_item_type);
     int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
     int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    trk_param.fs_in = fs_in;
     bool dump = configuration->property(role + ".dump", false);
+    trk_param.dump = dump;
     float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 5.0);
     if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz);
+    trk_param.pll_bw_hz = pll_bw_hz;
     float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 0.5);
     if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast<float>(FLAGS_dll_bw_hz);
+    trk_param.dll_bw_hz = dll_bw_hz;
     float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 2.0);
+    trk_param.pll_bw_narrow_hz = pll_bw_narrow_hz;
     float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 0.25);
+    trk_param.dll_bw_narrow_hz = dll_bw_narrow_hz;
     int extend_correlation_symbols = configuration->property(role + ".extend_correlation_symbols", 1);
     float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.15);
+    trk_param.early_late_space_chips = early_late_space_chips;
     float very_early_late_space_chips = configuration->property(role + ".very_early_late_space_chips", 0.6);
+    trk_param.very_early_late_space_chips = very_early_late_space_chips;
     float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.15);
+    trk_param.early_late_space_narrow_chips = early_late_space_narrow_chips;
     float very_early_late_space_narrow_chips = configuration->property(role + ".very_early_late_space_narrow_chips", 0.6);
+    trk_param.very_early_late_space_narrow_chips = very_early_late_space_narrow_chips;
     bool track_pilot = configuration->property(role + ".track_pilot", false);
     if (extend_correlation_symbols < 1)
         {
@@ -81,31 +92,21 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
         {
             std::cout << TEXT_RED << "WARNING: Galileo E1. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << std::endl;
         }
+    trk_param.track_pilot = track_pilot;
+    trk_param.extend_correlation_symbols = extend_correlation_symbols;
     std::string default_dump_filename = "./track_ch";
     std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename);
+    trk_param.dump_filename = dump_filename;
     int vector_length = std::round(fs_in / (Galileo_E1_CODE_CHIP_RATE_HZ / Galileo_E1_B_CODE_LENGTH_CHIPS));
-
+    trk_param.vector_length = vector_length;
+    trk_param.system = 'E';
+    char sig_[3] = "1B";
+    std::memcpy(trk_param.signal, sig_, 3);
     //################# MAKE TRACKING GNURadio object ###################
     if (item_type.compare("gr_complex") == 0)
         {
             item_size_ = sizeof(gr_complex);
-
+            tracking_ = dll_pll_veml_make_tracking(trk_param);
-            char sig_[3] = "1B";
-            tracking_ = dll_pll_veml_make_tracking(
-                fs_in,
-                vector_length,
-                dump,
-                dump_filename,
-                pll_bw_hz,
-                dll_bw_hz,
-                pll_bw_narrow_hz,
-                dll_bw_narrow_hz,
-                early_late_space_chips,
-                very_early_late_space_chips,
-                early_late_space_narrow_chips,
-                very_early_late_space_narrow_chips,
-                extend_correlation_symbols,
-                track_pilot, 'E', sig_);
         }
     else
         {

src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc

@@ -49,27 +49,36 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    dllpllconf_t trk_param;
     DLOG(INFO) << "role " << role;
     //################# CONFIGURATION PARAMETERS ########################
     std::string default_item_type = "gr_complex";
     std::string item_type = configuration->property(role + ".item_type", default_item_type);
     int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 12000000);
     int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    trk_param.fs_in = fs_in;
     bool dump = configuration->property(role + ".dump", false);
-    unified_ = configuration->property(role + ".unified", false);
+    trk_param.dump = dump;
     float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 20.0);
     if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz);
+    trk_param.pll_bw_hz = pll_bw_hz;
     float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 20.0);
     if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast<float>(FLAGS_dll_bw_hz);
+    trk_param.dll_bw_hz = dll_bw_hz;
     float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 5.0);
+    trk_param.pll_bw_narrow_hz = pll_bw_narrow_hz;
     float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 2.0);
-    int ti_ms = configuration->property(role + ".ti_ms", 3);
+    trk_param.dll_bw_narrow_hz = dll_bw_narrow_hz;
     float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5);
+    trk_param.early_late_space_chips = early_late_space_chips;
     std::string default_dump_filename = "./track_ch";
     std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename);
+    trk_param.dump_filename = dump_filename;
     int vector_length = std::round(fs_in / (Galileo_E5a_CODE_CHIP_RATE_HZ / Galileo_E5a_CODE_LENGTH_CHIPS));
+    trk_param.vector_length = vector_length;
     int extend_correlation_symbols = configuration->property(role + ".extend_correlation_symbols", 1);
     float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.15);
+    trk_param.early_late_space_narrow_chips = early_late_space_narrow_chips;
     bool track_pilot = configuration->property(role + ".track_pilot", false);
     if (extend_correlation_symbols < 1)
         {
@@ -85,33 +94,18 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking(
         {
             std::cout << TEXT_RED << "WARNING: Galileo E5a. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << std::endl;
         }
+    trk_param.extend_correlation_symbols = extend_correlation_symbols;
+    trk_param.track_pilot = track_pilot;
+    trk_param.very_early_late_space_chips = 0.0;
+    trk_param.very_early_late_space_narrow_chips = 0.0;
+    trk_param.system = 'E';
+    char sig_[3] = "5X";
+    std::memcpy(trk_param.signal, sig_, 3);
     //################# MAKE TRACKING GNURadio object ###################
     if (item_type.compare("gr_complex") == 0)
         {
             item_size_ = sizeof(gr_complex);
-            if (unified_)
+            tracking_ = dll_pll_veml_make_tracking(trk_param);
-                {
-                    char sig_[3] = "5X";
-                    item_size_ = sizeof(gr_complex);
-                    tracking_unified_ = dll_pll_veml_make_tracking(
-                        fs_in, vector_length, dump, dump_filename,
-                        pll_bw_hz, dll_bw_hz,
-                        pll_bw_narrow_hz, dll_bw_narrow_hz,
-                        early_late_space_chips,
-                        early_late_space_chips,
-                        early_late_space_narrow_chips,
-                        early_late_space_narrow_chips,
-                        extend_correlation_symbols,
-                        track_pilot, 'E', sig_);
-                }
-            else
-                {
-                    tracking_ = galileo_e5a_dll_pll_make_tracking_cc(
-                        0, fs_in, vector_length, dump, dump_filename,
-                        pll_bw_hz, dll_bw_hz, pll_bw_narrow_hz,
-                        dll_bw_narrow_hz, ti_ms,
-                        early_late_space_chips);
-                }
         }
     else
         {
@@ -130,33 +124,26 @@ GalileoE5aDllPllTracking::~GalileoE5aDllPllTracking()
 
 void GalileoE5aDllPllTracking::start_tracking()
 {
-    if (unified_)
-        tracking_unified_->start_tracking();
-    else
     tracking_->start_tracking();
 }
 
+
 /*
  * Set tracking channel unique ID
  */
 void GalileoE5aDllPllTracking::set_channel(unsigned int channel)
 {
     channel_ = channel;
-    if (unified_)
-        tracking_unified_->set_channel(channel);
-    else
     tracking_->set_channel(channel);
 }
 
 
 void GalileoE5aDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
 {
-    if (unified_)
-        tracking_unified_->set_gnss_synchro(p_gnss_synchro);
-    else
     tracking_->set_gnss_synchro(p_gnss_synchro);
 }
 
+
 void GalileoE5aDllPllTracking::connect(gr::top_block_sptr top_block)
 {
     if (top_block)
@@ -165,6 +152,7 @@ void GalileoE5aDllPllTracking::connect(gr::top_block_sptr top_block)
     //nothing to connect, now the tracking uses gr_sync_decimator
 }
 
+
 void GalileoE5aDllPllTracking::disconnect(gr::top_block_sptr top_block)
 {
     if (top_block)
@@ -173,18 +161,14 @@ void GalileoE5aDllPllTracking::disconnect(gr::top_block_sptr top_block)
     //nothing to disconnect, now the tracking uses gr_sync_decimator
 }
 
+
 gr::basic_block_sptr GalileoE5aDllPllTracking::get_left_block()
 {
-    if (unified_)
-        return tracking_unified_;
-    else
     return tracking_;
 }
 
+
 gr::basic_block_sptr GalileoE5aDllPllTracking::get_right_block()
 {
-    if (unified_)
-        return tracking_unified_;
-    else
     return tracking_;
 }

src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.h

@@ -40,7 +40,6 @@
 #define GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_H_
 
 #include "tracking_interface.h"
-#include "galileo_e5a_dll_pll_tracking_cc.h"
 #include "dll_pll_veml_tracking.h"
 #include <string>
 
@@ -94,14 +93,12 @@ public:
     void start_tracking() override;
 
 private:
-    galileo_e5a_dll_pll_tracking_cc_sptr tracking_;
+    dll_pll_veml_tracking_sptr tracking_;
-    dll_pll_veml_tracking_sptr tracking_unified_;
     size_t item_size_;
     unsigned int channel_;
     std::string role_;
     unsigned int in_streams_;
     unsigned int out_streams_;
-    bool unified_;
 };
 
 #endif /* GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_H_ */

src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc

@@ -49,24 +49,35 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    dllpllconf_t trk_param;
     DLOG(INFO) << "role " << role;
     //################# CONFIGURATION PARAMETERS ########################
     std::string default_item_type = "gr_complex";
     std::string item_type = configuration->property(role + ".item_type", default_item_type);
     int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
     int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    trk_param.fs_in = fs_in;
     bool dump = configuration->property(role + ".dump", false);
+    trk_param.dump = dump;
     float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0);
     if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz);
+    trk_param.pll_bw_hz = pll_bw_hz;
     float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 20.0);
+    trk_param.pll_bw_narrow_hz = pll_bw_narrow_hz;
     float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 2.0);
+    trk_param.dll_bw_narrow_hz = dll_bw_narrow_hz;
     float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0);
     if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast<float>(FLAGS_dll_bw_hz);
+    trk_param.dll_bw_hz = dll_bw_hz;
     float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5);
+    trk_param.early_late_space_chips = early_late_space_chips;
     float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.5);
+    trk_param.early_late_space_narrow_chips = early_late_space_narrow_chips;
     std::string default_dump_filename = "./track_ch";
     std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename);
+    trk_param.dump_filename = dump_filename;
     int vector_length = std::round(fs_in / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS));
+    trk_param.vector_length = vector_length;
     int symbols_extended_correlator = configuration->property(role + ".extend_correlation_symbols", 1);
     if (symbols_extended_correlator < 1)
         {
@@ -78,6 +89,7 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking(
             symbols_extended_correlator = 20;
             std::cout << TEXT_RED << "WARNING: GPS L1 C/A. extend_correlation_symbols must be lower than 21. Coherent integration has been set to 20 symbols (20 ms)" << TEXT_RESET << std::endl;
         }
+    trk_param.extend_correlation_symbols = symbols_extended_correlator;
     bool track_pilot = configuration->property(role + ".track_pilot", false);
     if (track_pilot)
         {
@@ -87,22 +99,17 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking(
         {
             std::cout << TEXT_RED << "WARNING: GPS L1 C/A. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << std::endl;
         }
+    trk_param.very_early_late_space_chips = 0.0;
+    trk_param.very_early_late_space_narrow_chips = 0.0;
+    trk_param.track_pilot = false;
+    trk_param.system = 'G';
+    char sig_[3] = "1C";
+    std::memcpy(trk_param.signal, sig_, 3);
     //################# MAKE TRACKING GNURadio object ###################
     if (item_type.compare("gr_complex") == 0)
         {
-            char sig_[3] = "1C";
             item_size_ = sizeof(gr_complex);
-            tracking_ = dll_pll_veml_make_tracking(
+            tracking_ = dll_pll_veml_make_tracking(trk_param);
-                fs_in, vector_length, dump,
-                dump_filename, pll_bw_hz, dll_bw_hz,
-                pll_bw_narrow_hz, dll_bw_narrow_hz,
-                early_late_space_chips,
-                early_late_space_chips,
-                early_late_space_narrow_chips,
-                early_late_space_narrow_chips,
-                symbols_extended_correlator,
-                false,
-                'G', sig_);
         }
     else
         {

src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc

@@ -49,56 +49,54 @@ GpsL2MDllPllTracking::GpsL2MDllPllTracking(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    dllpllconf_t trk_param;
     DLOG(INFO) << "role " << role;
     //################# CONFIGURATION PARAMETERS ########################
     std::string default_item_type = "gr_complex";
     std::string item_type = configuration->property(role + ".item_type", default_item_type);
     int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
     int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    trk_param.fs_in = fs_in;
     bool dump = configuration->property(role + ".dump", false);
+    trk_param.dump = dump;
     float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 2.0);
     if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz);
+    trk_param.pll_bw_hz = pll_bw_hz;
     float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 0.75);
     if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast<float>(FLAGS_dll_bw_hz);
-    unified_ = configuration->property(role + ".unified", false);
+    trk_param.dll_bw_hz = dll_bw_hz;
     float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5);
+    trk_param.early_late_space_chips = early_late_space_chips;
+    trk_param.early_late_space_narrow_chips = 0.0;
     std::string default_dump_filename = "./track_ch";
     std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename);
+    trk_param.dump_filename = dump_filename;
     int vector_length = std::round(static_cast<double>(fs_in) / (static_cast<double>(GPS_L2_M_CODE_RATE_HZ) / static_cast<double>(GPS_L2_M_CODE_LENGTH_CHIPS)));
+    trk_param.vector_length = vector_length;
     int symbols_extended_correlator = configuration->property(role + ".extend_correlation_symbols", 1);
     if (symbols_extended_correlator != 1)
         {
             std::cout << TEXT_RED << "WARNING: Extended coherent integration is not allowed in GPS L2. Coherent integration has been set to 20 ms (1 symbol)" << TEXT_RESET << std::endl;
         }
+    trk_param.extend_correlation_symbols = 1;
     bool track_pilot = configuration->property(role + ".track_pilot", false);
     if (track_pilot)
         {
             std::cout << TEXT_RED << "WARNING: GPS L2 does not have pilot signal. Data tracking has been enabled" << TEXT_RESET << std::endl;
         }
+    trk_param.track_pilot = false;
+    trk_param.very_early_late_space_chips = 0.0;
+    trk_param.very_early_late_space_narrow_chips = 0.0;
+    trk_param.pll_bw_narrow_hz = 0.0;
+    trk_param.dll_bw_narrow_hz = 0.0;
+    trk_param.system = 'G';
+    char sig_[3] = "2S";
+    std::memcpy(trk_param.signal, sig_, 3);
     //################# MAKE TRACKING GNURadio object ###################
     if (item_type.compare("gr_complex") == 0)
         {
             item_size_ = sizeof(gr_complex);
-            if (unified_)
+            tracking_ = dll_pll_veml_make_tracking(trk_param);
-                {
-                    char sig_[3] = "2S";
-                    item_size_ = sizeof(gr_complex);
-                    tracking_unified_ = dll_pll_veml_make_tracking(
-                        fs_in, vector_length, dump, dump_filename,
-                        pll_bw_hz, dll_bw_hz, pll_bw_hz, dll_bw_hz,
-                        early_late_space_chips,
-                        early_late_space_chips,
-                        early_late_space_chips,
-                        early_late_space_chips,
-                        1, false, 'G', sig_);
-                }
-            else
-                {
-                    tracking_ = gps_l2_m_dll_pll_make_tracking_cc(
-                        0, fs_in, vector_length, dump,
-                        dump_filename, pll_bw_hz, dll_bw_hz,
-                        early_late_space_chips);
-                }
         }
     else
         {
@@ -117,33 +115,26 @@ GpsL2MDllPllTracking::~GpsL2MDllPllTracking()
 
 void GpsL2MDllPllTracking::start_tracking()
 {
-    if (unified_)
-        tracking_unified_->start_tracking();
-    else
     tracking_->start_tracking();
 }
 
+
 /*
  * Set tracking channel unique ID
  */
 void GpsL2MDllPllTracking::set_channel(unsigned int channel)
 {
     channel_ = channel;
-    if (unified_)
-        tracking_unified_->set_channel(channel);
-    else
     tracking_->set_channel(channel);
 }
 
 
 void GpsL2MDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
 {
-    if (unified_)
-        tracking_unified_->set_gnss_synchro(p_gnss_synchro);
-    else
     tracking_->set_gnss_synchro(p_gnss_synchro);
 }
 
+
 void GpsL2MDllPllTracking::connect(gr::top_block_sptr top_block)
 {
     if (top_block)
@@ -152,6 +143,7 @@ void GpsL2MDllPllTracking::connect(gr::top_block_sptr top_block)
     //nothing to connect, now the tracking uses gr_sync_decimator
 }
 
+
 void GpsL2MDllPllTracking::disconnect(gr::top_block_sptr top_block)
 {
     if (top_block)
@@ -160,18 +152,14 @@ void GpsL2MDllPllTracking::disconnect(gr::top_block_sptr top_block)
     //nothing to disconnect, now the tracking uses gr_sync_decimator
 }
 
+
 gr::basic_block_sptr GpsL2MDllPllTracking::get_left_block()
 {
-    if (unified_)
-        return tracking_unified_;
-    else
     return tracking_;
 }
 
+
 gr::basic_block_sptr GpsL2MDllPllTracking::get_right_block()
 {
-    if (unified_)
-        return tracking_unified_;
-    else
     return tracking_;
 }

src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h

@@ -39,7 +39,6 @@
 #define GNSS_SDR_gps_l2_m_dll_pll_tracking_H_
 
 #include "tracking_interface.h"
-#include "gps_l2_m_dll_pll_tracking_cc.h"
 #include "dll_pll_veml_tracking.h"
 #include <string>
 
@@ -93,14 +92,12 @@ public:
     void start_tracking() override;
 
 private:
-    gps_l2_m_dll_pll_tracking_cc_sptr tracking_;
+    dll_pll_veml_tracking_sptr tracking_;
-    dll_pll_veml_tracking_sptr tracking_unified_;
     size_t item_size_;
     unsigned int channel_;
     std::string role_;
     unsigned int in_streams_;
     unsigned int out_streams_;
-    bool unified_;
 };
 
 #endif  // GNSS_SDR_gps_l2_m_dll_pll_tracking_H_

src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.cc

@@ -49,26 +49,36 @@ GpsL5iDllPllTracking::GpsL5iDllPllTracking(
     ConfigurationInterface* configuration, std::string role,
     unsigned int in_streams, unsigned int out_streams) : role_(role), in_streams_(in_streams), out_streams_(out_streams)
 {
+    dllpllconf_t trk_param;
     DLOG(INFO) << "role " << role;
     //################# CONFIGURATION PARAMETERS ########################
     std::string default_item_type = "gr_complex";
     std::string item_type = configuration->property(role + ".item_type", default_item_type);
     int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
     int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
+    trk_param.fs_in = fs_in;
     bool dump = configuration->property(role + ".dump", false);
-    unified_ = configuration->property(role + ".unified", false);
+    trk_param.dump = dump;
     float pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0);
     if (FLAGS_pll_bw_hz != 0.0) pll_bw_hz = static_cast<float>(FLAGS_pll_bw_hz);
+    trk_param.pll_bw_hz = pll_bw_hz;
     float dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0);
     if (FLAGS_dll_bw_hz != 0.0) dll_bw_hz = static_cast<float>(FLAGS_dll_bw_hz);
+    trk_param.dll_bw_hz = dll_bw_hz;
     float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 2.0);
+    trk_param.pll_bw_narrow_hz = pll_bw_narrow_hz;
     float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 0.25);
+    trk_param.dll_bw_narrow_hz = dll_bw_narrow_hz;
     float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5);
+    trk_param.early_late_space_chips = early_late_space_chips;
     std::string default_dump_filename = "./track_ch";
     std::string dump_filename = configuration->property(role + ".dump_filename", default_dump_filename);
+    trk_param.dump_filename = dump_filename;
     int vector_length = std::round(static_cast<double>(fs_in) / (static_cast<double>(GPS_L5i_CODE_RATE_HZ) / static_cast<double>(GPS_L5i_CODE_LENGTH_CHIPS)));
+    trk_param.vector_length = vector_length;
     int extend_correlation_symbols = configuration->property(role + ".extend_correlation_symbols", 1);
     float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.15);
+    trk_param.early_late_space_narrow_chips = early_late_space_narrow_chips;
     bool track_pilot = configuration->property(role + ".track_pilot", false);
     if (extend_correlation_symbols < 1)
         {
@@ -84,32 +94,18 @@ GpsL5iDllPllTracking::GpsL5iDllPllTracking(
         {
             std::cout << TEXT_RED << "WARNING: GPS L5. PLL or DLL narrow tracking bandwidth is higher than wide tracking one" << TEXT_RESET << std::endl;
         }
+    trk_param.extend_correlation_symbols = extend_correlation_symbols;
+    trk_param.track_pilot = track_pilot;
+    trk_param.very_early_late_space_chips = 0.0;
+    trk_param.very_early_late_space_narrow_chips = 0.0;
+    trk_param.system = 'G';
+    char sig_[3] = "L5";
+    std::memcpy(trk_param.signal, sig_, 3);
     //################# MAKE TRACKING GNURadio object ###################
     if (item_type.compare("gr_complex") == 0)
         {
             item_size_ = sizeof(gr_complex);
-            if (unified_)
+            tracking_ = dll_pll_veml_make_tracking(trk_param);
-                {
-                    char sig_[3] = "L5";
-                    item_size_ = sizeof(gr_complex);
-                    tracking_unified_ = dll_pll_veml_make_tracking(
-                        fs_in, vector_length, dump, dump_filename,
-                        pll_bw_hz, dll_bw_hz,
-                        pll_bw_narrow_hz, dll_bw_narrow_hz,
-                        early_late_space_chips,
-                        early_late_space_chips,
-                        early_late_space_narrow_chips,
-                        early_late_space_narrow_chips,
-                        extend_correlation_symbols,
-                        track_pilot, 'G', sig_);
-                }
-            else
-                {
-                    tracking_ = gps_l5i_dll_pll_make_tracking_cc(
-                        0, fs_in, vector_length, dump,
-                        dump_filename, pll_bw_hz, dll_bw_hz,
-                        early_late_space_chips);
-                }
         }
     else
         {
@@ -128,33 +124,26 @@ GpsL5iDllPllTracking::~GpsL5iDllPllTracking()
 
 void GpsL5iDllPllTracking::start_tracking()
 {
-    if (unified_)
-        tracking_unified_->start_tracking();
-    else
     tracking_->start_tracking();
 }
 
+
 /*
  * Set tracking channel unique ID
  */
 void GpsL5iDllPllTracking::set_channel(unsigned int channel)
 {
     channel_ = channel;
-    if (unified_)
-        tracking_unified_->set_channel(channel);
-    else
     tracking_->set_channel(channel);
 }
 
 
 void GpsL5iDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
 {
-    if (unified_)
-        tracking_unified_->set_gnss_synchro(p_gnss_synchro);
-    else
     tracking_->set_gnss_synchro(p_gnss_synchro);
 }
 
+
 void GpsL5iDllPllTracking::connect(gr::top_block_sptr top_block)
 {
     if (top_block)
@@ -163,6 +152,7 @@ void GpsL5iDllPllTracking::connect(gr::top_block_sptr top_block)
     //nothing to connect, now the tracking uses gr_sync_decimator
 }
 
+
 void GpsL5iDllPllTracking::disconnect(gr::top_block_sptr top_block)
 {
     if (top_block)
@@ -171,18 +161,14 @@ void GpsL5iDllPllTracking::disconnect(gr::top_block_sptr top_block)
     //nothing to disconnect, now the tracking uses gr_sync_decimator
 }
 
+
 gr::basic_block_sptr GpsL5iDllPllTracking::get_left_block()
 {
-    if (unified_)
-        return tracking_unified_;
-    else
     return tracking_;
 }
 
+
 gr::basic_block_sptr GpsL5iDllPllTracking::get_right_block()
 {
-    if (unified_)
-        return tracking_unified_;
-    else
     return tracking_;
 }

src/algorithms/tracking/adapters/gps_l5i_dll_pll_tracking.h

@@ -38,7 +38,6 @@
 #define GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_H_
 
 #include "tracking_interface.h"
-#include "gps_l5i_dll_pll_tracking_cc.h"
 #include "dll_pll_veml_tracking.h"
 #include <string>
 
@@ -92,14 +91,12 @@ public:
     void start_tracking() override;
 
 private:
-    gps_l5i_dll_pll_tracking_cc_sptr tracking_;
+    dll_pll_veml_tracking_sptr tracking_;
-    dll_pll_veml_tracking_sptr tracking_unified_;
     size_t item_size_;
     unsigned int channel_;
     std::string role_;
     unsigned int in_streams_;
     unsigned int out_streams_;
-    bool unified_;
 };
 
 #endif  // GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_H_

src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt

@@ -29,9 +29,6 @@ endif(ENABLE_FPGA)
 set(TRACKING_GR_BLOCKS_SOURCES
      galileo_e1_tcp_connector_tracking_cc.cc
      gps_l1_ca_tcp_connector_tracking_cc.cc
-     galileo_e5a_dll_pll_tracking_cc.cc
-     gps_l2_m_dll_pll_tracking_cc.cc
-     gps_l5i_dll_pll_tracking_cc.cc
      gps_l1_ca_dll_pll_c_aid_tracking_cc.cc
      gps_l1_ca_dll_pll_c_aid_tracking_sc.cc
      glonass_l1_ca_dll_pll_tracking_cc.cc

src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc

@@ -61,38 +61,9 @@
 
 using google::LogMessage;
 
-dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(
+dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(dllpllconf_t conf_)
-    double fs_in,
-    unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float pll_bw_narrow_hz,
-    float dll_bw_narrow_hz,
-    float early_late_space_chips,
-    float very_early_late_space_chips,
-    float early_late_space_narrow_chips,
-    float very_early_late_space_narrow_chips,
-    int extend_correlation_symbols,
-    bool track_pilot,
-    char system, char signal[3])
 {
-    return dll_pll_veml_tracking_sptr(new dll_pll_veml_tracking(
+    return dll_pll_veml_tracking_sptr(new dll_pll_veml_tracking(conf_));
-        fs_in,
-        vector_length,
-        dump,
-        dump_filename,
-        pll_bw_hz,
-        dll_bw_hz,
-        pll_bw_narrow_hz,
-        dll_bw_narrow_hz,
-        early_late_space_chips,
-        very_early_late_space_chips,
-        early_late_space_narrow_chips,
-        very_early_late_space_narrow_chips,
-        extend_correlation_symbols,
-        track_pilot, system, signal));
 }
 
 
@@ -101,40 +72,29 @@ void dll_pll_veml_tracking::forecast(int noutput_items,
 {
     if (noutput_items != 0)
         {
-            ninput_items_required[0] = static_cast<int>(d_vector_length) * 2;
+            ninput_items_required[0] = static_cast<int>(trk_parameters.vector_length) * 2;
         }
 }
 
 
-dll_pll_veml_tracking::dll_pll_veml_tracking(
+dll_pll_veml_tracking::dll_pll_veml_tracking(dllpllconf_t conf_) : gr::block("dll_pll_veml_tracking", gr::io_signature::make(1, 1, sizeof(gr_complex)),
-    double fs_in, unsigned int vector_length, bool dump,
-    std::string dump_filename, float pll_bw_hz, float dll_bw_hz,
-    float pll_bw_narrow_hz, float dll_bw_narrow_hz,
-    float early_late_space_chips, float very_early_late_space_chips,
-    float early_late_space_narrow_chips, float very_early_late_space_narrow_chips,
-    int extend_correlation_symbols, bool track_pilot, char system,
-    char signal[3]) : gr::block("dll_pll_veml_tracking", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                                                                        gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    trk_parameters = conf_;
     // Telemetry bit synchronization message port input
     this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
     this->message_port_register_out(pmt::mp("events"));
-    this->set_relative_rate(1.0 / static_cast<double>(vector_length));
+    this->set_relative_rate(1.0 / static_cast<double>(trk_parameters.vector_length));
 
     // initialize internal vars
-    d_dump = dump;
     d_veml = false;
     d_cloop = true;
     d_synchonizing = false;
-    d_track_pilot = track_pilot;
-    d_fs_in = fs_in;
-    d_vector_length = vector_length;
-    d_dump_filename = dump_filename;
     d_code_chip_rate = 0.0;
     d_secondary_code_length = 0;
     d_secondary_code_string = nullptr;
-    signal_type = std::string(signal);
+    signal_type = std::string(trk_parameters.signal);
-    if (system == 'G')
+    if (trk_parameters.system == 'G')
         {
             systemName = "GPS";
             if (signal_type.compare("1C") == 0)
@@ -148,7 +108,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
                     d_code_length_chips = static_cast<unsigned int>(GPS_L1_CA_CODE_LENGTH_CHIPS);
                     // GPS L1 C/A does not have pilot component nor secondary code
                     d_secondary = false;
-                    d_track_pilot = false;
+                    trk_parameters.track_pilot = false;
                     interchange_iq = false;
                 }
             else if (signal_type.compare("2S") == 0)
@@ -162,7 +122,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
                     d_code_samples_per_chip = 1;
                     // GPS L2 does not have pilot component nor secondary code
                     d_secondary = false;
-                    d_track_pilot = false;
+                    trk_parameters.track_pilot = false;
                     interchange_iq = false;
                 }
             else if (signal_type.compare("L5") == 0)
@@ -176,7 +136,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
                     d_code_length_chips = static_cast<unsigned int>(GPS_L5i_CODE_LENGTH_CHIPS);
                     // GPS L5 does not have pilot secondary code
                     d_secondary = true;
-                    if (d_track_pilot)
+                    if (trk_parameters.track_pilot)
                         {
                             d_secondary_code_length = static_cast<unsigned int>(GPS_L5q_NH_CODE_LENGTH);
                             d_secondary_code_string = const_cast<std::string *>(&GPS_L5q_NH_CODE_STR);
@@ -203,7 +163,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
                     d_symbols_per_bit = 0;
                 }
         }
-    else if (system == 'E')
+    else if (trk_parameters.system == 'E')
         {
             systemName = "Galileo";
             if (signal_type.compare("1B") == 0)
@@ -216,7 +176,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
                     d_correlation_length_ms = 4;
                     d_code_samples_per_chip = 2;  // CBOC disabled: 2 samples per chip. CBOC enabled: 12 samples per chip
                     d_veml = true;
-                    if (d_track_pilot)
+                    if (trk_parameters.track_pilot)
                         {
                             d_secondary = true;
                             d_secondary_code_length = static_cast<unsigned int>(Galileo_E1_C_SECONDARY_CODE_LENGTH);
@@ -238,7 +198,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
                     d_code_samples_per_chip = 1;
                     d_code_length_chips = static_cast<unsigned int>(Galileo_E5a_CODE_LENGTH_CHIPS);
                     d_secondary = true;
-                    if (d_track_pilot)
+                    if (trk_parameters.track_pilot)
                         {
                             interchange_iq = true;
                             d_secondary_code_length = static_cast<unsigned int>(Galileo_E5a_Q_SECONDARY_CODE_LENGTH);
@@ -284,23 +244,11 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
 
     // Initialize tracking  ==========================================
 
-    // Set bandwidth of code and carrier loop filters
+    d_code_loop_filter.set_DLL_BW(trk_parameters.dll_bw_hz);
-    d_dll_bw_hz = dll_bw_hz;
+    d_carrier_loop_filter.set_PLL_BW(trk_parameters.pll_bw_hz);
-    d_pll_bw_hz = pll_bw_hz;
-    d_dll_bw_narrow_hz = dll_bw_narrow_hz;
-    d_pll_bw_narrow_hz = pll_bw_narrow_hz;
-
-    d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
-    d_carrier_loop_filter.set_PLL_BW(d_pll_bw_hz);
     d_code_loop_filter = Tracking_2nd_DLL_filter(static_cast<float>(d_code_period));
     d_carrier_loop_filter = Tracking_2nd_PLL_filter(static_cast<float>(d_code_period));
 
-    // Correlator spacing
-    d_early_late_spc_chips = early_late_space_chips;                          // Define early-late offset (in chips)
-    d_very_early_late_spc_chips = very_early_late_space_chips;                // Define very-early-late offset (in chips)
-    d_early_late_spc_narrow_chips = early_late_space_narrow_chips;            // Define narrow early-late offset (in chips)
-    d_very_early_late_spc_narrow_chips = very_early_late_space_narrow_chips;  // Define narrow very-early-late offset (in chips)
-
     // Initialization of local code replica
     // Get space for a vector with the sinboc(1,1) replica sampled 2x/chip
     d_tracking_code = static_cast<float *>(volk_gnsssdr_malloc(2 * d_code_length_chips * sizeof(float), volk_gnsssdr_get_alignment()));
@@ -328,11 +276,11 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
             d_Prompt = &d_correlator_outs[2];
             d_Late = &d_correlator_outs[3];
             d_Very_Late = &d_correlator_outs[4];
-            d_local_code_shift_chips[0] = -d_very_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[0] = -trk_parameters.very_early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
-            d_local_code_shift_chips[1] = -d_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[1] = -trk_parameters.early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
             d_local_code_shift_chips[2] = 0.0;
-            d_local_code_shift_chips[3] = d_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[3] = trk_parameters.early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
-            d_local_code_shift_chips[4] = d_very_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[4] = trk_parameters.very_early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
             d_prompt_data_shift = &d_local_code_shift_chips[2];
         }
     else
@@ -342,30 +290,29 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
             d_Prompt = &d_correlator_outs[1];
             d_Late = &d_correlator_outs[2];
             d_Very_Late = nullptr;
-            d_local_code_shift_chips[0] = -d_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[0] = -trk_parameters.early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
             d_local_code_shift_chips[1] = 0.0;
-            d_local_code_shift_chips[2] = d_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[2] = trk_parameters.early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
             d_prompt_data_shift = &d_local_code_shift_chips[1];
         }
 
-    multicorrelator_cpu.init(2 * d_vector_length, d_n_correlator_taps);
+    multicorrelator_cpu.init(2 * trk_parameters.vector_length, d_n_correlator_taps);
 
-    if (extend_correlation_symbols > 1)
+    if (trk_parameters.extend_correlation_symbols > 1)
         {
             d_enable_extended_integration = true;
-            d_extend_correlation_symbols = extend_correlation_symbols;
         }
     else
         {
             d_enable_extended_integration = false;
-            d_extend_correlation_symbols = 1;
+            trk_parameters.extend_correlation_symbols = 1;
         }
 
     // Enable Data component prompt correlator (slave to Pilot prompt) if tracking uses Pilot signal
-    if (d_track_pilot)
+    if (trk_parameters.track_pilot)
         {
             // Extra correlator for the data component
-            correlator_data_cpu.init(2 * d_vector_length, 1);
+            correlator_data_cpu.init(2 * trk_parameters.vector_length, 1);
             d_Prompt_Data = static_cast<gr_complex *>(volk_gnsssdr_malloc(sizeof(gr_complex), volk_gnsssdr_get_alignment()));
             d_Prompt_Data[0] = gr_complex(0.0, 0.0);
             d_data_code = static_cast<float *>(volk_gnsssdr_malloc(2 * d_code_length_chips * sizeof(float), volk_gnsssdr_get_alignment()));
@@ -388,7 +335,7 @@ dll_pll_veml_tracking::dll_pll_veml_tracking(
     d_sample_counter = 0;
     d_acq_sample_stamp = 0;
 
-    d_current_prn_length_samples = static_cast<int>(d_vector_length);
+    d_current_prn_length_samples = static_cast<int>(trk_parameters.vector_length);
 
     // CN0 estimation and lock detector buffers
     d_cn0_estimation_counter = 0;
@@ -429,25 +376,25 @@ void dll_pll_veml_tracking::start_tracking()
     d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples;
 
     long int acq_trk_diff_samples = static_cast<long int>(d_sample_counter) - static_cast<long int>(d_acq_sample_stamp);
-    double acq_trk_diff_seconds = static_cast<double>(acq_trk_diff_samples) / d_fs_in;
+    double acq_trk_diff_seconds = static_cast<double>(acq_trk_diff_samples) / trk_parameters.fs_in;
     DLOG(INFO) << "Number of samples between Acquisition and Tracking = " << acq_trk_diff_samples;
     DLOG(INFO) << "Number of seconds between Acquisition and Tracking = " << acq_trk_diff_seconds;
     // Doppler effect Fd = (C / (C + Vr)) * F
     double radial_velocity = (d_signal_carrier_freq + d_acq_carrier_doppler_hz) / d_signal_carrier_freq;
     // new chip and prn sequence periods based on acq Doppler
     d_code_freq_chips = radial_velocity * d_code_chip_rate;
-    d_code_phase_step_chips = d_code_freq_chips / d_fs_in;
+    d_code_phase_step_chips = d_code_freq_chips / trk_parameters.fs_in;
     double T_chip_mod_seconds = 1.0 / d_code_freq_chips;
     double T_prn_mod_seconds = T_chip_mod_seconds * static_cast<double>(d_code_length_chips);
-    double T_prn_mod_samples = T_prn_mod_seconds * d_fs_in;
+    double T_prn_mod_samples = T_prn_mod_seconds * trk_parameters.fs_in;
 
     d_current_prn_length_samples = std::round(T_prn_mod_samples);
 
     double T_prn_true_seconds = static_cast<double>(d_code_length_chips) / d_code_chip_rate;
-    double T_prn_true_samples = T_prn_true_seconds * d_fs_in;
+    double T_prn_true_samples = T_prn_true_seconds * trk_parameters.fs_in;
     double T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds;
     double N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds;
-    double corrected_acq_phase_samples = std::fmod(d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * d_fs_in, T_prn_true_samples);
+    double corrected_acq_phase_samples = std::fmod(d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * trk_parameters.fs_in, T_prn_true_samples);
     if (corrected_acq_phase_samples < 0.0)
         {
             corrected_acq_phase_samples += T_prn_mod_samples;
@@ -457,7 +404,7 @@ void dll_pll_veml_tracking::start_tracking()
     d_acq_code_phase_samples = corrected_acq_phase_samples;
 
     d_carrier_doppler_hz = d_acq_carrier_doppler_hz;
-    d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / d_fs_in;
+    d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / trk_parameters.fs_in;
 
     // DLL/PLL filter initialization
     d_carrier_loop_filter.initialize();  // initialize the carrier filter
@@ -473,7 +420,7 @@ void dll_pll_veml_tracking::start_tracking()
         }
     else if (systemName.compare("GPS") == 0 and signal_type.compare("L5") == 0)
         {
-            if (d_track_pilot)
+            if (trk_parameters.track_pilot)
                 {
                     gps_l5q_code_gen_float(d_tracking_code, d_acquisition_gnss_synchro->PRN);
                     gps_l5i_code_gen_float(d_data_code, d_acquisition_gnss_synchro->PRN);
@@ -487,7 +434,7 @@ void dll_pll_veml_tracking::start_tracking()
         }
     else if (systemName.compare("Galileo") == 0 and signal_type.compare("1B") == 0)
         {
-            if (d_track_pilot)
+            if (trk_parameters.track_pilot)
                 {
                     char pilot_signal[3] = "1C";
                     galileo_e1_code_gen_sinboc11_float(d_tracking_code, pilot_signal, d_acquisition_gnss_synchro->PRN);
@@ -504,7 +451,7 @@ void dll_pll_veml_tracking::start_tracking()
         {
             gr_complex *aux_code = static_cast<gr_complex *>(volk_gnsssdr_malloc(sizeof(gr_complex) * d_code_length_chips, volk_gnsssdr_get_alignment()));
             galileo_e5_a_code_gen_complex_primary(aux_code, d_acquisition_gnss_synchro->PRN, const_cast<char *>(signal_type.c_str()));
-            if (d_track_pilot)
+            if (trk_parameters.track_pilot)
                 {
                     d_secondary_code_string = const_cast<std::string *>(&Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1]);
                     for (unsigned int i = 0; i < d_code_length_chips; i++)
@@ -539,20 +486,20 @@ void dll_pll_veml_tracking::start_tracking()
 
     if (d_veml)
         {
-            d_local_code_shift_chips[0] = -d_very_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[0] = -trk_parameters.very_early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
-            d_local_code_shift_chips[1] = -d_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[1] = -trk_parameters.early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
-            d_local_code_shift_chips[3] = d_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[3] = trk_parameters.early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
-            d_local_code_shift_chips[4] = d_very_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[4] = trk_parameters.very_early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
         }
     else
         {
-            d_local_code_shift_chips[0] = -d_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[0] = -trk_parameters.early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
-            d_local_code_shift_chips[2] = d_early_late_spc_chips * static_cast<float>(d_code_samples_per_chip);
+            d_local_code_shift_chips[2] = trk_parameters.early_late_space_chips * static_cast<float>(d_code_samples_per_chip);
         }
 
     d_code_phase_samples = d_acq_code_phase_samples;
-    d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
+    d_code_loop_filter.set_DLL_BW(trk_parameters.dll_bw_hz);
-    d_carrier_loop_filter.set_PLL_BW(d_pll_bw_hz);
+    d_carrier_loop_filter.set_PLL_BW(trk_parameters.pll_bw_hz);
     d_carrier_loop_filter.set_pdi(static_cast<float>(d_code_period));
     d_code_loop_filter.set_pdi(static_cast<float>(d_code_period));
 
@@ -585,7 +532,7 @@ dll_pll_veml_tracking::~dll_pll_veml_tracking()
                     LOG(WARNING) << "Exception in destructor " << ex.what();
                 }
         }
-    if (d_dump)
+    if (trk_parameters.dump)
         {
             if (d_channel == 0)
                 {
@@ -602,7 +549,7 @@ dll_pll_veml_tracking::~dll_pll_veml_tracking()
             volk_gnsssdr_free(d_local_code_shift_chips);
             volk_gnsssdr_free(d_correlator_outs);
             volk_gnsssdr_free(d_tracking_code);
-            if (d_track_pilot)
+            if (trk_parameters.track_pilot)
                 {
                     volk_gnsssdr_free(d_Prompt_Data);
                     volk_gnsssdr_free(d_data_code);
@@ -673,7 +620,7 @@ bool dll_pll_veml_tracking::cn0_and_tracking_lock_status()
         {
             d_cn0_estimation_counter = 0;
             // Code lock indicator
-            d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, FLAGS_cn0_samples, static_cast<long>(d_fs_in), static_cast<double>(d_code_length_chips));
+            d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, FLAGS_cn0_samples, static_cast<long>(trk_parameters.fs_in), static_cast<double>(d_code_length_chips));
             // Carrier lock indicator
             d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, FLAGS_cn0_samples);
             // Loss of lock detection
@@ -716,10 +663,10 @@ void dll_pll_veml_tracking::do_correlation_step(const gr_complex *input_samples)
         d_carrier_phase_step_rad,
         static_cast<float>(d_rem_code_phase_chips) * static_cast<float>(d_code_samples_per_chip),
         static_cast<float>(d_code_phase_step_chips) * static_cast<float>(d_code_samples_per_chip),
-        d_vector_length);
+        trk_parameters.vector_length);
 
     // DATA CORRELATOR (if tracking tracks the pilot signal)
-    if (d_track_pilot)
+    if (trk_parameters.track_pilot)
         {
             correlator_data_cpu.set_input_output_vectors(d_Prompt_Data, input_samples);
             correlator_data_cpu.Carrier_wipeoff_multicorrelator_resampler(
@@ -727,7 +674,7 @@ void dll_pll_veml_tracking::do_correlation_step(const gr_complex *input_samples)
                 d_carrier_phase_step_rad,
                 static_cast<float>(d_rem_code_phase_chips) * static_cast<float>(d_code_samples_per_chip),
                 static_cast<float>(d_code_phase_step_chips) * static_cast<float>(d_code_samples_per_chip),
-                d_vector_length);
+                trk_parameters.vector_length);
         }
 }
 
@@ -772,7 +719,7 @@ void dll_pll_veml_tracking::run_dll_pll()
 void dll_pll_veml_tracking::clear_tracking_vars()
 {
     std::fill_n(d_correlator_outs, d_n_correlator_taps, gr_complex(0.0, 0.0));
-    if (d_track_pilot) *d_Prompt_Data = gr_complex(0.0, 0.0);
+    if (trk_parameters.track_pilot) *d_Prompt_Data = gr_complex(0.0, 0.0);
     d_carr_error_hz = 0.0;
     d_carr_error_filt_hz = 0.0;
     d_code_error_chips = 0.0;
@@ -792,13 +739,13 @@ void dll_pll_veml_tracking::update_tracking_vars()
     // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT #######################
     // keep alignment parameters for the next input buffer
     // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation
-    T_prn_samples = T_prn_seconds * d_fs_in;
+    T_prn_samples = T_prn_seconds * trk_parameters.fs_in;
-    K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * d_fs_in;
+    K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * trk_parameters.fs_in;
     d_current_prn_length_samples = static_cast<int>(round(K_blk_samples));  // round to a discrete number of samples
 
     //################### PLL COMMANDS #################################################
     // carrier phase step (NCO phase increment per sample) [rads/sample]
-    d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / d_fs_in;
+    d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / trk_parameters.fs_in;
     // remnant carrier phase to prevent overflow in the code NCO
     d_rem_carr_phase_rad += d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples);
     d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, PI_2);
@@ -807,10 +754,10 @@ void dll_pll_veml_tracking::update_tracking_vars()
 
     //################### DLL COMMANDS #################################################
     // code phase step (Code resampler phase increment per sample) [chips/sample]
-    d_code_phase_step_chips = d_code_freq_chips / d_fs_in;
+    d_code_phase_step_chips = d_code_freq_chips / trk_parameters.fs_in;
     // remnant code phase [chips]
     d_rem_code_phase_samples = K_blk_samples - static_cast<double>(d_current_prn_length_samples);  // rounding error < 1 sample
-    d_rem_code_phase_chips = d_code_freq_chips * d_rem_code_phase_samples / d_fs_in;
+    d_rem_code_phase_chips = d_code_freq_chips * d_rem_code_phase_samples / trk_parameters.fs_in;
 }
 
 
@@ -858,7 +805,7 @@ void dll_pll_veml_tracking::save_correlation_results()
             d_current_symbol %= d_symbols_per_bit;
         }
     // If tracking pilot, disable Costas loop
-    if (d_track_pilot)
+    if (trk_parameters.track_pilot)
         d_cloop = false;
     else
         d_cloop = true;
@@ -867,7 +814,7 @@ void dll_pll_veml_tracking::save_correlation_results()
 
 void dll_pll_veml_tracking::log_data(bool integrating)
 {
-    if (d_dump)
+    if (trk_parameters.dump)
         {
             // Dump results to file
             float prompt_I;
@@ -875,7 +822,7 @@ void dll_pll_veml_tracking::log_data(bool integrating)
             float tmp_VE, tmp_E, tmp_P, tmp_L, tmp_VL;
             float tmp_float;
             double tmp_double;
-            if (d_track_pilot)
+            if (trk_parameters.track_pilot)
                 {
                     if (interchange_iq)
                         {
@@ -920,7 +867,7 @@ void dll_pll_veml_tracking::log_data(bool integrating)
                     // It compensates the amplitude difference while integrating
                     if (d_extend_correlation_symbols_count > 0)
                         {
-                            float scale_factor = static_cast<float>(d_extend_correlation_symbols) / static_cast<float>(d_extend_correlation_symbols_count);
+                            float scale_factor = static_cast<float>(trk_parameters.extend_correlation_symbols) / static_cast<float>(d_extend_correlation_symbols_count);
                             tmp_VE *= scale_factor;
                             tmp_E *= scale_factor;
                             tmp_P *= scale_factor;
@@ -994,7 +941,7 @@ int dll_pll_veml_tracking::save_matfile()
     dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
     try
         {
-            dump_file.open(d_dump_filename.c_str(), std::ios::binary | std::ios::ate);
+            dump_file.open(trk_parameters.dump_filename.c_str(), std::ios::binary | std::ios::ate);
         }
     catch (const std::ifstream::failure &e)
         {
@@ -1093,14 +1040,14 @@ int dll_pll_veml_tracking::save_matfile()
     // WRITE MAT FILE
     mat_t *matfp;
     matvar_t *matvar;
-    std::string filename = d_dump_filename;
+    std::string filename = trk_parameters.dump_filename;
     filename.erase(filename.length() - 4, 4);
     filename.append(".mat");
     matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73);
     if (reinterpret_cast<long *>(matfp) != NULL)
         {
             size_t dims[2] = {1, static_cast<size_t>(num_epoch)};
-            matvar = Mat_VarCreate("abs_VE", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0);
+            matvar = Mat_VarCreate("abs_VE", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_VE, 0);
             Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
             Mat_VarFree(matvar);
 
@@ -1116,7 +1063,7 @@ int dll_pll_veml_tracking::save_matfile()
             Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
             Mat_VarFree(matvar);
 
-            matvar = Mat_VarCreate("abs_VL", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0);
+            matvar = Mat_VarCreate("abs_VL", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_VL, 0);
             Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
             Mat_VarFree(matvar);
 
@@ -1211,17 +1158,17 @@ void dll_pll_veml_tracking::set_channel(unsigned int channel)
     d_channel = channel;
     LOG(INFO) << "Tracking Channel set to " << d_channel;
     // ############# ENABLE DATA FILE LOG #################
-    if (d_dump)
+    if (trk_parameters.dump)
         {
             if (!d_dump_file.is_open())
                 {
                     try
                         {
-                            d_dump_filename.append(boost::lexical_cast<std::string>(d_channel));
+                            trk_parameters.dump_filename.append(boost::lexical_cast<std::string>(d_channel));
-                            d_dump_filename.append(".dat");
+                            trk_parameters.dump_filename.append(".dat");
                             d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-                            d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
+                            d_dump_file.open(trk_parameters.dump_filename.c_str(), std::ios::out | std::ios::binary);
-                            LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str();
+                            LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << trk_parameters.dump_filename.c_str();
                         }
                     catch (const std::ifstream::failure &e)
                         {
@@ -1367,30 +1314,30 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused)
                                     {
                                         // UPDATE INTEGRATION TIME
                                         d_extend_correlation_symbols_count = 0;
-                                        float new_correlation_time = static_cast<float>(d_extend_correlation_symbols) * static_cast<float>(d_code_period);
+                                        float new_correlation_time = static_cast<float>(trk_parameters.extend_correlation_symbols) * static_cast<float>(d_code_period);
                                         d_carrier_loop_filter.set_pdi(new_correlation_time);
                                         d_code_loop_filter.set_pdi(new_correlation_time);
                                         d_state = 3;  // next state is the extended correlator integrator
-                                        LOG(INFO) << "Enabled " << d_extend_correlation_symbols << " [symbols] extended correlator for CH "
+                                        LOG(INFO) << "Enabled " << trk_parameters.extend_correlation_symbols << " [symbols] extended correlator for CH "
                                                   << d_channel
                                                   << " : Satellite " << Gnss_Satellite(systemName, d_acquisition_gnss_synchro->PRN);
-                                        std::cout << "Enabled " << d_extend_correlation_symbols << " [symbols] extended correlator for CH "
+                                        std::cout << "Enabled " << trk_parameters.extend_correlation_symbols << " [symbols] extended correlator for CH "
                                                   << d_channel
                                                   << " : Satellite " << Gnss_Satellite(systemName, d_acquisition_gnss_synchro->PRN) << std::endl;
                                         // Set narrow taps delay values [chips]
-                                        d_code_loop_filter.set_DLL_BW(d_dll_bw_narrow_hz);
+                                        d_code_loop_filter.set_DLL_BW(trk_parameters.dll_bw_narrow_hz);
-                                        d_carrier_loop_filter.set_PLL_BW(d_pll_bw_narrow_hz);
+                                        d_carrier_loop_filter.set_PLL_BW(trk_parameters.pll_bw_narrow_hz);
                                         if (d_veml)
                                             {
-                                                d_local_code_shift_chips[0] = -d_very_early_late_spc_narrow_chips * static_cast<float>(d_code_samples_per_chip);
+                                                d_local_code_shift_chips[0] = -trk_parameters.very_early_late_space_narrow_chips * static_cast<float>(d_code_samples_per_chip);
-                                                d_local_code_shift_chips[1] = -d_early_late_spc_narrow_chips * static_cast<float>(d_code_samples_per_chip);
+                                                d_local_code_shift_chips[1] = -trk_parameters.early_late_space_narrow_chips * static_cast<float>(d_code_samples_per_chip);
-                                                d_local_code_shift_chips[3] = d_early_late_spc_narrow_chips * static_cast<float>(d_code_samples_per_chip);
+                                                d_local_code_shift_chips[3] = trk_parameters.early_late_space_narrow_chips * static_cast<float>(d_code_samples_per_chip);
-                                                d_local_code_shift_chips[4] = d_very_early_late_spc_narrow_chips * static_cast<float>(d_code_samples_per_chip);
+                                                d_local_code_shift_chips[4] = trk_parameters.very_early_late_space_narrow_chips * static_cast<float>(d_code_samples_per_chip);
                                             }
                                         else
                                             {
-                                                d_local_code_shift_chips[0] = -d_early_late_spc_narrow_chips * static_cast<float>(d_code_samples_per_chip);
+                                                d_local_code_shift_chips[0] = -trk_parameters.early_late_space_narrow_chips * static_cast<float>(d_code_samples_per_chip);
-                                                d_local_code_shift_chips[2] = d_early_late_spc_narrow_chips * static_cast<float>(d_code_samples_per_chip);
+                                                d_local_code_shift_chips[2] = trk_parameters.early_late_space_narrow_chips * static_cast<float>(d_code_samples_per_chip);
                                             }
                                     }
                                 else
@@ -1413,7 +1360,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused)
                 // ########### Output the tracking results to Telemetry block ##########
                 if (interchange_iq)
                     {
-                        if (d_track_pilot)
+                        if (trk_parameters.track_pilot)
                             {
                                 // Note that data and pilot components are in quadrature. I and Q are interchanged
                                 current_synchro_data.Prompt_I = static_cast<double>((*d_Prompt_Data).imag());
@@ -1427,7 +1374,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused)
                     }
                 else
                     {
-                        if (d_track_pilot)
+                        if (trk_parameters.track_pilot)
                             {
                                 // Note that data and pilot components are in quadrature. I and Q are interchanged
                                 current_synchro_data.Prompt_I = static_cast<double>((*d_Prompt_Data).real());
@@ -1446,7 +1393,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused)
                 current_synchro_data.Flag_valid_symbol_output = true;
                 current_synchro_data.correlation_length_ms = d_correlation_length_ms;
                 d_extend_correlation_symbols_count++;
-                if (d_extend_correlation_symbols_count == (d_extend_correlation_symbols - 1))
+                if (d_extend_correlation_symbols_count == (trk_parameters.extend_correlation_symbols - 1))
                     {
                         d_extend_correlation_symbols_count = 0;
                         d_state = 4;
@@ -1477,7 +1424,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused)
                         // ########### Output the tracking results to Telemetry block ##########
                         if (interchange_iq)
                             {
-                                if (d_track_pilot)
+                                if (trk_parameters.track_pilot)
                                     {
                                         // Note that data and pilot components are in quadrature. I and Q are interchanged
                                         current_synchro_data.Prompt_I = static_cast<double>((*d_Prompt_Data).imag());
@@ -1491,7 +1438,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused)
                             }
                         else
                             {
-                                if (d_track_pilot)
+                                if (trk_parameters.track_pilot)
                                     {
                                         // Note that data and pilot components are in quadrature. I and Q are interchanged
                                         current_synchro_data.Prompt_I = static_cast<double>((*d_Prompt_Data).real());
@@ -1528,7 +1475,7 @@ int dll_pll_veml_tracking::general_work(int noutput_items __attribute__((unused)
     d_sample_counter += d_current_prn_length_samples;
     if (current_synchro_data.Flag_valid_symbol_output)
         {
-            current_synchro_data.fs = static_cast<long int>(d_fs_in);
+            current_synchro_data.fs = static_cast<long int>(trk_parameters.fs_in);
             current_synchro_data.Tracking_sample_counter = d_sample_counter;
             *out[0] = current_synchro_data;
             return 1;

src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h

@@ -39,20 +39,32 @@
 #include <fstream>
 #include <string>
 
+typedef struct
+{
+    /* DLL/PLL tracking configuration */
+    double fs_in;
+    unsigned int vector_length;
+    bool dump;
+    std::string dump_filename;
+    float pll_bw_hz;
+    float dll_bw_hz;
+    float pll_bw_narrow_hz;
+    float dll_bw_narrow_hz;
+    float early_late_space_chips;
+    float very_early_late_space_chips;
+    float early_late_space_narrow_chips;
+    float very_early_late_space_narrow_chips;
+    int extend_correlation_symbols;
+    bool track_pilot;
+    char system;
+    char signal[3];
+} dllpllconf_t;
 
 class dll_pll_veml_tracking;
 
 typedef boost::shared_ptr<dll_pll_veml_tracking> dll_pll_veml_tracking_sptr;
 
-dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(double fs_in, unsigned int vector_length,
+dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(dllpllconf_t conf_);
-    bool dump, std::string dump_filename,
-    float pll_bw_hz, float dll_bw_hz,
-    float pll_bw_narrow_hz, float dll_bw_narrow_hz,
-    float early_late_space_chips, float very_early_late_space_chips,
-    float early_late_space_narrow_chips,
-    float very_early_late_space_narrow_chips,
-    int extend_correlation_symbols, bool track_pilot,
-    char system, char signal[3]);
 
 /*!
  * \brief This class implements a code DLL + carrier PLL tracking block.
@@ -72,29 +84,9 @@ public:
     void forecast(int noutput_items, gr_vector_int &ninput_items_required);
 
 private:
-    friend dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(double fs_in, unsigned int vector_length,
+    friend dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(dllpllconf_t conf_);
-        bool dump, std::string dump_filename,
-        float pll_bw_hz, float dll_bw_hz, float pll_bw_narrow_hz,
-        float dll_bw_narrow_hz, float early_late_space_chips,
-        float very_early_late_space_chips, float early_late_space_narrow_chips,
-        float very_early_late_space_narrow_chips,
-        int extend_correlation_symbols, bool track_pilot,
-        char system, char signal[3]);
 
-    dll_pll_veml_tracking(double fs_in, unsigned int vector_length,
+    dll_pll_veml_tracking(dllpllconf_t conf_);
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float pll_bw_narrow_hz,
-        float dll_bw_narrow_hz,
-        float early_late_space_chips,
-        float very_early_late_space_chips,
-        float early_late_space_narrow_chips,
-        float very_early_late_space_narrow_chips,
-        int extend_correlation_symbols,
-        bool track_pilot,
-        char system, char signal[3]);
 
     bool cn0_and_tracking_lock_status();
     bool acquire_secondary();
@@ -107,12 +99,10 @@ private:
     int save_matfile();
 
     // tracking configuration vars
-    bool d_dump;
+    dllpllconf_t trk_parameters;
     bool d_veml;
     bool d_cloop;
-    unsigned int d_vector_length;
     unsigned int d_channel;
-    double d_fs_in;
     Gnss_Synchro *d_acquisition_gnss_synchro;
 
     //Signal parameters
@@ -135,10 +125,6 @@ private:
     //Integration period in samples
     int d_correlation_length_ms;
     int d_n_correlator_taps;
-    float d_early_late_spc_chips;
-    float d_very_early_late_spc_chips;
-    float d_early_late_spc_narrow_chips;
-    float d_very_early_late_spc_narrow_chips;
 
     float *d_tracking_code;
     float *d_data_code;
@@ -159,7 +145,6 @@ private:
     gr_complex *d_Very_Late;
 
     bool d_enable_extended_integration;
-    int d_extend_correlation_symbols;
     int d_extend_correlation_symbols_count;
     int d_current_symbol;
 
@@ -170,7 +155,6 @@ private:
     gr_complex d_VL_accu;
     gr_complex d_last_prompt;
 
-    bool d_track_pilot;
     gr_complex *d_Prompt_Data;
 
     double d_code_phase_step_chips;
@@ -187,11 +171,6 @@ private:
     double d_acq_code_phase_samples;
     double d_acq_carrier_doppler_hz;
 
-    // tracking parameters
-    float d_dll_bw_hz;
-    float d_pll_bw_hz;
-    float d_dll_bw_narrow_hz;
-    float d_pll_bw_narrow_hz;
     // tracking vars
     double d_carr_error_hz;
     double d_carr_error_filt_hz;
@@ -223,7 +202,6 @@ private:
     gr_complex *d_Prompt_buffer;
 
     // file dump
-    std::string d_dump_filename;
     std::ofstream d_dump_file;
 };
 

src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc

@@ -1,977 +0,0 @@
-/*!
- * \file galileo_e5a_dll_pll_tracking_cc.h
- * \brief Implementation of a code DLL + carrier PLL
- *  tracking block for Galileo E5a signals
- * \author Marc Sales, 2014. marcsales92(at)gmail.com
- * \based on work from:
- *          <ul>
- *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
- *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
- *          </ul>
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#include "galileo_e5a_dll_pll_tracking_cc.h"
-#include "galileo_e5_signal_processing.h"
-#include "tracking_discriminators.h"
-#include "lock_detectors.h"
-#include "Galileo_E5a.h"
-#include "Galileo_E1.h"
-#include "control_message_factory.h"
-#include "gnss_sdr_flags.h"
-#include <boost/lexical_cast.hpp>
-#include <gnuradio/io_signature.h>
-#include <glog/logging.h>
-#include <matio.h>
-#include <volk_gnsssdr/volk_gnsssdr.h>
-#include <cmath>
-#include <iostream>
-#include <sstream>
-
-
-using google::LogMessage;
-
-galileo_e5a_dll_pll_tracking_cc_sptr
-galileo_e5a_dll_pll_make_tracking_cc(
-    long if_freq,
-    long fs_in,
-    unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float pll_bw_narrow_hz,
-    float dll_bw_narrow_hz,
-    int ti_ms,
-    float early_late_space_chips)
-{
-    return galileo_e5a_dll_pll_tracking_cc_sptr(new Galileo_E5a_Dll_Pll_Tracking_cc(if_freq,
-        fs_in, vector_length, dump, dump_filename, pll_bw_hz, dll_bw_hz, pll_bw_narrow_hz, dll_bw_narrow_hz, ti_ms, early_late_space_chips));
-}
-
-
-void Galileo_E5a_Dll_Pll_Tracking_cc::forecast(int noutput_items, gr_vector_int &ninput_items_required)
-{
-    if (noutput_items != 0)
-        {
-            ninput_items_required[0] = static_cast<int>(d_vector_length) * 2;  //set the required available samples in each call
-        }
-}
-
-
-Galileo_E5a_Dll_Pll_Tracking_cc::Galileo_E5a_Dll_Pll_Tracking_cc(
-    long if_freq,
-    long fs_in,
-    unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float pll_bw_narrow_hz,
-    float dll_bw_narrow_hz,
-    int ti_ms,
-    float early_late_space_chips) : gr::block("Galileo_E5a_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
-                                        gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
-{
-    // Telemetry bit synchronization message port input
-    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
-    this->message_port_register_out(pmt::mp("events"));
-    this->set_relative_rate(1.0 / vector_length);
-    // initialize internal vars
-    d_dump = dump;
-    d_if_freq = if_freq;
-    d_fs_in = fs_in;
-    d_vector_length = vector_length;
-    d_dump_filename = dump_filename;
-    d_code_loop_filter = Tracking_2nd_DLL_filter(GALILEO_E5a_CODE_PERIOD);
-    d_carrier_loop_filter = Tracking_2nd_PLL_filter(GALILEO_E5a_CODE_PERIOD);
-    d_current_ti_ms = 1;  // initializes with 1ms of integration time until secondary code lock
-    d_ti_ms = ti_ms;
-    d_dll_bw_hz = dll_bw_hz;
-    d_pll_bw_hz = pll_bw_hz;
-    d_dll_bw_narrow_hz = dll_bw_narrow_hz;
-    d_pll_bw_narrow_hz = pll_bw_narrow_hz;
-
-    // Initialize tracking  ==========================================
-    d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
-    d_carrier_loop_filter.set_PLL_BW(d_pll_bw_hz);
-
-    //--- DLL variables --------------------------------------------------------
-    d_early_late_spc_chips = early_late_space_chips;  // Define early-late offset (in chips)
-
-    // Initialization of local code replica
-    // Get space for a vector with the E5a primary code replicas sampled 1x/chip
-    d_codeQ = static_cast<gr_complex *>(volk_gnsssdr_malloc(Galileo_E5a_CODE_LENGTH_CHIPS * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-    d_codeI = static_cast<gr_complex *>(volk_gnsssdr_malloc(Galileo_E5a_CODE_LENGTH_CHIPS * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-
-    // correlator Q outputs (scalar)
-    d_n_correlator_taps = 3;  //  Early, Prompt, Late
-    d_correlator_outs = static_cast<gr_complex *>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-    for (int n = 0; n < d_n_correlator_taps; n++)
-        {
-            d_correlator_outs[n] = gr_complex(0, 0);
-        }
-
-    // map memory pointers of correlator outputs
-    d_Single_Early = &d_correlator_outs[0];
-    d_Single_Prompt = &d_correlator_outs[1];
-    d_Single_Late = &d_correlator_outs[2];
-
-    d_local_code_shift_chips = static_cast<float *>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment()));
-    // Set TAPs delay values [chips]
-    d_local_code_shift_chips[0] = -d_early_late_spc_chips;
-    d_local_code_shift_chips[1] = 0.0;
-    d_local_code_shift_chips[2] = d_early_late_spc_chips;
-
-    multicorrelator_cpu_Q.init(2 * d_vector_length, d_n_correlator_taps);
-
-    // correlator I single output for data (scalar)
-    d_Single_Prompt_data = static_cast<gr_complex *>(volk_gnsssdr_malloc(sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-    *d_Single_Prompt_data = gr_complex(0, 0);
-    multicorrelator_cpu_I.init(2 * d_vector_length, 1);  // single correlator for data channel
-
-    //--- Perform initializations ------------------------------
-    // define initial code frequency basis of NCO
-    d_code_freq_chips = Galileo_E5a_CODE_CHIP_RATE_HZ;
-    // define residual code phase (in chips)
-    d_rem_code_phase_samples = 0.0;
-    // define residual carrier phase
-    d_rem_carr_phase_rad = 0.0;
-    //Filter error vars
-    d_code_error_filt_secs = 0.0;
-    // sample synchronization
-    d_sample_counter = 0;
-    d_acq_sample_stamp = 0;
-    d_first_transition = false;
-
-    d_secondary_lock = false;
-    d_secondary_delay = 0;
-    d_integration_counter = 0;
-
-    d_current_prn_length_samples = static_cast<int>(d_vector_length);
-
-    // CN0 estimation and lock detector buffers
-    d_cn0_estimation_counter = 0;
-    d_Prompt_buffer = new gr_complex[static_cast<unsigned int>(FLAGS_cn0_samples)];
-    d_carrier_lock_test = 1;
-    d_CN0_SNV_dB_Hz = 0;
-    d_carrier_lock_fail_counter = 0;
-    d_carrier_lock_threshold = FLAGS_carrier_lock_th;
-
-    d_acquisition_gnss_synchro = 0;
-    d_channel = 0;
-    tmp_E = 0;
-    tmp_P = 0;
-    tmp_L = 0;
-    d_acq_code_phase_samples = 0;
-    d_acq_carrier_doppler_hz = 0;
-    d_carrier_doppler_hz = 0;
-    d_acc_carrier_phase_rad = 0;
-    d_code_phase_samples = 0;
-    d_acc_code_phase_secs = 0;
-    d_state = 0;
-
-    d_rem_code_phase_chips = 0.0;
-    d_code_phase_step_chips = 0.0;
-    d_carrier_phase_step_rad = 0.0;
-
-    systemName["E"] = std::string("Galileo");
-}
-
-
-Galileo_E5a_Dll_Pll_Tracking_cc::~Galileo_E5a_Dll_Pll_Tracking_cc()
-{
-    if (d_dump_file.is_open())
-        {
-            try
-                {
-                    d_dump_file.close();
-                }
-            catch (const std::exception &ex)
-                {
-                    LOG(WARNING) << "Exception in destructor " << ex.what();
-                }
-        }
-
-    if (d_dump)
-        {
-            if (d_channel == 0)
-                {
-                    std::cout << "Writing .mat files ...";
-                }
-            Galileo_E5a_Dll_Pll_Tracking_cc::save_matfile();
-            if (d_channel == 0)
-                {
-                    std::cout << " done." << std::endl;
-                }
-        }
-
-    try
-        {
-            delete[] d_codeI;
-            delete[] d_codeQ;
-            delete[] d_Prompt_buffer;
-            volk_gnsssdr_free(d_local_code_shift_chips);
-            volk_gnsssdr_free(d_correlator_outs);
-            volk_gnsssdr_free(d_Single_Prompt_data);
-            multicorrelator_cpu_Q.free();
-            multicorrelator_cpu_I.free();
-        }
-    catch (const std::exception &ex)
-        {
-            LOG(WARNING) << "Exception in destructor " << ex.what();
-        }
-}
-
-
-void Galileo_E5a_Dll_Pll_Tracking_cc::start_tracking()
-{
-    /*
-     *  correct the code phase according to the delay between acq and trk
-     */
-    d_acq_code_phase_samples = d_acquisition_gnss_synchro->Acq_delay_samples;
-    d_acq_carrier_doppler_hz = d_acquisition_gnss_synchro->Acq_doppler_hz;
-    d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples;
-
-    long int acq_trk_diff_samples;
-    double acq_trk_diff_seconds;
-    acq_trk_diff_samples = static_cast<long int>(d_sample_counter) - static_cast<long int>(d_acq_sample_stamp);  //-d_vector_length;
-    LOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples;
-    acq_trk_diff_seconds = static_cast<float>(acq_trk_diff_samples) / static_cast<float>(d_fs_in);
-    //doppler effect
-    // Fd=(C/(C+Vr))*F
-    double radial_velocity;
-    radial_velocity = (Galileo_E5a_FREQ_HZ + d_acq_carrier_doppler_hz) / Galileo_E5a_FREQ_HZ;
-    // new chip and prn sequence periods based on acq Doppler
-    double T_chip_mod_seconds;
-    double T_prn_mod_seconds;
-    double T_prn_mod_samples;
-    d_code_freq_chips = radial_velocity * Galileo_E5a_CODE_CHIP_RATE_HZ;
-    T_chip_mod_seconds = 1 / d_code_freq_chips;
-    T_prn_mod_seconds = T_chip_mod_seconds * Galileo_E5a_CODE_LENGTH_CHIPS;
-    T_prn_mod_samples = T_prn_mod_seconds * static_cast<float>(d_fs_in);
-
-    d_current_prn_length_samples = round(T_prn_mod_samples);
-
-    double T_prn_true_seconds = Galileo_E5a_CODE_LENGTH_CHIPS / Galileo_E5a_CODE_CHIP_RATE_HZ;
-    double T_prn_true_samples = T_prn_true_seconds * static_cast<float>(d_fs_in);
-    double T_prn_diff_seconds;
-    T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds;
-    double N_prn_diff;
-    N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds;
-    double corrected_acq_phase_samples, delay_correction_samples;
-    corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * static_cast<float>(d_fs_in)), T_prn_true_samples);
-    if (corrected_acq_phase_samples < 0)
-        {
-            corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples;
-        }
-    delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples;
-
-    d_acq_code_phase_samples = corrected_acq_phase_samples;
-
-    d_carrier_doppler_hz = d_acq_carrier_doppler_hz;
-
-    // DLL/PLL filter initialization
-    d_carrier_loop_filter.initialize();  // initialize the carrier filter
-    d_code_loop_filter.initialize();     // initialize the code filter
-
-    // generate local reference ALWAYS starting at chip 1 (1 sample per chip)
-    char sig[3];
-    strcpy(sig, "5Q");
-    galileo_e5_a_code_gen_complex_primary(d_codeQ, d_acquisition_gnss_synchro->PRN, sig);
-
-    strcpy(sig, "5I");
-    galileo_e5_a_code_gen_complex_primary(d_codeI, d_acquisition_gnss_synchro->PRN, sig);
-
-    d_carrier_lock_fail_counter = 0;
-    d_rem_code_phase_samples = 0;
-    d_rem_carr_phase_rad = 0;
-    d_acc_carrier_phase_rad = 0;
-    d_acc_code_phase_secs = 0;
-
-    d_code_phase_samples = d_acq_code_phase_samples;
-
-    std::string sys_ = &d_acquisition_gnss_synchro->System;
-    sys = sys_.substr(0, 1);
-
-    // DEBUG OUTPUT
-    std::cout << "Tracking of Galileo E5a signal started on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl;
-    LOG(INFO) << "Galileo E5a starting tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel;
-
-    // enable tracking
-    d_state = 1;
-
-    LOG(INFO) << "PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz
-              << " Code Phase correction [samples]=" << delay_correction_samples
-              << " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
-}
-
-
-void Galileo_E5a_Dll_Pll_Tracking_cc::acquire_secondary()
-{
-    // 1. Transform replica to 1 and -1
-    int sec_code_signed[Galileo_E5a_Q_SECONDARY_CODE_LENGTH];
-    for (unsigned int i = 0; i < Galileo_E5a_Q_SECONDARY_CODE_LENGTH; i++)
-        {
-            if (Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1].at(i) == '0')
-                {
-                    sec_code_signed[i] = 1;
-                }
-            else
-                {
-                    sec_code_signed[i] = -1;
-                }
-        }
-    // 2. Transform buffer to 1 and -1
-    int in_corr[static_cast<unsigned int>(FLAGS_cn0_samples)];
-    for (unsigned int i = 0; i < static_cast<unsigned int>(FLAGS_cn0_samples); i++)
-        {
-            if (d_Prompt_buffer[i].real() > 0)
-                {
-                    in_corr[i] = 1;
-                }
-            else
-                {
-                    in_corr[i] = -1;
-                }
-        }
-    // 3. Serial search
-    int out_corr;
-    int current_best_ = 0;
-    for (unsigned int i = 0; i < Galileo_E5a_Q_SECONDARY_CODE_LENGTH; i++)
-        {
-            out_corr = 0;
-            for (unsigned int j = 0; j < static_cast<unsigned int>(FLAGS_cn0_samples); j++)
-                {
-                    //reverse replica sign since i*i=-1 (conjugated complex)
-                    out_corr += in_corr[j] * -sec_code_signed[(j + i) % Galileo_E5a_Q_SECONDARY_CODE_LENGTH];
-                }
-            if (abs(out_corr) > current_best_)
-                {
-                    current_best_ = abs(out_corr);
-                    d_secondary_delay = i;
-                }
-        }
-    if (current_best_ == FLAGS_cn0_samples)  // all bits correlate
-        {
-            d_secondary_lock = true;
-            d_secondary_delay = (d_secondary_delay + static_cast<unsigned int>(FLAGS_cn0_samples) - 1) % Galileo_E5a_Q_SECONDARY_CODE_LENGTH;
-        }
-}
-
-
-int Galileo_E5a_Dll_Pll_Tracking_cc::general_work(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items __attribute__((unused)),
-    gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
-{
-    // process vars
-    double carr_error_hz;
-    double carr_error_filt_hz;
-    double code_error_chips;
-    double code_error_filt_chips;
-
-    // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
-    Gnss_Synchro **out = reinterpret_cast<Gnss_Synchro **>(&output_items[0]);  //block output streams pointer
-
-    // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
-    Gnss_Synchro current_synchro_data;
-    // Fill the acquisition data
-    current_synchro_data = *d_acquisition_gnss_synchro;
-
-    /* States:     0 Tracking not enabled
-     *         1 Pull-in of primary code (alignment).
-     *         3 Tracking algorithm. Correlates EPL each loop and accumulates the result
-     *                     until it reaches integration time.
-     */
-    switch (d_state)
-        {
-        case 0:
-            {
-                d_Early = gr_complex(0, 0);
-                d_Prompt = gr_complex(0, 0);
-                d_Late = gr_complex(0, 0);
-                d_Prompt_data = gr_complex(0, 0);
-                current_synchro_data.Tracking_sample_counter = d_sample_counter;
-                break;
-            }
-        case 1:
-            {
-                int samples_offset;
-                double acq_trk_shif_correction_samples;
-                int acq_to_trk_delay_samples;
-                acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
-                acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast<float>(acq_to_trk_delay_samples), static_cast<float>(d_current_prn_length_samples));
-                samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
-                d_sample_counter = d_sample_counter + samples_offset;  //count for the processed samples
-                DLOG(INFO) << " samples_offset=" << samples_offset;
-                d_state = 2;  // start in Ti = 1 code, until secondary code lock.
-
-                // make an output to not stop the rest of the processing blocks
-                current_synchro_data.Prompt_I = 0.0;
-                current_synchro_data.Prompt_Q = 0.0;
-                current_synchro_data.Tracking_sample_counter = d_sample_counter;
-                current_synchro_data.Carrier_phase_rads = 0.0;
-                current_synchro_data.CN0_dB_hz = 0.0;
-                current_synchro_data.fs = d_fs_in;
-                consume_each(samples_offset);  //shift input to perform alignment with local replica
-                return 0;
-                break;
-            }
-        case 2:
-            {
-                // Block input data and block output stream pointers
-                const gr_complex *in = reinterpret_cast<const gr_complex *>(input_items[0]);  //PRN start block alignment
-                gr_complex sec_sign_Q;
-                gr_complex sec_sign_I;
-                // Secondary code Chip
-                if (d_secondary_lock)
-                    {
-                        sec_sign_Q = gr_complex((Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1].at(d_secondary_delay) == '0' ? -1 : 1), 0);
-                        sec_sign_I = gr_complex((Galileo_E5a_I_SECONDARY_CODE.at(d_secondary_delay % Galileo_E5a_I_SECONDARY_CODE_LENGTH) == '0' ? -1 : 1), 0);
-                    }
-                else
-                    {
-                        sec_sign_Q = gr_complex(1.0, 0.0);
-                        sec_sign_I = gr_complex(1.0, 0.0);
-                    }
-                // Reset integration counter
-                if (d_integration_counter == d_current_ti_ms)
-                    {
-                        d_integration_counter = 0;
-                    }
-                //Generate local code and carrier replicas (using \hat{f}_d(k-1))
-                if (d_integration_counter == 0)
-                    {
-                        // Reset accumulated values
-                        d_Early = gr_complex(0, 0);
-                        d_Prompt = gr_complex(0, 0);
-                        d_Late = gr_complex(0, 0);
-                    }
-
-                // perform carrier wipe-off and compute Early, Prompt and Late
-                // correlation of 1 primary code
-
-                multicorrelator_cpu_Q.set_local_code_and_taps(Galileo_E5a_CODE_LENGTH_CHIPS, d_codeQ, d_local_code_shift_chips);
-                multicorrelator_cpu_I.set_local_code_and_taps(Galileo_E5a_CODE_LENGTH_CHIPS, d_codeI, &d_local_code_shift_chips[1]);
-
-                // ################# CARRIER WIPEOFF AND CORRELATORS ##############################
-                // perform carrier wipe-off and compute Early, Prompt and Late correlation
-                multicorrelator_cpu_Q.set_input_output_vectors(d_correlator_outs, in);
-                multicorrelator_cpu_I.set_input_output_vectors(d_Single_Prompt_data, in);
-
-                double carr_phase_step_rad = GALILEO_TWO_PI * d_carrier_doppler_hz / static_cast<double>(d_fs_in);
-                double code_phase_step_chips = d_code_freq_chips / (static_cast<double>(d_fs_in));
-                double rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / d_fs_in);
-                multicorrelator_cpu_Q.Carrier_wipeoff_multicorrelator_resampler(
-                    d_rem_carr_phase_rad,
-                    carr_phase_step_rad,
-                    rem_code_phase_chips,
-                    code_phase_step_chips,
-                    d_current_prn_length_samples);
-
-                multicorrelator_cpu_I.Carrier_wipeoff_multicorrelator_resampler(
-                    d_rem_carr_phase_rad,
-                    carr_phase_step_rad,
-                    rem_code_phase_chips,
-                    code_phase_step_chips,
-                    d_current_prn_length_samples);
-
-                // Accumulate results (coherent integration since there are no bit transitions in pilot signal)
-                d_Early += (*d_Single_Early) * sec_sign_Q;
-                d_Prompt += (*d_Single_Prompt) * sec_sign_Q;
-                d_Late += (*d_Single_Late) * sec_sign_Q;
-                d_Prompt_data = (*d_Single_Prompt_data);
-                d_Prompt_data *= sec_sign_I;
-                d_integration_counter++;
-
-                // ################## PLL ##########################################################
-                // PLL discriminator
-                if (d_integration_counter == d_current_ti_ms)
-                    {
-                        if (d_secondary_lock == true)
-                            {
-                                carr_error_hz = pll_four_quadrant_atan(d_Prompt) / GALILEO_PI * 2.0;
-                            }
-                        else
-                            {
-                                carr_error_hz = pll_cloop_two_quadrant_atan(d_Prompt) / GALILEO_PI * 2.0;
-                            }
-
-                        // Carrier discriminator filter
-                        carr_error_filt_hz = d_carrier_loop_filter.get_carrier_nco(carr_error_hz);
-                        // New carrier Doppler frequency estimation
-                        d_carrier_doppler_hz = d_acq_carrier_doppler_hz + carr_error_filt_hz;
-                        // New code Doppler frequency estimation
-                        d_code_freq_chips = Galileo_E5a_CODE_CHIP_RATE_HZ + ((d_carrier_doppler_hz * Galileo_E5a_CODE_CHIP_RATE_HZ) / Galileo_E5a_FREQ_HZ);
-                    }
-                // carrier phase accumulator for (K) doppler estimation
-                d_acc_carrier_phase_rad -= 2.0 * GALILEO_PI * d_carrier_doppler_hz * GALILEO_E5a_CODE_PERIOD;
-                // remnant carrier phase to prevent overflow in the code NCO
-                d_rem_carr_phase_rad = d_rem_carr_phase_rad + 2.0 * GALILEO_PI * d_carrier_doppler_hz * GALILEO_E5a_CODE_PERIOD;
-                d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, 2.0 * GALILEO_PI);
-
-                // ################## DLL ##########################################################
-                if (d_integration_counter == d_current_ti_ms)
-                    {
-                        // DLL discriminator
-                        code_error_chips = dll_nc_e_minus_l_normalized(d_Early, d_Late);  //[chips/Ti]
-                        // Code discriminator filter
-                        code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips);  //[chips/second]
-                        //Code phase accumulator
-                        d_code_error_filt_secs = (GALILEO_E5a_CODE_PERIOD * code_error_filt_chips) / Galileo_E5a_CODE_CHIP_RATE_HZ;  //[seconds]
-                    }
-                d_acc_code_phase_secs = d_acc_code_phase_secs + d_code_error_filt_secs;
-
-                // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT #######################
-                // keep alignment parameters for the next input buffer
-                double T_chip_seconds;
-                double T_prn_seconds;
-                double T_prn_samples;
-                double K_blk_samples;
-                // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation
-                T_chip_seconds = 1.0 / d_code_freq_chips;
-                T_prn_seconds = T_chip_seconds * Galileo_E5a_CODE_LENGTH_CHIPS;
-                T_prn_samples = T_prn_seconds * static_cast<double>(d_fs_in);
-                K_blk_samples = T_prn_samples + d_rem_code_phase_samples + d_code_error_filt_secs * static_cast<double>(d_fs_in);
-                d_current_prn_length_samples = round(K_blk_samples);                      //round to a discrete samples
-                d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples;  //rounding error < 1 sample
-
-                // ####### CN0 ESTIMATION AND LOCK DETECTORS ######
-                if (d_cn0_estimation_counter < FLAGS_cn0_samples - 1)
-                    {
-                        // fill buffer with prompt correlator output values
-                        d_Prompt_buffer[d_cn0_estimation_counter] = d_Prompt;
-                        d_cn0_estimation_counter++;
-                    }
-                else
-                    {
-                        d_Prompt_buffer[d_cn0_estimation_counter] = d_Prompt;
-                        // ATTEMPT SECONDARY CODE ACQUISITION
-                        if (d_secondary_lock == false)
-                            {
-                                acquire_secondary();  // changes d_secondary_lock and d_secondary_delay
-                                if (d_secondary_lock == true)
-                                    {
-                                        std::cout << "Galileo E5a secondary code locked for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl;
-                                        d_current_ti_ms = d_ti_ms;
-                                        // Change loop parameters ==========================================
-                                        d_code_loop_filter.set_pdi(d_current_ti_ms * GALILEO_E5a_CODE_PERIOD);
-                                        d_carrier_loop_filter.set_pdi(d_current_ti_ms * GALILEO_E5a_CODE_PERIOD);
-                                        d_code_loop_filter.set_DLL_BW(d_dll_bw_narrow_hz);
-                                        d_carrier_loop_filter.set_PLL_BW(d_pll_bw_narrow_hz);
-                                    }
-                                else
-                                    {
-                                        //std::cout << "Secondary code delay couldn't be resolved." << std::endl;
-                                        d_carrier_lock_fail_counter++;
-                                        if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail)
-                                            {
-                                                std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl;
-                                                LOG(INFO) << "Loss of lock in channel " << d_channel << "!";
-                                                this->message_port_pub(pmt::mp("events"), pmt::from_long(3));  //3 -> loss of lock
-                                                d_carrier_lock_fail_counter = 0;
-                                                d_state = 0;  // TODO: check if disabling tracking is consistent with the channel state machine
-                                            }
-                                    }
-                            }
-                        else  // Secondary lock achieved, monitor carrier lock.
-                            {
-                                // Code lock indicator
-                                d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, static_cast<unsigned int>(FLAGS_cn0_samples), d_fs_in, d_current_ti_ms * Galileo_E5a_CODE_LENGTH_CHIPS);
-                                // Carrier lock indicator
-                                d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, static_cast<unsigned int>(FLAGS_cn0_samples));
-                                // Loss of lock detection
-                                if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < FLAGS_cn0_min)
-                                    {
-                                        d_carrier_lock_fail_counter++;
-                                    }
-                                else
-                                    {
-                                        if (d_carrier_lock_fail_counter > 0) d_carrier_lock_fail_counter--;
-
-                                        if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail)
-                                            {
-                                                std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl;
-                                                LOG(INFO) << "Loss of lock in channel " << d_channel << "!";
-                                                this->message_port_pub(pmt::mp("events"), pmt::from_long(3));  //3 -> loss of lock
-                                                d_carrier_lock_fail_counter = 0;
-                                                d_state = 0;
-                                            }
-                                    }
-                            }
-                        d_cn0_estimation_counter = 0;
-                    }
-                if (d_secondary_lock && (d_secondary_delay % Galileo_E5a_I_SECONDARY_CODE_LENGTH) == 0)
-                    {
-                        d_first_transition = true;
-                    }
-                // ########### Output the tracking data to navigation and PVT ##########
-                // The first Prompt output not equal to 0 is synchronized with the transition of a navigation data bit.
-                if (d_secondary_lock && d_first_transition)
-                    {
-                        current_synchro_data.Prompt_I = static_cast<double>(d_Prompt_data.real());
-                        current_synchro_data.Prompt_Q = static_cast<double>(d_Prompt_data.imag());
-                        current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples;
-                        current_synchro_data.Code_phase_samples = d_rem_code_phase_samples;
-                        current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad;
-                        current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
-                        current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
-                        current_synchro_data.Flag_valid_symbol_output = true;
-                    }
-                else
-                    {
-                        // make an output to not stop the rest of the processing blocks
-                        current_synchro_data.Prompt_I = 0.0;
-                        current_synchro_data.Prompt_Q = 0.0;
-                        current_synchro_data.Tracking_sample_counter = d_sample_counter;
-                        current_synchro_data.Carrier_phase_rads = 0.0;
-                        current_synchro_data.CN0_dB_hz = 0.0;
-                        current_synchro_data.Flag_valid_symbol_output = false;
-                    }
-
-                break;
-            }
-        }
-
-    current_synchro_data.fs = d_fs_in;
-    current_synchro_data.correlation_length_ms = GALILEO_E5a_CODE_PERIOD_MS;
-    if (current_synchro_data.Flag_valid_symbol_output)
-        {
-            *out[0] = current_synchro_data;
-        }
-
-    if (d_dump)
-        {
-            // MULTIPLEXED FILE RECORDING - Record results to file
-            float prompt_I;
-            float prompt_Q;
-            double tmp_double;
-            prompt_I = (d_Prompt_data).real();
-            prompt_Q = (d_Prompt_data).imag();
-            if (d_integration_counter == d_current_ti_ms)
-                {
-                    tmp_E = std::abs<float>(d_Early);
-                    tmp_P = std::abs<float>(d_Prompt);
-                    tmp_L = std::abs<float>(d_Late);
-                }
-            try
-                {
-                    // EPR
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_E), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_P), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_L), sizeof(float));
-                    // PROMPT I and Q (to analyze navigation symbols)
-                    d_dump_file.write(reinterpret_cast<char *>(&prompt_I), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&prompt_Q), sizeof(float));
-                    // PRN start sample stamp
-                    //tmp_float=(float)d_sample_counter;
-                    d_dump_file.write(reinterpret_cast<char *>(&d_sample_counter), sizeof(unsigned long int));
-                    // accumulated carrier phase
-                    d_dump_file.write(reinterpret_cast<char *>(&d_acc_carrier_phase_rad), sizeof(double));
-
-                    // carrier and code frequency
-                    d_dump_file.write(reinterpret_cast<char *>(&d_carrier_doppler_hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&d_code_freq_chips), sizeof(double));
-
-                    //PLL commands
-                    d_dump_file.write(reinterpret_cast<char *>(&carr_error_hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&carr_error_filt_hz), sizeof(double));
-
-                    //DLL commands
-                    d_dump_file.write(reinterpret_cast<char *>(&code_error_chips), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&code_error_filt_chips), sizeof(double));
-
-                    // CN0 and carrier lock test
-                    d_dump_file.write(reinterpret_cast<char *>(&d_CN0_SNV_dB_Hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&d_carrier_lock_test), sizeof(double));
-
-                    // AUX vars (for debug purposes)
-                    tmp_double = d_rem_code_phase_samples;
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
-                    tmp_double = static_cast<double>(d_sample_counter + d_current_prn_length_samples);
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
-
-                    // PRN
-                    unsigned int prn_ = d_acquisition_gnss_synchro->PRN;
-                    d_dump_file.write(reinterpret_cast<char *>(&prn_), sizeof(unsigned int));
-                }
-            catch (const std::ifstream::failure &e)
-                {
-                    LOG(WARNING) << "Exception writing trk dump file " << e.what();
-                }
-        }
-
-    d_secondary_delay = (d_secondary_delay + 1) % Galileo_E5a_Q_SECONDARY_CODE_LENGTH;
-    d_sample_counter += d_current_prn_length_samples;
-    consume_each(d_current_prn_length_samples);
-
-    if (current_synchro_data.Flag_valid_symbol_output)
-        {
-            return 1;
-        }
-    else
-        {
-            return 0;
-        }
-}
-
-
-void Galileo_E5a_Dll_Pll_Tracking_cc::set_channel(unsigned int channel)
-{
-    d_channel = channel;
-    LOG(INFO) << "Tracking Channel set to " << d_channel;
-    // ############# ENABLE DATA FILE LOG #################
-    if (d_dump == true)
-        {
-            if (d_dump_file.is_open() == false)
-                {
-                    try
-                        {
-                            d_dump_filename.append(boost::lexical_cast<std::string>(d_channel));
-                            d_dump_filename.append(".dat");
-                            d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-                            d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
-                            LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str();
-                        }
-                    catch (const std::ifstream::failure &e)
-                        {
-                            LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what();
-                        }
-                }
-        }
-}
-
-
-int Galileo_E5a_Dll_Pll_Tracking_cc::save_matfile()
-{
-    // READ DUMP FILE
-    std::ifstream::pos_type size;
-    int number_of_double_vars = 11;
-    int number_of_float_vars = 5;
-    int epoch_size_bytes = sizeof(unsigned long int) + sizeof(double) * number_of_double_vars +
-                           sizeof(float) * number_of_float_vars + sizeof(unsigned int);
-    std::ifstream dump_file;
-    dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-    try
-        {
-            dump_file.open(d_dump_filename.c_str(), std::ios::binary | std::ios::ate);
-        }
-    catch (const std::ifstream::failure &e)
-        {
-            std::cerr << "Problem opening dump file:" << e.what() << std::endl;
-            return 1;
-        }
-    // count number of epochs and rewind
-    long int num_epoch = 0;
-    if (dump_file.is_open())
-        {
-            size = dump_file.tellg();
-            num_epoch = static_cast<long int>(size) / static_cast<long int>(epoch_size_bytes);
-            dump_file.seekg(0, std::ios::beg);
-        }
-    else
-        {
-            return 1;
-        }
-    float *abs_E = new float[num_epoch];
-    float *abs_P = new float[num_epoch];
-    float *abs_L = new float[num_epoch];
-    float *Prompt_I = new float[num_epoch];
-    float *Prompt_Q = new float[num_epoch];
-    unsigned long int *PRN_start_sample_count = new unsigned long int[num_epoch];
-    double *acc_carrier_phase_rad = new double[num_epoch];
-    double *carrier_doppler_hz = new double[num_epoch];
-    double *code_freq_chips = new double[num_epoch];
-    double *carr_error_hz = new double[num_epoch];
-    double *carr_error_filt_hz = new double[num_epoch];
-    double *code_error_chips = new double[num_epoch];
-    double *code_error_filt_chips = new double[num_epoch];
-    double *CN0_SNV_dB_Hz = new double[num_epoch];
-    double *carrier_lock_test = new double[num_epoch];
-    double *aux1 = new double[num_epoch];
-    double *aux2 = new double[num_epoch];
-    unsigned int *PRN = new unsigned int[num_epoch];
-
-    try
-        {
-            if (dump_file.is_open())
-                {
-                    for (long int i = 0; i < num_epoch; i++)
-                        {
-                            dump_file.read(reinterpret_cast<char *>(&abs_E[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&abs_P[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&abs_L[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&Prompt_I[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&Prompt_Q[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&PRN_start_sample_count[i]), sizeof(unsigned long int));
-                            dump_file.read(reinterpret_cast<char *>(&acc_carrier_phase_rad[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carrier_doppler_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_freq_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carr_error_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carr_error_filt_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_error_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_error_filt_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&CN0_SNV_dB_Hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carrier_lock_test[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&aux1[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&aux2[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&PRN[i]), sizeof(unsigned int));
-                        }
-                }
-            dump_file.close();
-        }
-    catch (const std::ifstream::failure &e)
-        {
-            std::cerr << "Problem reading dump file:" << e.what() << std::endl;
-            delete[] abs_E;
-            delete[] abs_P;
-            delete[] abs_L;
-            delete[] Prompt_I;
-            delete[] Prompt_Q;
-            delete[] PRN_start_sample_count;
-            delete[] acc_carrier_phase_rad;
-            delete[] carrier_doppler_hz;
-            delete[] code_freq_chips;
-            delete[] carr_error_hz;
-            delete[] carr_error_filt_hz;
-            delete[] code_error_chips;
-            delete[] code_error_filt_chips;
-            delete[] CN0_SNV_dB_Hz;
-            delete[] carrier_lock_test;
-            delete[] aux1;
-            delete[] aux2;
-            delete[] PRN;
-            return 1;
-        }
-
-    // WRITE MAT FILE
-    mat_t *matfp;
-    matvar_t *matvar;
-    std::string filename = d_dump_filename;
-    filename.erase(filename.length() - 4, 4);
-    filename.append(".mat");
-    matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73);
-    if (reinterpret_cast<long *>(matfp) != NULL)
-        {
-            size_t dims[2] = {1, static_cast<size_t>(num_epoch)};
-            matvar = Mat_VarCreate("abs_E", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("abs_P", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_P, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("abs_L", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_L, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("Prompt_I", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_I, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("Prompt_Q", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_Q, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("PRN_start_sample_count", MAT_C_UINT64, MAT_T_UINT64, 2, dims, PRN_start_sample_count, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("acc_carrier_phase_rad", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, acc_carrier_phase_rad, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carrier_doppler_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_doppler_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_freq_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_freq_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carr_error_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carr_error_filt_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_filt_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_error_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_error_filt_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_filt_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("CN0_SNV_dB_Hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, CN0_SNV_dB_Hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carrier_lock_test", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_lock_test, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("aux1", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux1, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("aux2", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux2, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("PRN", MAT_C_UINT32, MAT_T_UINT32, 2, dims, PRN, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-        }
-    Mat_Close(matfp);
-    delete[] abs_E;
-    delete[] abs_P;
-    delete[] abs_L;
-    delete[] Prompt_I;
-    delete[] Prompt_Q;
-    delete[] PRN_start_sample_count;
-    delete[] acc_carrier_phase_rad;
-    delete[] carrier_doppler_hz;
-    delete[] code_freq_chips;
-    delete[] carr_error_hz;
-    delete[] carr_error_filt_hz;
-    delete[] code_error_chips;
-    delete[] code_error_filt_chips;
-    delete[] CN0_SNV_dB_Hz;
-    delete[] carrier_lock_test;
-    delete[] aux1;
-    delete[] aux2;
-    delete[] PRN;
-    return 0;
-}
-
-
-void Galileo_E5a_Dll_Pll_Tracking_cc::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro)
-{
-    d_acquisition_gnss_synchro = p_gnss_synchro;
-}

src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.h

@@ -1,207 +0,0 @@
-/*!
- * \file galileo_e5a_dll_pll_tracking_cc.h
- * \brief Implementation of a code DLL + carrier PLL
- *  tracking block for Galileo E5a signals
- * \author Marc Sales, 2014. marcsales92(at)gmail.com
- * \based on work from:
- *          <ul>
- *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
- *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
- *          </ul>
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#ifndef GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_CC_H_
-#define GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_CC_H_
-
-#include "gnss_synchro.h"
-#include "tracking_2nd_DLL_filter.h"
-#include "tracking_2nd_PLL_filter.h"
-#include "cpu_multicorrelator.h"
-#include <gnuradio/block.h>
-#include <fstream>
-#include <map>
-#include <string>
-
-class Galileo_E5a_Dll_Pll_Tracking_cc;
-
-typedef boost::shared_ptr<Galileo_E5a_Dll_Pll_Tracking_cc>
-    galileo_e5a_dll_pll_tracking_cc_sptr;
-
-galileo_e5a_dll_pll_tracking_cc_sptr
-galileo_e5a_dll_pll_make_tracking_cc(long if_freq,
-    long fs_in, unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float pll_bw_narrow_narrowhz,
-    float dll_bw_narrow_hz,
-    int ti_ms,
-    float early_late_space_chips);
-
-
-/*!
- * \brief This class implements a DLL + PLL tracking loop block
- */
-class Galileo_E5a_Dll_Pll_Tracking_cc : public gr::block
-{
-public:
-    ~Galileo_E5a_Dll_Pll_Tracking_cc();
-
-    void set_channel(unsigned int channel);
-    void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro);
-    void start_tracking();
-
-    int general_work(int noutput_items, gr_vector_int& ninput_items,
-        gr_vector_const_void_star& input_items, gr_vector_void_star& output_items);
-
-    void forecast(int noutput_items, gr_vector_int& ninput_items_required);
-
-private:
-    friend galileo_e5a_dll_pll_tracking_cc_sptr
-    galileo_e5a_dll_pll_make_tracking_cc(long if_freq,
-        long fs_in, unsigned int vector_length,
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float pll_bw_narrow_hz,
-        float dll_bw_narrow_hz,
-        int ti_ms,
-        float early_late_space_chips);
-
-    Galileo_E5a_Dll_Pll_Tracking_cc(long if_freq,
-        long fs_in, unsigned int vector_length,
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float pll_bw_narrow_hz,
-        float dll_bw_narrow_hz,
-        int ti_ms,
-        float early_late_space_chips);
-    void acquire_secondary();
-    // tracking configuration vars
-    unsigned int d_vector_length;
-    int d_current_ti_ms;
-    int d_ti_ms;
-    bool d_dump;
-
-
-    Gnss_Synchro* d_acquisition_gnss_synchro;
-    unsigned int d_channel;
-    long d_if_freq;
-    long d_fs_in;
-
-    double d_early_late_spc_chips;
-    double d_dll_bw_hz;
-    double d_pll_bw_hz;
-    double d_dll_bw_narrow_hz;
-    double d_pll_bw_narrow_hz;
-
-    gr_complex* d_codeQ;
-    gr_complex* d_codeI;
-
-    gr_complex d_Early;
-    gr_complex d_Prompt;
-    gr_complex d_Late;
-    gr_complex d_Prompt_data;
-
-    gr_complex* d_Single_Early;
-    gr_complex* d_Single_Prompt;
-    gr_complex* d_Single_Late;
-    gr_complex* d_Single_Prompt_data;
-
-
-    float tmp_E;
-    float tmp_P;
-    float tmp_L;
-    // remaining code phase and carrier phase between tracking loops
-    double d_rem_code_phase_samples;
-    double d_rem_code_phase_chips;
-    double d_rem_carr_phase_rad;
-
-    // PLL and DLL filter library
-    Tracking_2nd_DLL_filter d_code_loop_filter;
-    Tracking_2nd_PLL_filter d_carrier_loop_filter;
-
-    // acquisition
-    double d_acq_code_phase_samples;
-    double d_acq_carrier_doppler_hz;
-    // correlator
-    int d_n_correlator_taps;
-    float* d_local_code_shift_chips;
-    gr_complex* d_correlator_outs;
-    cpu_multicorrelator multicorrelator_cpu_I;
-    cpu_multicorrelator multicorrelator_cpu_Q;
-
-    // tracking vars
-    double d_code_freq_chips;
-    double d_carrier_doppler_hz;
-    double d_acc_carrier_phase_rad;
-    double d_code_phase_samples;
-    double d_acc_code_phase_secs;
-    double d_code_error_filt_secs;
-    double d_code_phase_step_chips;
-    double d_carrier_phase_step_rad;
-
-
-    //PRN period in samples
-    int d_current_prn_length_samples;
-
-    //processing samples counters
-    unsigned long int d_sample_counter;
-    unsigned long int d_acq_sample_stamp;
-
-    // CN0 estimation and lock detector
-    int d_cn0_estimation_counter;
-    gr_complex* d_Prompt_buffer;
-    double d_carrier_lock_test;
-    double d_CN0_SNV_dB_Hz;
-    double d_carrier_lock_threshold;
-    int d_carrier_lock_fail_counter;
-
-    // control vars
-    int d_state;
-    bool d_first_transition;
-
-    // Secondary code acquisition
-    bool d_secondary_lock;
-    int d_secondary_delay;
-    int d_integration_counter;
-
-    // file dump
-    std::string d_dump_filename;
-    std::ofstream d_dump_file;
-
-    std::map<std::string, std::string> systemName;
-    std::string sys;
-
-    int save_matfile();
-};
-
-#endif /* GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_CC_H_ */

src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc

@@ -1,761 +0,0 @@
-/*!
- * \file gps_l2_m_dll_pll_tracking_cc.cc
- * \brief Implementation of a code DLL + carrier PLL tracking block for GPS L2C
- * \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com
- *         Javier Arribas, 2011. jarribas(at)cttc.es
- *
- * Code DLL + carrier PLL according to the algorithms described in:
- * [1] K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen,
- * A Software-Defined GPS and Galileo Receiver. A Single-Frequency
- * Approach, Birkhauser, 2007
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#include "gps_l2_m_dll_pll_tracking_cc.h"
-#include "gps_l2c_signal.h"
-#include "tracking_discriminators.h"
-#include "lock_detectors.h"
-#include "GPS_L2C.h"
-#include "control_message_factory.h"
-#include "gnss_sdr_flags.h"
-#include <boost/lexical_cast.hpp>
-#include <gnuradio/io_signature.h>
-#include <glog/logging.h>
-#include <matio.h>
-#include <volk_gnsssdr/volk_gnsssdr.h>
-#include <cmath>
-#include <iostream>
-#include <memory>
-#include <sstream>
-
-using google::LogMessage;
-
-gps_l2_m_dll_pll_tracking_cc_sptr
-gps_l2_m_dll_pll_make_tracking_cc(
-    long if_freq,
-    long fs_in,
-    unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float early_late_space_chips)
-{
-    return gps_l2_m_dll_pll_tracking_cc_sptr(new gps_l2_m_dll_pll_tracking_cc(if_freq,
-        fs_in, vector_length, dump, dump_filename, pll_bw_hz, dll_bw_hz, early_late_space_chips));
-}
-
-
-void gps_l2_m_dll_pll_tracking_cc::forecast(int noutput_items,
-    gr_vector_int &ninput_items_required)
-{
-    if (noutput_items != 0)
-        {
-            ninput_items_required[0] = static_cast<int>(d_vector_length) * 2;  //set the required available samples in each call
-        }
-}
-
-
-gps_l2_m_dll_pll_tracking_cc::gps_l2_m_dll_pll_tracking_cc(
-    long if_freq,
-    long fs_in,
-    unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float early_late_space_chips) : gr::block("gps_l2_m_dll_pll_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
-                                        gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
-{
-    // Telemetry bit synchronization message port input
-    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
-    this->message_port_register_out(pmt::mp("events"));
-    // initialize internal vars
-    d_dump = dump;
-    d_if_freq = if_freq;
-    d_fs_in = fs_in;
-    d_vector_length = vector_length;
-    d_dump_filename = dump_filename;
-
-    d_current_prn_length_samples = static_cast<int>(d_vector_length);
-
-    // DLL/PLL filter initialization
-    d_carrier_loop_filter = Tracking_2nd_PLL_filter(GPS_L2_M_PERIOD);
-    d_code_loop_filter = Tracking_2nd_DLL_filter(GPS_L2_M_PERIOD);
-
-    // Initialize tracking  ==========================================
-    d_code_loop_filter.set_DLL_BW(dll_bw_hz);
-    d_carrier_loop_filter.set_PLL_BW(pll_bw_hz);
-
-    //--- DLL variables --------------------------------------------------------
-    d_early_late_spc_chips = early_late_space_chips;  // Define early-late offset (in chips)
-
-    // Initialization of local code replica
-    // Get space for a vector with the C/A code replica sampled 1x/chip
-    d_ca_code = static_cast<gr_complex *>(volk_gnsssdr_malloc(static_cast<int>(GPS_L2_M_CODE_LENGTH_CHIPS) * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-
-    // correlator outputs (scalar)
-    d_n_correlator_taps = 3;  // Early, Prompt, and Late
-    d_correlator_outs = static_cast<gr_complex *>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-    for (int n = 0; n < d_n_correlator_taps; n++)
-        {
-            d_correlator_outs[n] = gr_complex(0, 0);
-        }
-    d_local_code_shift_chips = static_cast<float *>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment()));
-    // Set TAPs delay values [chips]
-    d_local_code_shift_chips[0] = -d_early_late_spc_chips;
-    d_local_code_shift_chips[1] = 0.0;
-    d_local_code_shift_chips[2] = d_early_late_spc_chips;
-
-    multicorrelator_cpu.init(2 * d_current_prn_length_samples, d_n_correlator_taps);
-
-    //--- Perform initializations ------------------------------
-    // define initial code frequency basis of NCO
-    d_code_freq_chips = GPS_L2_M_CODE_RATE_HZ;
-    // define residual code phase (in chips)
-    d_rem_code_phase_samples = 0.0;
-    // define residual carrier phase
-    d_rem_carr_phase_rad = 0.0;
-
-    // sample synchronization
-    d_sample_counter = 0;
-    //d_sample_counter_seconds = 0;
-    d_acq_sample_stamp = 0;
-
-    d_enable_tracking = false;
-    d_pull_in = false;
-
-    // CN0 estimation and lock detector buffers
-    d_cn0_estimation_counter = 0;
-    d_Prompt_buffer = new gr_complex[FLAGS_cn0_samples];
-    d_carrier_lock_test = 1;
-    d_CN0_SNV_dB_Hz = 0;
-    d_carrier_lock_fail_counter = 0;
-    d_carrier_lock_threshold = FLAGS_carrier_lock_th;
-
-    systemName["G"] = std::string("GPS");
-
-    //set_min_output_buffer((long int)300);
-
-    d_acquisition_gnss_synchro = 0;
-    d_channel = 0;
-    d_acq_code_phase_samples = 0.0;
-    d_acq_carrier_doppler_hz = 0.0;
-    d_carrier_doppler_hz = 0.0;
-    d_acc_carrier_phase_rad = 0.0;
-    d_code_phase_samples = 0.0;
-
-    d_rem_code_phase_chips = 0.0;
-    d_code_phase_step_chips = 0.0;
-    d_carrier_phase_step_rad = 0.0;
-
-    set_relative_rate(1.0 / static_cast<double>(d_vector_length));
-}
-
-
-void gps_l2_m_dll_pll_tracking_cc::start_tracking()
-{
-    /*
-     *  correct the code phase according to the delay between acq and trk
-     */
-    d_acq_code_phase_samples = d_acquisition_gnss_synchro->Acq_delay_samples;
-    d_acq_carrier_doppler_hz = d_acquisition_gnss_synchro->Acq_doppler_hz;
-    d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples;
-
-    long int acq_trk_diff_samples;
-    double acq_trk_diff_seconds;
-    acq_trk_diff_samples = static_cast<long int>(d_sample_counter) - static_cast<long int>(d_acq_sample_stamp);  //-d_vector_length;
-    DLOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples;
-    acq_trk_diff_seconds = static_cast<float>(acq_trk_diff_samples) / static_cast<float>(d_fs_in);
-    // Doppler effect
-    // Fd=(C/(C+Vr))*F
-    double radial_velocity = (GPS_L2_FREQ_HZ + d_acq_carrier_doppler_hz) / GPS_L2_FREQ_HZ;
-    // new chip and prn sequence periods based on acq Doppler
-    double T_chip_mod_seconds;
-    double T_prn_mod_seconds;
-    double T_prn_mod_samples;
-    d_code_freq_chips = radial_velocity * GPS_L2_M_CODE_RATE_HZ;
-    d_code_phase_step_chips = static_cast<double>(d_code_freq_chips) / static_cast<double>(d_fs_in);
-    T_chip_mod_seconds = 1 / d_code_freq_chips;
-    T_prn_mod_seconds = T_chip_mod_seconds * GPS_L2_M_CODE_LENGTH_CHIPS;
-    T_prn_mod_samples = T_prn_mod_seconds * static_cast<double>(d_fs_in);
-
-    d_current_prn_length_samples = round(T_prn_mod_samples);
-
-    double T_prn_true_seconds = GPS_L2_M_CODE_LENGTH_CHIPS / GPS_L2_M_CODE_RATE_HZ;
-    double T_prn_true_samples = T_prn_true_seconds * static_cast<double>(d_fs_in);
-    double T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds;
-    double N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds;
-    double corrected_acq_phase_samples, delay_correction_samples;
-    corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * static_cast<double>(d_fs_in)), T_prn_true_samples);
-    if (corrected_acq_phase_samples < 0)
-        {
-            corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples;
-        }
-    delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples;
-
-    d_acq_code_phase_samples = corrected_acq_phase_samples;
-
-    d_carrier_doppler_hz = d_acq_carrier_doppler_hz;
-    d_carrier_phase_step_rad = GPS_L2_TWO_PI * d_carrier_doppler_hz / static_cast<double>(d_fs_in);
-
-    // DLL/PLL filter initialization
-    d_carrier_loop_filter.initialize();  // initialize the carrier filter
-    d_code_loop_filter.initialize();     // initialize the code filter
-
-    // generate local reference ALWAYS starting at chip 1 (1 sample per chip)
-    gps_l2c_m_code_gen_complex(d_ca_code, d_acquisition_gnss_synchro->PRN);
-
-    multicorrelator_cpu.set_local_code_and_taps(static_cast<int>(GPS_L2_M_CODE_LENGTH_CHIPS), d_ca_code, d_local_code_shift_chips);
-    for (int n = 0; n < d_n_correlator_taps; n++)
-        {
-            d_correlator_outs[n] = gr_complex(0, 0);
-        }
-
-    d_carrier_lock_fail_counter = 0;
-    d_rem_code_phase_samples = 0;
-    d_rem_carr_phase_rad = 0.0;
-    d_rem_code_phase_chips = 0.0;
-    d_acc_carrier_phase_rad = 0.0;
-
-    d_code_phase_samples = d_acq_code_phase_samples;
-
-    std::string sys_ = &d_acquisition_gnss_synchro->System;
-    sys = sys_.substr(0, 1);
-
-    // DEBUG OUTPUT
-    std::cout << "Tracking of GPS L2CM signal started on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl;
-    LOG(INFO) << "Starting GPS L2CM tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel;
-
-    // enable tracking
-    d_pull_in = true;
-    d_enable_tracking = true;
-
-    LOG(INFO) << "GPS L2CM PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz
-              << " Code Phase correction [samples]=" << delay_correction_samples
-              << " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
-}
-
-
-int gps_l2_m_dll_pll_tracking_cc::save_matfile()
-{
-    // READ DUMP FILE
-    std::ifstream::pos_type size;
-    int number_of_double_vars = 11;
-    int number_of_float_vars = 5;
-    int epoch_size_bytes = sizeof(unsigned long int) + sizeof(double) * number_of_double_vars +
-                           sizeof(float) * number_of_float_vars + sizeof(unsigned int);
-    std::ifstream dump_file;
-    dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-    try
-        {
-            dump_file.open(d_dump_filename.c_str(), std::ios::binary | std::ios::ate);
-        }
-    catch (const std::ifstream::failure &e)
-        {
-            std::cerr << "Problem opening dump file:" << e.what() << std::endl;
-            return 1;
-        }
-    // count number of epochs and rewind
-    long int num_epoch = 0;
-    if (dump_file.is_open())
-        {
-            size = dump_file.tellg();
-            num_epoch = static_cast<long int>(size) / static_cast<long int>(epoch_size_bytes);
-            dump_file.seekg(0, std::ios::beg);
-        }
-    else
-        {
-            return 1;
-        }
-    float *abs_E = new float[num_epoch];
-    float *abs_P = new float[num_epoch];
-    float *abs_L = new float[num_epoch];
-    float *Prompt_I = new float[num_epoch];
-    float *Prompt_Q = new float[num_epoch];
-    unsigned long int *PRN_start_sample_count = new unsigned long int[num_epoch];
-    double *acc_carrier_phase_rad = new double[num_epoch];
-    double *carrier_doppler_hz = new double[num_epoch];
-    double *code_freq_chips = new double[num_epoch];
-    double *carr_error_hz = new double[num_epoch];
-    double *carr_error_filt_hz = new double[num_epoch];
-    double *code_error_chips = new double[num_epoch];
-    double *code_error_filt_chips = new double[num_epoch];
-    double *CN0_SNV_dB_Hz = new double[num_epoch];
-    double *carrier_lock_test = new double[num_epoch];
-    double *aux1 = new double[num_epoch];
-    double *aux2 = new double[num_epoch];
-    unsigned int *PRN = new unsigned int[num_epoch];
-
-    try
-        {
-            if (dump_file.is_open())
-                {
-                    for (long int i = 0; i < num_epoch; i++)
-                        {
-                            dump_file.read(reinterpret_cast<char *>(&abs_E[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&abs_P[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&abs_L[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&Prompt_I[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&Prompt_Q[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&PRN_start_sample_count[i]), sizeof(unsigned long int));
-                            dump_file.read(reinterpret_cast<char *>(&acc_carrier_phase_rad[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carrier_doppler_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_freq_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carr_error_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carr_error_filt_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_error_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_error_filt_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&CN0_SNV_dB_Hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carrier_lock_test[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&aux1[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&aux2[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&PRN[i]), sizeof(unsigned int));
-                        }
-                }
-            dump_file.close();
-        }
-    catch (const std::ifstream::failure &e)
-        {
-            std::cerr << "Problem reading dump file:" << e.what() << std::endl;
-            delete[] abs_E;
-            delete[] abs_P;
-            delete[] abs_L;
-            delete[] Prompt_I;
-            delete[] Prompt_Q;
-            delete[] PRN_start_sample_count;
-            delete[] acc_carrier_phase_rad;
-            delete[] carrier_doppler_hz;
-            delete[] code_freq_chips;
-            delete[] carr_error_hz;
-            delete[] carr_error_filt_hz;
-            delete[] code_error_chips;
-            delete[] code_error_filt_chips;
-            delete[] CN0_SNV_dB_Hz;
-            delete[] carrier_lock_test;
-            delete[] aux1;
-            delete[] aux2;
-            delete[] PRN;
-            return 1;
-        }
-
-    // WRITE MAT FILE
-    mat_t *matfp;
-    matvar_t *matvar;
-    std::string filename = d_dump_filename;
-    filename.erase(filename.length() - 4, 4);
-    filename.append(".mat");
-    matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73);
-    if (reinterpret_cast<long *>(matfp) != NULL)
-        {
-            size_t dims[2] = {1, static_cast<size_t>(num_epoch)};
-            matvar = Mat_VarCreate("abs_E", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("abs_P", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_P, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("abs_L", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_L, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("Prompt_I", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_I, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("Prompt_Q", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_Q, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("PRN_start_sample_count", MAT_C_UINT64, MAT_T_UINT64, 2, dims, PRN_start_sample_count, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("acc_carrier_phase_rad", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, acc_carrier_phase_rad, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carrier_doppler_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_doppler_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_freq_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_freq_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carr_error_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carr_error_filt_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_filt_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_error_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_error_filt_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_filt_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("CN0_SNV_dB_Hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, CN0_SNV_dB_Hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carrier_lock_test", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_lock_test, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("aux1", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux1, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("aux2", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux2, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("PRN", MAT_C_UINT32, MAT_T_UINT32, 2, dims, PRN, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-        }
-    Mat_Close(matfp);
-    delete[] abs_E;
-    delete[] abs_P;
-    delete[] abs_L;
-    delete[] Prompt_I;
-    delete[] Prompt_Q;
-    delete[] PRN_start_sample_count;
-    delete[] acc_carrier_phase_rad;
-    delete[] carrier_doppler_hz;
-    delete[] code_freq_chips;
-    delete[] carr_error_hz;
-    delete[] carr_error_filt_hz;
-    delete[] code_error_chips;
-    delete[] code_error_filt_chips;
-    delete[] CN0_SNV_dB_Hz;
-    delete[] carrier_lock_test;
-    delete[] aux1;
-    delete[] aux2;
-    delete[] PRN;
-    return 0;
-}
-
-
-gps_l2_m_dll_pll_tracking_cc::~gps_l2_m_dll_pll_tracking_cc()
-{
-    if (d_dump_file.is_open())
-        {
-            try
-                {
-                    d_dump_file.close();
-                }
-            catch (const std::exception &ex)
-                {
-                    LOG(WARNING) << "Exception in destructor " << ex.what();
-                }
-        }
-    if (d_dump)
-        {
-            if (d_channel == 0)
-                {
-                    std::cout << "Writing .mat files ...";
-                }
-            gps_l2_m_dll_pll_tracking_cc::save_matfile();
-            if (d_channel == 0)
-                {
-                    std::cout << " done." << std::endl;
-                }
-        }
-    try
-        {
-            volk_gnsssdr_free(d_local_code_shift_chips);
-            volk_gnsssdr_free(d_correlator_outs);
-            volk_gnsssdr_free(d_ca_code);
-            delete[] d_Prompt_buffer;
-            multicorrelator_cpu.free();
-        }
-    catch (const std::exception &ex)
-        {
-            LOG(WARNING) << "Exception in destructor " << ex.what();
-        }
-}
-
-
-int gps_l2_m_dll_pll_tracking_cc::general_work(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items __attribute__((unused)),
-    gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
-{
-    // process vars
-    double carr_error_hz = 0;
-    double carr_error_filt_hz = 0;
-    double code_error_chips = 0;
-    double code_error_filt_chips = 0;
-
-    // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
-    Gnss_Synchro current_synchro_data = Gnss_Synchro();
-
-    // Block input data and block output stream pointers
-    const gr_complex *in = reinterpret_cast<const gr_complex *>(input_items[0]);
-    Gnss_Synchro **out = reinterpret_cast<Gnss_Synchro **>(&output_items[0]);
-
-    if (d_enable_tracking == true)
-        {
-            // Fill the acquisition data
-            current_synchro_data = *d_acquisition_gnss_synchro;
-            // Receiver signal alignment
-            if (d_pull_in == true)
-                {
-                    int samples_offset;
-                    double acq_trk_shif_correction_samples;
-                    int acq_to_trk_delay_samples;
-                    acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
-                    acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast<float>(acq_to_trk_delay_samples), static_cast<float>(d_current_prn_length_samples));
-                    samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
-                    current_synchro_data.Tracking_sample_counter = d_sample_counter + samples_offset;
-                    d_sample_counter = d_sample_counter + samples_offset;  // count for the processed samples
-                    d_pull_in = false;
-                    // take into account the carrier cycles accumulated in the pull in signal alignment
-                    d_acc_carrier_phase_rad -= d_carrier_phase_step_rad * samples_offset;
-                    current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad;
-                    current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
-                    current_synchro_data.fs = d_fs_in;
-                    current_synchro_data.correlation_length_ms = 20;
-                    consume_each(samples_offset);  // shift input to perform alignment with local replica
-                    return 0;
-                }
-
-            // ################# CARRIER WIPEOFF AND CORRELATORS ##############################
-            // perform carrier wipe-off and compute Early, Prompt and Late correlation
-            multicorrelator_cpu.set_input_output_vectors(d_correlator_outs, in);
-            multicorrelator_cpu.Carrier_wipeoff_multicorrelator_resampler(d_rem_carr_phase_rad,
-                d_carrier_phase_step_rad,
-                d_rem_code_phase_chips,
-                d_code_phase_step_chips,
-                d_current_prn_length_samples);
-
-            // ################## PLL ##########################################################
-            // PLL discriminator
-            // Update PLL discriminator [rads/Ti -> Secs/Ti]
-            carr_error_hz = pll_cloop_two_quadrant_atan(d_correlator_outs[1]) / GPS_L2_TWO_PI;
-            // Carrier discriminator filter
-            carr_error_filt_hz = d_carrier_loop_filter.get_carrier_nco(carr_error_hz);
-            // New carrier Doppler frequency estimation
-            d_carrier_doppler_hz = d_acq_carrier_doppler_hz + carr_error_filt_hz;
-            // New code Doppler frequency estimation
-            d_code_freq_chips = GPS_L2_M_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L2_M_CODE_RATE_HZ) / GPS_L2_FREQ_HZ);
-
-            // ################## DLL ##########################################################
-            // DLL discriminator
-            code_error_chips = dll_nc_e_minus_l_normalized(d_correlator_outs[0], d_correlator_outs[2]);  // [chips/Ti]
-            // Code discriminator filter
-            code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips);  //[chips/second]
-            double T_chip_seconds = 1.0 / static_cast<double>(d_code_freq_chips);
-            double T_prn_seconds = T_chip_seconds * GPS_L2_M_CODE_LENGTH_CHIPS;
-            double code_error_filt_secs = (T_prn_seconds * code_error_filt_chips * T_chip_seconds);  //[seconds]
-            //double code_error_filt_secs = (GPS_L2_M_PERIOD * code_error_filt_chips) / GPS_L2_M_CODE_RATE_HZ; //[seconds]
-
-            // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT #######################
-            // keep alignment parameters for the next input buffer
-            // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation
-            double T_prn_samples = T_prn_seconds * static_cast<double>(d_fs_in);
-            double K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * static_cast<double>(d_fs_in);
-            d_current_prn_length_samples = round(K_blk_samples);  // round to a discrete number of samples
-
-            //################### PLL COMMANDS #################################################
-            // carrier phase step (NCO phase increment per sample) [rads/sample]
-            d_carrier_phase_step_rad = GPS_L2_TWO_PI * d_carrier_doppler_hz / static_cast<double>(d_fs_in);
-            // remnant carrier phase to prevent overflow in the code NCO
-            d_rem_carr_phase_rad = d_rem_carr_phase_rad + d_carrier_phase_step_rad * d_current_prn_length_samples;
-            d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, GPS_L2_TWO_PI);
-            // carrier phase accumulator
-            d_acc_carrier_phase_rad -= d_carrier_phase_step_rad * d_current_prn_length_samples;
-
-            //################### DLL COMMANDS #################################################
-            // code phase step (Code resampler phase increment per sample) [chips/sample]
-            d_code_phase_step_chips = d_code_freq_chips / static_cast<double>(d_fs_in);
-            // remnant code phase [chips]
-            d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples;  // rounding error < 1 sample
-            d_rem_code_phase_chips = d_code_freq_chips * (d_rem_code_phase_samples / static_cast<double>(d_fs_in));
-
-            // ####### CN0 ESTIMATION AND LOCK DETECTORS ######
-            if (d_cn0_estimation_counter < FLAGS_cn0_samples)
-                {
-                    // fill buffer with prompt correlator output values
-                    d_Prompt_buffer[d_cn0_estimation_counter] = d_correlator_outs[1];
-                    d_cn0_estimation_counter++;
-                }
-            else
-                {
-                    d_cn0_estimation_counter = 0;
-                    // Code lock indicator
-                    d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, FLAGS_cn0_samples, d_fs_in, GPS_L2_M_CODE_LENGTH_CHIPS);
-                    // Carrier lock indicator
-                    d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, FLAGS_cn0_samples);
-                    // Loss of lock detection
-                    if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < FLAGS_cn0_min)
-                        {
-                            d_carrier_lock_fail_counter++;
-                        }
-                    else
-                        {
-                            if (d_carrier_lock_fail_counter > 0) d_carrier_lock_fail_counter--;
-                        }
-                    if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail)
-                        {
-                            std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl;
-                            LOG(INFO) << "Loss of lock in channel " << d_channel << "!";
-                            this->message_port_pub(pmt::mp("events"), pmt::from_long(3));  //3 -> loss of lock
-                            d_carrier_lock_fail_counter = 0;
-                            d_enable_tracking = false;  // TODO: check if disabling tracking is consistent with the channel state machine
-                        }
-                }
-            // ########### Output the tracking data to navigation and PVT ##########
-            current_synchro_data.Prompt_I = static_cast<double>(d_correlator_outs[1].real());
-            current_synchro_data.Prompt_Q = static_cast<double>(d_correlator_outs[1].imag());
-            current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples;
-            current_synchro_data.Code_phase_samples = d_rem_code_phase_samples;
-            current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad;
-            current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
-            current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
-            current_synchro_data.Flag_valid_symbol_output = true;
-            current_synchro_data.correlation_length_ms = 20;
-        }
-    else
-        {
-            for (int n = 0; n < d_n_correlator_taps; n++)
-                {
-                    d_correlator_outs[n] = gr_complex(0, 0);
-                }
-            current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples;
-            current_synchro_data.correlation_length_ms = 20;
-        }
-    //assign the GNURadio block output data
-    current_synchro_data.fs = d_fs_in;
-    *out[0] = current_synchro_data;
-
-    if (d_dump)
-        {
-            // MULTIPLEXED FILE RECORDING - Record results to file
-            float prompt_I;
-            float prompt_Q;
-            float tmp_E, tmp_P, tmp_L;
-            double tmp_double;
-            prompt_I = d_correlator_outs[1].real();
-            prompt_Q = d_correlator_outs[1].imag();
-            tmp_E = std::abs<float>(d_correlator_outs[0]);
-            tmp_P = std::abs<float>(d_correlator_outs[1]);
-            tmp_L = std::abs<float>(d_correlator_outs[2]);
-            try
-                {
-                    // EPR
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_E), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_P), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_L), sizeof(float));
-                    // PROMPT I and Q (to analyze navigation symbols)
-                    d_dump_file.write(reinterpret_cast<char *>(&prompt_I), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&prompt_Q), sizeof(float));
-                    // PRN start sample stamp
-                    //tmp_float=(float)d_sample_counter;
-                    d_dump_file.write(reinterpret_cast<char *>(&d_sample_counter), sizeof(unsigned long int));
-                    // accumulated carrier phase
-                    d_dump_file.write(reinterpret_cast<char *>(&d_acc_carrier_phase_rad), sizeof(double));
-
-                    // carrier and code frequency
-                    d_dump_file.write(reinterpret_cast<char *>(&d_carrier_doppler_hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&d_code_freq_chips), sizeof(double));
-
-                    //PLL commands
-                    d_dump_file.write(reinterpret_cast<char *>(&carr_error_hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&d_carrier_doppler_hz), sizeof(double));
-
-                    //DLL commands
-                    d_dump_file.write(reinterpret_cast<char *>(&code_error_chips), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&code_error_filt_chips), sizeof(double));
-
-                    // CN0 and carrier lock test
-                    d_dump_file.write(reinterpret_cast<char *>(&d_CN0_SNV_dB_Hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&d_carrier_lock_test), sizeof(double));
-
-                    // AUX vars (for debug purposes)
-                    tmp_double = d_rem_code_phase_samples;
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
-                    tmp_double = static_cast<double>(d_sample_counter + d_current_prn_length_samples);
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
-
-                    // PRN
-                    unsigned int prn_ = d_acquisition_gnss_synchro->PRN;
-                    d_dump_file.write(reinterpret_cast<char *>(&prn_), sizeof(unsigned int));
-                }
-            catch (std::ifstream::failure &e)
-                {
-                    LOG(WARNING) << "Exception writing trk dump file " << e.what();
-                }
-        }
-    consume_each(d_current_prn_length_samples);
-    d_sample_counter += d_current_prn_length_samples;
-    if (current_synchro_data.Flag_valid_symbol_output)
-        {
-            return 1;
-        }
-    else
-        {
-            return 0;
-        }
-}
-
-
-void gps_l2_m_dll_pll_tracking_cc::set_channel(unsigned int channel)
-{
-    d_channel = channel;
-    LOG(INFO) << "Tracking Channel set to " << d_channel;
-    // ############# ENABLE DATA FILE LOG #################
-    if (d_dump == true)
-        {
-            if (d_dump_file.is_open() == false)
-                {
-                    try
-                        {
-                            d_dump_filename.append(boost::lexical_cast<std::string>(d_channel));
-                            d_dump_filename.append(".dat");
-                            d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-                            d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
-                            LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str();
-                        }
-                    catch (std::ifstream::failure &e)
-                        {
-                            LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what();
-                        }
-                }
-        }
-}
-
-
-void gps_l2_m_dll_pll_tracking_cc::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro)
-{
-    d_acquisition_gnss_synchro = p_gnss_synchro;
-}

src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.h

@@ -1,165 +0,0 @@
-/*!
- * \file gps_l2_m_dll_pll_tracking_cc.h
- * \brief Interface of a code DLL + carrier PLL tracking block for GPS L2C
- * \author Javier Arribas, 2015. jarribas(at)cttc.es
- *
- * Code DLL + carrier PLL according to the algorithms described in:
- * K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen,
- * A Software-Defined GPS and Galileo Receiver. A Single-Frequency Approach,
- * Birkhauser, 2007
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#ifndef GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H
-#define GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H
-
-#include "gnss_synchro.h"
-#include "tracking_2nd_DLL_filter.h"
-#include "tracking_2nd_PLL_filter.h"
-#include "cpu_multicorrelator.h"
-#include <gnuradio/block.h>
-#include <fstream>
-#include <map>
-#include <string>
-
-class gps_l2_m_dll_pll_tracking_cc;
-
-typedef boost::shared_ptr<gps_l2_m_dll_pll_tracking_cc>
-    gps_l2_m_dll_pll_tracking_cc_sptr;
-
-gps_l2_m_dll_pll_tracking_cc_sptr
-gps_l2_m_dll_pll_make_tracking_cc(long if_freq,
-    long fs_in, unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float early_late_space_chips);
-
-
-/*!
- * \brief This class implements a DLL + PLL tracking loop block
- */
-class gps_l2_m_dll_pll_tracking_cc : public gr::block
-{
-public:
-    ~gps_l2_m_dll_pll_tracking_cc();
-
-    void set_channel(unsigned int channel);
-    void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro);
-    void start_tracking();
-
-    int general_work(int noutput_items, gr_vector_int& ninput_items,
-        gr_vector_const_void_star& input_items, gr_vector_void_star& output_items);
-
-    void forecast(int noutput_items, gr_vector_int& ninput_items_required);
-
-private:
-    friend gps_l2_m_dll_pll_tracking_cc_sptr
-    gps_l2_m_dll_pll_make_tracking_cc(long if_freq,
-        long fs_in, unsigned int vector_length,
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float early_late_space_chips);
-
-    gps_l2_m_dll_pll_tracking_cc(long if_freq,
-        long fs_in, unsigned int vector_length,
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float early_late_space_chips);
-
-    // tracking configuration vars
-    unsigned int d_vector_length;
-    bool d_dump;
-
-    Gnss_Synchro* d_acquisition_gnss_synchro;
-    unsigned int d_channel;
-    long d_if_freq;
-    long d_fs_in;
-
-    double d_early_late_spc_chips;
-
-    // remaining code phase and carrier phase between tracking loops
-    double d_rem_code_phase_samples;
-    double d_rem_code_phase_chips;
-    double d_rem_carr_phase_rad;
-
-    // PLL and DLL filter library
-    Tracking_2nd_DLL_filter d_code_loop_filter;
-    Tracking_2nd_PLL_filter d_carrier_loop_filter;
-
-    // acquisition
-    double d_acq_code_phase_samples;
-    double d_acq_carrier_doppler_hz;
-    // correlator
-    int d_n_correlator_taps;
-    gr_complex* d_ca_code;
-    float* d_local_code_shift_chips;
-    gr_complex* d_correlator_outs;
-    cpu_multicorrelator multicorrelator_cpu;
-
-    // tracking vars
-    double d_code_freq_chips;
-    double d_code_phase_step_chips;
-    double d_carrier_doppler_hz;
-    double d_carrier_phase_step_rad;
-    double d_acc_carrier_phase_rad;
-    double d_code_phase_samples;
-
-    // PRN period in samples
-    int d_current_prn_length_samples;
-
-    // processing samples counters
-    unsigned long int d_sample_counter;
-    unsigned long int d_acq_sample_stamp;
-
-    // CN0 estimation and lock detector
-    int d_cn0_estimation_counter;
-    gr_complex* d_Prompt_buffer;
-    double d_carrier_lock_test;
-    double d_CN0_SNV_dB_Hz;
-    double d_carrier_lock_threshold;
-    int d_carrier_lock_fail_counter;
-
-    // control vars
-    bool d_enable_tracking;
-    bool d_pull_in;
-
-    // file dump
-    std::string d_dump_filename;
-    std::ofstream d_dump_file;
-
-    std::map<std::string, std::string> systemName;
-    std::string sys;
-
-    int save_matfile();
-};
-
-#endif  //GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H

src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.cc

@@ -1,762 +0,0 @@
-/*!
- * \file gps_l5i_dll_pll_tracking_cc.cc
- * \brief Implementation of a code DLL + carrier PLL tracking block for GPS L2C
- * \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com
- *         Javier Arribas, 2011. jarribas(at)cttc.es
- *
- * Code DLL + carrier PLL according to the algorithms described in:
- * [1] K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen,
- * A Software-Defined GPS and Galileo Receiver. A Single-Frequency
- * Approach, Birkhauser, 2007
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#include "gps_l5i_dll_pll_tracking_cc.h"
-#include "gps_l5_signal.h"
-#include "tracking_discriminators.h"
-#include "lock_detectors.h"
-#include "GPS_L5.h"
-#include "control_message_factory.h"
-#include "gnss_sdr_flags.h"
-#include <boost/lexical_cast.hpp>
-#include <gnuradio/io_signature.h>
-#include <glog/logging.h>
-#include <matio.h>
-#include <volk_gnsssdr/volk_gnsssdr.h>
-#include <cmath>
-#include <iostream>
-#include <memory>
-#include <sstream>
-
-
-using google::LogMessage;
-
-gps_l5i_dll_pll_tracking_cc_sptr
-gps_l5i_dll_pll_make_tracking_cc(
-    long if_freq,
-    long fs_in,
-    unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float early_late_space_chips)
-{
-    return gps_l5i_dll_pll_tracking_cc_sptr(new gps_l5i_dll_pll_tracking_cc(if_freq,
-        fs_in, vector_length, dump, dump_filename, pll_bw_hz, dll_bw_hz, early_late_space_chips));
-}
-
-
-void gps_l5i_dll_pll_tracking_cc::forecast(int noutput_items,
-    gr_vector_int &ninput_items_required)
-{
-    if (noutput_items != 0)
-        {
-            ninput_items_required[0] = static_cast<int>(d_vector_length) * 2;  //set the required available samples in each call
-        }
-}
-
-
-gps_l5i_dll_pll_tracking_cc::gps_l5i_dll_pll_tracking_cc(
-    long if_freq,
-    long fs_in,
-    unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float early_late_space_chips) : gr::block("gps_l5i_dll_pll_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
-                                        gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
-{
-    // Telemetry bit synchronization message port input
-    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
-    this->message_port_register_out(pmt::mp("events"));
-    // initialize internal vars
-    d_dump = dump;
-    d_if_freq = if_freq;
-    d_fs_in = fs_in;
-    d_vector_length = vector_length;
-    d_dump_filename = dump_filename;
-
-    d_current_prn_length_samples = static_cast<int>(d_vector_length);
-
-    // DLL/PLL filter initialization
-    d_carrier_loop_filter = Tracking_2nd_PLL_filter(GPS_L5i_PERIOD);
-    d_code_loop_filter = Tracking_2nd_DLL_filter(GPS_L5i_PERIOD);
-
-    // Initialize tracking  ==========================================
-    d_code_loop_filter.set_DLL_BW(dll_bw_hz);
-    d_carrier_loop_filter.set_PLL_BW(pll_bw_hz);
-
-    //--- DLL variables --------------------------------------------------------
-    d_early_late_spc_chips = early_late_space_chips;  // Define early-late offset (in chips)
-
-    // Initialization of local code replica
-    // Get space for a vector with the C/A code replica sampled 1x/chip
-    d_ca_code = static_cast<gr_complex *>(volk_gnsssdr_malloc(static_cast<int>(GPS_L5i_CODE_LENGTH_CHIPS) * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-
-    // correlator outputs (scalar)
-    d_n_correlator_taps = 3;  // Early, Prompt, and Late
-    d_correlator_outs = static_cast<gr_complex *>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
-    for (int n = 0; n < d_n_correlator_taps; n++)
-        {
-            d_correlator_outs[n] = gr_complex(0, 0);
-        }
-    d_local_code_shift_chips = static_cast<float *>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment()));
-    // Set TAPs delay values [chips]
-    d_local_code_shift_chips[0] = -d_early_late_spc_chips;
-    d_local_code_shift_chips[1] = 0.0;
-    d_local_code_shift_chips[2] = d_early_late_spc_chips;
-
-    multicorrelator_cpu.init(2 * d_current_prn_length_samples, d_n_correlator_taps);
-
-    //--- Perform initializations ------------------------------
-    // define initial code frequency basis of NCO
-    d_code_freq_chips = GPS_L5i_CODE_RATE_HZ;
-    // define residual code phase (in chips)
-    d_rem_code_phase_samples = 0.0;
-    // define residual carrier phase
-    d_rem_carr_phase_rad = 0.0;
-
-    // sample synchronization
-    d_sample_counter = 0;
-    //d_sample_counter_seconds = 0;
-    d_acq_sample_stamp = 0;
-
-    d_enable_tracking = false;
-    d_pull_in = false;
-
-    // CN0 estimation and lock detector buffers
-    d_cn0_estimation_counter = 0;
-    d_Prompt_buffer = new gr_complex[FLAGS_cn0_samples];
-    d_carrier_lock_test = 1;
-    d_CN0_SNV_dB_Hz = 0;
-    d_carrier_lock_fail_counter = 0;
-    d_carrier_lock_threshold = FLAGS_carrier_lock_th;
-
-    systemName["G"] = std::string("GPS");
-
-    //set_min_output_buffer((long int)300);
-
-    d_acquisition_gnss_synchro = 0;
-    d_channel = 0;
-    d_acq_code_phase_samples = 0.0;
-    d_acq_carrier_doppler_hz = 0.0;
-    d_carrier_doppler_hz = 0.0;
-    d_acc_carrier_phase_rad = 0.0;
-    d_code_phase_samples = 0.0;
-
-    d_rem_code_phase_chips = 0.0;
-    d_code_phase_step_chips = 0.0;
-    d_carrier_phase_step_rad = 0.0;
-
-    set_relative_rate(1.0 / static_cast<double>(d_vector_length));
-}
-
-
-void gps_l5i_dll_pll_tracking_cc::start_tracking()
-{
-    /*
-     *  correct the code phase according to the delay between acq and trk
-     */
-    d_acq_code_phase_samples = d_acquisition_gnss_synchro->Acq_delay_samples;
-    d_acq_carrier_doppler_hz = d_acquisition_gnss_synchro->Acq_doppler_hz;
-    d_acq_sample_stamp = d_acquisition_gnss_synchro->Acq_samplestamp_samples;
-
-    long int acq_trk_diff_samples;
-    double acq_trk_diff_seconds;
-    acq_trk_diff_samples = static_cast<long int>(d_sample_counter) - static_cast<long int>(d_acq_sample_stamp);  //-d_vector_length;
-    DLOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples;
-    acq_trk_diff_seconds = static_cast<float>(acq_trk_diff_samples) / static_cast<float>(d_fs_in);
-    // Doppler effect
-    // Fd=(C/(C+Vr))*F
-    double radial_velocity = (GPS_L5_FREQ_HZ + d_acq_carrier_doppler_hz) / GPS_L5_FREQ_HZ;
-    // new chip and prn sequence periods based on acq Doppler
-    double T_chip_mod_seconds;
-    double T_prn_mod_seconds;
-    double T_prn_mod_samples;
-    d_code_freq_chips = radial_velocity * GPS_L5i_CODE_RATE_HZ;
-    d_code_phase_step_chips = static_cast<double>(d_code_freq_chips) / static_cast<double>(d_fs_in);
-    T_chip_mod_seconds = 1 / d_code_freq_chips;
-    T_prn_mod_seconds = T_chip_mod_seconds * GPS_L5i_CODE_LENGTH_CHIPS;
-    T_prn_mod_samples = T_prn_mod_seconds * static_cast<double>(d_fs_in);
-
-    d_current_prn_length_samples = round(T_prn_mod_samples);
-
-    double T_prn_true_seconds = GPS_L5i_CODE_LENGTH_CHIPS / GPS_L5i_CODE_RATE_HZ;
-    double T_prn_true_samples = T_prn_true_seconds * static_cast<double>(d_fs_in);
-    double T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds;
-    double N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds;
-    double corrected_acq_phase_samples, delay_correction_samples;
-    corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * static_cast<double>(d_fs_in)), T_prn_true_samples);
-    if (corrected_acq_phase_samples < 0)
-        {
-            corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples;
-        }
-    delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples;
-
-    d_acq_code_phase_samples = corrected_acq_phase_samples;
-
-    d_carrier_doppler_hz = d_acq_carrier_doppler_hz;
-    d_carrier_phase_step_rad = GPS_L5_TWO_PI * d_carrier_doppler_hz / static_cast<double>(d_fs_in);
-
-    // DLL/PLL filter initialization
-    d_carrier_loop_filter.initialize();  // initialize the carrier filter
-    d_code_loop_filter.initialize();     // initialize the code filter
-
-    // generate local reference ALWAYS starting at chip 1 (1 sample per chip)
-    gps_l5i_code_gen_complex(d_ca_code, d_acquisition_gnss_synchro->PRN);
-
-    multicorrelator_cpu.set_local_code_and_taps(static_cast<int>(GPS_L5i_CODE_LENGTH_CHIPS), d_ca_code, d_local_code_shift_chips);
-    for (int n = 0; n < d_n_correlator_taps; n++)
-        {
-            d_correlator_outs[n] = gr_complex(0, 0);
-        }
-
-    d_carrier_lock_fail_counter = 0;
-    d_rem_code_phase_samples = 0;
-    d_rem_carr_phase_rad = 0.0;
-    d_rem_code_phase_chips = 0.0;
-    d_acc_carrier_phase_rad = 0.0;
-
-    d_code_phase_samples = d_acq_code_phase_samples;
-
-    std::string sys_ = &d_acquisition_gnss_synchro->System;
-    sys = sys_.substr(0, 1);
-
-    // DEBUG OUTPUT
-    std::cout << "Tracking of GPS L5i signal started on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl;
-    LOG(INFO) << "Starting GPS L5i tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel;
-
-    // enable tracking
-    d_pull_in = true;
-    d_enable_tracking = true;
-
-    LOG(INFO) << "GPS L5i PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz
-              << " Code Phase correction [samples]=" << delay_correction_samples
-              << " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
-}
-
-
-int gps_l5i_dll_pll_tracking_cc::save_matfile()
-{
-    // READ DUMP FILE
-    std::ifstream::pos_type size;
-    int number_of_double_vars = 11;
-    int number_of_float_vars = 5;
-    int epoch_size_bytes = sizeof(unsigned long int) + sizeof(double) * number_of_double_vars +
-                           sizeof(float) * number_of_float_vars + sizeof(unsigned int);
-    std::ifstream dump_file;
-    dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-    try
-        {
-            dump_file.open(d_dump_filename.c_str(), std::ios::binary | std::ios::ate);
-        }
-    catch (const std::ifstream::failure &e)
-        {
-            std::cerr << "Problem opening dump file:" << e.what() << std::endl;
-            return 1;
-        }
-    // count number of epochs and rewind
-    long int num_epoch = 0;
-    if (dump_file.is_open())
-        {
-            size = dump_file.tellg();
-            num_epoch = static_cast<long int>(size) / static_cast<long int>(epoch_size_bytes);
-            dump_file.seekg(0, std::ios::beg);
-        }
-    else
-        {
-            return 1;
-        }
-    float *abs_E = new float[num_epoch];
-    float *abs_P = new float[num_epoch];
-    float *abs_L = new float[num_epoch];
-    float *Prompt_I = new float[num_epoch];
-    float *Prompt_Q = new float[num_epoch];
-    unsigned long int *PRN_start_sample_count = new unsigned long int[num_epoch];
-    double *acc_carrier_phase_rad = new double[num_epoch];
-    double *carrier_doppler_hz = new double[num_epoch];
-    double *code_freq_chips = new double[num_epoch];
-    double *carr_error_hz = new double[num_epoch];
-    double *carr_error_filt_hz = new double[num_epoch];
-    double *code_error_chips = new double[num_epoch];
-    double *code_error_filt_chips = new double[num_epoch];
-    double *CN0_SNV_dB_Hz = new double[num_epoch];
-    double *carrier_lock_test = new double[num_epoch];
-    double *aux1 = new double[num_epoch];
-    double *aux2 = new double[num_epoch];
-    unsigned int *PRN = new unsigned int[num_epoch];
-
-    try
-        {
-            if (dump_file.is_open())
-                {
-                    for (long int i = 0; i < num_epoch; i++)
-                        {
-                            dump_file.read(reinterpret_cast<char *>(&abs_E[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&abs_P[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&abs_L[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&Prompt_I[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&Prompt_Q[i]), sizeof(float));
-                            dump_file.read(reinterpret_cast<char *>(&PRN_start_sample_count[i]), sizeof(unsigned long int));
-                            dump_file.read(reinterpret_cast<char *>(&acc_carrier_phase_rad[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carrier_doppler_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_freq_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carr_error_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carr_error_filt_hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_error_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&code_error_filt_chips[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&CN0_SNV_dB_Hz[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&carrier_lock_test[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&aux1[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&aux2[i]), sizeof(double));
-                            dump_file.read(reinterpret_cast<char *>(&PRN[i]), sizeof(unsigned int));
-                        }
-                }
-            dump_file.close();
-        }
-    catch (const std::ifstream::failure &e)
-        {
-            std::cerr << "Problem reading dump file:" << e.what() << std::endl;
-            delete[] abs_E;
-            delete[] abs_P;
-            delete[] abs_L;
-            delete[] Prompt_I;
-            delete[] Prompt_Q;
-            delete[] PRN_start_sample_count;
-            delete[] acc_carrier_phase_rad;
-            delete[] carrier_doppler_hz;
-            delete[] code_freq_chips;
-            delete[] carr_error_hz;
-            delete[] carr_error_filt_hz;
-            delete[] code_error_chips;
-            delete[] code_error_filt_chips;
-            delete[] CN0_SNV_dB_Hz;
-            delete[] carrier_lock_test;
-            delete[] aux1;
-            delete[] aux2;
-            delete[] PRN;
-            return 1;
-        }
-
-    // WRITE MAT FILE
-    mat_t *matfp;
-    matvar_t *matvar;
-    std::string filename = d_dump_filename;
-    filename.erase(filename.length() - 4, 4);
-    filename.append(".mat");
-    matfp = Mat_CreateVer(filename.c_str(), NULL, MAT_FT_MAT73);
-    if (reinterpret_cast<long *>(matfp) != NULL)
-        {
-            size_t dims[2] = {1, static_cast<size_t>(num_epoch)};
-            matvar = Mat_VarCreate("abs_E", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_E, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("abs_P", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_P, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("abs_L", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, abs_L, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("Prompt_I", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_I, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("Prompt_Q", MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, Prompt_Q, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("PRN_start_sample_count", MAT_C_UINT64, MAT_T_UINT64, 2, dims, PRN_start_sample_count, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("acc_carrier_phase_rad", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, acc_carrier_phase_rad, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carrier_doppler_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_doppler_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_freq_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_freq_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carr_error_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carr_error_filt_hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carr_error_filt_hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_error_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("code_error_filt_chips", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, code_error_filt_chips, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("CN0_SNV_dB_Hz", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, CN0_SNV_dB_Hz, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("carrier_lock_test", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, carrier_lock_test, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("aux1", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux1, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("aux2", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, aux2, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-
-            matvar = Mat_VarCreate("PRN", MAT_C_UINT32, MAT_T_UINT32, 2, dims, PRN, 0);
-            Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB);  // or MAT_COMPRESSION_NONE
-            Mat_VarFree(matvar);
-        }
-    Mat_Close(matfp);
-    delete[] abs_E;
-    delete[] abs_P;
-    delete[] abs_L;
-    delete[] Prompt_I;
-    delete[] Prompt_Q;
-    delete[] PRN_start_sample_count;
-    delete[] acc_carrier_phase_rad;
-    delete[] carrier_doppler_hz;
-    delete[] code_freq_chips;
-    delete[] carr_error_hz;
-    delete[] carr_error_filt_hz;
-    delete[] code_error_chips;
-    delete[] code_error_filt_chips;
-    delete[] CN0_SNV_dB_Hz;
-    delete[] carrier_lock_test;
-    delete[] aux1;
-    delete[] aux2;
-    delete[] PRN;
-    return 0;
-}
-
-
-gps_l5i_dll_pll_tracking_cc::~gps_l5i_dll_pll_tracking_cc()
-{
-    if (d_dump_file.is_open())
-        {
-            try
-                {
-                    d_dump_file.close();
-                }
-            catch (const std::exception &ex)
-                {
-                    LOG(WARNING) << "Exception in destructor " << ex.what();
-                }
-        }
-    if (d_dump)
-        {
-            if (d_channel == 0)
-                {
-                    std::cout << "Writing .mat files ...";
-                }
-            gps_l5i_dll_pll_tracking_cc::save_matfile();
-            if (d_channel == 0)
-                {
-                    std::cout << " done." << std::endl;
-                }
-        }
-    try
-        {
-            volk_gnsssdr_free(d_local_code_shift_chips);
-            volk_gnsssdr_free(d_correlator_outs);
-            volk_gnsssdr_free(d_ca_code);
-            delete[] d_Prompt_buffer;
-            multicorrelator_cpu.free();
-        }
-    catch (const std::exception &ex)
-        {
-            LOG(WARNING) << "Exception in destructor " << ex.what();
-        }
-}
-
-
-int gps_l5i_dll_pll_tracking_cc::general_work(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items __attribute__((unused)),
-    gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
-{
-    // process vars
-    double carr_error_hz = 0;
-    double carr_error_filt_hz = 0;
-    double code_error_chips = 0;
-    double code_error_filt_chips = 0;
-
-    // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
-    Gnss_Synchro current_synchro_data = Gnss_Synchro();
-
-    // Block input data and block output stream pointers
-    const gr_complex *in = reinterpret_cast<const gr_complex *>(input_items[0]);
-    Gnss_Synchro **out = reinterpret_cast<Gnss_Synchro **>(&output_items[0]);
-
-    if (d_enable_tracking == true)
-        {
-            // Fill the acquisition data
-            current_synchro_data = *d_acquisition_gnss_synchro;
-            // Receiver signal alignment
-            if (d_pull_in == true)
-                {
-                    int samples_offset;
-                    double acq_trk_shif_correction_samples;
-                    int acq_to_trk_delay_samples;
-                    acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
-                    acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast<float>(acq_to_trk_delay_samples), static_cast<float>(d_current_prn_length_samples));
-                    samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
-                    current_synchro_data.Tracking_sample_counter = d_sample_counter + samples_offset;
-                    d_sample_counter = d_sample_counter + samples_offset;  // count for the processed samples
-                    d_pull_in = false;
-                    // take into account the carrier cycles accumulated in the pull in signal alignment
-                    d_acc_carrier_phase_rad -= d_carrier_phase_step_rad * samples_offset;
-                    current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad;
-                    current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
-                    current_synchro_data.fs = d_fs_in;
-                    current_synchro_data.correlation_length_ms = 1;
-                    consume_each(samples_offset);  // shift input to perform alignment with local replica
-                    return 0;
-                }
-
-            // ################# CARRIER WIPEOFF AND CORRELATORS ##############################
-            // perform carrier wipe-off and compute Early, Prompt and Late correlation
-            multicorrelator_cpu.set_input_output_vectors(d_correlator_outs, in);
-            multicorrelator_cpu.Carrier_wipeoff_multicorrelator_resampler(d_rem_carr_phase_rad,
-                d_carrier_phase_step_rad,
-                d_rem_code_phase_chips,
-                d_code_phase_step_chips,
-                d_current_prn_length_samples);
-
-            // ################## PLL ##########################################################
-            // PLL discriminator
-            // Update PLL discriminator [rads/Ti -> Secs/Ti]
-            carr_error_hz = pll_cloop_two_quadrant_atan(d_correlator_outs[1]) / GPS_L5_TWO_PI;
-            // Carrier discriminator filter
-            carr_error_filt_hz = d_carrier_loop_filter.get_carrier_nco(carr_error_hz);
-            // New carrier Doppler frequency estimation
-            d_carrier_doppler_hz = d_acq_carrier_doppler_hz + carr_error_filt_hz;
-            // New code Doppler frequency estimation
-            d_code_freq_chips = GPS_L5i_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L5i_CODE_RATE_HZ) / GPS_L5_FREQ_HZ);
-
-            // ################## DLL ##########################################################
-            // DLL discriminator
-            code_error_chips = dll_nc_e_minus_l_normalized(d_correlator_outs[0], d_correlator_outs[2]);  // [chips/Ti]
-            // Code discriminator filter
-            code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips);  //[chips/second]
-            double T_chip_seconds = 1.0 / static_cast<double>(d_code_freq_chips);
-            double T_prn_seconds = T_chip_seconds * GPS_L5i_CODE_LENGTH_CHIPS;
-            double code_error_filt_secs = (T_prn_seconds * code_error_filt_chips * T_chip_seconds);  //[seconds]
-            //double code_error_filt_secs = (GPS_L5i_PERIOD * code_error_filt_chips) / GPS_L5i_CODE_RATE_HZ; //[seconds]
-
-            // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT #######################
-            // keep alignment parameters for the next input buffer
-            // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation
-            double T_prn_samples = T_prn_seconds * static_cast<double>(d_fs_in);
-            double K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * static_cast<double>(d_fs_in);
-            d_current_prn_length_samples = round(K_blk_samples);  // round to a discrete number of samples
-
-            //################### PLL COMMANDS #################################################
-            // carrier phase step (NCO phase increment per sample) [rads/sample]
-            d_carrier_phase_step_rad = GPS_L5_TWO_PI * d_carrier_doppler_hz / static_cast<double>(d_fs_in);
-            // remnant carrier phase to prevent overflow in the code NCO
-            d_rem_carr_phase_rad = d_rem_carr_phase_rad + d_carrier_phase_step_rad * d_current_prn_length_samples;
-            d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, GPS_L5_TWO_PI);
-            // carrier phase accumulator
-            d_acc_carrier_phase_rad -= d_carrier_phase_step_rad * d_current_prn_length_samples;
-
-            //################### DLL COMMANDS #################################################
-            // code phase step (Code resampler phase increment per sample) [chips/sample]
-            d_code_phase_step_chips = d_code_freq_chips / static_cast<double>(d_fs_in);
-            // remnant code phase [chips]
-            d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples;  // rounding error < 1 sample
-            d_rem_code_phase_chips = d_code_freq_chips * (d_rem_code_phase_samples / static_cast<double>(d_fs_in));
-
-            // ####### CN0 ESTIMATION AND LOCK DETECTORS ######
-            if (d_cn0_estimation_counter < FLAGS_cn0_samples)
-                {
-                    // fill buffer with prompt correlator output values
-                    d_Prompt_buffer[d_cn0_estimation_counter] = d_correlator_outs[1];
-                    d_cn0_estimation_counter++;
-                }
-            else
-                {
-                    d_cn0_estimation_counter = 0;
-                    // Code lock indicator
-                    d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, FLAGS_cn0_samples, d_fs_in, GPS_L5i_CODE_LENGTH_CHIPS);
-                    // Carrier lock indicator
-                    d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, FLAGS_cn0_samples);
-                    // Loss of lock detection
-                    if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < FLAGS_cn0_min)
-                        {
-                            d_carrier_lock_fail_counter++;
-                        }
-                    else
-                        {
-                            if (d_carrier_lock_fail_counter > 0) d_carrier_lock_fail_counter--;
-                        }
-                    if (d_carrier_lock_fail_counter > FLAGS_max_lock_fail)
-                        {
-                            std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl;
-                            LOG(INFO) << "Loss of lock in channel " << d_channel << "!";
-                            this->message_port_pub(pmt::mp("events"), pmt::from_long(3));  //3 -> loss of lock
-                            d_carrier_lock_fail_counter = 0;
-                            d_enable_tracking = false;  // TODO: check if disabling tracking is consistent with the channel state machine
-                        }
-                }
-            // ########### Output the tracking data to navigation and PVT ##########
-            current_synchro_data.Prompt_I = static_cast<double>(d_correlator_outs[1].real());
-            current_synchro_data.Prompt_Q = static_cast<double>(d_correlator_outs[1].imag());
-            current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples;
-            current_synchro_data.Code_phase_samples = d_rem_code_phase_samples;
-            current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad;
-            current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
-            current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
-            current_synchro_data.Flag_valid_symbol_output = true;
-            current_synchro_data.correlation_length_ms = 1;
-        }
-    else
-        {
-            for (int n = 0; n < d_n_correlator_taps; n++)
-                {
-                    d_correlator_outs[n] = gr_complex(0, 0);
-                }
-            current_synchro_data.Tracking_sample_counter = d_sample_counter + d_current_prn_length_samples;
-            current_synchro_data.correlation_length_ms = 1;
-        }
-    //assign the GNURadio block output data
-    current_synchro_data.fs = d_fs_in;
-    *out[0] = current_synchro_data;
-
-    if (d_dump)
-        {
-            // MULTIPLEXED FILE RECORDING - Record results to file
-            float prompt_I;
-            float prompt_Q;
-            float tmp_E, tmp_P, tmp_L;
-            double tmp_double;
-            prompt_I = d_correlator_outs[1].real();
-            prompt_Q = d_correlator_outs[1].imag();
-            tmp_E = std::abs<float>(d_correlator_outs[0]);
-            tmp_P = std::abs<float>(d_correlator_outs[1]);
-            tmp_L = std::abs<float>(d_correlator_outs[2]);
-            try
-                {
-                    // EPR
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_E), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_P), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_L), sizeof(float));
-                    // PROMPT I and Q (to analyze navigation symbols)
-                    d_dump_file.write(reinterpret_cast<char *>(&prompt_I), sizeof(float));
-                    d_dump_file.write(reinterpret_cast<char *>(&prompt_Q), sizeof(float));
-                    // PRN start sample stamp
-                    //tmp_float=(float)d_sample_counter;
-                    d_dump_file.write(reinterpret_cast<char *>(&d_sample_counter), sizeof(unsigned long int));
-                    // accumulated carrier phase
-                    d_dump_file.write(reinterpret_cast<char *>(&d_acc_carrier_phase_rad), sizeof(double));
-
-                    // carrier and code frequency
-                    d_dump_file.write(reinterpret_cast<char *>(&d_carrier_doppler_hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&d_code_freq_chips), sizeof(double));
-
-                    //PLL commands
-                    d_dump_file.write(reinterpret_cast<char *>(&carr_error_hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&d_carrier_doppler_hz), sizeof(double));
-
-                    //DLL commands
-                    d_dump_file.write(reinterpret_cast<char *>(&code_error_chips), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&code_error_filt_chips), sizeof(double));
-
-                    // CN0 and carrier lock test
-                    d_dump_file.write(reinterpret_cast<char *>(&d_CN0_SNV_dB_Hz), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char *>(&d_carrier_lock_test), sizeof(double));
-
-                    // AUX vars (for debug purposes)
-                    tmp_double = d_rem_code_phase_samples;
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
-                    tmp_double = static_cast<double>(d_sample_counter + d_current_prn_length_samples);
-                    d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
-
-                    // PRN
-                    unsigned int prn_ = d_acquisition_gnss_synchro->PRN;
-                    d_dump_file.write(reinterpret_cast<char *>(&prn_), sizeof(unsigned int));
-                }
-            catch (std::ifstream::failure &e)
-                {
-                    LOG(WARNING) << "Exception writing trk dump file " << e.what();
-                }
-        }
-    consume_each(d_current_prn_length_samples);        // this is necessary in gr::block derivates
-    d_sample_counter += d_current_prn_length_samples;  // count for the processed samples
-    if (current_synchro_data.Flag_valid_symbol_output)
-        {
-            return 1;
-        }
-    else
-        {
-            return 0;
-        }
-}
-
-
-void gps_l5i_dll_pll_tracking_cc::set_channel(unsigned int channel)
-{
-    d_channel = channel;
-    LOG(INFO) << "Tracking Channel set to " << d_channel;
-    // ############# ENABLE DATA FILE LOG #################
-    if (d_dump == true)
-        {
-            if (d_dump_file.is_open() == false)
-                {
-                    try
-                        {
-                            d_dump_filename.append(boost::lexical_cast<std::string>(d_channel));
-                            d_dump_filename.append(".dat");
-                            d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
-                            d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
-                            LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str();
-                        }
-                    catch (std::ifstream::failure &e)
-                        {
-                            LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what();
-                        }
-                }
-        }
-}
-
-
-void gps_l5i_dll_pll_tracking_cc::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro)
-{
-    d_acquisition_gnss_synchro = p_gnss_synchro;
-}

src/algorithms/tracking/gnuradio_blocks/gps_l5i_dll_pll_tracking_cc.h

@@ -1,165 +0,0 @@
-/*!
- * \file gps_l5i_dll_pll_tracking_cc.h
- * \brief Interface of a code DLL + carrier PLL tracking block for GPS L2C
- * \author Javier Arribas, 2015. jarribas(at)cttc.es
- *
- * Code DLL + carrier PLL according to the algorithms described in:
- * K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen,
- * A Software-Defined GPS and Galileo Receiver. A Single-Frequency Approach,
- * Birkhauser, 2007
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#ifndef GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_CC_H
-#define GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_CC_H
-
-#include "gnss_synchro.h"
-#include "tracking_2nd_DLL_filter.h"
-#include "tracking_2nd_PLL_filter.h"
-#include "cpu_multicorrelator.h"
-#include <gnuradio/block.h>
-#include <fstream>
-#include <map>
-#include <string>
-
-class gps_l5i_dll_pll_tracking_cc;
-
-typedef boost::shared_ptr<gps_l5i_dll_pll_tracking_cc>
-    gps_l5i_dll_pll_tracking_cc_sptr;
-
-gps_l5i_dll_pll_tracking_cc_sptr
-gps_l5i_dll_pll_make_tracking_cc(long if_freq,
-    long fs_in, unsigned int vector_length,
-    bool dump,
-    std::string dump_filename,
-    float pll_bw_hz,
-    float dll_bw_hz,
-    float early_late_space_chips);
-
-
-/*!
- * \brief This class implements a DLL + PLL tracking loop block
- */
-class gps_l5i_dll_pll_tracking_cc : public gr::block
-{
-public:
-    ~gps_l5i_dll_pll_tracking_cc();
-
-    void set_channel(unsigned int channel);
-    void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro);
-    void start_tracking();
-
-    int general_work(int noutput_items, gr_vector_int& ninput_items,
-        gr_vector_const_void_star& input_items, gr_vector_void_star& output_items);
-
-    void forecast(int noutput_items, gr_vector_int& ninput_items_required);
-
-private:
-    friend gps_l5i_dll_pll_tracking_cc_sptr
-    gps_l5i_dll_pll_make_tracking_cc(long if_freq,
-        long fs_in, unsigned int vector_length,
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float early_late_space_chips);
-
-    gps_l5i_dll_pll_tracking_cc(long if_freq,
-        long fs_in, unsigned int vector_length,
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float early_late_space_chips);
-
-    // tracking configuration vars
-    unsigned int d_vector_length;
-    bool d_dump;
-
-    Gnss_Synchro* d_acquisition_gnss_synchro;
-    unsigned int d_channel;
-    long d_if_freq;
-    long d_fs_in;
-
-    double d_early_late_spc_chips;
-
-    // remaining code phase and carrier phase between tracking loops
-    double d_rem_code_phase_samples;
-    double d_rem_code_phase_chips;
-    double d_rem_carr_phase_rad;
-
-    // PLL and DLL filter library
-    Tracking_2nd_DLL_filter d_code_loop_filter;
-    Tracking_2nd_PLL_filter d_carrier_loop_filter;
-
-    // acquisition
-    double d_acq_code_phase_samples;
-    double d_acq_carrier_doppler_hz;
-    // correlator
-    int d_n_correlator_taps;
-    gr_complex* d_ca_code;
-    float* d_local_code_shift_chips;
-    gr_complex* d_correlator_outs;
-    cpu_multicorrelator multicorrelator_cpu;
-
-    // tracking vars
-    double d_code_freq_chips;
-    double d_code_phase_step_chips;
-    double d_carrier_doppler_hz;
-    double d_carrier_phase_step_rad;
-    double d_acc_carrier_phase_rad;
-    double d_code_phase_samples;
-
-    // PRN period in samples
-    int d_current_prn_length_samples;
-
-    // processing samples counters
-    unsigned long int d_sample_counter;
-    unsigned long int d_acq_sample_stamp;
-
-    // CN0 estimation and lock detector
-    int d_cn0_estimation_counter;
-    gr_complex* d_Prompt_buffer;
-    double d_carrier_lock_test;
-    double d_CN0_SNV_dB_Hz;
-    double d_carrier_lock_threshold;
-    int d_carrier_lock_fail_counter;
-
-    // control vars
-    bool d_enable_tracking;
-    bool d_pull_in;
-
-    // file dump
-    std::string d_dump_filename;
-    std::ofstream d_dump_file;
-
-    std::map<std::string, std::string> systemName;
-    std::string sys;
-
-    int save_matfile();
-};
-
-#endif  //GNSS_SDR_GPS_L5i_DLL_PLL_TRACKING_CC_H

src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l2_m_pcps_acquisition_test.cc

@@ -168,6 +168,7 @@ void GpsL2MPcpsAcquisitionTest::init()
     config->set_property("Acquisition_2S.doppler_max", std::to_string(doppler_max));
     config->set_property("Acquisition_2S.doppler_step", std::to_string(doppler_step));
     config->set_property("Acquisition_2S.repeat_satellite", "false");
+    config->set_property("Acquisition_2S.make_two_steps", "false");
 }
 
 

src/utils/reproducibility/ieee-access18/README.md

@@ -4,11 +4,11 @@ Continuous Reproducibility in GNSS Signal Processing
 
 This folder contains files required for the reproduction of the experiment proposed in:
 
-C. Fernández-Prades, J. Vilà-Valls, J. Arribas and A. Ramos, *Continuous Reproducibility in GNSS Signal Processing*, submitted to IEEE Access, Feb. 2018.
+C. Fernández-Prades, J. Vilà-Valls, J. Arribas and A. Ramos, [*Continuous Reproducibility in GNSS Signal Processing*](http://ieeexplore.ieee.org/document/8331069/), IEEE Access, accepted for publication, April 2018. DOI: 10.1109/ACCESS.2018.2822835
 
-The dataset used in this paper is available at
+The data set used in this paper is available at https://zenodo.org/record/1184601
 
-The sample format is `ibyte`: Interleaved (I&Q) stream of samples of type signed integer, 8-bit two’s complement number ranging from -128 to 127. 
+The sample format is `ibyte`: Interleaved (I&Q) stream of samples of type signed integer, 8-bit two’s complement number ranging from -128 to 127. The sampling rate is 3 MSps.
 
 The figure appearing in that paper can be automatically generated with the pipeline available at https://gitlab.com/gnss-sdr/gnss-sdr/pipelines