Integrate unified block for DLL/PLL Tracking

src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_cc.cc

@@ -34,12 +34,14 @@
 #include <boost/archive/xml_oarchive.hpp>
 #include <boost/archive/xml_iarchive.hpp>
 #include <boost/serialization/map.hpp>
+#include <boost/exception/all.hpp>
 #include <glog/logging.h>
 #include <gnuradio/gr_complex.h>
 #include <gnuradio/io_signature.h>
 #include <algorithm>
 #include <iostream>
 #include <map>
+#include <exception>
 
 
 using google::LogMessage;
@@ -544,7 +546,8 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
                                     // store valid observables in a map.
                                     gnss_observables_map.insert(std::pair<int, Gnss_Synchro>(i, in[i][epoch]));
                                 }
-
+                            try
+                                {
                                     if (d_ls_pvt->gps_ephemeris_map.size() > 0)
                                         {
                                             if (tmp_eph_iter_gps != d_ls_pvt->gps_ephemeris_map.end())
@@ -574,6 +577,17 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
                                                 }
                                         }
                                 }
+                            catch (const boost::exception& ex)
+                                {
+                                    std::cout << "RTCM boost exception: " << boost::diagnostic_information(ex) << std::endl;
+                                    LOG(ERROR) << "RTCM boost exception: " << boost::diagnostic_information(ex);
+                                }
+                            catch (const std::exception& ex)
+                                {
+                                    std::cout << "RTCM std exception: " << ex.what() << std::endl;
+                                    LOG(ERROR) << "RTCM std exception: " << ex.what();
+                                }
+                        }
                 }
 
             // ############ 2 COMPUTE THE PVT ################################
@@ -590,10 +604,7 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
                     // compute on the fly PVT solution
                     if (flag_compute_pvt_output == true)
                         {
-                            bool pvt_result;
+                            if (d_ls_pvt->get_PVT(gnss_observables_map, d_rx_time, false))
-                            pvt_result = d_ls_pvt->get_PVT(gnss_observables_map, d_rx_time, false);
-
-                            if (pvt_result == true)
                                 {
                                     if (std::fabs(current_RX_time - last_pvt_display_T_rx_s) * 1000.0 >= static_cast<double>(d_display_rate_ms))
                                         {
@@ -1274,6 +1285,8 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
                                         }
 
                                     // ####################### RTCM MESSAGES #################
+                                    try
+                                        {
                                             if (b_rtcm_writing_started)
                                                 {
                                                     if (type_of_rx == 1)  // GPS L1 C/A
@@ -2034,10 +2047,22 @@ int rtklib_pvt_cc::work(int noutput_items, gr_vector_const_void_star& input_item
                                                         }
                                                 }
                                         }
+
+                                    catch (const boost::exception& ex)
+                                        {
+                                            std::cout << "RTCM boost exception: " << boost::diagnostic_information(ex) << std::endl;
+                                            LOG(ERROR) << "RTCM boost exception: " << boost::diagnostic_information(ex);
+                                        }
+                                    catch (const std::exception& ex)
+                                        {
+                                            std::cout << "RTCM std exception: " << ex.what() << std::endl;
+                                            LOG(ERROR) << "RTCM std exception: " << ex.what();
+                                        }
+                                }
                         }
 
                     // DEBUG MESSAGE: Display position in console output
-                    if ((d_ls_pvt->is_valid_position() == true) && (flag_display_pvt == true))
+                    if (d_ls_pvt->is_valid_position() and flag_display_pvt)
                         {
                             std::cout << "Position at " << boost::posix_time::to_simple_string(d_ls_pvt->get_position_UTC_time())
                                       << " UTC using " << d_ls_pvt->get_num_valid_observations() << " observations is Lat = " << d_ls_pvt->get_latitude() << " [deg], Long = " << d_ls_pvt->get_longitude()

src/algorithms/libs/galileo_e1_signal_processing.cc

@@ -53,7 +53,7 @@ void galileo_e1_code_gen_int(int* _dest, char _Signal[3], signed int _prn)
             for (size_t i = 0; i < Galileo_E1_B_PRIMARY_CODE[prn].length(); i++)
                 {
                     hex_to_binary_converter(&_dest[index], Galileo_E1_B_PRIMARY_CODE[prn].at(i));
-                    index = index + 4;
+                    index += 4;
                 }
         }
     else if (_galileo_signal.rfind("1C") != std::string::npos && _galileo_signal.length() >= 2)
@@ -61,13 +61,9 @@ void galileo_e1_code_gen_int(int* _dest, char _Signal[3], signed int _prn)
             for (size_t i = 0; i < Galileo_E1_C_PRIMARY_CODE[prn].length(); i++)
                 {
                     hex_to_binary_converter(&_dest[index], Galileo_E1_C_PRIMARY_CODE[prn].at(i));
-                    index = index + 4;
+                    index += 4;
                 }
         }
-    else
-        {
-            return;
-        }
 }
 
 
@@ -107,6 +103,18 @@ void galileo_e1_sinboc_61_gen_int(int* _dest, int* _prn, unsigned int _length_ou
         }
 }
 
+void galileo_e1_code_gen_sinboc11_float(float* _dest, char _Signal[3], unsigned int _prn)
+{
+    std::string _galileo_signal = _Signal;
+    unsigned int _codeLength = static_cast<unsigned int>(Galileo_E1_B_CODE_LENGTH_CHIPS);
+    int primary_code_E1_chips[4092];                                // _codeLength not accepted by Clang
+    galileo_e1_code_gen_int(primary_code_E1_chips, _Signal, _prn);  //generate Galileo E1 code, 1 sample per chip
+    for (unsigned int i = 0; i < _codeLength; i++)
+        {
+            _dest[2 * i] = static_cast<float>(primary_code_E1_chips[i]);
+            _dest[2 * i + 1] = -_dest[2 * i];
+        }
+}
 
 void galileo_e1_gen_float(float* _dest, int* _prn, char _Signal[3])
 {
@@ -137,8 +145,6 @@ void galileo_e1_gen_float(float* _dest, int* _prn, char _Signal[3])
                                beta * static_cast<float>(sinboc_61[i]);
                 }
         }
-    else
-        return;
 }
 
 

src/algorithms/libs/galileo_e1_signal_processing.h

@@ -34,6 +34,11 @@
 
 #include <complex>
 
+/*!
+ * \brief This function generates Galileo E1 code (can select E1B or E1C sinboc).
+ *
+ */
+void galileo_e1_code_gen_sinboc11_float(float* _dest, char _Signal[3], unsigned int _prn);
 
 /*!
  * \brief This function generates Galileo E1 code (can select E1B or E1C, cboc or sinboc

src/algorithms/libs/gps_l2c_signal.cc

@@ -71,6 +71,23 @@ void gps_l2c_m_code_gen_complex(std::complex<float>* _dest, unsigned int _prn)
     delete[] _code;
 }
 
+void gps_l2c_m_code_gen_float(float* _dest, unsigned int _prn)
+{
+    int32_t* _code = new int32_t[GPS_L2_M_CODE_LENGTH_CHIPS];
+
+    if (_prn > 0 and _prn < 51)
+        {
+            gps_l2c_m_code(_code, _prn);
+        }
+
+    for (signed int i = 0; i < GPS_L2_M_CODE_LENGTH_CHIPS; i++)
+        {
+            _dest[i] = 1.0 - 2.0 * static_cast<float>(_code[i]);
+        }
+
+    delete[] _code;
+}
+
 
 /*
  *  Generates complex GPS L2C M code for the desired SV ID and sampled to specific sampling frequency

src/algorithms/libs/gps_l2c_signal.h

@@ -38,7 +38,7 @@
 
 //!Generates complex GPS L2C M code for the desired SV ID
 void gps_l2c_m_code_gen_complex(std::complex<float>* _dest, unsigned int _prn);
-
+void gps_l2c_m_code_gen_float(float* _dest, unsigned int _prn);
 
 //! Generates complex GPS L2C M code for the desired SV ID, and sampled to specific sampling frequency
 void gps_l2c_m_code_gen_complex_sampled(std::complex<float>* _dest, unsigned int _prn, signed int _fs);

src/algorithms/libs/gps_l5_signal.cc

@@ -197,6 +197,22 @@ void gps_l5i_code_gen_complex(std::complex<float>* _dest, unsigned int _prn)
     delete[] _code;
 }
 
+void gps_l5i_code_gen_float(float* _dest, unsigned int _prn)
+{
+    int32_t* _code = new int32_t[GPS_L5i_CODE_LENGTH_CHIPS];
+
+    if (_prn > 0 and _prn < 51)
+        {
+            make_l5i(_code, _prn - 1);
+        }
+
+    for (signed int i = 0; i < GPS_L5i_CODE_LENGTH_CHIPS; i++)
+        {
+            _dest[i] = 1.0 - 2.0 * static_cast<float>(_code[i]);
+        }
+
+    delete[] _code;
+}
 
 /*
  *  Generates complex GPS L5i code for the desired SV ID and sampled to specific sampling frequency
@@ -264,7 +280,22 @@ void gps_l5q_code_gen_complex(std::complex<float>* _dest, unsigned int _prn)
     delete[] _code;
 }
 
+void gps_l5q_code_gen_float(float* _dest, unsigned int _prn)
+{
+    int32_t* _code = new int32_t[GPS_L5q_CODE_LENGTH_CHIPS];
 
+    if (_prn > 0 and _prn < 51)
+        {
+            make_l5q(_code, _prn - 1);
+        }
+
+    for (signed int i = 0; i < GPS_L5q_CODE_LENGTH_CHIPS; i++)
+        {
+            _dest[i] = 1.0 - 2.0 * static_cast<float>(_code[i]);
+        }
+
+    delete[] _code;
+}
 /*
  *  Generates complex GPS L5i code for the desired SV ID and sampled to specific sampling frequency
  */

src/algorithms/libs/gps_l5_signal.h

@@ -38,9 +38,11 @@
 
 //!Generates complex GPS L5i M code for the desired SV ID
 void gps_l5i_code_gen_complex(std::complex<float>* _dest, unsigned int _prn);
+void gps_l5i_code_gen_float(float* _dest, unsigned int _prn);
 
 //!Generates complex GPS L5q M code for the desired SV ID
 void gps_l5q_code_gen_complex(std::complex<float>* _dest, unsigned int _prn);
+void gps_l5q_code_gen_float(float* _dest, unsigned int _prn);
 
 //! Generates complex GPS L5i M code for the desired SV ID, and sampled to specific sampling frequency
 void gps_l5i_code_gen_complex_sampled(std::complex<float>* _dest, unsigned int _prn, signed int _fs);

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l5_telemetry_decoder_cc.cc

@@ -70,9 +70,9 @@ gps_l5_telemetry_decoder_cc::gps_l5_telemetry_decoder_cc(
     d_TOW_at_Preamble = 0.0;
     //initialize the CNAV frame decoder (libswiftcnav)
     cnav_msg_decoder_init(&d_cnav_decoder);
-    for (int aux = 0; aux < GPS_L5_NH_CODE_LENGTH; aux++)
+    for (int aux = 0; aux < GPS_L5i_NH_CODE_LENGTH; aux++)
         {
-            if (GPS_L5_NH_CODE[aux] == 0)
+            if (GPS_L5i_NH_CODE[aux] == 0)
                 {
                     bits_NH[aux] = -1.0;
                 }
@@ -119,9 +119,9 @@ int gps_l5_telemetry_decoder_cc::general_work(int noutput_items __attribute__((u
     int symbol_value = 0;
 
     //Search correlation with Neuman-Hofman Code (see IS-GPS-705D)
-    if (sym_hist.size() == GPS_L5_NH_CODE_LENGTH)
+    if (sym_hist.size() == GPS_L5i_NH_CODE_LENGTH)
         {
-            for (int i = 0; i < GPS_L5_NH_CODE_LENGTH; i++)
+            for (int i = 0; i < GPS_L5i_NH_CODE_LENGTH; i++)
                 {
                     if ((bits_NH[i] * sym_hist.at(i)) > 0.0)
                         {
@@ -132,7 +132,7 @@ int gps_l5_telemetry_decoder_cc::general_work(int noutput_items __attribute__((u
                             corr_NH -= 1;
                         }
                 }
-            if (abs(corr_NH) == GPS_L5_NH_CODE_LENGTH)
+            if (abs(corr_NH) == GPS_L5i_NH_CODE_LENGTH)
                 {
                     sync_NH = true;
                     if (corr_NH > 0)

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l5_telemetry_decoder_cc.h

@@ -42,8 +42,7 @@
 #include <utility>
 #include <vector>
 
-extern "C"
+extern "C" {
-{
 #include "cnav_msg.h"
 #include "edc.h"
 #include "bits.h"
@@ -91,7 +90,7 @@ private:
     bool d_flag_valid_word;
 
     Gps_CNAV_Navigation_Message d_CNAV_Message;
-    double bits_NH[GPS_L5_NH_CODE_LENGTH];
+    double bits_NH[GPS_L5i_NH_CODE_LENGTH];
     std::deque<double> sym_hist;
     bool sync_NH;
     bool new_sym;

src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc

@@ -51,7 +51,6 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
     //################# CONFIGURATION PARAMETERS ########################
     int fs_in;
     int vector_length;
-    int f_if;
     bool dump;
     std::string dump_filename;
     std::string item_type;
@@ -64,11 +63,10 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
     float very_early_late_space_chips;
     float early_late_space_narrow_chips;
     float very_early_late_space_narrow_chips;
-
+    unified_ = configuration->property(role + ".unified", false);
     item_type = configuration->property(role + ".item_type", default_item_type);
     int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
     fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
-    f_if = configuration->property(role + ".if", 0);
     dump = configuration->property(role + ".dump", false);
     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);
@@ -94,8 +92,29 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
     if (item_type.compare("gr_complex") == 0)
         {
             item_size_ = sizeof(gr_complex);
+            if (unified_)
+                {
+                    char sig_[3] = "1B";
+                    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,
+                        very_early_late_space_chips,
+                        early_late_space_narrow_chips,
+                        very_early_late_space_narrow_chips,
+                        extend_correlation_symbols,
+                        track_pilot, 'E', sig_);
+                }
+            else
+                {
                     tracking_ = galileo_e1_dll_pll_veml_make_tracking_cc(
-                f_if,
+                        0,
                         fs_in,
                         vector_length,
                         dump,
@@ -111,6 +130,7 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
                         extend_correlation_symbols,
                         track_pilot);
                 }
+        }
     else
         {
             item_size_ = sizeof(gr_complex);
@@ -130,6 +150,9 @@ GalileoE1DllPllVemlTracking::~GalileoE1DllPllVemlTracking()
 
 void GalileoE1DllPllVemlTracking::start_tracking()
 {
+    if (unified_)
+        tracking_unified_->start_tracking();
+    else
         tracking_->start_tracking();
 }
 
@@ -140,12 +163,18 @@ void GalileoE1DllPllVemlTracking::start_tracking()
 void GalileoE1DllPllVemlTracking::set_channel(unsigned int channel)
 {
     channel_ = channel;
+    if (unified_)
+        tracking_unified_->set_channel(channel);
+    else
         tracking_->set_channel(channel);
 }
 
 
 void GalileoE1DllPllVemlTracking::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);
 }
 
@@ -170,11 +199,17 @@ void GalileoE1DllPllVemlTracking::disconnect(gr::top_block_sptr top_block)
 
 gr::basic_block_sptr GalileoE1DllPllVemlTracking::get_left_block()
 {
+    if (unified_)
+        return tracking_unified_;
+    else
         return tracking_;
 }
 
 
 gr::basic_block_sptr GalileoE1DllPllVemlTracking::get_right_block()
 {
+    if (unified_)
+        return tracking_unified_;
+    else
         return tracking_;
 }

src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.h

@@ -39,6 +39,7 @@
 
 #include "tracking_interface.h"
 #include "galileo_e1_dll_pll_veml_tracking_cc.h"
+#include "dll_pll_veml_tracking.h"
 #include <string>
 
 
@@ -95,11 +96,13 @@ public:
 
 private:
     galileo_e1_dll_pll_veml_tracking_cc_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_E1_DLL_PLL_VEML_TRACKING_H_

src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc

@@ -52,34 +52,56 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking(
     //################# CONFIGURATION PARAMETERS ########################
     int fs_in;
     int vector_length;
-    int f_if;
     bool dump;
     std::string dump_filename;
     std::string item_type;
     std::string default_item_type = "gr_complex";
-    float pll_bw_hz;
-    float dll_bw_hz;
-    float early_late_space_chips;
     item_type = configuration->property(role + ".item_type", default_item_type);
     int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
     fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
-    f_if = configuration->property(role + ".if", 0);
     dump = configuration->property(role + ".dump", false);
-    pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0);
+    unified_ = configuration->property(role + ".unified", false);
+    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);
-    dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0);
+    float pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 20.0);
+    float dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 2.0);
+    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);
-    early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5);
+    float early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5);
+    float early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.5);
     std::string default_dump_filename = "./track_ch";
     dump_filename = configuration->property(role + ".dump_filename", default_dump_filename);  //unused!
     vector_length = std::round(fs_in / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS));
-
+    int symbols_extended_correlator = configuration->property(role + ".extend_correlation_symbols", 1);
+    if (symbols_extended_correlator < 1) symbols_extended_correlator = 1;
     //################# MAKE TRACKING GNURadio object ###################
     if (item_type.compare("gr_complex") == 0)
         {
             item_size_ = sizeof(gr_complex);
+            if (unified_)
+                {
+                    char sig_[3] = "1C";
+                    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,
+                        symbols_extended_correlator,
+                        false,
+                        'G', sig_);
+                }
+            else
+                {
                     tracking_ = gps_l1_ca_dll_pll_make_tracking_cc(
-                f_if,
+                        0,
                         fs_in,
                         vector_length,
                         dump,
@@ -88,6 +110,7 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking(
                         dll_bw_hz,
                         early_late_space_chips);
                 }
+        }
     else
         {
             item_size_ = sizeof(gr_complex);
@@ -105,6 +128,9 @@ GpsL1CaDllPllTracking::~GpsL1CaDllPllTracking()
 
 void GpsL1CaDllPllTracking::start_tracking()
 {
+    if (unified_)
+        tracking_unified_->start_tracking();
+    else
         tracking_->start_tracking();
 }
 
@@ -115,12 +141,18 @@ void GpsL1CaDllPllTracking::start_tracking()
 void GpsL1CaDllPllTracking::set_channel(unsigned int channel)
 {
     channel_ = channel;
+    if (unified_)
+        tracking_unified_->set_channel(channel);
+    else
         tracking_->set_channel(channel);
 }
 
 
 void GpsL1CaDllPllTracking::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);
 }
 
@@ -145,11 +177,17 @@ void GpsL1CaDllPllTracking::disconnect(gr::top_block_sptr top_block)
 
 gr::basic_block_sptr GpsL1CaDllPllTracking::get_left_block()
 {
+    if (unified_)
+        return tracking_unified_;
+    else
         return tracking_;
 }
 
 
 gr::basic_block_sptr GpsL1CaDllPllTracking::get_right_block()
 {
+    if (unified_)
+        return tracking_unified_;
+    else
         return tracking_;
 }

src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.h

@@ -40,6 +40,7 @@
 
 #include "tracking_interface.h"
 #include "gps_l1_ca_dll_pll_tracking_cc.h"
+#include "dll_pll_veml_tracking.h"
 #include <string>
 
 class ConfigurationInterface;
@@ -93,11 +94,13 @@ public:
 
 private:
     gps_l1_ca_dll_pll_tracking_cc_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_L1_CA_DLL_PLL_TRACKING_H_

src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt

@@ -42,6 +42,7 @@ set(TRACKING_GR_BLOCKS_SOURCES
      glonass_l2_ca_dll_pll_tracking_cc.cc
      glonass_l2_ca_dll_pll_c_aid_tracking_cc.cc
      glonass_l2_ca_dll_pll_c_aid_tracking_sc.cc
+     dll_pll_veml_tracking.cc
      ${OPT_TRACKING_BLOCKS}
 )
 

src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h

@@ -0,0 +1,230 @@
+/*!
+ * \file dll_pll_veml_tracking.h
+ * \brief Implementation of a code DLL + carrier PLL tracking block.
+ * \author Antonio Ramos, 2018 antonio.ramosdet(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2018  (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_DLL_PLL_VEML_TRACKING_H
+#define GNSS_SDR_DLL_PLL_VEML_TRACKING_H
+
+#include "gnss_synchro.h"
+#include "tracking_2nd_DLL_filter.h"
+#include "tracking_2nd_PLL_filter.h"
+#include "cpu_multicorrelator_real_codes.h"
+#include <gnuradio/block.h>
+#include <fstream>
+#include <string>
+
+
+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,
+    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.
+ */
+class dll_pll_veml_tracking : public gr::block
+{
+public:
+    ~dll_pll_veml_tracking();
+
+    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 dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(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]);
+
+    dll_pll_veml_tracking(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]);
+
+    bool cn0_and_tracking_lock_status();
+    bool acquire_secondary();
+    void do_correlation_step(const gr_complex *input_samples);
+    void run_dll_pll();
+    void update_tracking_vars();
+    void clear_tracking_vars();
+    void save_correlation_results();
+    void log_data(bool integrating);
+    int save_matfile();
+
+    // tracking configuration vars
+    bool d_dump;
+    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
+    bool d_secondary;
+    bool interchange_iq;
+    double d_signal_carrier_freq;
+    double d_code_period;
+    double d_code_chip_rate;
+    unsigned int d_secondary_code_length;
+    unsigned int d_code_length_chips;
+    unsigned int d_code_samples_per_chip;  // All signals have 1 sample per chip code except Gal. E1 which has 2 (CBOC disabled) or 12 (CBOC enabled)
+    int d_symbols_per_bit;
+    std::string systemName;
+    std::string signal_type;
+    std::string *d_secondary_code_string;
+
+    //tracking state machine
+    int d_state;
+    bool d_synchonizing;
+    //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;
+    float *d_local_code_shift_chips;
+    float *d_prompt_data_shift;
+    cpu_multicorrelator_real_codes multicorrelator_cpu;
+    cpu_multicorrelator_real_codes correlator_data_cpu;  //for data channel
+    /*  TODO: currently the multicorrelator does not support adding extra correlator
+        with different local code, thus we need extra multicorrelator instance.
+        Implement this functionality inside multicorrelator class
+        as an enhancement to increase the performance
+     */
+    gr_complex *d_correlator_outs;
+    gr_complex *d_Very_Early;
+    gr_complex *d_Early;
+    gr_complex *d_Prompt;
+    gr_complex *d_Late;
+    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;
+
+    gr_complex d_VE_accu;
+    gr_complex d_E_accu;
+    gr_complex d_P_accu;
+    gr_complex d_L_accu;
+    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;
+    double d_carrier_phase_step_rad;
+    // remaining code phase and carrier phase between tracking loops
+    double d_rem_code_phase_samples;
+    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;
+
+    // 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;
+    double d_code_error_chips;
+    double d_code_error_filt_chips;
+    double d_K_blk_samples;
+    double d_code_freq_chips;
+    double d_carrier_doppler_hz;
+    double d_acc_carrier_phase_rad;
+    double d_rem_code_phase_chips;
+    double d_code_phase_samples;
+    double T_chip_seconds;
+    double T_prn_seconds;
+    double T_prn_samples;
+    double K_blk_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;
+    int d_carrier_lock_fail_counter;
+    double d_carrier_lock_test;
+    double d_CN0_SNV_dB_Hz;
+    double d_carrier_lock_threshold;
+    std::deque<gr_complex> d_Prompt_buffer_deque;
+    gr_complex *d_Prompt_buffer;
+
+    // file dump
+    std::string d_dump_filename;
+    std::ofstream d_dump_file;
+};
+
+#endif  // GNSS_SDR_DLL_PLL_VEML_TRACKING_H

src/algorithms/tracking/libs/cpu_multicorrelator_real_codes.cc

@@ -122,7 +122,7 @@ bool cpu_multicorrelator_real_codes::Carrier_wipeoff_multicorrelator_resampler(
     lv_32fc_t phase_offset_as_complex[1];
     phase_offset_as_complex[0] = lv_cmake(std::cos(rem_carrier_phase_in_rad), -std::sin(rem_carrier_phase_in_rad));
     // call VOLK_GNSSSDR kernel
-    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn(d_corr_out, d_sig_in, std::exp(lv_32fc_t(0, -phase_step_rad)), phase_offset_as_complex, (const float**)d_local_codes_resampled, d_n_correlators, signal_length_samples);
+    volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn(d_corr_out, d_sig_in, std::exp(lv_32fc_t(0.0, -phase_step_rad)), phase_offset_as_complex, const_cast<const float**>(d_local_codes_resampled), d_n_correlators, signal_length_samples);
     return true;
 }
 

src/algorithms/tracking/libs/lock_detectors.cc

@@ -67,20 +67,20 @@
  */
 float cn0_svn_estimator(gr_complex* Prompt_buffer, int length, long fs_in, double code_length)
 {
-    double SNR = 0;
+    double SNR = 0.0;
-    double SNR_dB_Hz = 0;
+    double SNR_dB_Hz = 0.0;
-    double Psig = 0;
+    double Psig = 0.0;
-    double Ptot = 0;
+    double Ptot = 0.0;
     for (int i = 0; i < length; i++)
         {
             Psig += std::abs(static_cast<double>(Prompt_buffer[i].real()));
             Ptot += static_cast<double>(Prompt_buffer[i].imag()) * static_cast<double>(Prompt_buffer[i].imag()) + static_cast<double>(Prompt_buffer[i].real()) * static_cast<double>(Prompt_buffer[i].real());
         }
-    Psig = Psig / static_cast<double>(length);
+    Psig /= static_cast<double>(length);
     Psig = Psig * Psig;
-    Ptot = Ptot / static_cast<double>(length);
+    Ptot /= static_cast<double>(length);
     SNR = Psig / (Ptot - Psig);
-    SNR_dB_Hz = 10 * log10(SNR) + 10 * log10(static_cast<double>(fs_in) / 2) - 10 * log10(code_length);
+    SNR_dB_Hz = 10.0 * log10(SNR) + 10.0 * log10(static_cast<double>(fs_in) / 2.0) - 10.0 * log10(code_length);
     return static_cast<float>(SNR_dB_Hz);
 }
 
@@ -96,10 +96,10 @@ float cn0_svn_estimator(gr_complex* Prompt_buffer, int length, long fs_in, doubl
  */
 float carrier_lock_detector(gr_complex* Prompt_buffer, int length)
 {
-    float tmp_sum_I = 0;
+    float tmp_sum_I = 0.0;
-    float tmp_sum_Q = 0;
+    float tmp_sum_Q = 0.0;
-    float NBD = 0;
+    float NBD = 0.0;
-    float NBP = 0;
+    float NBP = 0.0;
     for (int i = 0; i < length; i++)
         {
             tmp_sum_I += Prompt_buffer[i].real();

src/algorithms/tracking/libs/tracking_2nd_DLL_filter.cc

@@ -41,11 +41,10 @@
 void Tracking_2nd_DLL_filter::calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k)
 {
     // Solve natural frequency
-    float Wn;
+    float Wn = lbw * 8.0 * zeta / (4.0 * zeta * zeta + 1.0);
-    Wn = lbw * 8 * zeta / (4 * zeta * zeta + 1);
     // solve for t1 & t2
     *tau1 = k / (Wn * Wn);
-    *tau2 = (2.0 * zeta) / Wn;
+    *tau2 = 2.0 * zeta / Wn;
 }
 
 
@@ -67,9 +66,7 @@ void Tracking_2nd_DLL_filter::initialize()
 
 float Tracking_2nd_DLL_filter::get_code_nco(float DLL_discriminator)
 {
-    float code_nco;
+    float code_nco = d_old_code_nco + (d_tau2_code / d_tau1_code) * (DLL_discriminator - d_old_code_error) + (DLL_discriminator + d_old_code_error) * (d_pdi_code / (2.0 * d_tau1_code));
-    code_nco = d_old_code_nco + (d_tau2_code / d_tau1_code) * (DLL_discriminator - d_old_code_error) + (DLL_discriminator + d_old_code_error) * (d_pdi_code / (2 * d_tau1_code));
-    //code_nco = d_old_code_nco + (d_tau2_code/d_tau1_code)*(DLL_discriminator - d_old_code_error) + DLL_discriminator * (d_pdi_code/d_tau1_code);
     d_old_code_nco = code_nco;
     d_old_code_error = DLL_discriminator;  //[chips]
     return code_nco;

src/algorithms/tracking/libs/tracking_2nd_DLL_filter.h

@@ -49,13 +49,13 @@ class Tracking_2nd_DLL_filter
 {
 private:
     // PLL filter parameters
-    float d_tau1_code = 0;
+    float d_tau1_code = 0.0;
-    float d_tau2_code = 0;
+    float d_tau2_code = 0.0;
-    float d_pdi_code = 0;
+    float d_pdi_code = 0.0;
-    float d_dllnoisebandwidth = 0;
+    float d_dllnoisebandwidth = 0.0;
-    float d_dlldampingratio = 0;
+    float d_dlldampingratio = 0.0;
-    float d_old_code_error = 0;
+    float d_old_code_error = 0.0;
-    float d_old_code_nco = 0;
+    float d_old_code_nco = 0.0;
     void calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k);
 
 public:

src/algorithms/tracking/libs/tracking_2nd_PLL_filter.cc

@@ -40,11 +40,10 @@
 void Tracking_2nd_PLL_filter::calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k)
 {
     // Solve natural frequency
-    float Wn;
+    float Wn = lbw * 8.0 * zeta / (4.0 * zeta * zeta + 1.0);
-    Wn = lbw * 8 * zeta / (4 * zeta * zeta + 1);
     // solve for t1 & t2
     *tau1 = k / (Wn * Wn);
-    *tau2 = (2.0 * zeta) / Wn;
+    *tau2 = 2.0 * zeta / Wn;
 }
 
 
@@ -71,8 +70,7 @@ void Tracking_2nd_PLL_filter::initialize()
  */
 float Tracking_2nd_PLL_filter::get_carrier_nco(float PLL_discriminator)
 {
-    float carr_nco;
+    float carr_nco = d_old_carr_nco + (d_tau2_carr / d_tau1_carr) * (PLL_discriminator - d_old_carr_error) + (PLL_discriminator + d_old_carr_error) * (d_pdi_carr / (2.0 * d_tau1_carr));
-    carr_nco = d_old_carr_nco + (d_tau2_carr / d_tau1_carr) * (PLL_discriminator - d_old_carr_error) + (PLL_discriminator + d_old_carr_error) * (d_pdi_carr / (2 * d_tau1_carr));
     //carr_nco = d_old_carr_nco + (d_tau2_carr/d_tau1_carr)*(PLL_discriminator - d_old_carr_error) + PLL_discriminator * (d_pdi_carr/d_tau1_carr);
     d_old_carr_nco = carr_nco;
     d_old_carr_error = PLL_discriminator;

src/algorithms/tracking/libs/tracking_2nd_PLL_filter.h

@@ -48,15 +48,15 @@ class Tracking_2nd_PLL_filter
 {
 private:
     // PLL filter parameters
-    float d_tau1_carr = 0;
+    float d_tau1_carr = 0.0;
-    float d_tau2_carr = 0;
+    float d_tau2_carr = 0.0;
-    float d_pdi_carr = 0;
+    float d_pdi_carr = 0.0;
 
-    float d_pllnoisebandwidth = 0;
+    float d_pllnoisebandwidth = 0.0;
-    float d_plldampingratio = 0;
+    float d_plldampingratio = 0.0;
 
-    float d_old_carr_error = 0;
+    float d_old_carr_error = 0.0;
-    float d_old_carr_nco = 0;
+    float d_old_carr_nco = 0.0;
 
     void calculate_lopp_coef(float* tau1, float* tau2, float lbw, float zeta, float k);
 

src/algorithms/tracking/libs/tracking_discriminators.cc

@@ -83,7 +83,7 @@ double pll_cloop_two_quadrant_atan(gr_complex prompt_s1)
         }
     else
         {
-            return 0;
+            return 0.0;
         }
 }
 
@@ -107,7 +107,7 @@ double dll_nc_e_minus_l_normalized(gr_complex early_s1, gr_complex late_s1)
         }
     else
         {
-            return 0.5 * (P_early - P_late) / ((P_early + P_late));
+            return 0.5 * (P_early - P_late) / (P_early + P_late);
         }
 }
 
@@ -131,6 +131,6 @@ double dll_nc_vemlp_normalized(gr_complex very_early_s1, gr_complex early_s1, gr
         }
     else
         {
-            return (P_early - P_late) / ((P_early + P_late));
+            return (P_early - P_late) / (P_early + P_late);
         }
 }

src/algorithms/tracking/libs/tracking_loop_filter.cc

@@ -37,9 +37,6 @@
 #include <glog/logging.h>
 
 
-#define MAX_LOOP_ORDER 3
-#define MAX_HISTORY_LENGTH 4
-
 Tracking_loop_filter::Tracking_loop_filter(float update_interval,
     float noise_bandwidth,
     int loop_order,
@@ -50,8 +47,8 @@ Tracking_loop_filter::Tracking_loop_filter(float update_interval,
       d_noise_bandwidth(noise_bandwidth),
       d_update_interval(update_interval)
 {
-    d_inputs.resize(MAX_HISTORY_LENGTH, 0.0);
+    d_inputs.resize(MAX_LOOP_HISTORY_LENGTH, 0.0);
-    d_outputs.resize(MAX_HISTORY_LENGTH, 0.0);
+    d_outputs.resize(MAX_LOOP_HISTORY_LENGTH, 0.0);
     update_coefficients();
 }
 
@@ -62,8 +59,8 @@ Tracking_loop_filter::Tracking_loop_filter()
       d_noise_bandwidth(15.0),
       d_update_interval(0.001)
 {
-    d_inputs.resize(MAX_HISTORY_LENGTH, 0.0);
+    d_inputs.resize(MAX_LOOP_HISTORY_LENGTH, 0.0);
-    d_outputs.resize(MAX_HISTORY_LENGTH, 0.0);
+    d_outputs.resize(MAX_LOOP_HISTORY_LENGTH, 0.0);
     update_coefficients();
 }
 
@@ -75,12 +72,12 @@ Tracking_loop_filter::~Tracking_loop_filter()
 float Tracking_loop_filter::apply(float current_input)
 {
     // Now apply the filter coefficients:
-    float result = 0;
+    float result = 0.0;
 
     // Hanlde the old outputs first:
     for (unsigned int ii = 0; ii < d_output_coefficients.size(); ++ii)
         {
-            result += d_output_coefficients[ii] * d_outputs[(d_current_index + ii) % MAX_HISTORY_LENGTH];
+            result += d_output_coefficients[ii] * d_outputs[(d_current_index + ii) % MAX_LOOP_HISTORY_LENGTH];
         }
 
     // Now update the index to handle the inputs.
@@ -93,7 +90,7 @@ float Tracking_loop_filter::apply(float current_input)
     d_current_index--;
     if (d_current_index < 0)
         {
-            d_current_index += MAX_HISTORY_LENGTH;
+            d_current_index += MAX_LOOP_HISTORY_LENGTH;
         }
 
     d_inputs[d_current_index] = current_input;
@@ -101,7 +98,7 @@ float Tracking_loop_filter::apply(float current_input)
 
     for (unsigned int ii = 0; ii < d_input_coefficients.size(); ++ii)
         {
-            result += d_input_coefficients[ii] * d_inputs[(d_current_index + ii) % MAX_HISTORY_LENGTH];
+            result += d_input_coefficients[ii] * d_inputs[(d_current_index + ii) % MAX_LOOP_HISTORY_LENGTH];
         }
 
 
@@ -122,7 +119,7 @@ void Tracking_loop_filter::update_coefficients(void)
     float wn;
     float T = d_update_interval;
 
-    float zeta = 1 / std::sqrt(2);
+    float zeta = 1.0 / std::sqrt(2.0);
 
     // The following is based on the bilinear transform approximation of
     // the analog integrator. The loop format is from Kaplan & Hegarty
@@ -146,7 +143,7 @@ void Tracking_loop_filter::update_coefficients(void)
                     d_input_coefficients[1] = g1 * T / 2.0;
 
                     d_output_coefficients.resize(1);
-                    d_output_coefficients[0] = 1;
+                    d_output_coefficients[0] = 1.0;
                 }
             else
                 {
@@ -157,28 +154,28 @@ void Tracking_loop_filter::update_coefficients(void)
                 }
             break;
         case 2:
-            wn = d_noise_bandwidth * (8 * zeta) / (4 * zeta * zeta + 1);
+            wn = d_noise_bandwidth * (8.0 * zeta) / (4.0 * zeta * zeta + 1.0);
             g1 = wn * wn;
-            g2 = wn * 2 * zeta;
+            g2 = wn * 2.0 * zeta;
             if (d_include_last_integrator)
                 {
                     d_input_coefficients.resize(3);
-                    d_input_coefficients[0] = T / 2 * (g1 * T / 2 + g2);
+                    d_input_coefficients[0] = T / 2.0 * (g1 * T / 2.0 + g2);
-                    d_input_coefficients[1] = T * T / 2 * g1;
+                    d_input_coefficients[1] = T * T / 2.0 * g1;
-                    d_input_coefficients[2] = T / 2 * (g1 * T / 2 - g2);
+                    d_input_coefficients[2] = T / 2.0 * (g1 * T / 2.0 - g2);
 
                     d_output_coefficients.resize(2);
-                    d_output_coefficients[0] = 2;
+                    d_output_coefficients[0] = 2.0;
-                    d_output_coefficients[1] = -1;
+                    d_output_coefficients[1] = -1.0;
                 }
             else
                 {
                     d_input_coefficients.resize(2);
                     d_input_coefficients[0] = (g1 * T / 2.0 + g2);
-                    d_input_coefficients[1] = g1 * T / 2 - g2;
+                    d_input_coefficients[1] = g1 * T / 2.0 - g2;
 
                     d_output_coefficients.resize(1);
-                    d_output_coefficients[0] = 1;
+                    d_output_coefficients[0] = 1.0;
                 }
             break;
 
@@ -193,27 +190,27 @@ void Tracking_loop_filter::update_coefficients(void)
             if (d_include_last_integrator)
                 {
                     d_input_coefficients.resize(4);
-                    d_input_coefficients[0] = T / 2 * (g3 + T / 2 * (g2 + T / 2 * g1));
+                    d_input_coefficients[0] = T / 2.0 * (g3 + T / 2.0 * (g2 + T / 2.0 * g1));
-                    d_input_coefficients[1] = T / 2 * (-g3 + T / 2 * (g2 + 3 * T / 2 * g1));
+                    d_input_coefficients[1] = T / 2.0 * (-g3 + T / 2.0 * (g2 + 3.0 * T / 2.0 * g1));
-                    d_input_coefficients[2] = T / 2 * (-g3 - T / 2 * (g2 - 3 * T / 2 * g1));
+                    d_input_coefficients[2] = T / 2.0 * (-g3 - T / 2.0 * (g2 - 3.0 * T / 2.0 * g1));
-                    d_input_coefficients[3] = T / 2 * (g3 - T / 2 * (g2 - T / 2 * g1));
+                    d_input_coefficients[3] = T / 2.0 * (g3 - T / 2.0 * (g2 - T / 2.0 * g1));
 
                     d_output_coefficients.resize(3);
-                    d_output_coefficients[0] = 3;
+                    d_output_coefficients[0] = 3.0;
-                    d_output_coefficients[1] = -3;
+                    d_output_coefficients[1] = -3.0;
-                    d_output_coefficients[2] = 1;
+                    d_output_coefficients[2] = 1.0;
                 }
             else
                 {
                     d_input_coefficients.resize(3);
-                    d_input_coefficients[0] = g3 + T / 2 * (g2 + T / 2 * g1);
+                    d_input_coefficients[0] = g3 + T / 2.0 * (g2 + T / 2.0 * g1);
-                    d_input_coefficients[1] = g1 * T * T / 2 - 2 * g3;
+                    d_input_coefficients[1] = g1 * T * T / 2.0 - 2.0 * g3;
-                    d_input_coefficients[2] = g3 + T / 2 * (-g2 + T / 2 * g1);
+                    d_input_coefficients[2] = g3 + T / 2.0 * (-g2 + T / 2.0 * g1);
 
 
                     d_output_coefficients.resize(2);
-                    d_output_coefficients[0] = 2;
+                    d_output_coefficients[0] = 2.0;
-                    d_output_coefficients[1] = -1;
+                    d_output_coefficients[1] = -1.0;
                 }
             break;
         };
@@ -254,7 +251,7 @@ bool Tracking_loop_filter::get_include_last_integrator(void) const
 
 void Tracking_loop_filter::set_order(int loop_order)
 {
-    if (loop_order < 1 || loop_order > MAX_LOOP_ORDER)
+    if (loop_order < 1 or loop_order > MAX_LOOP_ORDER)
         {
             LOG(ERROR) << "Ignoring attempt to set loop order to " << loop_order
                        << ". Maximum allowed order is: " << MAX_LOOP_ORDER
@@ -274,7 +271,7 @@ int Tracking_loop_filter::get_order(void) const
 
 void Tracking_loop_filter::initialize(float initial_output)
 {
-    d_inputs.assign(MAX_HISTORY_LENGTH, 0.0);
+    d_inputs.assign(MAX_LOOP_HISTORY_LENGTH, 0.0);
-    d_outputs.assign(MAX_HISTORY_LENGTH, initial_output);
+    d_outputs.assign(MAX_LOOP_HISTORY_LENGTH, initial_output);
-    d_current_index = MAX_HISTORY_LENGTH - 1;
+    d_current_index = MAX_LOOP_HISTORY_LENGTH - 1;
 }

src/algorithms/tracking/libs/tracking_loop_filter.h

@@ -33,6 +33,8 @@
 
 #ifndef GNSS_SDR_TRACKING_LOOP_FILTER_H_
 #define GNSS_SDR_TRACKING_LOOP_FILTER_H_
+#define MAX_LOOP_ORDER 3
+#define MAX_LOOP_HISTORY_LENGTH 4
 
 #include <vector>
 

src/core/system_parameters/GPS_L5.h

@@ -36,6 +36,7 @@
 #include "GPS_CNAV.h"
 #include "MATH_CONSTANTS.h"
 #include <cstdint>
+#include <string>
 
 
 // Physical constants
@@ -181,7 +182,11 @@ const int GPS_L5_SYMBOLS_PER_BIT = 2;
 const int GPS_L5_SAMPLES_PER_SYMBOL = 10;
 const int GPS_L5_CNAV_DATA_PAGE_SYMBOLS = 600;
 const int GPS_L5_CNAV_DATA_PAGE_DURATION_S = 6;
-const int GPS_L5_NH_CODE_LENGTH = 10;
+const int GPS_L5i_NH_CODE_LENGTH = 10;
-const int GPS_L5_NH_CODE[10] = {0, 0, 0, 0, 1, 1, 0, 1, 0, 1};
+const int GPS_L5i_NH_CODE[10] = {0, 0, 0, 0, 1, 1, 0, 1, 0, 1};
+const std::string GPS_L5i_NH_CODE_STR = "0000110101";
+const int GPS_L5q_NH_CODE_LENGTH = 20;
+const int GPS_L5q_NH_CODE[20] = {0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0};
+const std::string GPS_L5q_NH_CODE_STR = "00000100110101001110";
 
 #endif /* GNSS_SDR_GPS_L5_H_ */

src/tests/unit-tests/signal-processing-blocks/libs/tracking_dump_reader.cc

@@ -35,24 +35,24 @@ bool tracking_dump_reader::read_binary_obs()
 {
     try
         {
+            d_dump_file.read(reinterpret_cast<char *>(&abs_VE), sizeof(float));
             d_dump_file.read(reinterpret_cast<char *>(&abs_E), sizeof(float));
             d_dump_file.read(reinterpret_cast<char *>(&abs_P), sizeof(float));
             d_dump_file.read(reinterpret_cast<char *>(&abs_L), sizeof(float));
+            d_dump_file.read(reinterpret_cast<char *>(&abs_VL), sizeof(float));
             d_dump_file.read(reinterpret_cast<char *>(&prompt_I), sizeof(float));
             d_dump_file.read(reinterpret_cast<char *>(&prompt_Q), sizeof(float));
-
             d_dump_file.read(reinterpret_cast<char *>(&PRN_start_sample_count), sizeof(unsigned long int));
-
+            d_dump_file.read(reinterpret_cast<char *>(&acc_carrier_phase_rad), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&acc_carrier_phase_rad), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&carrier_doppler_hz), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&carrier_doppler_hz), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&code_freq_chips), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&code_freq_chips), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&carr_error_hz), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&carr_error_hz), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&carr_error_filt_hz), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&carr_error_filt_hz), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&code_error_chips), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&code_error_chips), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&code_error_filt_chips), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&code_error_filt_chips), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&CN0_SNV_dB_Hz), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&CN0_SNV_dB_Hz), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&carrier_lock_test), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&carrier_lock_test), sizeof(double));
+            d_dump_file.read(reinterpret_cast<char *>(&aux1), sizeof(float));
-            d_dump_file.read(reinterpret_cast<char *>(&aux1), sizeof(double));
             d_dump_file.read(reinterpret_cast<char *>(&aux2), sizeof(double));
             d_dump_file.read(reinterpret_cast<char *>(&PRN), sizeof(unsigned int));
         }
@@ -82,8 +82,8 @@ bool tracking_dump_reader::restart()
 long int tracking_dump_reader::num_epochs()
 {
     std::ifstream::pos_type size;
-    int number_of_double_vars = 11;
+    int number_of_double_vars = 1;
-    int number_of_float_vars = 5;
+    int number_of_float_vars = 17;
     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 tmpfile(d_dump_filename.c_str(), std::ios::binary | std::ios::ate);

src/tests/unit-tests/signal-processing-blocks/libs/tracking_dump_reader.h

@@ -45,10 +45,12 @@ public:
     bool open_obs_file(std::string out_file);
 
     //tracking dump variables
-    // EPR
+    // VEPLVL
+    float abs_VE;
     float abs_E;
     float abs_P;
     float abs_L;
+    float abs_VL;
     // PROMPT I and Q (to analyze navigation symbols)
     float prompt_I;
     float prompt_Q;
@@ -56,26 +58,26 @@ public:
     unsigned long int PRN_start_sample_count;
 
     // accumulated carrier phase
-    double acc_carrier_phase_rad;
+    float acc_carrier_phase_rad;
 
     // carrier and code frequency
-    double carrier_doppler_hz;
+    float carrier_doppler_hz;
-    double code_freq_chips;
+    float code_freq_chips;
 
     // PLL commands
-    double carr_error_hz;
+    float carr_error_hz;
-    double carr_error_filt_hz;
+    float carr_error_filt_hz;
 
     // DLL commands
-    double code_error_chips;
+    float code_error_chips;
-    double code_error_filt_chips;
+    float code_error_filt_chips;
 
     // CN0 and carrier lock test
-    double CN0_SNV_dB_Hz;
+    float CN0_SNV_dB_Hz;
-    double carrier_lock_test;
+    float carrier_lock_test;
 
     // AUX vars (for debug purposes)
-    double aux1;
+    float aux1;
     double aux2;
 
     unsigned int PRN;

src/tests/unit-tests/signal-processing-blocks/tracking/gps_l1_ca_dll_pll_tracking_test.cc

@@ -225,6 +225,10 @@ void GpsL1CADllPllTrackingTest::configure_receiver()
     config->set_property("Tracking_1C.pll_bw_hz", "20.0");
     config->set_property("Tracking_1C.dll_bw_hz", "2.0");
     config->set_property("Tracking_1C.early_late_space_chips", "0.5");
+    config->set_property("Tracking_1C.pll_bw_narrow_hz", "20.0");
+    config->set_property("Tracking_1C.dll_bw_narrow_hz", "2.0");
+    config->set_property("Tracking_1C.early_late_space_narrow_chips", "0.5");
+    config->set_property("Tracking_1C.unified", "true");
     config->set_property("Tracking_1C.extend_correlation_ms", "1");
     config->set_property("Tracking_1C.dump", "true");
     config->set_property("Tracking_1C.dump_filename", "./tracking_ch_");

src/utils/matlab/dll_pll_veml_plot_sample.m

@@ -0,0 +1,84 @@
+% /*!
+%  * \file dll_pll_vml_plot_sample.m
+%  * \brief Read GNSS-SDR Tracking dump binary file using the provided
+%  function and plot some internal variables
+%  * \author Javier Arribas, 2011. jarribas(at)cttc.es
+%  * \author Antonio Ramos,  2018. antonio.ramos(at)cttc.es
+%  * -------------------------------------------------------------------------
+%  *
+%  * Copyright (C) 2010-2018  (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/>.
+%  *
+%  * -------------------------------------------------------------------------
+%  */ 
+close all;
+clear all;
+
+if ~exist('dll_pll_veml_read_tracking_dump.m','file')
+    addpath('./libs')
+end
+
+samplingFreq = 5000000;     %[Hz]
+coherent_integration_time_ms = 20; %[ms]
+channels = 5;   % Number of channels
+first_channel = 0;  % Number of the first channel
+
+path = '/dump_dir/';  %% CHANGE THIS PATH
+
+for N=1:1:channels
+    tracking_log_path = [path 'track_ch_' num2str(N+first_channel-1) '.dat']; %% CHANGE track_ch BY YOUR dump_filename
+    GNSS_tracking(N)= dll_pll_veml_read_tracking_dump(tracking_log_path);   
+end
+
+% GNSS-SDR format conversion to MATLAB GPS receiver
+
+for N=1:1:channels
+        trackResults(N).status = 'T'; %fake track
+        trackResults(N).codeFreq       = GNSS_tracking(N).code_freq_hz.';
+        trackResults(N).carrFreq       = GNSS_tracking(N).carrier_doppler_hz.';
+        trackResults(N).dllDiscr       = GNSS_tracking(N).code_error.';
+        trackResults(N).dllDiscrFilt   = GNSS_tracking(N).code_nco.';
+        trackResults(N).pllDiscr       = GNSS_tracking(N).carr_error.';
+        trackResults(N).pllDiscrFilt   = GNSS_tracking(N).carr_nco.';
+ 
+        trackResults(N).I_P = GNSS_tracking(N).P.';
+        trackResults(N).Q_P = zeros(1,length(GNSS_tracking(N).P));
+
+        trackResults(N).I_VE = GNSS_tracking(N).VE.';
+        trackResults(N).I_E = GNSS_tracking(N).E.';
+        trackResults(N).I_L = GNSS_tracking(N).L.';
+        trackResults(N).I_VL = GNSS_tracking(N).VL.';
+        trackResults(N).Q_VE = zeros(1,length(GNSS_tracking(N).VE));
+        trackResults(N).Q_E = zeros(1,length(GNSS_tracking(N).E));
+        trackResults(N).Q_L = zeros(1,length(GNSS_tracking(N).L));
+        trackResults(N).Q_VL = zeros(1,length(GNSS_tracking(N).VL));
+        trackResults(N).data_I = GNSS_tracking(N).prompt_I.';
+        trackResults(N).data_Q = GNSS_tracking(N).prompt_Q.';
+        trackResults(N).PRN = GNSS_tracking(N).PRN.';
+        trackResults(N).CNo = GNSS_tracking(N).CN0_SNV_dB_Hz.';
+        
+        % Use original MATLAB tracking plot function
+        settings.numberOfChannels = channels;
+        settings.msToProcess = length(GNSS_tracking(N).E)*coherent_integration_time_ms;
+        plotVEMLTracking(N,trackResults,settings)
+end
+
+
+

src/utils/matlab/libs/dll_pll_veml_read_tracking_dump.m

@@ -0,0 +1,153 @@
+% /*!
+%  * \file dll_pll_veml_read_tracking_dump.m
+%  * \brief Read GNSS-SDR Tracking dump binary file into MATLAB.
+%  * \author Luis Esteve, 2012. luis(at)epsilon-formacion.com
+%  * -------------------------------------------------------------------------
+%  *
+%  * Copyright (C) 2010-2012  (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/>.
+%  *
+%  * -------------------------------------------------------------------------
+%  */         
+
+function [GNSS_tracking] = dll_pll_veml_read_tracking_dump (filename, count)
+  %% usage: dll_pll_veml_read_tracking_dump (filename, [count])
+  %%
+  %% open GNSS-SDR tracking binary log file .dat and return the contents
+  %%
+
+  m = nargchk (1,2,nargin);
+  
+  num_float_vars = 17;
+  num_unsigned_long_int_vars = 1;
+  num_double_vars = 1;
+  num_unsigned_int_vars = 1;
+  
+  if(~isempty(strfind(computer('arch'), '64')))
+      % 64-bit computer
+      double_size_bytes = 8;
+      unsigned_long_int_size_bytes = 8;
+      float_size_bytes = 4;
+      unsigned_int_size_bytes = 4;
+  else
+      double_size_bytes = 8;
+      unsigned_long_int_size_bytes = 4;
+      float_size_bytes = 4;
+      unsigned_int_size_bytes = 4;
+  end
+  
+  skip_bytes_each_read = float_size_bytes * num_float_vars + unsigned_long_int_size_bytes * num_unsigned_long_int_vars + ...
+   double_size_bytes * num_double_vars + num_unsigned_int_vars*unsigned_int_size_bytes;
+  
+  bytes_shift = 0;
+        
+  if (m)
+    usage (m);
+  end
+
+  if (nargin < 2)
+    count = Inf;
+  end
+    %loops_counter = fread (f, count, 'uint32',4*12);
+  f = fopen (filename, 'rb');
+  if (f < 0)
+  else
+    v1 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v2 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v3 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v4 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v5 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v6 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v7 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next interleaved float
+    v8 = fread (f, count, 'long', skip_bytes_each_read - unsigned_long_int_size_bytes);
+        bytes_shift = bytes_shift + unsigned_long_int_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v9 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v10 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v11 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v12 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v13 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v14 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v15 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v16 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next interleaved float
+    v17 = fread (f, count, 'float', skip_bytes_each_read - float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next float
+    v18 = fread (f, count, 'float', skip_bytes_each_read-float_size_bytes);
+        bytes_shift = bytes_shift + float_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next double
+    v19 = fread (f, count, 'double', skip_bytes_each_read - double_size_bytes);  
+        bytes_shift = bytes_shift + double_size_bytes;
+    fseek(f,bytes_shift,'bof'); % move to next unsigned int
+    v20 = fread (f, count, 'uint', skip_bytes_each_read - unsigned_int_size_bytes);
+    fclose (f);
+    
+    GNSS_tracking.VE = v1;
+    GNSS_tracking.E = v2;
+    GNSS_tracking.P = v3;
+    GNSS_tracking.L = v4;
+    GNSS_tracking.VL = v5;
+    GNSS_tracking.prompt_I = v6;
+    GNSS_tracking.prompt_Q = v7;
+    GNSS_tracking.PRN_start_sample = v8;
+    GNSS_tracking.acc_carrier_phase_rad = v9;
+    GNSS_tracking.carrier_doppler_hz = v10;
+    GNSS_tracking.code_freq_hz = v11;
+    GNSS_tracking.carr_error = v12;
+    GNSS_tracking.carr_nco = v13;
+    GNSS_tracking.code_error = v14;
+    GNSS_tracking.code_nco = v15;
+    GNSS_tracking.CN0_SNV_dB_Hz = v16;
+    GNSS_tracking.carrier_lock_test = v17;
+    GNSS_tracking.var1 = v18;
+    GNSS_tracking.var2 = v19;
+    GNSS_tracking.PRN = v20;
+  end
+  

src/utils/matlab/libs/plotVEMLTracking.m

@@ -69,8 +69,8 @@ for channelNr = channelList
         timeAxisInSeconds = (1:4:settings.msToProcess)/1000;
 
         %----- Discrete-Time Scatter Plot ---------------------------------
-        plot(handles(1, 1), trackResults(channelNr).I_P,...
+        plot(handles(1, 1), trackResults(channelNr).data_I,...
-                            trackResults(channelNr).Q_P, ...
+                            trackResults(channelNr).data_Q, ...
                             '.');
 
         grid  (handles(1, 1));
@@ -80,8 +80,9 @@ for channelNr = channelList
         ylabel(handles(1, 1), 'Q prompt');
 
         %----- Nav bits ---------------------------------------------------
-        plot  (handles(1, 2), timeAxisInSeconds, ...
+        t = (1:length(trackResults(channelNr).data_I));
-                              trackResults(channelNr).I_P);
+        plot  (handles(1, 2), t, ...
+                              trackResults(channelNr).data_I);
 
         grid  (handles(1, 2));
         title (handles(1, 2), 'Bits of the navigation message');
@@ -89,7 +90,8 @@ for channelNr = channelList
         axis  (handles(1, 2), 'tight');
 
         %----- PLL discriminator unfiltered--------------------------------
-        plot  (handles(2, 1), timeAxisInSeconds, ...
+        t = (1:length(trackResults(channelNr).pllDiscr));
+        plot  (handles(2, 1), t, ...
                               trackResults(channelNr).pllDiscr, 'r');      
 
         grid  (handles(2, 1));
@@ -99,7 +101,8 @@ for channelNr = channelList
         title (handles(2, 1), 'Raw PLL discriminator');
 
         %----- Correlation ------------------------------------------------
-        plot(handles(2, 2), timeAxisInSeconds, ...
+        t = (1:length(trackResults(channelNr).I_VE));
+        plot(handles(2, 2), t, ...
                             [sqrt(trackResults(channelNr).I_VE.^2 + ...
                                   trackResults(channelNr).Q_VE.^2)', ...
                              sqrt(trackResults(channelNr).I_E.^2 + ...
@@ -127,7 +130,8 @@ for channelNr = channelList
         set(hLegend, 'Interpreter', 'Latex');
 
         %----- PLL discriminator filtered----------------------------------
-        plot  (handles(3, 1), timeAxisInSeconds, ...
+        t = (1:length(trackResults(channelNr).pllDiscrFilt));
+        plot  (handles(3, 1), t, ...
                               trackResults(channelNr).pllDiscrFilt, 'b');      
 
         grid  (handles(3, 1));
@@ -137,7 +141,8 @@ for channelNr = channelList
         title (handles(3, 1), 'Filtered PLL discriminator');
 
         %----- DLL discriminator unfiltered--------------------------------
-        plot  (handles(3, 2), timeAxisInSeconds, ...
+        t = (1:length(trackResults(channelNr).dllDiscr));
+        plot  (handles(3, 2), t, ...
                               trackResults(channelNr).dllDiscr, 'r');      
 
         grid  (handles(3, 2));
@@ -147,7 +152,8 @@ for channelNr = channelList
         title (handles(3, 2), 'Raw DLL discriminator');
 
         %----- DLL discriminator filtered----------------------------------
-        plot  (handles(3, 3), timeAxisInSeconds, ...
+        t = (1:length(trackResults(channelNr).dllDiscrFilt));
+        plot  (handles(3, 3), t, ...
                               trackResults(channelNr).dllDiscrFilt, 'b');      
 
         grid  (handles(3, 3));