Tracking
A generic GNSS signal defined by its complex baseband equivalent, \(s_{T}(t)\), the digital signal at the input of a Tracking block can be written as:
\[\begin{equation} \label{xin} x_\text{IN}[k] = A(t)\tilde{s}_{T}(t\tau(t))e^{j \left( 2\pi f_D(t) t + \phi(t) \right) } \Bigr \rvert_{t=kT_s} + n(t) \Bigr \rvert_{t=kT_s} \end{equation}\]where \(A(t)\) is the signal amplitude, \(\tilde{s}_{T}(t)\) is a filtered version of \(s_T(t)\), \(\tau(t)\) is a timevarying code delay, \(f_D(t)\) is a timevarying Doppler shift, \(\phi(t)\) is a timevarying carrier phase shift, \(n(t)\) is a term modeling random noise and \(T_s\) is the sampling period.
The role of a Tracking block is to follow the evolution of the signal synchronization parameters: code phase \(\tau(t)\), Doppler shift \(f_D(t)\) and carrier phase \(\phi(t)\).
According to the Maximum Likelihood (ML) approach^{1}, obtaining the optimum estimators implies the maximization of the correlation of the incoming signal with its matched filter. The ML estimates of \(f_D\) and \(\tau\) can be obtained by maximizing the function
\[\begin{equation} \hat{f}_{\!D_{ML}}, \hat{\tau}_{ML} = \arg \max_{f_D,\tau} \left\{ \left \hat{R}_{xd}(f_D,\tau)\right^2\right\}~, \end{equation}\]where
\[\begin{equation} \hat{R}_{xd}(f_D,\tau)=\frac{1}{K}\sum_{k=0}^{K1}x_{\text{IN}}[k]d[kT_s\tau]e^{j 2 \pi f_D kT_s}~, \end{equation}\]with \(K\) being the number of samples in an integration period, and \(d[k]\) is a locally generated reference.
This is usually achieved with closedloop structures designed to minimize the difference between the code phase, carrier phase and frequency of the incoming signal with respect to the locallygenerated replica \(d[k]\).
In the case of code phase tracking, the cost function is driven to the maximum using feedback loops that employ the derivative \(\frac{dR_{xd}(\tau)}{d\tau}\) zerocrossing as a timing error detector. This is the case of the Delay Lock Loop (DLL) architecture and its wide range of variants, where the receiver computes three samples of \(R_{xd}\), usually referred to as Early \(E=R_{xd}(\hat{\tau}+\epsilon)\), Prompt \(P=R_{xd}(\hat{\tau})\) and Late \(L=R_{xd}(\hat{\tau}\epsilon)\), with \(\epsilon\) ranging from \(0.1T_c\) to \(0.5T_c\), and then computes a timing error with some combination of those samples, known as discriminator functions. The result is lowpass filtered and reinjected back to the matched filter, as shown in the figure below:
Typical diagram of a tracking block. Colored boxes indicate functions implemented in the VOLK_GNSSSDR library.
GNSSSDR’s Tracking implementations make heavy use of VOLK_GNSSSDR, an extension module of the original VOLK library which contains some functions that are specially useful in the context of a GNSS receiver (some examples in the figure above).
The VOLK_GNSSSDR library addresses Efficiency and Portability at the same time, by providing several implementations of the same functions in different SIMD technologies, benchmarking them and selecting the fastest in your machine at runtime.
Tracking State Machine
The Tracking blocks are continually receiving the data stream \(x_\text{IN}[k]\), but they do nothing until receiving a “positive acquisition” message, along with the coarse estimations \(\hat{\tau}_{acq}\) and \(\hat{f}_{\!D_{acq}}\), provided by an Acquisition block. Then, the role of the Tracking blocks is to refine such estimations and track their changes along time. As shown in the figure below, more refinements can be made once the navigation message bits (in the case of tracking a data component of a GNSS signal) or the secondary spreading code (in the case of tracking a pilot component of a GNSS signal) is synchronized, for instance by extending the integration time or by narrowing the tracking loops.
Internal state machine of a Tracking block.
In addition to track the synchronization parameters, the Tracking blocks must also implement code and carrier lock detectors, providing indicators of the tracking performance, as well as an estimation of the carriertonoisedensity ratio, \(C/N_0\).
Carriertonoisedensity ratio
The carriertonoisedensity ratio, expressed as \(C/N_0 =\frac{C}{\frac{N}{BW}}\) (where \(C\) is the carrier power, \(N\) is the noise power and \(BW\) is the bandwidth of observation) refers to the ratio of the carrier power and the noise power per unit of bandwidth, so it is expressed in decibelHertz (dBHz). The term \(\frac{C}{N}\) is known as the signaltonoise power ratio (SNR).
Considering that the observation bandwidth is the inverse of the coherent integration time, \(T_{int}\), we can write:
\[\begin{equation} C/N_0 = \frac{SNR}{T_{int}} \end{equation}\]The SNR estimation for complex signals can be computed as^{2}:
\[\begin{equation} \widehat{SNR}=\frac{\hat{C}}{\hat{N}}=\frac{\sqrt{2 \hat{\mathcal{M}}_2^2  \hat{\mathcal{M}}_4 }}{\hat{\mathcal{M}}_2\sqrt{2 \hat{\mathcal{M}}_2^2  \hat{\mathcal{M}}_4 }}, \end{equation}\]where:
 \(\displaystyle \hat{\mathcal{M}}_2 = \frac{1}{M}\sum^{M1}_{m=0} \vert P[m] \vert^2\) is the estimation of the second moment of \(P[m]\),
 \(\displaystyle \hat{\mathcal{M}}_4 = \frac{1}{M}\sum^{M1}_{m=0} \vert P[m] \vert^4\) is the estimation of the fourth moment of \(P[m]\),
 \(M\) is the number of samples used to perform the estimation (see tracking block parameter
cn0_samples
),  \(\vert \cdot \vert\) is the absolute value (also known as norm, modulus, or magnitude),
 \(P[m]\) is the prompt correlator output (complex value) for the integration period \(m\).
Then, the estimated \(C/N_0\) value in dBHz can be written as:
\[\begin{equation} \widehat{C/N}_{0_{dBHz}} = 10\log_{10}(\widehat{SNR})10\log_{10}(T_{int}) \end{equation}\]This estimation is smoothed with an exponential smoother of the form
\[\begin{equation} {\widehat{C/N}_{0}}_{smoothed}[k]= \alpha \widehat{C/N}_{0}[k] + (1\alpha) {\widehat{C/N}_{0}}_{smoothed}[k1] \end{equation}\]with \(\alpha\) controlled by the configuration parameter cn0_smoother_alpha
, after an initialization averaging cn0_smoother_samples
samples.
The \(C/N_0\) value provides an indication of the signal quality that is independent of the acquisition and tracking algorithms used by a receiver, and it remains constant through the different processing stages of the receiver.
The number of correlation outputs to perform the estimation defaults to \(M = 20\). This value can be changed by using the command line flag cn0_samples
when running the executable:
$ gnsssdr cn0_samples=100 c=./configuration_file.conf
Code lock detector
The lock detector for the code tracking loop is defined as:
\[\begin{equation} \widehat{C/N}_{0_{dBHz}} \overset{\text{lock}}{\underset{\text{no lock}}{\gtrless}} \gamma_{code} \end{equation}\]If the estimated \(C/N_{0_{dBHz}}\) is above a certain threshold, the tracking loop is declared locked.
The threshold \(\gamma_{code}\) is set by default to 25 dBHz. This value can be changed by using the command line flag cn0_min
when running the executable:
$ gnsssdr cn0_min=22 c=./configuration_file.conf
Carrier lock detector
The lock detector test for the carrier tracking loop is defined as:
\[\begin{equation} \cos(2\widehat{\Delta \phi}) \overset{\text{lock}}{\underset{\text{no lock}}{\gtrless}} \gamma_{carrier} \end{equation}\]where \(\Delta \phi = \phi  \hat{\phi}\) is the carrier phase error. If the estimate of the cosine of twice the carrier phase error is above a certain threshold, the loop is declared in lock.
The estimate of the cosine of twice the carrier phase error is computed as:
\[\begin{equation} \cos(2\widehat{\Delta \phi})=\frac{NBD}{NBP}, \end{equation}\]where:
 \(\displaystyle NBD=\left(\sum^{M1}_{m=0}P_{Q}[m]\right)^2\left(\sum^{M1}_{i=0}P_{I}[m]\right)^2\),
 \(\displaystyle NBP=\left(\sum^{M1}_{m=0}P_{Q}[m]\right)^2+\left(\sum^{M1}_{i=0}P_{I}[m]\right)^2\),
 \(P_I[m]\) and \(P_Q[m]\) are the prompt correlator output I and Q components for the integration period \(m\).
This estimation is smoothed with an exponential smoother of the form
\[\begin{equation} \!\!\!\!\!\!\!\!\!{\cos(2\widehat{\Delta \phi})}_{smoothed}[k]= \alpha \cos(2\widehat{\Delta \phi})[k] + (1\alpha){\cos(2\widehat{\Delta \phi})}_{smoothed}[k1] \end{equation}\]with \(\alpha\) controlled by the configuration parameter carrier_lock_test_smoother_alpha
, after an initialization averaging carrier_lock_test_smoother_samples
samples.
The threshold \(\gamma_{carrier}\) is set by default to 0.85 radians (corresponding to an error of approx. 31 degrees). This value can be changed by using the command line flag carrier_lock_th
when running the executable:
$ gnsssdr carrier_lock_th=0.75 c=./configuration_file.conf
Number of failures allowed before declaring a loss of lock
The maximum number of lock failures before dropping a satellite is set by default to 50 consecutive failures. This value can be changed by using the command line flag max_lock_fail
when running the executable:
$ gnsssdr max_lock_fail=100 c=./configuration_file.conf
Discriminators

Code Discriminator: For BPSK signals, it is used the DLL noncoherent Early minus Late envelopenormalized discriminator:
\[\begin{equation} \Delta_c[m]=\frac{y_{intercept}  \text{slope} \cdot \epsilon}{\text{slope}} \cdot \frac{\vert E[m]\vert\vert L[m]\vert}{\vert E[m]\vert+\vert L[m]\vert}, \end{equation}\]where:
 \(y_{intercept}\) is the interception point of the correlation function in the yaxis,
 \(\text{slope}\) is the slope of the correlation function,
 \(\epsilon\) is the EarlytoPrompt (or PrompttoLate) spacing, normalized by the chip period,
 \(\vert E[m]\vert=\sqrt{E_{I}[m]^2+E_{Q}[m]^2}\) is the magnitude of the Early correlator output,
 \(\vert L[m]\vert=\sqrt{L_{I}[m]^2+L_{Q}[m]^2}\) is the magnitude of the Late correlator output.
For BOC(1,1) signals, the DLL discriminator is
\[\begin{equation} \Delta_c[m]= \frac{\vert VE[m]\vert + \vert E[m]\vert \left(\vert VL[m]\vert + \vert L[m]\vert\right) }{\vert VE[m]\vert + \vert E[m]\vert +\vert VL[m]\vert + \vert L[m]\vert} \end{equation}\]where:
 \(\vert VE[m]\vert = \sqrt{VE_{I}[m]^2+VE_{Q}[m]^2}\) is the magnitude of the Very Early correlator output,
 \(\vert VL[m]\vert = \sqrt{VL_{I}[m]^2+VL_{Q}[m]^2}\) is the magnitude of the Very Late correlator output.

Phase Discriminator
PLL Costas loop twoquadrant discriminator for signals with data bit transitions:
\[\begin{equation} \Delta_p^{\text(Costas)}[m]=\text{arctan} \left(\frac{P_{Q}[m]}{P_{I}[m]}\right) \end{equation}\]PLL fourquadrant discriminator for dataless channels:
\[\begin{equation} \Delta_p^{\text(atan2)}[m]=\text{arctan2} \left(P_{Q}[m], P_{I}[m]\right) \end{equation}\] 
Frequency Discriminator
If the Frequency Locked Loop (FLL) is activated, the receiver uses the fourquadrant discriminator:
\[\begin{equation} \Delta_f[m]=\frac{1}{T_{int}}\text{arctan2}\left(\text{cross}[m], \text{dot}[m]\right), \end{equation}\]where
\[\text{cross}[m]=P_{I}[k1]P_{Q}[m]P_{I}[m]P_{Q}[k1]\]and
\[\text{dot}[m]=P_{I}[k1]P_{I}[m]+P_{Q}[k1]P_{Q}[m].\]
Low pass filters
Diagrams of digital lowpass filters of different order are shown below:
Firstorder digital lowpass filter.
Secondorder digital lowpass filter.
Thirdorder digital lowpass filter.
Filter order  Parameters 

First  \(\omega_0 = 0.25 \cdot \text{BW}\) 
Second  \(\omega_0=\frac{\text{BW}}{0.53}\), \(a_2=1.414\) 
Third  \(\omega_0=\frac{\text{BW}}{0.7845}\), \(a_3=1.1\), \(b_3=2.4\) 
Filter parameters, from Kaplan & Hegarty^{3}.
The user can configure the noise bandwidth with parameters dll_bw_hz
and pll_bw_hz
, and the filter order with dll_filter_order
and pll_filter_order
.
The configuration interfaces for the available Tracking block implementations are described below.
GPS L1 C/A signal tracking
This signal, centered at \(f_{\text{GPS L1}}=1575.42\) MHz, has a complex baseband transmitted signal that can be written as:
\[\begin{equation} \label{GPSL1} s^{\text{(GPS L1)}}_{T}(t)=e_{L1I}(t) + j e_{L1Q}(t)~, \end{equation}\]with
\[\begin{equation} e_{L1I}(t) = \sum_{l=\infty}^{\infty} D_{\text{NAV}}\Big[ [l]_{204600}\Big] \oplus C_{\text{P(Y)}} \Big[ l_{L_{\text{P(Y)}}} \Big] p(t  lT_{c,\text{P(Y)}})~, \end{equation}\] \[\begin{equation} e_{L1Q}(t) = \sum_{l=\infty}^{\infty} D_{\text{NAV}}\Big[ [l]_{20460} \Big] \oplus C_{\text{C/A}} \Big[ l_{1023} \Big] p(t  lT_{c,\text{C/A}})~, \end{equation}\]where \(\oplus\) is the exclusive–or operation (modulo–2 addition), \(l_{L}\) means \(l\) modulo \(L\), \([l]_{L}\) means the integer part of \(\frac{l}{L}\), \(D_{\text{NAV}}\) is the GPS navigation message bit sequence, transmitted at \(50\) bit/s, \(T_{c,\text{P(Y)}}=\frac{1}{10.23}\) \(\mu\)s, \(T_{c,\text{C/A}}=\frac{1}{1.023}\) \(\mu\)s, \(L_{\text{P(Y)}}=6.1871 \cdot 10^{12}\), and \(p(t)\) is the chip pulse of a chip–period duration.
Then, applying equation \((\ref{GPSL1})\) in \((\ref{xin})\), the digital signal at the input of the Tracking block can be written as:
\[\begin{equation} \!\!\!\!\!\!\!\!\! x_\text{IN}[k] = A(kT_s)\tilde{s}^{\text{(GPS L1)}}_{T}(kT_s\tau(kT_s)) e^{j \left( 2\pi f_D(kT_s) kT_s + \phi(kT_s) \right) } + n(kT_s)~. \end{equation}\]The implementations described below perform the estimation of \(\tau\), \(f_D\) and \(\phi\), which are assumed piecewise constant (that is, constant within an integration time, but allowed to vary from one integration period to the next one).
Implementation: GPS_L1_CA_DLL_PLL_Tracking
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
GPS_L1_CA_DLL_PLL_Tracking 
Mandatory 
item_type 
[gr_complex ]: Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
extend_correlation_symbols 
Sets the number of correlation symbols to be extended after bit synchronization has been achieved. Each symbol is 1 ms, so setting this parameter to 20 means a coherent integration time of 20 ms. Each bit is 20 ms, so the value of this parameter must be a divisor of it (e.g., 2, 4, 5, 10, 20). The higher this parameter is, the better local clock stability will be required. It defaults to 1.  Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter, in Hz. It defaults to 50 Hz.  Optional 
pll_bw_narrow_hz 
Bandwidth of the PLL low pass filter after bit synchronization, in Hz. It defaults to 20 Hz.  Optional 
pll_filter_order 
[2 , 3 ]. Sets the order of the PLL lowpass filter. It defaults to 3. 
Optional 
enable_fll_pull_in 
[true , false ]. If set to true , enables the FLL during the pullin time. It defaults to false . 
Optional 
enable_fll_steady_state 
[true , false ]. If set to true , the FLL is enabled beyond the pullin stage. It defaults to false . 
Optional 
fll_bw_hz 
Bandwidth of the FLL low pass filter, in Hz. It defaults to 35 Hz.  Optional 
pull_in_time_s 
Time, in seconds, in which the tracking loop will be in pullin mode. It defaults to 2 s.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter, in Hz. It defaults to 2 Hz.  Optional 
dll_bw_narrow_hz 
Bandwidth of the DLL low pass filter after bit synchronization, in Hz. It defaults to 2 Hz.  Optional 
dll_filter_order 
[1 , 2 , 3 ]. Sets the order of the DLL lowpass filter. It defaults to 2. 
Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
early_late_space_narrow_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\), after bit synchronization. It defaults to \(0.5\).  Optional 
carrier_aiding 
[true , false ]. If set to true , the code loop is aided by the carrier loop. It defaults to true . 
Optional 
cn0_samples 
Number of \(P\) correlator outputs used for CN0 estimation. It defaults to 20.  Optional 
cn0_min 
Minimum valid CN0 (in dBHz). It defaults to 25 dBHz.  Optional 
max_lock_fail 
Maximum number of lock failures before dropping a satellite. It defaults to 50.  Optional 
carrier_lock_th 
Carrier lock threshold (in rad). It defaults to 0.85 rad.  Optional 
cn0_smoother_samples 
Number of samples used to smooth the value of the estimated \(C/N_0\). It defaults to 200 samples.  Optional 
cn0_smoother_alpha 
Forgetting factor of the \(C/N_0\) smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
carrier_lock_test_smoother_samples 
Number of samples used to smooth the value of the carrier lock test. It defaults to 25 samples.  Optional 
carrier_lock_test_smoother_alpha 
Forgetting factor of the carrier lock detector smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging, in form of “.dat” files. This format can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. This parameter accepts either a relative or an absolute path; if there are nonexisting specified folders, they will be created. It defaults to ./track_ch , so files in the form “./track_chX.dat”, where X is the channel number, will be generated. 
Optional 
dump_mat 
[true , false ]. If dump=true , when the receiver exits it can convert the “.dat” files stored by this block into “.mat” files directly readable from Matlab and Octave. If the receiver has processed more than a few minutes of signal, this conversion can take a long time. In systems with limited resources, you can turn off this conversion by setting this parameter to false . It defaults to true , so “.mat” files are generated by default if dump=true . 
Optional 
Tracking implementation: GPS_L1_CA_DLL_PLL_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Tracking
Tracking_1C.item_type=gr_complex
Tracking_1C.extend_correlation_symbols=20
Tracking_1C.early_late_space_chips=0.5;
Tracking_1C.early_late_space_narrow_chips=0.1;
Tracking_1C.pll_bw_hz=35;
Tracking_1C.dll_bw_hz=2.0;
Tracking_1C.pll_bw_narrow_hz=5.0;
Tracking_1C.dll_bw_narrow_hz=0.50;
Tracking_1C.fll_bw_hz=10
Tracking_1C.enable_fll_pull_in=true;
Tracking_1C.enable_fll_steady_state=false
Tracking_1C.dump=false
Tracking_1C.dump_filename=tracking_ch_
Implementation: GPS_L1_CA_DLL_PLL_Tracking_GPU
GPUaccelerated computing consists in the use of a graphics processing unit (GPU) together with a CPU to accelerate the execution of a software application, by offloading computationintensive portions of the application to the GPU, while the remainder of the code still runs on the CPU. The key idea is to utilize the computation power of both CPU cores and GPU execution units in tandem for better utilization of available computing power.
This implementation follows the CUDA programming model and targets NVIDIA’s GPU computing platform. Thus, you will need a CUDAenabled GPU and the CUDA Toolkit installed. Moreover, it is only available if GNSSSDR has been built from source and configured with the flag ENABLE_CUDA
set to ON
:
$ cmake DENABLE_CUDA=ON ../ && make && sudo make install
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
GPS_L1_CA_DLL_PLL_Tracking_GPU 
Mandatory 
item_type 
[gr_complex ]: Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter, in Hz. It defaults to 50 Hz.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter, in Hz. It defaults to 2 Hz.  Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. It defaults to ./track_ch 
Optional 
Tracking implementation: GPS_L1_CA_DLL_PLL_Tracking_GPU
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Tracking_GPU
Tracking_1C.pll_bw_hz=40.0;
Tracking_1C.dll_bw_hz=4.0;
Galileo E1 signal tracking
This band, centered at \(f_{\text{Gal E1}}=1575.420\) MHz and with a reference bandwidth of \(24.5520\) MHz, uses the Composite Binary Offset Carrier (CBOC) modulation, defined in baseband as:
\[\begin{eqnarray} s^{\text{(Gal E1)}}_{T}(t)& = &\frac{1}{\sqrt{2}} \Big( e_{E1B}(t)\left( \alpha sc_A(t)+ \beta sc_B(t) \right) + \nonumber \\ {} & {} & ~e_{E1C}(t) \left( \alpha sc_A(t) \beta sc_B(t) \right) \Big)~, \label{GalE1} \end{eqnarray}\]where the subcarriers \(sc(t)\) are defined as
\[\begin{equation} sc_A(t) = \text{sign} \Big(\sin(2\pi f_{s,E1A}t) \Big)~, \end{equation}\] \[\begin{equation} sc_B(t) = \text{sign} \Big(\sin(2\pi f_{s,E1B}t) \Big)~, \end{equation}\]and \(f_{s,E1A}=1.023\) MHz, \(f_{s, E1B}=6.138\) MHz are the subcarrier rates, \(\alpha=\sqrt{\frac{10}{11}}\), and \(\beta=\sqrt{\frac{1}{11}}\). Channel B contains the I/NAV type of navigation message, \(D_{I/NAV}\), intended for Safety–of–Life (SoL) services:
\[\begin{equation} e_{E1B}(t) = \sum_{l=\infty}^{+\infty} D_{\text{I/NAV}} \Big[ [l]_{4092}\Big] \oplus C_{E1B}\Big[l_{4092}\Big] p(t  lT_{c,E1B})~. \end{equation}\]In case of channel C, it is a pilot (dataless) channel with a secondary code, forming a tiered code:
\[\begin{equation} \!\!\!\!\!\!\!\!\!\!\!\!\!\!e_{E1C}(t) = \!\sum_{m=\infty}^{+\infty}\!C_{E1Cs}\Big[m_{25}\Big] \oplus \sum_{l=1}^{4092}C_{E1Cp}\Big[ l \Big] \cdot p(tmT_{c,E1Cs}lT_{c,E1Cp})~, \end{equation}\]with \(T_{c,E1B}=T_{c,E1Cp}=\frac{1}{1.023}\) \(\mu\)s and \(T_{c,E1Cs}=4\) ms.
Then, applying equation \((\ref{GalE1})\) in \((\ref{xin})\), the digital signal at the input of the Tracking block can be written as
\[\begin{equation} \!\!\!\!\!\!\!\!\!x_\text{IN}[k] = A(kT_s)\tilde{s}^{\text{(Gal E1)}}_{T}(kT_s\tau(kT_s)) e^{j \left( 2\pi f_D(kT_s) kT_s + \phi(kT_s) \right) } + n(kT_s)~. \end{equation}\]The implementation described below performs the estimation of \(\tau\), \(f_D\) and \(\phi\), which are assumed piecewise constant (that is, constant within an integration time, but allowed to vary from one integration period to the next one).
Implementation: Galileo_E1_DLL_PLL_VEML_Tracking
In case of Galileo E1, the CBOC(6,1,\(\frac{1}{11}\)) modulation creates correlation ambiguities, as shown in the following figure:
Normalized \(\leftR_{xd}\left(\check{f}_D=f_D, \tau \right) \right^2\) for different sampling rates and local reference waveforms^{4}.
The possibility of tracking a local maximum instead of the global one can be avoided by using discriminators that consider two extra samples of the cost function, referred to as Very Early \(\text{VE}=R_{xd}(\hat{\tau}\epsilon^\prime)\) and Very Late \(\text{VL}=R_{xd}(\hat{\tau}+\epsilon^\prime)\), with \(\epsilon^\prime > \epsilon\).
In the case of carrier tracking loops, the pilot channel E1C can be used for the phase error estimation, since it does not contain data bit transitions, and, theoretically, coherent integration of several code periods can be used for as long as needed once the secondary code has been removed. As a consequence, a discriminator that is insensitive to phase jumps can be used. Using pure PLL tracking on the pilot channel as well as longer coherent integration improves the carrier tracking sensitivity, the minimum signal power at which the receiver can keep the tracking process in lock.
The implementation of this block is described in Algorithm below. The computation of the complex values VE, E, P, L and VL in step \(5\) was implemented using the VOLK_GNSSSDR library. The PLL discriminator implemented in step \(6\) is the extended arctangent (fourquadrant) discriminator, and for the DLL we used the normalized Very Early Minus Late Power discriminator (step \(10\) ). The lowpass filters of the DLL, PLL and FLL (when available, see implementations below) are based in the description by Kaplan and Hegarty^{3}, section 8.8. For code lock detection (step \(13\) ), we used the Squared SignaltoNoise Variance (SNV) estimator^{5}. In the case of carrier lock detection (step \(14\) ), we used the normalized estimate of the cosine of twice the carrier phase^{6}. The values of the lock indicator range from \(1\), when the locally generated carrier is completely out of phase, to \(1\), that indicates a perfect match. When either the code or the carrier detectors are below given thresholds during a consecutive number of code periods \(\vartheta\), the Tracking block informs to control plane through the message queue.
 Require: Complex sample stream, \(\mathbf{x}_{\text{IN}}\); estimations of code phase \(\hat{\tau}_{acq}\) and Doppler shift \(\hat{f}_{\!D_{acq}}\); buffer size for power estimation, \(\mathcal{U}\); carrier lock detector threshold, \(\mathcal{T}\); \(CN0_{min}\); maximum value for the lock fail counter, \(\vartheta\); correlators spacing \(\epsilon\) and \(\epsilon^\prime\); loop filters bandwidth \(BW_{DLL}\) and \(BW_{PLL}\); integration time \(T_{int}\). Track signal’s synchronization parameters within a given lock margin. Inform about a loss of lock.

Initialization: Using \(\hat{\tau}_{acq}\) and a sample counter \(\mathcal{N}\), skip samples until \(\mathbf{x}_{\text{IN}}\) is aligned with local PRN replica. Set \(\upsilon=0\), \(k=0\), \(\hat{f}_{\!D_{0}}=\hat{f}_{\!D_{acq}}\), \(\hat{\phi}_0=0\), \(\psi_1=0\), \(N_1=\text{round}(T_{int} f_{\text{IN}})\).

Increase the integration period counter: \(k=k+1\).
 Generate local code references: for \(n=1...N_k\), \(s[n]=d_{E1B/E1C_{p}}\left[\text{round}(\delta_{k} \cdot n + \psi_{k})\right]\), where \(\delta_{k}= \frac{1}{T_{c,E1B} \cdot f_{\text{IN}} }\left( 1 + \frac{\hat{f}_{\!D_{k1}}}{f^{\text{(Gal E1)}}_c} \right)\), and the Very Early, Early, Late, and Very Late versions with \(\epsilon\) and \(\epsilon^\prime\).

Generate local carrier: for \(n=1...N_k\), \(c[n]=e^{j\left(2\pi \hat{f}_{\!D_{k1}} \frac{n}{f_{\text{IN}}}+\text{mod}\left(\hat{\phi}_{k1},2\pi \right) \right)}\).

Perform carrier wipeoff and compute the complex samples VE\(_k\), E\(_k\), P\(_k\), L\(_k\) and VL\(_k\). Example: \(\text{P}_k=\frac{1}{N_k} \sum_{n=0}^{N_k1} x_{\text{IN}}[n] s[n] c[n]\).

Compute PLL discriminator: \(\Delta \hat{\phi}_{k} = \mbox{atan2}\left( \frac{ \text{P}_{Q_{k}}}{\text{P}_{I_{k}}} \right)\)

Filter \(\Delta \hat{\phi}_{k}\) with a bandwidth \(BW_{PLL}\): \(h_{PLL}\left( \Delta \hat{\phi}_{k}\right)\).

Update carrier frequency estimation (in Hz): \(\hat{f}_{\!D_{k}}=\hat{f}_{\!D_{acq}}+\frac{1}{ 2\pi T_{int} } h_{PLL}\left( \Delta \hat{\phi}_{k} \right)\).

Update carrier phase estimation (in rad): \(\hat{\phi}_k=\hat{\phi}_{k1}+ 2 \pi \hat{f}_{\!D_{k}} T_{int}+ h_{PLL}(\Delta \hat{\phi})\).

Compute DLL discriminator: \(\Delta \hat{\tau}_{k}=\frac{\mathcal{E}_{k}\mathcal{L}_{k}}{\mathcal{E}_{k}+\mathcal{L}_{k}}\), where: \(\mathcal{E}_{k}=\sqrt{\text{VE}_{I_{k}}^2+\text{VE}_{Q_{k}}^2+E_{I_{k}}^2+E_{Q_{k}}^2}\), and \(\mathcal{L}_{k}=\sqrt{\text{VL}_{I_{k}}^2+\text{VL}_{Q_{k}}^2+L_{I_{k}}^2+L_{Q_{k}}^2}\).

Filter \(\Delta \hat{\tau}_{k}\) with a bandwidth \(BW_{DLL}\): \(h_{DLL}\left( \Delta \hat{\tau}_{k}\right)\).

Update code phase estimation (in samples): \(N_{k+1}=\text{round}(S)\) and \(\psi_{k+1}=SN_{k+1}\), where \(S = \frac{T_{int}f_{\text{IN} } }{\left( 1 + \frac{\hat{f}_{D_{k} } }{f^{\text{(Gal E1) } }_c} \right)} +\psi_{k} + h_{DLL}(\hat{\Delta \tau}_k)f_{\text{IN} }\).

Code lock indicator: \(\hat{ \text{CN0} } = 10 \cdot \log_{10} ( \hat{\rho}) + 10 \cdot \log_{10}(\frac{ f_{ \text{IN} } }{2} )10 \cdot \log_{10} (L_{ \text{PRN} })\), where: \(\hat{\rho}=\frac{ \hat{P}_s }{ \hat{P}_n } = \frac{\hat{P}_s}{\hat{P}_{tot}\hat{P}_s}\), \(\hat{P}_s = \left(\frac{1}{\mathcal{U}}\sum^{\mathcal{U}1}_{i=0}\text{P}_{I_{ki}} \right)^2\), and \(\hat{P}_{tot} = \frac{1}{\mathcal{U}}\sum^{\mathcal{U}1}_{i=0}\text{P}_{ki}^2\).

Phase lock indicator: \(T_{carrier} = \frac{ \left( \sum^{\mathcal{U}1}_{i=0} \text{P}_{ {I}_{ki}}\right)^2  \left( \sum^{\mathcal{U} 1}_{i=0} \text{P}_{Q_{ki}}\right)^2}{\left(\sum^{\mathcal{U}1}_{i=0} \text{P}_{ {I}_{ki}}\right)^2 + \left( \sum^{\mathcal{U} 1}_{i=0} \text{P}_{Q_{ki}}\right)^2}\).
 if \(T_{carrier} < \mathcal{T}\) or \(\hat{ CN0 } < CN0_{min}\)
 Increase lock fail counter \(\upsilon \leftarrow \upsilon +1\).
 else
 Decrease lock fail counter \(\upsilon \leftarrow \max(\upsilon 1,0)\).

endif
 if \(\upsilon > \vartheta\)
 Notify the loss of lock to the control plane through the message queue.

endif
 Output: \(\text{P}_k\), accumulated carrier phase error \(\hat{\phi}_k\), code phase \(\mathcal{N} \leftarrow \mathcal{N}+ N_k + \psi_k\), carriertonoisedensity ratio \(\hat{\text{CN0}}\).
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
Galileo_E1_DLL_PLL_VEML_Tracking 
Mandatory 
item_type 
[gr_complex ]: Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
track_pilot 
[true , false ]: If set to true , the receiver is set to track the pilot signal E1C and enables an extra prompt correlator (slave to pilot’s prompt) in the data component E1B. If set to false , the receiver performs correlations on a data length of 4 ms over the E1B component. This parameter defaults to true . 
Optional 
extend_correlation_symbols 
If track_pilot=true , sets the number of correlation symbols to be extended after the secondary code \(C_{E1C_{s}}\) is removed from the pilot signal, in number of symbols. Each symbol is 4 ms, so setting this parameter to 25 means a coherent integration time of 100 ms. The higher this parameter is, the better local clock stability will be required. It defaults to 1. 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter, in Hz. It defaults to 50 Hz.  Optional 
pll_bw_narrow_hz 
If track_pilot=true and extend_correlation_symbols \(>\) 1, sets the bandwidth of the PLL low pass filter after removal of the secondary code \(C_{E1C_{s}}\), in Hz. It defaults to 2 Hz. This implementation uses a fourquadrant arctangent discriminator (atan2). 
Optional 
pll_filter_order 
[2 , 3 ]. Sets the order of the PLL lowpass filter. It defaults to 3. 
Optional 
enable_fll_pull_in 
[true , false ]. If set to true , enables the FLL during the pullin time. It defaults to false . 
Optional 
enable_fll_steady_state 
[true , false ]. If set to true , the FLL is enabled beyond the pullin stage. It defaults to false . 
Optional 
fll_bw_hz 
Bandwidth of the FLL low pass filter, in Hz. It defaults to 35 Hz.  Optional 
pull_in_time_s 
Time, in seconds, in which the tracking loop will be in pullin mode. It defaults to 2 s.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter, in Hz. It defaults to 2 Hz.  Optional 
dll_bw_narrow_hz 
If track_pilot=true and extend_correlation_symbols \(>\) 1, sets the bandwidth of the DLL low pass filter after removal of the secondary code \(C_{E1C_{s}}\) and extension of the coherent integration time, in Hz. It defaults to 0.25 Hz. 
Optional 
dll_filter_order 
[1 , 2 , 3 ]. Sets the order of the DLL lowpass filter. It defaults to 2. 
Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.15\).  Optional 
very_early_late_space_chips 
Spacing between Very Early and Prompt and between Prompt and Very Late correlators, normalized by the chip period \(T_c\) It defaults to \(0.6\).  Optional 
early_late_space_narrow_chips 
If track_pilot=true and extend_correlation_symbols \(>\) 1, sets the spacing between Early and Prompt and between Prompt and Late correlators after removal of the secondary code \(C_{E1C_{s}}\), normalized by the chip period \(T_c\). It defaults to \(0.15\). 
Optional 
very_early_late_space_narrow_chips 
If track_pilot=true and extend_correlation_symbols \(>\) 1, sets the spacing between Very Early and Prompt and between Prompt and Very Late correlators after removal of the secondary code \(C_{E1C_{s}}\) and extension of the coherent integration time, normalized by the chip period \(T_c\). It defaults to \(0.6\). 
Optional 
carrier_aiding 
[true , false ]. If set to true , the code loop is aided by the carrier loop. It defaults to true . 
Optional 
cn0_samples 
Number of \(P\) correlator outputs used for CN0 estimation. It defaults to 20.  Optional 
cn0_min 
Minimum valid CN0 (in dBHz). It defaults to 25 dBHz.  Optional 
max_lock_fail 
Maximum number of lock failures before dropping a satellite. It defaults to 50.  Optional 
carrier_lock_th 
Carrier lock threshold (in rad). It defaults to 0.85 rad.  Optional 
cn0_smoother_samples 
Number of samples used to smooth the value of the estimated \(C/N_0\). It defaults to 200 samples.  Optional 
cn0_smoother_alpha 
Forgetting factor of the \(C/N_0\) smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
carrier_lock_test_smoother_samples 
Number of samples used to smooth the value of the carrier lock test. It defaults to 25 samples.  Optional 
carrier_lock_test_smoother_alpha 
Forgetting factor of the carrier lock detector smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging, in form of “.dat” files. This format can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. This parameter accepts either a relative or an absolute path; if there are nonexisting specified folders, they will be created. It defaults to ./track_ch , so files in the form “./track_chX.dat”, where X is the channel number, will be generated. 
Optional 
dump_mat 
[true , false ]. If dump=true , when the receiver exits it can convert the “.dat” files stored by this block into “.mat” files directly readable from Matlab and Octave. If the receiver has processed more than a few minutes of signal, this conversion can take a long time. In systems with limited resources, you can turn off this conversion by setting this parameter to false . It defaults to true , so “.mat” files are generated by default if dump=true . 
Optional 
Tracking implementation: Galileo_E1_DLL_PLL_VEML_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_1B.implementation=Galileo_E1_DLL_PLL_VEML_Tracking
Tracking_1B.item_type=gr_complex
Tracking_1B.track_pilot=true
Tracking_1B.pll_bw_hz=15.0;
Tracking_1B.dll_bw_hz=0.75;
Tracking_1B.early_late_space_chips=0.25;
Tracking_1B.early_late_space_narrow_chips=0.15;
Tracking_1B.very_early_late_space_chips=0.5;
Tracking_1B.very_early_late_space_narrow_chips=0.5;
Tracking_1B.pll_bw_narrow_hz=5.0
Tracking_1B.dll_bw_narrow_hz=0.2
Tracking_1B.extend_correlation_symbols=5
Tracking_1B.enable_fll_pull_in=true;
Tracking_1B.enable_fll_steady_state=false
Tracking_1B.fll_bw_hz=10
Tracking_1B.dump=false
Tracking_1B.dump_filename=tracking_ch_
Glonass L1 C/A signal tracking
The complex baseband transmitted signal can be written as:
\[\begin{equation} \label{GLOL1} s^{\text{(GLO L1)}}_{T}(t)=e_{L1I}(t) + j e_{L1Q}(t)~, \end{equation}\]with
\[\begin{equation} e_{L1I}(t) = \sum_{l=\infty}^{\infty} D_{\text{GNAV}}\Big[ [l]_{102200}\Big] \oplus C_{\text{HP}} \Big[ l_{L_{\text{HP}}} \Big] p(t  lT_{c,\text{HP}})~,\end{equation}\] \[\begin{equation} e_{L1Q}(t) = \sum_{l=\infty}^{\infty} D_{\text{GNAV}}\Big[ [l]_{10220} \Big] \oplus C_{\text{C/A}} \Big[ l_{511} \Big] p(t  lT_{c,\text{C/A}})~,\end{equation}\]where \(T_{c,\text{HP}}=\frac{1}{5.11}\) \(\mu\)s, \(T_{c,\text{C/A}}=\frac{1}{0.511}\) \(\mu\)s, and \(L_{\text{HP}}=3.3554\cdot 10^7\). The navigation message \(D_{\text{GNAV}}\) is transmitted at \(50\) bit/s.
Then, applying equation \((\ref{GLOL1})\) in \((\ref{xin})\), the digital signal at the input of the Tracking block can be written as
\[\begin{equation} \!\!\!\!\!\!\!\!\!x_\text{IN}[k] = A(kT_s)\tilde{s}^{\text{(GLO L1)}}_{T}(kT_s\tau(kT_s)) e^{j \left( 2\pi f_D(kT_s) kT_s + \phi(kT_s) \right) } + n(kT_s)~. \end{equation}\]The implementations described below perform the estimation of \(\tau\), \(f_D\) and \(\phi\), which are assumed piecewise constant (that is, constant within an integration time, but allowed to vary from one integration period to the next one).
Implementation: GLONASS_L1_CA_DLL_PLL_Tracking
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
GLONASS_L1_CA_DLL_PLL_Tracking 
Mandatory 
item_type 
[gr_complex ]: Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter, in Hz. It defaults to 50 Hz.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter, in Hz. It defaults to 2 Hz.  Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging. Binary data can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. It defaults to ./track_ch 
Optional 
Tracking implementation: GLONASS_L1_CA_DLL_PLL_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_1G.implementation=GLONASS_L1_CA_DLL_PLL_Tracking
Tracking_1G.pll_bw_hz=30.0
Tracking_1G.dll_bw_hz=4.0
Tracking_1G.early_late_space_chips=0.5
Implementation: GLONASS_L1_CA_DLL_PLL_C_Aid_Tracking
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
GLONASS_L1_CA_DLL_PLL_C_Aid_Tracking 
Mandatory 
item_type 
[gr_complex , cshort ]. Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter before bit synchronization, in Hz. It defaults to 50 Hz.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter before bit synchronization, in Hz. It defaults to 2 Hz.  Optional 
pll_bw_narrow_hz 
Bandwidth of the PLL low pass filter after bit synchronization, in Hz. It defaults to 20 Hz.  Optional 
dll_bw_narrow_hz 
Bandwidth of the DLL low pass filter after bit synchronization, in Hz. It defaults to 2 Hz.  Optional 
extend_correlation_ms 
Correlation length, in ms. It defaults to 1 ms.  Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging. Binary data can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. It defaults to ./track_ch 
Optional 
Tracking implementation: GLONASS_L1_CA_DLL_PLL_C_Aid_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_1G.implementation=GLONASS_L1_CA_DLL_PLL_C_Aid_Tracking
Tracking_1G.item_type=cshort
Tracking_1G.pll_bw_hz=40.0;
Tracking_1G.dll_bw_hz=4.0;
GPS L2CM signal tracking
This signal, centered at \(f_{\text{GPS L2}}=1227.60\) MHz, has a complex baseband transmitted signal that can be written as:
\[\begin{equation} \label{GPSL2} s^{\text{(GPS L2)}}_{T}(t)=e_{L2I}(t) + j e_{L2Q}(t)~, \end{equation}\]with the In–phase and Quadrature components defined as:
\[\begin{equation} e_{L2I}(t) = \sum_{l=\infty}^{\infty} D_{\text{NAV}}\Big[ [l]_{204600}\Big] \oplus C_{\text{P(Y)}} \Big[ l_{L_{\text{P(Y)}}} \Big] p(t  lT_{c,\text{P(Y)}})\end{equation}\]and
\[\begin{eqnarray} e_{L2Q}(t) & = & \sum_{l=\infty}^{\infty}\left( D_{\text{CNAV}} \Big[ [l]_{10230} \Big] \oplus C_{\text{CM}} \Big[ l_{L_{\text{CM}}} \Big] p_{\text{1/2}} \left(t  lT_{c,L2C} \right) + \right. \nonumber \\ {} & {} & \left. +~C_{\text{CL}} \Big[ l_{L_{\text{CL}}} \Big] p_{\text{1/2}}\left(t  \left(l+\frac{1}{2}\right)T_{c,L2C}\right) \right)~, \end{eqnarray}\]where \(T_{c,L2C}=\frac{1}{511.5}\) ms and \(p_{\text{1/2}}(t)\) is a rectangular pulse of half chip–period duration, thus time–multiplexing codes \(C_{\text{CL}}\) and \(C_{\text{CM}}\). The civilian long code \(C_{\text{CL}}\) is \(L_{\text{CL}}=767250\) chips long, repeating every \(1.5\) s, while the civilian moderate code \(C_{\text{CM}}\) is \(L_{\text{CM}}=10230\) chips long and it repeats every \(20\) ms.
Then, applying equation \((\ref{GPSL2})\) in \((\ref{xin})\), the digital signal at the input of the Tracking block can be written as
\[\begin{equation} \!\!\!\!\!\!\!\!\!x_\text{IN}[k] = A(kT_s)\tilde{s}^{\text{(GPS L2)}}_{T}(kT_s\tau(kT_s)) e^{j \left( 2\pi f_D(kT_s) kT_s + \phi(kT_s) \right) } + n(kT_s)~. \end{equation}\]The implementation described below performs the estimation of \(\tau\), \(f_D\) and \(\phi\), which are assumed piecewise constant (that is, constant within an integration time, but allowed to vary from one integration period to the next one).
Implementation: GPS_L2_M_DLL_PLL_Tracking
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
GPS_L2_M_DLL_PLL_Tracking 
Mandatory 
item_type 
[gr_complex ]: Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter, in Hz. It defaults to 50 Hz.  Optional 
pll_filter_order 
[2 , 3 ]. Sets the order of the PLL lowpass filter. It defaults to 3. 
Optional 
enable_fll_pull_in 
[true , false ]. If set to true , enables the FLL during the pullin time. It defaults to false . 
Optional 
enable_fll_steady_state 
[true , false ]. If set to true , the FLL is enabled beyond the pullin stage. It defaults to false . 
Optional 
fll_bw_hz 
Bandwidth of the FLL low pass filter, in Hz. It defaults to 35 Hz.  Optional 
pull_in_time_s 
Time, in seconds, in which the tracking loop will be in pullin mode. It defaults to 2 s.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter, in Hz. It defaults to 2 Hz.  Optional 
dll_bw_narrow_hz 
Bandwidth of the DLL low pass filter after the secondary code lock, in Hz. It defaults to 0.25 Hz.  Optional 
dll_filter_order 
[1 , 2 , 3 ]. Sets the order of the DLL lowpass filter. It defaults to 2. 
Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
carrier_aiding 
[true , false ]. If set to true , the code loop is aided by the carrier loop. It defaults to true . 
Optional 
cn0_samples 
Number of \(P\) correlator outputs used for CN0 estimation. It defaults to 20.  Optional 
cn0_min 
Minimum valid CN0 (in dBHz). It defaults to 25 dBHz.  Optional 
max_lock_fail 
Maximum number of lock failures before dropping a satellite. It defaults to 50.  Optional 
carrier_lock_th 
Carrier lock threshold (in rad). It defaults to 0.85 rad.  Optional 
cn0_smoother_samples 
Number of samples used to smooth the value of the estimated \(C/N_0\). It defaults to 200 samples.  Optional 
cn0_smoother_alpha 
Forgetting factor of the \(C/N_0\) smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
carrier_lock_test_smoother_samples 
Number of samples used to smooth the value of the carrier lock test. It defaults to 25 samples.  Optional 
carrier_lock_test_smoother_alpha 
Forgetting factor of the carrier lock detector smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging, in form of “.dat” files. This format can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. This parameter accepts either a relative or an absolute path; if there are nonexisting specified folders, they will be created. It defaults to ./track_ch , so files in the form “./track_chX.dat”, where X is the channel number, will be generated. 
Optional 
dump_mat 
[true , false ]. If dump=true , when the receiver exits it can convert the “.dat” files stored by this block into “.mat” files directly readable from Matlab and Octave. If the receiver has processed more than a few minutes of signal, this conversion can take a long time. In systems with limited resources, you can turn off this conversion by setting this parameter to false . It defaults to true , so “.mat” files are generated by default if dump=true . 
Optional 
Tracking implementation: GPS_L2_M_DLL_PLL_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_2S.implementation=GPS_L2_M_DLL_PLL_Tracking
Tracking_2S.pll_bw_hz=40.0;
Tracking_2S.dll_bw_hz=4.0;
Tracking_2S.early_late_space_chips=0.4
Glonass L2 C/A signal tracking
Beginning with the second generation of satellites, called GLONASS–M and first launched in 2001, a second civil signal is available using the same C/A code than the one in the L1 band but centered at \(1246\) MHz.
Implementation: GLONASS_L2_CA_DLL_PLL_Tracking
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
GLONASS_L2_CA_DLL_PLL_Tracking 
Mandatory 
item_type 
[gr_complex ]: Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter, in Hz. It defaults to 50 Hz.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter, in Hz. It defaults to 2 Hz.  Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging. Binary data can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. It defaults to ./track_ch 
Optional 
Tracking implementation: GLONASS_L2_CA_DLL_PLL_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_2G.implementation=GLONASS_L2_CA_DLL_PLL_Tracking
Tracking_2G.pll_bw_hz=30.0
Tracking_2G.dll_bw_hz=4.0
Tracking_2G.early_late_space_chips=0.5
Implementation: GLONASS_L2_CA_DLL_PLL_C_Aid_Tracking
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
GLONASS_L2_CA_DLL_PLL_C_Aid_Tracking 
Mandatory 
item_type 
[gr_complex , cshort ]. Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter before bit synchronization, in Hz. It defaults to 50 Hz.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter before bit synchronization, in Hz. It defaults to 2 Hz.  Optional 
pll_bw_narrow_hz 
Bandwidth of the PLL low pass filter after bit synchronization, in Hz. It defaults to 20 Hz.  Optional 
dll_bw_narrow_hz 
Bandwidth of the DLL low pass filter after bit synchronization, in Hz. It defaults to 2 Hz.  Optional 
extend_correlation_ms 
Correlation length, in ms. It defaults to 1 ms.  Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging. Binary data can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. It defaults to ./track_ch 
Optional 
Tracking implementation: GLONASS_L2_CA_DLL_PLL_C_Aid_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_2G.implementation=GLONASS_L2_CA_DLL_PLL_C_Aid_Tracking
Tracking_2G.item_type=cshort
Tracking_2G.pll_bw_hz=40.0;
Tracking_2G.dll_bw_hz=4.0;
GPS L5 signal tracking
The GPS L5 link is only available on Block IIF and subsequent satellite blocks. Centered at \(f_{\text{GPS L5}}=1176.45\) MHz, this signal can be written as:
\[\begin{equation} \label{GPSL5} s^{\text{(GPS L5)}}_{T}(t)=e_{L5I}(t) +j e_{L5Q}(t)~, \end{equation}\]with:
\[\begin{eqnarray} e_{L5I}(t) & = & \sum_{m=\infty}^{+\infty} C_{nh_{10}} \Big[ m_{10}\Big] \oplus \ D_{\text{CNAV}}\Big[ [m]_{10}\Big] \oplus \nonumber \\ {} & {} & \oplus \sum_{l=1}^{102300} C_{L5I}\Big[l_{10230}\Big] \cdot p(t  m T_{c,nh}  lT_{c,L5}) ~,\end{eqnarray}\] \[\begin{equation}\!\!\!\!\!\!\!\!\!\!\!\!\!\!\! e_{L5Q}(t) = \!\sum_{m=\infty}^{+\infty} \!C_{nh_{20}} \Big[ m_{20}\Big] \! \oplus \! \sum_{l=1}^{102300}\!C_{L5Q}\Big[l_{10230}\Big] \cdot p(t  m T_{c,nh}  lT_{c,L5})~, \end{equation}\]where \(T_{c,nh}=1\) ms and \(T_{c,L5}=\frac{1}{10.23}\) \(\mu\)s. The L5I component contains a synchronization sequence \(C_{nh_{10}}=0000110101\), a \(10\)–bit Neuman–Hoffman code that modulates each \(100\) symbols of the GPS L5 civil navigation data \(D_{\text{CNAV}}\), and the L5Q component has another synchronization sequence \(C_{nh_{20}}=00000100110101001110\).
Then, applying equation \((\ref{GPSL5})\) in \((\ref{xin})\), the digital signal at the input of the Tracking block can be written as
\[\begin{equation}\!\!\!\!\!\!\!\!\! x_\text{IN}[k] = A(kT_s)\tilde{s}^{\text{(GPS L5)}}_{T}(kT_s\tau(kT_s)) e^{j \left( 2\pi f_D(kT_s) kT_s + \phi(kT_s) \right) } + n(kT_s)~. \end{equation}\]The implementation described below performs the estimation of \(\tau\), \(f_D\) and \(\phi\), which are assumed piecewise constant (that is, constant within an integration time, but allowed to vary from one integration period to the next one).
Implementation: GPS_L5_DLL_PLL_Tracking
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
GPS_L5_DLL_PLL_Tracking 
Mandatory 
item_type 
[gr_complex ]: Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
track_pilot 
[true , false ]: If set to true , the receiver is set to track the pilot signal L5Q and enables an extra prompt correlator (slave to pilot’s prompt) in the data component L5I. If set to false , the receiver performs correlations on a data length of 1 ms over the L5I component. This parameter defaults to true . 
Optional 
extend_correlation_symbols 
If track_pilot=true , sets the number of correlation symbols to be extended after the secondary code \(C_{nh_{20}}\) is removed from the pilot signal, in number of symbols. Each symbol is 1 ms, so setting this parameter to 25 means a coherent integration time of 25 ms. The higher this parameter is, the better local clock stability will be required. It defaults to 1. 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter, in Hz. It defaults to 50 Hz.  Optional 
pll_bw_narrow_hz 
Bandwidth of the PLL low pass filter after bit synchronization, in Hz. It defaults to 2 Hz.  Optional 
pll_filter_order 
[2 , 3 ]. Sets the order of the PLL lowpass filter. It defaults to 3. 
Optional 
enable_fll_pull_in 
[true , false ]. If set to true , enables the FLL during the pullin time. It defaults to false . 
Optional 
enable_fll_steady_state 
[true , false ]. If set to true , the FLL is enabled beyond the pullin stage. It defaults to false . 
Optional 
fll_bw_hz 
Bandwidth of the FLL low pass filter, in Hz. It defaults to 35 Hz.  Optional 
pull_in_time_s 
Time, in seconds, in which the tracking loop will be in pullin mode. It defaults to 2 s.  Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter, in Hz. It defaults to 2 Hz.  Optional 
dll_bw_narrow_hz 
Bandwidth of the DLL low pass filter after the secondary code lock, in Hz. It defaults to 0.25 Hz.  Optional 
dll_filter_order 
[1 , 2 , 3 ]. Sets the order of the DLL lowpass filter. It defaults to 2. 
Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
early_late_space_narrow_chips 
If track_pilot=true and extend_correlation_symbols \(>\) 1, sets the spacing between Early and Prompt and between Prompt and Late correlators after removal of the secondary code \(C_{nh_{20}}\), normalized by the chip period \(T_{c,L5}\). It defaults to \(0.15\). 
Optional 
carrier_aiding 
[true , false ]. If set to true , the code loop is aided by the carrier loop. It defaults to true . 
Optional 
cn0_samples 
Number of \(P\) correlator outputs used for CN0 estimation. It defaults to 20.  Optional 
cn0_min 
Minimum valid CN0 (in dBHz). It defaults to 25 dBHz.  Optional 
max_lock_fail 
Maximum number of lock failures before dropping a satellite. It defaults to 50.  Optional 
carrier_lock_th 
Carrier lock threshold (in rad). It defaults to 0.85 rad.  Optional 
cn0_smoother_samples 
Number of samples used to smooth the value of the estimated \(C/N_0\). It defaults to 200 samples.  Optional 
cn0_smoother_alpha 
Forgetting factor of the \(C/N_0\) smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
carrier_lock_test_smoother_samples 
Number of samples used to smooth the value of the carrier lock test. It defaults to 25 samples.  Optional 
carrier_lock_test_smoother_alpha 
Forgetting factor of the carrier lock detector smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging, in form of “.dat” files. This format can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , this parameter sets the base name of the files in which internal data will be stored. This parameter accepts either a relative or an absolute path; if there are nonexisting specified folders, they will be created. It defaults to ./track_ch , so files in the form “./track_chX.dat”, where X is the channel number, will be generated. 
Optional 
dump_mat 
[true , false ]. If dump=true , when the receiver exits it can convert the “.dat” files stored by this block into “.mat” files directly readable from Matlab and Octave. If the receiver has processed more than a few minutes of signal, this conversion can take a long time. In systems with limited resources, you can turn off this conversion by setting this parameter to false . It defaults to true , so “.mat” files are generated by default if dump=true . 
Optional 
Tracking implementation: GPS_L5_DLL_PLL_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_L5.implementation=GPS_L5_DLL_PLL_Tracking
Tracking_L5.item_type=gr_complex
Tracking_L5.track_pilot=true
Tracking_L5.pll_bw_hz=20.0;
Tracking_L5.dll_bw_hz=1.5;
Tracking_L5.extend_correlation_symbols=20
Tracking_L5.pll_bw_narrow_hz=6.0
Tracking_L5.dll_bw_narrow_hz=0.5
Tracking_L5.enable_fll_pull_in=true
Tracking_L5.enable_fll_steady_state=false
Tracking_L5.fll_bw_hz=4.0
Tracking_L5.early_late_space_chips=0.5;
Tracking_L5.early_late_space_narrow_chips=0.1;
Tracking_L5.dump=false
Tracking_L5.dump_filename=./tracking_ch_
Galileo E5a signal tracking
The AltBOC modulation in the Galileo E5 band allows the approximation to two subbands, referred to as E5a and E5b, QPSKmodulated and centered at \(f_{\text{Gal E5a}}=1176.450\) MHz and \(f_{Gal E5b}=1207.140\) MHz, respectively.
The baseband signal at E5a can then be approximated by:
\[\begin{equation} \label{GalE5a} s^{\text{(Gal E5a)}}_{T}(t) = e_{E5aI}(t)+je_{E5aQ}(t)~, \end{equation}\]where the signal components are defined as:
\[\begin{eqnarray} e_{E5aI}(t) & = & \sum_{m=\infty}^{+\infty}C_{E5aIs}\Big[m_{20}\Big] \oplus \sum_{l=1}^{10230}C_{E5aIp}\Big[ l \Big] \oplus \nonumber \\ {} & {} & \oplus D_{\text{F/NAV}} \Big[ [l]_{204600}\Big] \cdot p(tmT_{c,E5s}lT_{c,E5p})~, \end{eqnarray}\] \[\begin{equation} \!\!\!\!\!\!\!\!\!\!\!\!\!\!e_{E5aQ}(t) \! = \! \sum_{m=\infty}^{+\infty}\!C_{E5aQs}\Big[m_{100}\Big]\! \oplus \!\sum_{l=1}^{10230}C_{E5aQp}\Big[ l \Big] \cdot p(tmT_{c,E5s}lT_{c,E5p})~, \end{equation}\]where \(T_{c,E5s}=1\) ms and \(T_{c,E5p}=\frac{1}{10.23}\) \(\mu\)s.
Then, applying equation \((\ref{GalE5a})\) in \((\ref{xin})\), the digital signal at the input of the Tracking block can be written as
\[\begin{equation} \!\!\!\!\!\!\!\!\!x_\text{IN}[k] = A(kT_s)\tilde{s}^{\text{(Gal E5a)}}_{T}(kT_s\tau(kT_s)) e^{j \left( 2\pi f_D(kT_s) kT_s + \phi(kT_s) \right) } + n(kT_s)~. \end{equation}\]The implementation described below performs the estimation of \(\tau\), \(f_D\) and \(\phi\), which are assumed piecewise constant (that is, constant within an integration time, but allowed to vary from one integration period to the next one).
Implementation: Galileo_E5a_DLL_PLL_Tracking
This implementation accepts the following parameters:
Global Parameter  Description  Required 

GNSSSDR.internal_fs_sps 
Input sample rate to the processing channels, in samples per second.  Mandatory 
Parameter  Description  Required 

implementation 
Galileo_E5a_DLL_PLL_Tracking 
Mandatory 
item_type 
[gr_complex ]: Set the sample data type expected at the block input. It defaults to gr_complex . 
Optional 
track_pilot 
[true , false ]: If set to true , the receiver is set to track the pilot signal E5aQ and enables an extra prompt correlator (slave to pilot’s prompt) in the data component E5aI. If set to false , the receiver performs correlations on a data length of 1 ms over the E5aI component. This parameter defaults to true . 
Optional 
extend_correlation_symbols 
If track_pilot=true , sets the number of correlation symbols to be extended after the secondary code \(C_{E5aQs}\) is removed from the pilot signal, in number of symbols. Each symbol is 1 ms, so setting this parameter to 25 means a coherent integration time of 25 ms. The higher this parameter is, the better local clock stability will be required. It defaults to 1. 
Optional 
pll_bw_hz 
Bandwidth of the PLL low pass filter, in Hz. It defaults to 50 Hz.  Optional 
pll_bw_narrow_hz 
Bandwidth of the PLL low pass filter after the secondary code lock, in Hz. It defaults to 2 Hz.  Optional 
pll_filter_order 
[2 , 3 ]. Sets the order of the PLL lowpass filter. It defaults to 3. 
Optional 
dll_bw_hz 
Bandwidth of the DLL low pass filter, in Hz. It defaults to 2 Hz.  Optional 
dll_bw_narrow_hz 
Bandwidth of the DLL low pass filter after the secondary code lock, in Hz. It defaults to 0.25 Hz.  Optional 
dll_filter_order 
[1 , 2 , 3 ]. Sets the order of the DLL lowpass filter. It defaults to 2. 
Optional 
enable_fll_pull_in 
[true , false ]. If set to true , enables the FLL during the pullin time. It defaults to false . 
Optional 
enable_fll_steady_state 
[true , false ]. If set to true , the FLL is enabled beyond the pullin stage. It defaults to false . 
Optional 
fll_bw_hz 
Bandwidth of the FLL low pass filter, in Hz. It defaults to 35 Hz.  Optional 
pull_in_time_s 
Time, in seconds, in which the tracking loop will be in pullin mode. It defaults to 2 s.  Optional 
early_late_space_chips 
Spacing between Early and Prompt and between Prompt and Late correlators, normalized by the chip period \(T_c\). It defaults to \(0.5\).  Optional 
early_late_space_narrow_chips 
If track_pilot=true and extend_correlation_symbols \(>\) 1, sets the spacing between Early and Prompt and between Prompt and Late correlators after removal of the secondary code \(C_{E5aQs}\), normalized by the chip period \(T_{c,E5p}\). It defaults to \(0.15\). 
Optional 
carrier_aiding 
[true , false ]. If set to true , the code loop is aided by the carrier loop. It defaults to true . 
Optional 
cn0_samples 
Number of \(P\) correlator outputs used for CN0 estimation. It defaults to 20.  Optional 
cn0_min 
Minimum valid CN0 (in dBHz). It defaults to 25 dBHz.  Optional 
max_lock_fail 
Maximum number of lock failures before dropping a satellite. It defaults to 50.  Optional 
carrier_lock_th 
Carrier lock threshold (in rad). It defaults to 0.85 rad.  Optional 
cn0_smoother_samples 
Number of samples used to smooth the value of the estimated \(C/N_0\). It defaults to 200 samples.  Optional 
cn0_smoother_alpha 
Forgetting factor of the \(C/N_0\) smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
carrier_lock_test_smoother_samples 
Number of samples used to smooth the value of the carrier lock test. It defaults to 25 samples.  Optional 
carrier_lock_test_smoother_alpha 
Forgetting factor of the carrier lock detector smoother, as in \(y_k = \alpha x_k + (1  \alpha) y_{k1}\). It defaults to 0.002.  Optional 
dump 
[true , false ]: If set to true , it enables the Tracking internal binary data file logging, in form of “.dat” files. This format can be retrieved and plotted in Matlab / Octave, see scripts under gnsssdr/src/utils/matlab/. It defaults to false . 
Optional 
dump_filename 
If dump is set to true , name of the file in which internal data will be stored. This parameter accepts either a relative or an absolute path; if there are nonexisting specified folders, they will be created. It defaults to ./track_ch , so files in the form “./track_chX.dat”, where X is the channel number, will be generated. 
Optional 
dump_mat 
[true , false ]. If dump=true , when the receiver exits it can convert the “.dat” files stored by this block into “.mat” files directly readable from Matlab and Octave. If the receiver has processed more than a few minutes of signal, this conversion can take a long time. In systems with limited resources, you can turn off this conversion by setting this parameter to false . It defaults to true , so “.mat” files are generated by default if dump=true . 
Optional 
Tracking implementation: Galileo_E5a_DLL_PLL_Tracking
.
Example:
;######### TRACKING GLOBAL CONFIG ############
Tracking_5X.implementation=Galileo_E5a_DLL_PLL_Tracking
Tracking_5X.item_type=gr_complex
Tracking_5X.track_pilot=true
Tracking_5X.pll_bw_hz=20.0;
Tracking_5X.dll_bw_hz=1.5;
Tracking_5X.extend_correlation_symbols=20
Tracking_5X.pll_bw_narrow_hz=5.0;
Tracking_5X.dll_bw_narrow_hz=0.5;
Tracking_5X.early_late_space_chips=0.5;
Tracking_5X.early_late_space_chips_narrow=0.1;
Tracking_5X.fll_bw_hz=4.0
Tracking_5X.enable_fll_pull_in=true;
Tracking_5X.enable_fll_steady_state=false
Tracking_5X.dump=false
Tracking_5X.dump_filename=./tracking_ch_
Plotting results with MATLAB/Octave
Some Tracking block implementations are able to dump intermediate results of the channel indicated by the dump_channel
parameter in MATLAB Level 5 MATfile v7.3 file format (.mat
files), which can be opened in MATLAB/Octave.
The list of output vector variables contained in each .mat
file is the following:
abs_E
: Magnitude of the Early correlator.abs_L
: Magnitude of the Late correlator.abs_P
: Magnitude of the Prompt correlator.abs_VE
: Magnitude of the Very Early correlator.abs_VL
: Magnitude of the Very Late correlator.acc_carrier_phase_rad
: Accumulated carrier phase, in rad.aux1
: not used.aux2
: not used.carrier_error_filt_hz
: Carrier error at the output of the PLL filter, in Hz.carr_error_hz
: Raw carrier error (unfiltered) at the PLL output, in Hz.carrier_doppler_hz
: Doppler shift, in Hz.carrier_doppler_rate_hz
: Doppler rate, in Hz/s.carrier_lock_test
: Output of the carrier lock test.CN0_SNV_dB_Hz
: \(C / N_0\) estimation, in dBHz.code_error_chips
: Raw code error (unfiltered) at the DLL output, in chips.code_error_filt_chips
: Code error at the output of the DLL filter, in chips.code_freq_chips
: Code frequency, in chips/s.code_freq_rate_chips
: Code frequency rate, in chips/s\(^2\).PRN
: Satellite ID.PRN_start_sample_counter
: Sample counter from tracking start.Prompt_I
: Value of the Prompt correlator in the Inphase component.Prompt_Q
: Value of the Prompt correlator in the Quadrature component.
Each variable is a vector containing the outputs of every integration period.
Example:
Assuming that you are processing GPS L1 C/A signals, and you have included the following lines in your configuration file:
Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Tracking
;... (other parameters) ...
Tracking_1C.dump=true
Tracking_1C.dump_filename=./trk_dump
Then, after the processing, you will get a list of .mat
files (in this case, ./trk_dump0.mat
, ./trk_dump1.mat
, etc., up to the number of channels) storing the intermediate results obtained by the Tracking blocks.
Some Matlab/Octave plotting scripts examples are available from src/utils/matlab. For instance, the dll_pll_veml_plot_sample.m
script just requires the modification of the samplingFreq
, channels
, tracking_log_path
and path
variables to get a set of figures with the main tracking results for each channel.
Tracking results for a given channel.
References

J. G. Proakis, Digital Communications, 5th Ed., McGrawHill, 2008. ↩

D. R. Pauluzzi and N. C. Beaulieu, A comparison of SNR estimation techniques for the AWGN channel, IEEE Transactions on Communications, Vol. 48, no. 10, pp 16811691, Oct. 2000. ↩

E. D. Kaplan and C. J. Hegarty, Eds., Understanding GPS. Principles and Applications, 3rd edition, Artech House, Norwood, MA, 2017. ↩ ↩^{2}

C. FernándezPrades, J. Arribas, L. EsteveElfau, D. Pubill, P. Closas, An Open Source Galileo E1 Software Receiver, in Proceedings of the 6th ESA Workshop on Satellite Navigation Technologies (NAVITEC 2012), 57 December 2012, ESTEC, Noordwijk (The Netherlands). ↩

M. Petovello, E. Falletti, M. Pini, L. Lo Presti, Are CarriertoNoise algorithms equivalent in all situations?. Inside GNSS, Vol. 5, no. 1, pp. 2027, Jan.Feb. 2010. ↩

A. J. Van Dierendonck, “GPS Receivers”, from Global Positioning System: Theory and Applications, Volume I, Edited by B. W. Parkinson and J. J. Spilker Jr. American Institute of Aeronautics and Astronautics, 1996. ↩
Leave a comment