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

conf/gnss-sdr_GPS_L1_USRP_X300_realtime.conf

@@ -299,7 +299,6 @@ Acquisition_GPS.max_dwells=1
 ;######### TRACKING GLOBAL CONFIG ############
 
 ;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking]
-;Tracking_GPS.implementation=GPS_L1_CA_DLL_PLL_Optim_Tracking
 Tracking_GPS.implementation=GPS_L1_CA_DLL_PLL_Tracking
 ;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version.
 Tracking_GPS.item_type=gr_complex

conf/gnss-sdr_GPS_L1_USRP_realtime.conf

@@ -299,7 +299,7 @@ Acquisition_GPS.max_dwells=1
 ;######### TRACKING GLOBAL CONFIG ############
 
 ;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking]
-Tracking_GPS.implementation=GPS_L1_CA_DLL_PLL_Optim_Tracking
+Tracking_GPS.implementation=GPS_L1_CA_DLL_PLL_Tracking
 ;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version.
 Tracking_GPS.item_type=gr_complex
 

conf/gnss-sdr_GPS_L1_ishort.conf

@@ -0,0 +1,87 @@
+; You can define your own receiver and invoke it by doing
+; gnss-sdr --config_file=my_GNSS_SDR_configuration.conf
+;
+
+[GNSS-SDR]
+
+;######### GLOBAL OPTIONS ##################
+;internal_fs_hz: Internal signal sampling frequency after the signal conditioning stage [Hz].
+GNSS-SDR.internal_fs_hz=4000000
+
+;######### CONTROL_THREAD CONFIG ############
+ControlThread.wait_for_flowgraph=false
+
+;######### SIGNAL_SOURCE CONFIG ############
+SignalSource.implementation=File_Signal_Source
+SignalSource.filename=/media/javier/SISTEMA/signals/test gestalt 22_1_2016/signal_source_gr_complex_4MSPS.dat
+SignalSource.item_type=gr_complex
+SignalSource.sampling_frequency=4000000
+SignalSource.freq=1575420000
+SignalSource.samples=250000000
+SignalSource.repeat=false
+SignalSource.dump=false
+SignalSource.dump_filename=../data/signal_source.dat
+SignalSource.enable_throttle_control=false
+
+
+;######### SIGNAL_CONDITIONER CONFIG ############
+SignalConditioner.implementation=Pass_Through
+
+
+;######### CHANNELS GLOBAL CONFIG ############
+Channels_1C.count=8
+Channels.in_acquisition=1
+Channel.signal=1C
+
+
+;######### ACQUISITION GLOBAL CONFIG ############
+Acquisition_1C.dump=false
+Acquisition_1C.dump_filename=./acq_dump.dat
+Acquisition_1C.item_type=gr_complex
+Acquisition_1C.if=0
+Acquisition_1C.sampled_ms=1
+Acquisition_1C.implementation=GPS_L1_CA_PCPS_Acquisition
+Acquisition_1C.threshold=0.006
+;Acquisition_1C.pfa=0.01
+Acquisition_1C.doppler_max=10000
+Acquisition_1C.doppler_step=500
+
+;######### TRACKING GLOBAL CONFIG ############
+Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Tracking
+Tracking_1C.item_type=gr_complex
+Tracking_1C.if=0
+Tracking_1C.dump=false
+Tracking_1C.dump_filename=../data/epl_tracking_ch_
+Tracking_1C.pll_bw_hz=45.0;
+Tracking_1C.dll_bw_hz=2.0;
+Tracking_1C.order=3;
+
+;######### TELEMETRY DECODER GPS CONFIG ############
+TelemetryDecoder_1C.implementation=GPS_L1_CA_Telemetry_Decoder
+TelemetryDecoder_1C.dump=false
+TelemetryDecoder_1C.decimation_factor=1;
+
+;######### OBSERVABLES CONFIG ############
+Observables.implementation=GPS_L1_CA_Observables
+Observables.dump=false
+Observables.dump_filename=./observables.dat
+
+
+;######### PVT CONFIG ############
+PVT.implementation=GPS_L1_CA_PVT
+PVT.averaging_depth=100
+PVT.flag_averaging=false
+PVT.output_rate_ms=10
+PVT.display_rate_ms=500
+PVT.dump_filename=./PVT
+PVT.nmea_dump_filename=./gnss_sdr_pvt.nmea;
+PVT.flag_nmea_tty_port=false;
+PVT.nmea_dump_devname=/dev/pts/4
+PVT.flag_rtcm_server=false
+PVT.flag_rtcm_tty_port=false
+PVT.rtcm_dump_devname=/dev/pts/1
+PVT.dump=false
+
+;######### OUTPUT_FILTER CONFIG ############
+OutputFilter.implementation=Null_Sink_Output_Filter
+OutputFilter.item_type=gr_complex

conf/gnss-sdr_GPS_L1_rtl_tcp_realtime.conf

@@ -210,7 +210,7 @@ Acquisition_1C.max_dwells=15
 ;######### TRACKING GLOBAL CONFIG ############
 
 ;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking] [GPS_L1_CA_DLL_PLL_Optim_Tracking]
-Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Optim_Tracking
+Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Tracking
 ;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version.
 Tracking_1C.item_type=gr_complex
 

conf/gnss-sdr_GPS_L1_rtlsdr_realtime.conf

@@ -104,7 +104,7 @@ Acquisition_1C.max_dwells=15
 
 
 ;######### TRACKING GLOBAL CONFIG ############
-Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Optim_Tracking
+Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Tracking
 Tracking_1C.item_type=gr_complex
 Tracking_1C.if=0
 Tracking_1C.dump=false

conf/gnss-sdr_Hybrid_gr_complex.conf

@@ -7,29 +7,28 @@
 
 ;######### GLOBAL OPTIONS ##################
 ;internal_fs_hz: Internal signal sampling frequency after the signal conditioning stage [Hz].
-GNSS-SDR.internal_fs_hz=4000000
+GNSS-SDR.internal_fs_hz=4092000
 
 ;######### CONTROL_THREAD CONFIG ############
 ControlThread.wait_for_flowgraph=false
-
 ;######### SIGNAL_SOURCE CONFIG ############
-;#implementation: Use [File_Signal_Source] or [UHD_Signal_Source] or [GN3S_Signal_Source] (experimental)
+;#implementation: Use [File_Signal_Source] [Nsr_File_Signal_Source] or [UHD_Signal_Source] or [GN3S_Signal_Source] (experimental)
 SignalSource.implementation=File_Signal_Source
 
 ;#filename: path to file with the captured GNSS signal samples to be processed
-SignalSource.filename=../data/agilent_cap2.dat
+SignalSource.filename=/home/javier/signals/GPS_sim1.dat
 
 ;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
 SignalSource.item_type=gr_complex
 
 ;#sampling_frequency: Original Signal sampling frequency in [Hz]
-SignalSource.sampling_frequency=4000000
+SignalSource.sampling_frequency=4092000
 
 ;#freq: RF front-end center frequency in [Hz]
 SignalSource.freq=1575420000
 
 ;#samples: Number of samples to be processed. Notice that 0 indicates the entire file.
-SignalSource.samples=250000000
+SignalSource.samples=0
 
 ;#repeat: Repeat the processing file. Disable this option in this version
 SignalSource.repeat=false
@@ -51,24 +50,21 @@ SignalSource.enable_throttle_control=false
 ;#implementation: Use [Pass_Through] or [Signal_Conditioner]
 ;#[Pass_Through] disables this block and the [DataTypeAdapter], [InputFilter] and [Resampler] blocks
 ;#[Signal_Conditioner] enables this block. Then you have to configure [DataTypeAdapter], [InputFilter] and [Resampler] blocks
-;SignalConditioner.implementation=Signal_Conditioner
 SignalConditioner.implementation=Pass_Through
 
 ;######### DATA_TYPE_ADAPTER CONFIG ############
-;## Changes the type of input data. Please disable it in this version.
+;## Changes the type of input data.
 ;#implementation: [Pass_Through] disables this block
 DataTypeAdapter.implementation=Pass_Through
+DataTypeAdapter.item_type=gr_complex
 
 ;######### INPUT_FILTER CONFIG ############
 ;## Filter the input data. Can be combined with frequency translation for IF signals
 
 ;#implementation: Use [Pass_Through] or [Fir_Filter] or [Freq_Xlating_Fir_Filter]
-;#[Pass_Through] disables this block
+;#[Freq_Xlating_Fir_Filter] enables FIR filter and a composite frequency translation
-;#[Fir_Filter] enables a FIR Filter
+;# that shifts IF down to zero Hz.
-;#[Freq_Xlating_Fir_Filter] enables FIR filter and a composite frequency translation that shifts IF down to zero Hz.
 
-;InputFilter.implementation=Fir_Filter
-;InputFilter.implementation=Freq_Xlating_Fir_Filter
 InputFilter.implementation=Pass_Through
 
 ;#dump: Dump the filtered data to a file.
@@ -79,7 +75,9 @@ InputFilter.dump_filename=../data/input_filter.dat
 
 ;#The following options are used in the filter design of Fir_Filter and Freq_Xlating_Fir_Filter implementation.
 ;#These options are based on parameters of gnuradio's function: gr_remez.
-;#These function calculates the optimal (in the Chebyshev/minimax sense) FIR filter inpulse reponse given a set of band edges, the desired reponse on those bands, and the weight given to the error in those bands.
+;#These function calculates the optimal (in the Chebyshev/minimax sense) FIR filter inpulse
+;#reponse given a set of band edges, the desired reponse on those bands,
+;#and the weight given to the error in those bands.
 
 ;#input_item_type: Type and resolution for input signal samples. Use only gr_complex in this version.
 InputFilter.input_item_type=gr_complex
@@ -125,12 +123,16 @@ InputFilter.filter_type=bandpass
 ;The minimum value is 16; higher values are slower to compute the filter.
 InputFilter.grid_density=16
 
+;# Original sampling frequency stored in the signal file
+InputFilter.sampling_frequency=4092000
+
 ;#The following options are used only in Freq_Xlating_Fir_Filter implementation.
 ;#InputFilter.IF is the intermediate frequency (in Hz) shifted down to zero Hz
 
-InputFilter.sampling_frequency=4000000
+InputFilter.IF=5499998.47412109
-InputFilter.IF=0
 
+;# Decimation factor after the frequency tranaslating block
+InputFilter.decimation_factor=8
 
 
 ;######### RESAMPLER CONFIG ############
@@ -139,35 +141,43 @@ InputFilter.IF=0
 ;#implementation: Use [Pass_Through] or [Direct_Resampler]
 ;#[Pass_Through] disables this block
 ;#[Direct_Resampler] enables a resampler that implements a nearest neigbourhood interpolation
-;Resampler.implementation=Direct_Resampler
 Resampler.implementation=Pass_Through
 
-;#dump: Dump the resamplered data to a file.
-Resampler.dump=false
-;#dump_filename: Log path and filename.
-Resampler.dump_filename=../data/resampler.dat
-
-;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
-Resampler.item_type=gr_complex
-
-;#sample_freq_in: the sample frequency of the input signal
-Resampler.sample_freq_in=8000000
-
-;#sample_freq_out: the desired sample frequency of the output signal
-Resampler.sample_freq_out=4000000
-
-_1C
 ;######### CHANNELS GLOBAL CONFIG ############
 ;#count: Number of available GPS satellite channels.
-Channels_1C.count=8
+Channels_1C.count=1
+;#count: Number of available Galileo satellite channels.
+Channels_1B.count=0
 ;#in_acquisition: Number of channels simultaneously acquiring for the whole receiver
 Channels.in_acquisition=1
+
 ;#signal:
+;# "1C" GPS L1 C/A
+;# "2S" GPS L2 L2C (M)
+;# "1B" GALILEO E1 B (I/NAV OS/CS/SoL)
+;# "5X" GALILEO E5a I+Q
+
 ;#if the option is disabled by default is assigned "1C" GPS L1 C/A
-Channel.signal=1C
+Channel0.signal=1C
+Channel1.signal=1B
+Channel2.signal=1B
+Channel3.signal=1B
+Channel4.signal=1B
+Channel5.signal=1B
+Channel6.signal=1B
+Channel7.signal=1B
+Channel8.signal=1B
+Channel9.signal=1B
+Channel10.signal=1B
+Channel11.signal=1B
+Channel12.signal=1B
+Channel13.signal=1B
+Channel14.signal=1B
+Channel15.signal=1B
 
 
-;######### ACQUISITION GLOBAL CONFIG ############
+;######### GPS ACQUISITION CONFIG ############
+
 ;#dump: Enable or disable the acquisition internal data file logging [true] or [false]
 Acquisition_1C.dump=false
 ;#filename: Log path and filename
@@ -180,20 +190,44 @@ Acquisition_1C.if=0
 Acquisition_1C.sampled_ms=1
 ;#implementation: Acquisition algorithm selection for this channel: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
 Acquisition_1C.implementation=GPS_L1_CA_PCPS_Acquisition
+Acquisition_1C.use_CFAR_algorithm=false;
 ;#threshold: Acquisition threshold
-Acquisition_1C.threshold=0.008
+Acquisition_1C.threshold=30
 ;#pfa: Acquisition false alarm probability. This option overrides the threshold option. Only use with implementations: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
 ;Acquisition_1C.pfa=0.01
 ;#doppler_max: Maximum expected Doppler shift [Hz]
-Acquisition_1C.doppler_max=10000
+Acquisition_1C.doppler_max=5000
 ;#doppler_max: Doppler step in the grid search [Hz]
-Acquisition_1C.doppler_step=500
+Acquisition_1C.doppler_step=100
 
 
+;######### GALILEO ACQUISITION CONFIG ############
 
-;######### TRACKING GLOBAL CONFIG ############
+;#dump: Enable or disable the acquisition internal data file logging [true] or [false]
-;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking]
+Acquisition_1B.dump=false
-Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Optim_Tracking
+;#filename: Log path and filename
+Acquisition_1B.dump_filename=./acq_dump.dat
+;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
+Acquisition_1B.item_type=gr_complex
+;#if: Signal intermediate frequency in [Hz]
+Acquisition_1B.if=0
+;#sampled_ms: Signal block duration for the acquisition signal detection [ms]
+Acquisition_1B.sampled_ms=4
+;#implementation: Acquisition algorithm selection for this channel: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
+Acquisition_1B.implementation=Galileo_E1_PCPS_Ambiguous_Acquisition
+;#threshold: Acquisition threshold
+;Acquisition_1B.threshold=0
+;#pfa: Acquisition false alarm probability. This option overrides the threshold option. Only use with implementations: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
+Acquisition_1B.pfa=0.0000002
+;#doppler_max: Maximum expected Doppler shift [Hz]
+Acquisition_1B.doppler_max=15000
+;#doppler_max: Doppler step in the grid search [Hz]
+Acquisition_1B.doppler_step=125
+
+;######### TRACKING GPS CONFIG ############
+
+;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking] or [GPS_L1_CA_TCP_CONNECTOR_Tracking] or [Galileo_E1_DLL_PLL_VEML_Tracking]
+Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_C_Aid_Tracking
 ;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version.
 Tracking_1C.item_type=gr_complex
 
@@ -201,36 +235,83 @@ Tracking_1C.item_type=gr_complex
 Tracking_1C.if=0
 
 ;#dump: Enable or disable the Tracking internal binary data file logging [true] or [false]
-Tracking_1C.dump=false
+Tracking_1C.dump=true
 
 ;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number.
-Tracking_1C.dump_filename=./tracking_ch_
+Tracking_1C.dump_filename=../data/epl_tracking_ch_
+
+;# Extended correlation after telemetry bit synchronization
+;# Valid values are: [1,2,4,5,10,20] (integer divisors of the GPS L1 CA bit period (20 ms) )
+;# Longer integration period require more stable front-end LO
+
+Tracking_1C.extend_correlation_ms=10
 
 ;#pll_bw_hz: PLL loop filter bandwidth [Hz]
-Tracking_1C.pll_bw_hz=50.0;
+Tracking_1C.pll_bw_hz=40;
+Tracking_1C.pll_bw_narrow_hz=25;
 
 ;#dll_bw_hz: DLL loop filter bandwidth [Hz]
 Tracking_1C.dll_bw_hz=2.0;
 
+Tracking_1C.dll_bw_narrow_hz=2.0;
+
 ;#fll_bw_hz: FLL loop filter bandwidth [Hz]
-Tracking_1C.fll_bw_hz=10.0;
+Tracking_1C.fll_bw_hz=2.0;
 
 ;#order: PLL/DLL loop filter order [2] or [3]
 Tracking_1C.order=3;
 
-;#early_late_space_chips: correlator early-late space [chips]. Use [0.5]
+;######### TRACKING GALILEO CONFIG ############
-Tracking_1C.early_late_space_chips=0.5;
+
+;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking] or [GPS_L1_CA_TCP_CONNECTOR_Tracking] or [Galileo_E1_DLL_PLL_VEML_Tracking]
+Tracking_1B.implementation=Galileo_E1_DLL_PLL_VEML_Tracking
+;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version.
+Tracking_1B.item_type=gr_complex
+
+;#sampling_frequency: Signal Intermediate Frequency in [Hz]
+Tracking_1B.if=0
+
+;#dump: Enable or disable the Tracking internal binary data file logging [true] or [false]
+Tracking_1B.dump=false
+
+;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number.
+Tracking_1B.dump_filename=../data/veml_tracking_ch_
+
+;#pll_bw_hz: PLL loop filter bandwidth [Hz]
+Tracking_1B.pll_bw_hz=15.0;
+
+;#dll_bw_hz: DLL loop filter bandwidth [Hz]
+Tracking_1B.dll_bw_hz=2.0;
+
+;#fll_bw_hz: FLL loop filter bandwidth [Hz]
+Tracking_1B.fll_bw_hz=10.0;
+
+;#order: PLL/DLL loop filter order [2] or [3]
+Tracking_1B.order=3;
+
+;#early_late_space_chips: correlator early-late space [chips]. Use [0.5] for GPS and [0.15] for Galileo
+Tracking_1B.early_late_space_chips=0.15;
+
+;#very_early_late_space_chips: only for [Galileo_E1_DLL_PLL_VEML_Tracking], correlator very early-late space [chips]. Use [0.6]
+Tracking_1B.very_early_late_space_chips=0.6;
+
 
 ;######### TELEMETRY DECODER GPS CONFIG ############
 ;#implementation: Use [GPS_L1_CA_Telemetry_Decoder] for GPS L1 C/A
 TelemetryDecoder_1C.implementation=GPS_L1_CA_Telemetry_Decoder
 TelemetryDecoder_1C.dump=false
 ;#decimation factor
-TelemetryDecoder_1C.decimation_factor=1;
+TelemetryDecoder_1C.decimation_factor=4;
+
+;######### TELEMETRY DECODER GALILEO CONFIG ############
+;#implementation: Use [Galileo_E1B_Telemetry_Decoder] for Galileo E1B
+TelemetryDecoder_1B.implementation=Galileo_E1B_Telemetry_Decoder
+TelemetryDecoder_1B.dump=false
+TelemetryDecoder_1B_factor=4;
 
 ;######### OBSERVABLES CONFIG ############
 ;#implementation: Use [GPS_L1_CA_Observables] for GPS L1 C/A.
-Observables.implementation=GPS_L1_CA_Observables
+Observables.implementation=Hybrid_Observables
 
 ;#dump: Enable or disable the Observables internal binary data file logging [true] or [false]
 Observables.dump=false
@@ -241,40 +322,29 @@ Observables.dump_filename=./observables.dat
 
 ;######### PVT CONFIG ############
 ;#implementation: Position Velocity and Time (PVT) implementation algorithm: Use [GPS_L1_CA_PVT] in this version.
-PVT.implementation=GPS_L1_CA_PVT
+PVT.implementation=Hybrid_PVT
 
 ;#averaging_depth: Number of PVT observations in the moving average algorithm
-PVT.averaging_depth=100
+PVT.averaging_depth=10
 
 ;#flag_average: Enables the PVT averaging between output intervals (arithmetic mean) [true] or [false]
 PVT.flag_averaging=false
 
 ;#output_rate_ms: Period between two PVT outputs. Notice that the minimum period is equal to the tracking integration time (for GPS CA L1 is 1ms) [ms]
-PVT.output_rate_ms=10
+PVT.output_rate_ms=10;
 
 ;#display_rate_ms: Position console print (std::out) interval [ms]. Notice that output_rate_ms<=display_rate_ms.
-PVT.display_rate_ms=500
+PVT.display_rate_ms=500;
 
-;# KML, GeoJSON, NMEA and RTCM output configuration
+;#dump: Enable or disable the PVT internal binary data file logging [true] or [false]
-
+PVT.dump=false
-;#dump_filename: Log path and filename without extension. Notice that PVT will add ".dat" to the binary dump and ".kml" to GoogleEarth dump.
-PVT.dump_filename=./PVT
-
-;#nmea_dump_filename: NMEA log path and filename
-PVT.nmea_dump_filename=./gnss_sdr_pvt.nmea;
-
-;#flag_nmea_tty_port: Enable or disable the NMEA log to a serial TTY port (Can be used with real hardware or virtual one)
-PVT.flag_nmea_tty_port=false;
-
-;#nmea_dump_devname: serial device descriptor for NMEA logging
-PVT.nmea_dump_devname=/dev/pts/4
 
 PVT.flag_rtcm_server=false
 PVT.flag_rtcm_tty_port=false
 PVT.rtcm_dump_devname=/dev/pts/1
 
-;#dump: Enable or disable the PVT internal binary data file logging [true] or [false]
+;#dump_filename: Log path and filename without extension. Notice that PVT will add ".dat" to the binary dump and ".kml" to GoogleEarth dump.
-PVT.dump=true
+PVT.dump_filename=./PVT
 
 ;######### OUTPUT_FILTER CONFIG ############
 ;# Receiver output filter: Leave this block disabled in this version

conf/gnss-sdr_Hybrid_nsr.conf

@@ -19,7 +19,7 @@ ControlThread.wait_for_flowgraph=false
 SignalSource.implementation=Nsr_File_Signal_Source
 
 ;#filename: path to file with the captured GNSS signal samples to be processed
-SignalSource.filename=/datalogger/signals/ifen/E1L1_FE0_Band0.stream
+SignalSource.filename=/media/javier/SISTEMA/signals/ifen/E1L1_FE0_Band0.stream
 
 ;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
 SignalSource.item_type=byte
@@ -150,7 +150,7 @@ Resampler.implementation=Pass_Through
 ;#count: Number of available GPS satellite channels.
 Channels_1C.count=8
 ;#count: Number of available Galileo satellite channels.
-Channels_1B.count=8
+Channels_1B.count=0
 ;#in_acquisition: Number of channels simultaneously acquiring for the whole receiver
 Channels.in_acquisition=1
 
@@ -198,7 +198,7 @@ Acquisition_1C.threshold=0.0075
 ;#pfa: Acquisition false alarm probability. This option overrides the threshold option. Only use with implementations: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
 ;Acquisition_1C.pfa=0.01
 ;#doppler_max: Maximum expected Doppler shift [Hz]
-Acquisition_1C.doppler_max=10000
+Acquisition_1C.doppler_max=5000
 ;#doppler_max: Doppler step in the grid search [Hz]
 Acquisition_1C.doppler_step=500
 
@@ -242,11 +242,20 @@ Tracking_1C.dump=false
 ;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number.
 Tracking_1C.dump_filename=../data/epl_tracking_ch_
 
+;# Extended correlation after telemetry bit synchronization
+;# Valid values are: [1,2,4,5,10,20] (integer divisors of the GPS L1 CA bit period (20 ms) )
+;# Longer integration period require more stable front-end LO
+
+Tracking_1C.extend_correlation_ms=10
+
 ;#pll_bw_hz: PLL loop filter bandwidth [Hz]
-Tracking_1C.pll_bw_hz=45.0;
+
+Tracking_1C.pll_bw_hz=40;
+Tracking_1C.pll_bw_narrow_hz=40;
 
 ;#dll_bw_hz: DLL loop filter bandwidth [Hz]
 Tracking_1C.dll_bw_hz=2.0;
+Tracking_1C.dll_bw_narrow_hz=2.0;
 
 ;#fll_bw_hz: FLL loop filter bandwidth [Hz]
 Tracking_1C.fll_bw_hz=10.0;

src/algorithms/PVT/libs/galileo_e1_ls_pvt.cc

@@ -57,7 +57,7 @@ galileo_e1_ls_pvt::galileo_e1_ls_pvt(int nchannels, std::string dump_filename, b
                             d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
                             LOG(INFO) << "PVT lib dump enabled Log file: " << d_dump_filename.c_str();
                     }
-                    catch (std::ifstream::failure e)
+                    catch (const std::ifstream::failure &e)
                     {
                             LOG(WARNING) << "Exception opening PVT lib dump file " << e.what();
                     }
@@ -164,7 +164,7 @@ bool galileo_e1_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map
             DLOG(INFO) << "obs="<< obs;
             DLOG(INFO) << "W=" << W;
 
-            mypos = galileo_e1_ls_pvt::leastSquarePos(satpos, obs, W);
+            mypos = leastSquarePos(satpos, obs, W);
 
             // Compute Gregorian time
             utc = galileo_utc_model.GST_to_UTC_time(GST, Galileo_week_number);
@@ -176,7 +176,8 @@ bool galileo_e1_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map
 
             DLOG(INFO) << "Galileo Position at TOW=" << galileo_current_time << " in ECEF (X,Y,Z) = " << mypos;
 
-            galileo_e1_ls_pvt::cart2geo(static_cast<double>(mypos(0)), static_cast<double>(mypos(1)), static_cast<double>(mypos(2)), 4);
+            cart2geo(static_cast<double>(mypos(0)), static_cast<double>(mypos(1)), static_cast<double>(mypos(2)), 4);
+            d_rx_dt_m = mypos(3)/GALILEO_C_m_s; // Convert RX time offset from meters to seconds
             //ToDo: Find an Observables/PVT random bug with some satellite configurations that gives an erratic PVT solution (i.e. height>50 km)
             if (d_height_m > 50000)
                 {
@@ -185,10 +186,10 @@ bool galileo_e1_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map
                 }
             DLOG(INFO) << "Galileo Position at " << boost::posix_time::to_simple_string(p_time)
                       << " is Lat = " << d_latitude_d << " [deg], Long = " << d_longitude_d
-                      << " [deg], Height= " << d_height_m << " [m]";
+                      << " [deg], Height= " << d_height_m << " [m]" << " RX time offset= " << d_rx_dt_m << " [s]";
 
             // ###### Compute DOPs ########
-            galileo_e1_ls_pvt::compute_DOP();
+            compute_DOP();
 
             // ######## LOG FILE #########
             if(d_flag_dump_enabled == true)

src/algorithms/PVT/libs/gps_l1_ca_ls_pvt.cc

@@ -58,7 +58,7 @@ gps_l1_ca_ls_pvt::gps_l1_ca_ls_pvt(int nchannels, std::string dump_filename, boo
                             d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
                             LOG(INFO) << "PVT lib dump enabled Log file: " << d_dump_filename.c_str();
                     }
-                    catch (std::ifstream::failure e)
+                    catch (const std::ifstream::failure &e)
                     {
                             LOG(WARNING) << "Exception opening PVT lib dump file " << e.what();
                     }
@@ -167,11 +167,12 @@ bool gps_l1_ca_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map,
             DLOG(INFO) << "obs=" << obs;
             DLOG(INFO) << "W=" << W;
 
-            mypos = gps_l1_ca_ls_pvt::leastSquarePos(satpos, obs, W);
+            mypos = leastSquarePos(satpos, obs, W);
-
             DLOG(INFO) << "(new)Position at TOW=" << GPS_current_time << " in ECEF (X,Y,Z) = " << mypos;
 
-            gps_l1_ca_ls_pvt::cart2geo(mypos(0), mypos(1), mypos(2), 4);
+            cart2geo(static_cast<double>(mypos(0)), static_cast<double>(mypos(1)), static_cast<double>(mypos(2)), 4);
+
+            d_rx_dt_m = mypos(3)/GPS_C_m_s; // Convert RX time offset from meters to seconds
 
             //ToDo: Find an Observables/PVT random bug with some satellite configurations that gives an erratic PVT solution (i.e. height>50 km)
             if (d_height_m > 50000)
@@ -188,10 +189,10 @@ bool gps_l1_ca_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map,
 
             LOG(INFO) << "(new)Position at " << boost::posix_time::to_simple_string(p_time)
             << " is Lat = " << d_latitude_d << " [deg], Long = " << d_longitude_d
-            << " [deg], Height= " << d_height_m << " [m]";
+            << " [deg], Height= " << d_height_m << " [m]" << " RX time offset= " << d_rx_dt_m << " [s]";
 
             // ###### Compute DOPs ########
-            gps_l1_ca_ls_pvt::compute_DOP();
+            compute_DOP();
 
             // ######## LOG FILE #########
             if(d_flag_dump_enabled == true)
@@ -225,14 +226,14 @@ bool gps_l1_ca_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map,
                             tmp_double = d_height_m;
                             d_dump_file.write((char*)&tmp_double, sizeof(double));
                     }
-                    catch (std::ifstream::failure e)
+                    catch (const std::ifstream::failure &e)
                     {
                             LOG(WARNING) << "Exception writing PVT LS dump file " << e.what();
                     }
                 }
 
             // MOVING AVERAGE PVT
-            gps_l1_ca_ls_pvt::pos_averaging(flag_averaging);
+            pos_averaging(flag_averaging);
         }
     else
         {

src/algorithms/PVT/libs/hybrid_ls_pvt.cc

@@ -60,7 +60,7 @@ hybrid_ls_pvt::hybrid_ls_pvt(int nchannels, std::string dump_filename, bool flag
                             d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
                             LOG(INFO) << "PVT lib dump enabled Log file: " << d_dump_filename.c_str();
                     }
-                    catch (std::ifstream::failure e)
+                    catch (const std::ifstream::failure &e)
                     {
                             LOG(WARNING) << "Exception opening PVT lib dump file " << e.what();
                     }
@@ -98,8 +98,8 @@ bool hybrid_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map, do
     int GPS_week = 0;
     double utc = 0.0;
     double GST = 0.0;
-    double utc_tx_corrected = 0.0; //utc computed at tx_time_corrected, added for Galileo constellation (in GPS utc is directly computed at TX_time_corrected_s)
+    //double utc_tx_corrected = 0.0; //utc computed at tx_time_corrected, added for Galileo constellation (in GPS utc is directly computed at TX_time_corrected_s)
-    double TX_time_corrected_s;
+    double TX_time_corrected_s = 0.0;
     double SV_clock_bias_s = 0.0;
 
     d_flag_averaging = flag_averaging;
@@ -239,8 +239,8 @@ bool hybrid_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map, do
             DLOG(INFO) << "obs="<< obs;
             DLOG(INFO) << "W=" << W;
 
-            mypos = hybrid_ls_pvt::leastSquarePos(satpos, obs, W);
+            mypos = leastSquarePos(satpos, obs, W);
-
+            d_rx_dt_m = mypos(3)/GPS_C_m_s; // Convert RX time offset from meters to seconds
             // Compute GST and Gregorian time
             if( GST != 0.0)
                 {
@@ -251,30 +251,27 @@ bool hybrid_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map, do
                     utc = gps_utc_model.utc_time(TX_time_corrected_s, GPS_week);
                 }
             // get time string Gregorian calendar
-            boost::posix_time::time_duration t = boost::posix_time::seconds(utc);
+            double secondsperweek = 604800.0; // number of seconds in one week (7*24*60*60)
+            boost::posix_time::time_duration t = boost::posix_time::seconds(utc + secondsperweek * static_cast<double>(GPS_week));
             // 22 August 1999 00:00 last Galileo start GST epoch (ICD sec 5.1.2)
             boost::posix_time::ptime p_time(boost::gregorian::date(1999, 8, 22), t);
             d_position_UTC_time = p_time;
             DLOG(INFO) << "HYBRID Position at TOW=" << hybrid_current_time << " in ECEF (X,Y,Z) = " << mypos;
 
-            hybrid_ls_pvt::cart2geo(static_cast<double>(mypos(0)), static_cast<double>(mypos(1)), static_cast<double>(mypos(2)), 4);
+            cart2geo(static_cast<double>(mypos(0)), static_cast<double>(mypos(1)), static_cast<double>(mypos(2)), 4);
             //ToDo: Find an Observables/PVT random bug with some satellite configurations that gives an erratic PVT solution (i.e. height>50 km)
             if (d_height_m > 50000)
                 {
                     b_valid_position = false;
                     LOG(INFO) << "Hybrid Position at " << boost::posix_time::to_simple_string(p_time)
                     << " is Lat = " << d_latitude_d << " [deg], Long = " << d_longitude_d
-                    << " [deg], Height= " << d_height_m << " [m]";
+                    << " [deg], Height= " << d_height_m << " [m]" << " RX time offset= " << mypos(3) << " [s]";
-
-                    //std::cout << "Hybrid Position at " << boost::posix_time::to_simple_string(p_time)
-                    //          << " is Lat = " << d_latitude_d << " [deg], Long = " << d_longitude_d
-                    //          << " [deg], Height= " << d_height_m << " [m]" << std::endl;
                     return false;
                 }
 
             LOG(INFO) << "Hybrid Position at " << boost::posix_time::to_simple_string(p_time)
             << " is Lat = " << d_latitude_d << " [deg], Long = " << d_longitude_d
-            << " [deg], Height= " << d_height_m << " [m]";
+            << " [deg], Height= " << d_height_m << " [m]" << " RX time offset= " << d_rx_dt_m << " [s]";
 
             // ###### Compute DOPs ########
             hybrid_ls_pvt::compute_DOP();
@@ -318,7 +315,7 @@ bool hybrid_ls_pvt::get_PVT(std::map<int,Gnss_Synchro> gnss_pseudoranges_map, do
                 }
 
             // MOVING AVERAGE PVT
-            hybrid_ls_pvt::pos_averaging(flag_averaging);
+            pos_averaging(flag_averaging);
         }
     else
         {

src/algorithms/PVT/libs/pvt_solution.h

@@ -48,9 +48,10 @@ class Pvt_Solution
 public:
     Pvt_Solution();
 
-    double d_latitude_d;
+    double d_latitude_d; //!< RX position Latitude WGS84 [deg]
-    double d_longitude_d;
+    double d_longitude_d; //!< RX position Longitude WGS84 [deg]
-    double d_height_m;
+    double d_height_m; //!< RX position height WGS84 [m]
+    double d_rx_dt_m; //!< RX time offset [s]
 
     boost::posix_time::ptime d_position_UTC_time;
 

src/algorithms/channel/adapters/channel.cc

@@ -119,12 +119,17 @@ void Channel::connect(gr::top_block_sptr top_block)
     trk_->connect(top_block);
     nav_->connect(top_block);
 
+    //Synchronous ports
     top_block->connect(pass_through_->get_right_block(), 0, acq_->get_left_block(), 0);
     DLOG(INFO) << "pass_through_ -> acquisition";
     top_block->connect(pass_through_->get_right_block(), 0, trk_->get_left_block(), 0);
     DLOG(INFO) << "pass_through_ -> tracking";
     top_block->connect(trk_->get_right_block(), 0, nav_->get_left_block(), 0);
     DLOG(INFO) << "tracking -> telemetry_decoder";
+
+    // Message ports
+    top_block->msg_connect(nav_->get_left_block(),pmt::mp("preamble_timestamp_s"),trk_->get_right_block(),pmt::mp("preamble_timestamp_s"));
+    DLOG(INFO) << "MSG FEEDBACK CHANNEL telemetry_decoder -> tracking";
     connected_ = true;
 }
 

src/algorithms/libs/CMakeLists.txt

@@ -23,7 +23,6 @@ set(GNSS_SPLIBS_SOURCES
     gnss_sdr_valve.cc
     gnss_signal_processing.cc
     gps_sdr_signal_processing.cc
-    nco_lib.cc
     pass_through.cc
     galileo_e5_signal_processing.cc
     complex_byte_to_float_x2.cc

src/algorithms/libs/nco_lib.cc

@@ -1,106 +0,0 @@
-/*!
- * \file nco_lib.cc
- * \brief A set of Numeric Controlled Oscillator (NCO) functions to generate the carrier wipeoff signal,
- *  regardless of system used
- *
- * \author Javier Arribas 2012, jarribas(at)cttc.es
- *
- * Detailed description of the file here if needed.
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#include "nco_lib.h"
-#include <cmath>
-
-
-void fxp_nco(std::complex<float> *dest, int n_samples, float start_phase_rad, float phase_step_rad)
-{
-    int phase_rad_i;
-    phase_rad_i = gr::fxpt::float_to_fixed(start_phase_rad);
-    int phase_step_rad_i;
-    phase_step_rad_i = gr::fxpt::float_to_fixed(phase_step_rad);
-    float sin_f,cos_f;
-
-    for(int i = 0; i < n_samples; i++)
-        {
-            //using temp variables
-            gr::fxpt::sincos(-phase_rad_i,&sin_f,&cos_f);
-            dest[i] = gr_complex(cos_f, sin_f);
-            phase_rad_i += phase_step_rad_i;
-        }
-}
-
-void fxp_nco_cpyref(std::complex<float> *dest, int n_samples, float start_phase_rad, float phase_step_rad)
-{
-    int phase_rad_i;
-    phase_rad_i = gr::fxpt::float_to_fixed(start_phase_rad);
-    int phase_step_rad_i;
-    phase_step_rad_i = gr::fxpt::float_to_fixed(phase_step_rad);
-
-    float* vector_cpx;
-    vector_cpx = (float*)dest;
-    for(int i = 0; i < n_samples; i++)
-        {
-            //using references (maybe it can be a problem for c++11 ?)
-            //gr_fxpt::sincos(phase_rad_i,&d_carr_sign[i].imag(),&d_carr_sign[i].real());
-            gr::fxpt::sincos(-phase_rad_i, &vector_cpx[i*2+1], &vector_cpx[i*2]);
-            phase_rad_i += phase_step_rad_i;
-
-        }
-}
-
-void fxp_nco_IQ_split(float* I, float* Q , int n_samples,float start_phase_rad, float phase_step_rad)
-{
-    int phase_rad_i;
-    phase_rad_i = gr::fxpt::float_to_fixed(start_phase_rad);
-    int phase_step_rad_i;
-    phase_step_rad_i = gr::fxpt::float_to_fixed(phase_step_rad);
-
-    float sin_f,cos_f;
-    for(int i = 0; i < n_samples; i++)
-        {
-            gr::fxpt::sincos(-phase_rad_i,&sin_f,&cos_f);
-            I[i] = cos_f;
-            Q[i] = sin_f;
-            phase_rad_i += phase_step_rad_i;
-
-        }
-}
-
-
-
-void std_nco(std::complex<float> *dest, int n_samples, float start_phase_rad, float phase_step_rad)
-{
-    float phase_rad;
-    phase_rad = start_phase_rad;
-
-    for(int i = 0; i < n_samples; i++)
-        {
-            // Using std::cos and std::sin
-            dest[i] = gr_complex(std::cos(phase_rad), -std::sin(phase_rad));
-            phase_rad = phase_rad+phase_step_rad;
-        }
-}

src/algorithms/libs/nco_lib.h

@@ -1,87 +0,0 @@
-/*!
- * \file nco_lib.h
- * \brief A set of Numeric Controlled Oscillator (NCO) functions to generate the carrier wipeoff signal,
- *  regardless of system used
- *
- * \author Javier Arribas 2012, jarribas(at)cttc.es
- *
- * Detailed description of the file here if needed.
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-
-
-#ifndef GNSS_SDR_NCO_LIB_CC_H_
-#define	GNSS_SDR_NCO_LIB_CC_H_
-
-#include <gnuradio/fxpt.h>
-
-
-/*!
- * \brief Implements a complex conjugate exponential vector in std::complex<float> *d_carr_sign
- * containing int n_samples, with the starting phase float start_phase_rad and the pase step between vector elements
- * float phase_step_rad. This function uses a SSE CORDIC implementation.
- *
- */
-void sse_nco(std::complex<float> *dest, int n_samples,float start_phase_rad, float phase_step_rad);
-
-/*!
- * \brief Implements a complex conjugate exponential vector in std::complex<float> *d_carr_sign
- * containing int n_samples, with the starting phase float start_phase_rad and the pase step between vector elements
- * float phase_step_rad. This function uses the GNU Radio fixed point CORDIC implementation.
- *
- */
-void fxp_nco(std::complex<float> *dest, int n_samples,float start_phase_rad, float phase_step_rad);
-
-/*!
- * \brief Implements a complex conjugate exponential vector in std::complex<float> *d_carr_sign
- * containing int n_samples, with the starting phase float start_phase_rad and the pase step between vector elements
- * float phase_step_rad. This function uses the stdlib sin() and cos() implementation.
- *
- */
-
-void std_nco(std::complex<float> *dest, int n_samples,float start_phase_rad, float phase_step_rad);
-
-/*!
- * \brief Implements a complex conjugate exponential vector in std::complex<float> *d_carr_sign
- * containing int n_samples, with the starting phase float start_phase_rad and the pase step between vector elements
- * float phase_step_rad. This function uses the GNU Radio fixed point CORDIC implementation.
- *
- */
-
-void fxp_nco_cpyref(std::complex<float> *dest, int n_samples,float start_phase_rad, float phase_step_rad);
-
-
-/*!
- * \brief Implements a complex conjugate exponential vector in two separated float arrays (In-phase and Quadrature)
- * containing int n_samples, with the starting phase float start_phase_rad and the pase step between vector elements
- * float phase_step_rad. This function uses the GNU Radio fixed point CORDIC implementation.
- *
- */
-
-void fxp_nco_IQ_split(float* I, float* Q, int n_samples,float start_phase_rad, float phase_step_rad);
-
-#endif //NCO_LIB_CC_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_resamplerxnpuppet_16ic.h

@@ -45,7 +45,7 @@
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_generic(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     float code_phase_step_chips = 0.1;
-    int code_length_chips = 1023;
+    int code_length_chips = 2046;
     int num_out_vectors = 3;
     float* rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
 
@@ -73,7 +73,7 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_generic(lv_16sc_t* r
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_a_sse2(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     float code_phase_step_chips = 0.1;
-    int code_length_chips = 1023;
+    int code_length_chips = 2046;
     int num_out_vectors = 3;
     float * rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
     lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
@@ -100,7 +100,7 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_a_sse2(lv_16sc_t* re
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_u_sse2(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     float code_phase_step_chips = 0.1;
-    int code_length_chips = 1023;
+    int code_length_chips = 2046;
     int num_out_vectors = 3;
     float * rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
     lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
@@ -127,7 +127,7 @@ static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_u_sse2(lv_16sc_t* re
 static inline void volk_gnsssdr_16ic_resamplerxnpuppet_16ic_neon(lv_16sc_t* result, const lv_16sc_t* local_code, unsigned int num_points)
 {
     float code_phase_step_chips = 0.1;
-    int code_length_chips = 1023;
+    int code_length_chips = 2046;
     int num_out_vectors = 3;
     float * rem_code_phase_chips = (float*)volk_gnsssdr_malloc(sizeof(float) * num_out_vectors, volk_gnsssdr_get_alignment());
     lv_16sc_t** result_aux =  (lv_16sc_t**)volk_gnsssdr_malloc(sizeof(lv_16sc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_resamplerxnpuppet_32fc.h

@@ -0,0 +1,248 @@
+/*!
+ * \file volk_gnsssdr_32fc_resamplerxnpuppet_32fc.h
+ * \brief VOLK_GNSSSDR puppet for the multiple 16-bit complex vector resampler kernel.
+ * \authors <ul>
+ *          <li> Carles Fernandez Prades 2016 cfernandez at cttc dot cat
+ *          </ul>
+ *
+ * VOLK_GNSSSDR puppet for integrating the multiple resampler into the test system
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef INCLUDED_volk_gnsssdr_32fc_resamplerxnpuppet_32fc_H
+#define INCLUDED_volk_gnsssdr_32fc_resamplerxnpuppet_32fc_H
+
+#include "volk_gnsssdr/volk_gnsssdr_32fc_xn_resampler_32fc_xn.h"
+#include <volk_gnsssdr/volk_gnsssdr_malloc.h>
+#include <volk_gnsssdr/volk_gnsssdr_complex.h>
+#include <volk_gnsssdr/volk_gnsssdr.h>
+#include <string.h>
+
+#ifdef LV_HAVE_GENERIC
+static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_generic(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
+{
+    float code_phase_step_chips = 0.6;
+    int code_length_chips = 2046;
+    int num_out_vectors = 3;
+    float rem_code_phase_chips = -0.234;
+
+    float shifts_chips[3] = { -0.1, 0.0, 0.1  };
+
+    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+    }
+
+    volk_gnsssdr_32fc_xn_resampler_32fc_xn_generic(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
+
+    memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
+
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+        volk_gnsssdr_free(result_aux[n]);
+    }
+    volk_gnsssdr_free(result_aux);
+}
+
+#endif /* LV_HAVE_GENERIC */
+ 
+
+#ifdef LV_HAVE_SSE3
+static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_sse3(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
+{
+    float code_phase_step_chips = 0.6;
+    int code_length_chips = 2046;
+    int num_out_vectors = 3;
+    float rem_code_phase_chips = -0.234;
+
+    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+
+    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+    }
+
+    volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
+
+    memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
+
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+        volk_gnsssdr_free(result_aux[n]);
+    }
+    volk_gnsssdr_free(result_aux);
+}
+
+#endif
+
+#ifdef LV_HAVE_SSE3
+static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_sse3(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
+{
+    float code_phase_step_chips = 0.6;
+    int code_length_chips = 2046;
+    int num_out_vectors = 3;
+    float rem_code_phase_chips = -0.234;
+
+    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+
+    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+    }
+
+    volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse3(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
+
+    memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
+
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+        volk_gnsssdr_free(result_aux[n]);
+    }
+    volk_gnsssdr_free(result_aux);
+}
+
+#endif
+
+
+#ifdef LV_HAVE_SSE4_1
+static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_sse4_1(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
+{
+    float code_phase_step_chips = 0.6;
+    int code_length_chips = 2046;
+    int num_out_vectors = 3;
+    float rem_code_phase_chips = -0.234;
+
+    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+
+    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+    }
+
+    volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
+
+    memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
+
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+        volk_gnsssdr_free(result_aux[n]);
+    }
+    volk_gnsssdr_free(result_aux);
+}
+
+#endif
+
+#ifdef LV_HAVE_SSE4_1
+static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_sse4_1(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
+{
+    float code_phase_step_chips = 0.6;
+    int code_length_chips = 2046;
+    int num_out_vectors = 3;
+    float rem_code_phase_chips = -0.234;
+
+    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+
+    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+    }
+
+    volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse4_1(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
+
+    memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
+
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+        volk_gnsssdr_free(result_aux[n]);
+    }
+    volk_gnsssdr_free(result_aux);
+}
+
+#endif
+
+#ifdef LV_HAVE_AVX
+static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_a_avx(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
+{
+    float code_phase_step_chips = 0.6;
+    int code_length_chips = 2046;
+    int num_out_vectors = 3;
+    float rem_code_phase_chips = -0.234;
+
+    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+
+    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+    }
+
+    volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
+
+    memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
+
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+        volk_gnsssdr_free(result_aux[n]);
+    }
+    volk_gnsssdr_free(result_aux);
+}
+#endif
+
+
+#ifdef LV_HAVE_AVX
+static inline void volk_gnsssdr_32fc_resamplerxnpuppet_32fc_u_avx(lv_32fc_t* result, const lv_32fc_t* local_code, unsigned int num_points)
+{
+    float code_phase_step_chips = 0.6;
+    int code_length_chips = 2046;
+    int num_out_vectors = 3;
+    float rem_code_phase_chips = -0.234;
+
+    float shifts_chips[3] = { -0.1, 0.0, 0.1 };
+
+    lv_32fc_t** result_aux =  (lv_32fc_t**)volk_gnsssdr_malloc(sizeof(lv_32fc_t*) * num_out_vectors, volk_gnsssdr_get_alignment());
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+       result_aux[n] = (lv_32fc_t*)volk_gnsssdr_malloc(sizeof(lv_32fc_t) * num_points, volk_gnsssdr_get_alignment());
+    }
+
+    volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx(result_aux, local_code, rem_code_phase_chips, code_phase_step_chips, shifts_chips, code_length_chips, num_out_vectors, num_points);
+
+    memcpy((lv_32fc_t*)result, (lv_32fc_t*)result_aux[0], sizeof(lv_32fc_t) * num_points);
+
+    for(unsigned int n = 0; n < num_out_vectors; n++)
+    {
+        volk_gnsssdr_free(result_aux[n]);
+    }
+    volk_gnsssdr_free(result_aux);
+}
+#endif
+
+#endif // INCLUDED_volk_gnsssdr_32fc_resamplerpuppet_32fc_H

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_xn_resampler_32fc_xn.h

@@ -0,0 +1,290 @@
+/*!
+ * \file volk_gnsssdr_16ic_xn_resampler_16ic_xn.h
+ * \brief VOLK_GNSSSDR kernel: Resamples N 16 bits integer short complex vectors using zero hold resample algorithm.
+ * \authors <ul>
+ *          <li> Javier Arribas, 2015. jarribas(at)cttc.es
+ *          </ul>
+ *
+ * VOLK_GNSSSDR kernel that esamples N 16 bits integer short complex vectors using zero hold resample algorithm.
+ * It is optimized to resample a sigle GNSS local code signal replica into N vectors fractional-resampled and fractional-delayed
+ * (i.e. it creates the Early, Prompt, and Late code replicas)
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+/*!
+ * \page volk_gnsssdr_16ic_xn_resampler_16ic_xn
+ *
+ * \b Overview
+ *
+ * Resamples a complex vector (16-bit integer each component), providing \p num_out_vectors outputs.
+ *
+ * <b>Dispatcher Prototype</b>
+ * \code
+ * void volk_gnsssdr_16ic_xn_resampler_16ic_xn(lv_16sc_t** result, const lv_16sc_t* local_code, float* rem_code_phase_chips, float code_phase_step_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
+ * \endcode
+ *
+ * \b Inputs
+ * \li local_code:            One of the vectors to be multiplied.
+ * \li rem_code_phase_chips:  Remnant code phase [chips].
+ * \li code_phase_step_chips: Phase increment per sample [chips/sample].
+ * \li code_length_chips:     Code length in chips.
+ * \li num_out_vectors        Number of output vectors.
+ * \li num_output_samples:    The number of data values to be in the resampled vector.
+ *
+ * \b Outputs
+ * \li result:                Pointer to a vector of pointers where the results will be stored.
+ *
+ */
+
+#ifndef INCLUDED_volk_gnsssdr_32fc_xn_resampler_32fc_xn_H
+#define INCLUDED_volk_gnsssdr_32fc_xn_resampler_32fc_xn_H
+
+#include <math.h>
+#include <volk_gnsssdr/volk_gnsssdr_common.h>
+#include <volk_gnsssdr/volk_gnsssdr_complex.h>
+
+//#pragma STDC FENV_ACCESS ON
+
+#ifdef LV_HAVE_GENERIC
+
+
+static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_generic(lv_32fc_t** result, const lv_32fc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, float* shifts_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
+{
+    int local_code_chip_index;
+    for (int current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
+        {
+            for (int n = 0; n < num_output_samples; n++)
+                {
+                    // resample code for current tap
+                    local_code_chip_index = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
+                    local_code_chip_index = local_code_chip_index % code_length_chips;
+                    //Take into account that in multitap correlators, the shifts can be negative!
+                    if (local_code_chip_index < 0) local_code_chip_index += code_length_chips;
+                    result[current_correlator_tap][n] = local_code[local_code_chip_index];
+                }
+        }
+}
+
+#endif /*LV_HAVE_GENERIC*/
+
+
+#ifdef LV_HAVE_SSE3
+#include <pmmintrin.h>
+static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse3(lv_32fc_t** result, const lv_32fc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, float* shifts_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
+{
+    lv_32fc_t** _result = result;
+    const unsigned int quarterPoints = num_output_samples / 4;
+
+    const __m128 ones = _mm_set1_ps(1.0f);
+    const __m128 fours = _mm_set1_ps(4.0f);
+    const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
+    const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
+
+    __attribute__((aligned(16))) int local_code_chip_index[4];
+    int local_code_chip_index_;
+
+    const __m128i zeros = _mm_setzero_si128();
+    const __m128 code_length_chips_reg_f = _mm_set_ps1((float)code_length_chips);
+    const __m128i code_length_chips_reg_i = _mm_set1_epi32((int)code_length_chips);
+    __m128i local_code_chip_index_reg, aux_i, negatives, i;
+    __m128 aux, aux2, shifts_chips_reg, fi, igx, j, c, cTrunc, base;
+
+    for (int current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
+        {
+            shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
+            aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
+            __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
+            for(unsigned int n = 0; n < quarterPoints; n++)
+                {
+                    aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
+                    aux = _mm_add_ps(aux, aux2);
+                    // floor
+                    i = _mm_cvttps_epi32(aux);
+                    fi = _mm_cvtepi32_ps(i);
+                    igx = _mm_cmpgt_ps(fi, aux);
+                    j = _mm_and_ps(igx, ones);
+                    aux = _mm_sub_ps(fi, j);
+                    // fmod
+                    c = _mm_div_ps(aux, code_length_chips_reg_f);
+                    i = _mm_cvttps_epi32(c);
+                    cTrunc = _mm_cvtepi32_ps(i);
+                    base = _mm_mul_ps(cTrunc, code_length_chips_reg_f);
+                    local_code_chip_index_reg = _mm_cvtps_epi32(_mm_sub_ps(aux, base));
+
+                    negatives = _mm_cmplt_epi32(local_code_chip_index_reg, zeros);
+                    aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
+                    local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
+                    _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
+                    for(unsigned int k = 0; k < 4; ++k)
+                        {
+                            _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
+                        }
+                    indexn = _mm_add_ps(indexn, fours);
+                }
+            for(unsigned int n = quarterPoints * 4; n < num_output_samples; n++)
+                {
+                    // resample code for current tap
+                    local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
+                    local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
+                    //Take into account that in multitap correlators, the shifts can be negative!
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += code_length_chips;
+                    _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
+                }
+
+        }
+}
+#endif 
+
+#ifdef LV_HAVE_SSE4_1
+#include <smmintrin.h>
+static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_sse4_1(lv_32fc_t** result, const lv_32fc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, float* shifts_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
+{
+    lv_32fc_t** _result = result;
+    const unsigned int quarterPoints = num_output_samples / 4;
+
+    const __m128 fours = _mm_set1_ps(4.0f);
+    const __m128 rem_code_phase_chips_reg = _mm_set_ps1(rem_code_phase_chips);
+    const __m128 code_phase_step_chips_reg = _mm_set_ps1(code_phase_step_chips);
+
+    __attribute__((aligned(16))) int local_code_chip_index[4];
+    int local_code_chip_index_;
+
+    const __m128i zeros = _mm_setzero_si128();
+    const __m128 code_length_chips_reg_f = _mm_set_ps1((float)code_length_chips);
+    const __m128i code_length_chips_reg_i = _mm_set1_epi32((int)code_length_chips);
+    __m128i local_code_chip_index_reg, aux_i, negatives, i;
+    __m128 aux, aux2, shifts_chips_reg, c, cTrunc, base;
+
+    for (int current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
+        {
+            shifts_chips_reg = _mm_set_ps1((float)shifts_chips[current_correlator_tap]);
+            aux2 = _mm_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
+            __m128 indexn = _mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f);
+            for(unsigned int n = 0; n < quarterPoints; n++)
+                {
+                    aux = _mm_mul_ps(code_phase_step_chips_reg, indexn);
+                    aux = _mm_add_ps(aux, aux2);
+                    // floor
+                    aux = _mm_floor_ps(aux);
+
+                    // fmod
+                    c = _mm_div_ps(aux, code_length_chips_reg_f);
+                    i = _mm_cvttps_epi32(c);
+                    cTrunc = _mm_cvtepi32_ps(i);
+                    base = _mm_mul_ps(cTrunc, code_length_chips_reg_f);
+                    local_code_chip_index_reg = _mm_cvtps_epi32(_mm_sub_ps(aux, base));
+
+                    negatives = _mm_cmplt_epi32(local_code_chip_index_reg, zeros);
+                    aux_i = _mm_and_si128(code_length_chips_reg_i, negatives);
+                    local_code_chip_index_reg = _mm_add_epi32(local_code_chip_index_reg, aux_i);
+                    _mm_store_si128((__m128i*)local_code_chip_index, local_code_chip_index_reg);
+                    for(unsigned int k = 0; k < 4; ++k)
+                        {
+                            _result[current_correlator_tap][n * 4 + k] = local_code[local_code_chip_index[k]];
+                        }
+                    indexn = _mm_add_ps(indexn, fours);
+                }
+            for(unsigned int n = quarterPoints * 4; n < num_output_samples; n++)
+                {
+                    // resample code for current tap
+                    local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
+                    local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
+                    //Take into account that in multitap correlators, the shifts can be negative!
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += code_length_chips;
+                    _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
+                }
+
+        }
+}
+#endif 
+
+
+#ifdef LV_HAVE_AVX
+#include <immintrin.h>
+static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_a_avx(lv_32fc_t** result, const lv_32fc_t* local_code, float rem_code_phase_chips, float code_phase_step_chips, float* shifts_chips, unsigned int code_length_chips, int num_out_vectors, unsigned int num_output_samples)
+{
+    lv_32fc_t** _result = result;
+    const unsigned int avx_iters = num_output_samples / 8;
+
+    const __m256 eights = _mm256_set1_ps(8.0f);
+    const __m256 rem_code_phase_chips_reg = _mm256_set1_ps(rem_code_phase_chips);
+    const __m256 code_phase_step_chips_reg = _mm256_set1_ps(code_phase_step_chips);
+
+    __attribute__((aligned(32))) int local_code_chip_index[8];
+    int local_code_chip_index_;
+
+    const __m256 zeros = _mm256_setzero_ps();
+    const __m256 code_length_chips_reg_f = _mm256_set1_ps((float)code_length_chips);
+
+    __m256i local_code_chip_index_reg, i;
+    __m256 aux, aux2, shifts_chips_reg, c, cTrunc, base, negatives;
+
+    for (int current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
+        {
+            shifts_chips_reg = _mm256_set1_ps((float)shifts_chips[current_correlator_tap]);
+            aux2 = _mm256_sub_ps(shifts_chips_reg, rem_code_phase_chips_reg);
+            __m256 indexn = _mm256_set_ps(7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 0.0f);
+            for(unsigned int n = 0; n < avx_iters; n++)
+                {
+                    aux = _mm256_mul_ps(code_phase_step_chips_reg, indexn);
+                    aux = _mm256_add_ps(aux, aux2);
+                    // floor
+                    aux = _mm256_floor_ps(aux);
+
+                    // fmod
+                    c = _mm256_div_ps(aux, code_length_chips_reg_f);
+                    i = _mm256_cvttps_epi32(c);
+                    cTrunc = _mm256_cvtepi32_ps(i);
+                    base = _mm256_mul_ps(cTrunc, code_length_chips_reg_f);
+                    aux = _mm256_sub_ps(aux, base);
+
+                    negatives = _mm256_cmp_ps(aux, zeros, 0x01);
+                    aux2 = _mm256_and_ps(code_length_chips_reg_f, negatives);
+                    local_code_chip_index_reg = _mm256_cvtps_epi32(_mm256_add_ps(aux, aux2));
+                    _mm256_store_si256((__m256i*)local_code_chip_index, local_code_chip_index_reg);
+                    for(unsigned int k = 0; k < 8; ++k)
+                        {
+                            _result[current_correlator_tap][n * 8 + k] = local_code[local_code_chip_index[k]];
+                        }
+                    indexn = _mm256_add_ps(indexn, eights);
+                }
+            _mm256_zeroupper();
+            for(unsigned int n = avx_iters * 8; n < num_output_samples; n++)
+                {
+                    // resample code for current tap
+                    local_code_chip_index_ = (int)floor(code_phase_step_chips * (float)n + shifts_chips[current_correlator_tap] - rem_code_phase_chips);
+                    local_code_chip_index_ = local_code_chip_index_ % code_length_chips;
+                    //Take into account that in multitap correlators, the shifts can be negative!
+                    if (local_code_chip_index_ < 0) local_code_chip_index_ += code_length_chips;
+                    _result[current_correlator_tap][n] = local_code[local_code_chip_index_];
+                }
+
+        }
+}
+#endif
+
+#endif /*INCLUDED_volk_gnsssdr_16ic_xn_resampler_16ic_xn_H*/
+

src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/kernel_tests.h

@@ -87,6 +87,7 @@ std::vector<volk_gnsssdr_test_case_t> init_test_list(volk_gnsssdr_test_params_t
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_rotatorpuppet_16ic, volk_gnsssdr_16ic_s32fc_x2_rotator_16ic, test_params_int1))
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerpuppet_16ic, volk_gnsssdr_16ic_resampler_16ic, test_params))
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_resamplerxnpuppet_16ic, volk_gnsssdr_16ic_xn_resampler_16ic_xn, test_params))
+        (VOLK_INIT_PUPP(volk_gnsssdr_32fc_resamplerxnpuppet_32fc, volk_gnsssdr_32fc_xn_resampler_32fc_xn, test_params))
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_dot_prod_16ic_xn, test_params))
         (VOLK_INIT_PUPP(volk_gnsssdr_16ic_x2_rotator_dotprodxnpuppet_16ic, volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn, test_params_int16))
         (VOLK_INIT_PUPP(volk_gnsssdr_32fc_x2_rotator_dotprodxnpuppet_32fc, volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn, test_params_int1))

src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_e1b_telemetry_decoder_cc.cc

@@ -120,6 +120,8 @@ galileo_e1b_telemetry_decoder_cc::galileo_e1b_telemetry_decoder_cc(
            gr::block("galileo_e1b_telemetry_decoder_cc", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
 	   gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry Bit transition synchronization port out
+    this->message_port_register_out(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;

src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_e5a_telemetry_decoder_cc.cc

@@ -197,6 +197,8 @@ galileo_e5a_telemetry_decoder_cc::galileo_e5a_telemetry_decoder_cc(
                    gr::block("galileo_e5a_telemetry_decoder_cc", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
                            gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry Bit transition synchronization port out
+    this->message_port_register_out(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc

@@ -29,11 +29,6 @@
  * -------------------------------------------------------------------------
  */
 
-/*!
- * \todo Clean this code and move the telemetry definitions to GPS_L1_CA system definitions file
- */
-
-
 #include "gps_l1_ca_telemetry_decoder_cc.h"
 #include <iostream>
 #include <boost/lexical_cast.hpp>
@@ -47,29 +42,17 @@
 #endif
 
 using google::LogMessage;
-/*!
+
- * \todo name and move the magic numbers to GPS_L1_CA.h
- */
 gps_l1_ca_telemetry_decoder_cc_sptr
 gps_l1_ca_make_telemetry_decoder_cc(Gnss_Satellite satellite, boost::shared_ptr<gr::msg_queue> queue, bool dump)
 {
     return gps_l1_ca_telemetry_decoder_cc_sptr(new gps_l1_ca_telemetry_decoder_cc(satellite, queue, dump));
 }
 
-
-
 void gps_l1_ca_telemetry_decoder_cc::forecast (int noutput_items, gr_vector_int &ninput_items_required)
 {
-    if (noutput_items != 0)
+    ninput_items_required[0] = GPS_CA_PREAMBLE_LENGTH_SYMBOLS; //set the required sample history
-        {
-            for (unsigned i = 0; i < 3; i++)
-                {
-                    ninput_items_required[i] = d_samples_per_bit * 8; //set the required sample history
 }
-        }
-}
-
-
 
 gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc(
         Gnss_Satellite satellite,
@@ -78,24 +61,24 @@ gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc(
         gr::block("gps_navigation_cc", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
         gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry Bit transition synchronization port out
+    this->message_port_register_out(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;
     d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
-    d_samples_per_bit = ( GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS ) / GPS_CA_TELEMETRY_RATE_BITS_SECOND;
+
-    //d_preamble_duration_seconds = (1.0 / GPS_CA_TELEMETRY_RATE_BITS_SECOND) * GPS_CA_PREAMBLE_LENGTH_BITS;
-    //std::cout<<"d_preamble_duration_seconds="<<d_preamble_duration_seconds<<"\r\n";
     // set the preamble
     unsigned short int preambles_bits[GPS_CA_PREAMBLE_LENGTH_BITS] = GPS_PREAMBLE;
 
     memcpy((unsigned short int*)this->d_preambles_bits, (unsigned short int*)preambles_bits, GPS_CA_PREAMBLE_LENGTH_BITS*sizeof(unsigned short int));
 
     // preamble bits to sampled symbols
-    d_preambles_symbols = (signed int*)malloc(sizeof(signed int) * GPS_CA_PREAMBLE_LENGTH_BITS * d_samples_per_bit);
+    d_preambles_symbols = (signed int*)malloc(sizeof(signed int) * GPS_CA_PREAMBLE_LENGTH_SYMBOLS);
     int n = 0;
     for (int i = 0; i < GPS_CA_PREAMBLE_LENGTH_BITS; i++)
         {
-            for (unsigned int j = 0; j < d_samples_per_bit; j++)
+            for (unsigned int j = 0; j < GPS_CA_TELEMETRY_SYMBOLS_PER_BIT; j++)
                 {
                     if (d_preambles_bits[i] == 1)
                         {
@@ -108,10 +91,7 @@ gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc(
                     n++;
                 }
         }
-    d_sample_counter = 0;
-    //d_preamble_code_phase_seconds = 0;
     d_stat = 0;
-    d_preamble_index = 0;
     d_symbol_accumulator = 0;
     d_symbol_accumulator_counter = 0;
     d_frame_bit_index = 0;
@@ -130,7 +110,6 @@ gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc(
     d_channel = 0;
     Prn_timestamp_at_preamble_ms = 0.0;
     flag_PLL_180_deg_phase_locked = false;
-    //set_history(d_samples_per_bit*8); // At least a history of 8 bits are needed to correlate with the preamble
 }
 
 
@@ -140,8 +119,6 @@ gps_l1_ca_telemetry_decoder_cc::~gps_l1_ca_telemetry_decoder_cc()
     d_dump_file.close();
 }
 
-
-
 bool gps_l1_ca_telemetry_decoder_cc::gps_word_parityCheck(unsigned int gpsword)
 {
     unsigned int d1, d2, d3, d4, d5, d6, d7, t, parity;
@@ -169,88 +146,94 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i
         gr_vector_const_void_star &input_items,	gr_vector_void_star &output_items)
 {
     int corr_value = 0;
-    int preamble_diff = 0;
+    int preamble_diff_ms = 0;
 
     Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0];
-    d_sample_counter++; //count for the processed samples
 
     // ########### Output the tracking data to navigation and PVT ##########
     const Gnss_Synchro **in = (const Gnss_Synchro **)  &input_items[0]; //Get the input samples pointer
 
-    // TODO Optimize me!
     //******* preamble correlation ********
-    for (unsigned int i = 0; i < d_samples_per_bit*8; i++)
+    for (unsigned int i = 0; i < GPS_CA_PREAMBLE_LENGTH_SYMBOLS; i++)
+        {
+            if (in[0][i].Flag_valid_symbol_output == true)
                 {
                     if (in[0][i].Prompt_I < 0)	// symbols clipping
                         {
-                    corr_value -= d_preambles_symbols[i];
+                            corr_value -= d_preambles_symbols[i] * in[0][i].correlation_length_ms;
                         }
                     else
                         {
-                    corr_value += d_preambles_symbols[i];
+                            corr_value += d_preambles_symbols[i] * in[0][i].correlation_length_ms;
                         }
                 }
+            if (corr_value >= GPS_CA_PREAMBLE_LENGTH_SYMBOLS) break;
+        }
     d_flag_preamble = false;
 
     //******* frame sync ******************
-    if (abs(corr_value) >= 160)
+    if (abs(corr_value) == GPS_CA_PREAMBLE_LENGTH_SYMBOLS)
         {
-            //TODO: Rewrite with state machine
             if (d_stat == 0)
                 {
                     d_GPS_FSM.Event_gps_word_preamble();
-                    d_preamble_index = d_sample_counter;//record the preamble sample stamp
+                    d_preamble_time_seconds = in[0][0].Tracking_timestamp_secs; // record the preamble sample stamp
-                    LOG(INFO) << "Preamble detection for SAT " << this->d_satellite;
+                    DLOG(INFO)  << "Preamble detection for SAT " << this->d_satellite << "in[0][0].Tracking_timestamp_secs=" << round(in[0][0].Tracking_timestamp_secs * 1000.0);
-                    d_symbol_accumulator = 0; //sync the symbol to bits integrator
+                    //sync the symbol to bits integrator
+                    d_symbol_accumulator = 0;
                     d_symbol_accumulator_counter = 0;
-                    d_frame_bit_index = 8;
+                    d_frame_bit_index = 0;
                     d_stat = 1; // enter into frame pre-detection status
                 }
             else if (d_stat == 1) //check 6 seconds of preamble separation
                 {
-                    preamble_diff = d_sample_counter - d_preamble_index;
+                    preamble_diff_ms = round((in[0][0].Tracking_timestamp_secs - d_preamble_time_seconds) * 1000.0);
-                    if (abs(preamble_diff - 6000) < 1)
+                    if (abs(preamble_diff_ms - GPS_SUBFRAME_MS) < 1)
                         {
+                            DLOG(INFO) << "Preamble confirmation for SAT " << this->d_satellite  << "in[0][0].Tracking_timestamp_secs=" << round(in[0][0].Tracking_timestamp_secs * 1000.0);
                             d_GPS_FSM.Event_gps_word_preamble();
                             d_flag_preamble = true;
-                            d_preamble_index = d_sample_counter;  //record the preamble sample stamp (t_P)
+                            d_preamble_time_seconds = in[0][0].Tracking_timestamp_secs; // record the PRN start sample index associated to the preamble
-                            d_preamble_time_seconds = in[0][0].Tracking_timestamp_secs;// - d_preamble_duration_seconds; //record the PRN start sample index associated to the preamble
-
                             if (!d_flag_frame_sync)
                                 {
+                                    // send asynchronous message to tracking to inform of frame sync and extend correlation time
+                                    pmt::pmt_t value = pmt::from_double(d_preamble_time_seconds - 0.001);
+                                    this->message_port_pub(pmt::mp("preamble_timestamp_s"), value);
+
                                     d_flag_frame_sync = true;
                                     if (corr_value < 0)
                                         {
                                             flag_PLL_180_deg_phase_locked = true; // PLL is locked to opposite phase!
-                                            LOG(INFO) << " PLL in opposite phase for Sat "<< this->d_satellite.get_PRN();
+                                            DLOG(INFO)  << " PLL in opposite phase for Sat "<< this->d_satellite.get_PRN();
                                         }
                                     else
                                         {
                                             flag_PLL_180_deg_phase_locked = false;
                                         }
-                                    LOG(INFO) << " Frame sync SAT " << this->d_satellite << " with preamble start at " << d_preamble_time_seconds << " [s]";
+                                    DLOG(INFO)  << " Frame sync SAT " << this->d_satellite << " with preamble start at " << d_preamble_time_seconds << " [s]";
-                                }
-                        }
                                 }
                         }
                     else
                         {
-            if (d_stat == 1)
+                            if (preamble_diff_ms > GPS_SUBFRAME_MS+1)
                                 {
-                    preamble_diff = d_sample_counter - d_preamble_index;
+                                    DLOG(INFO) << "Lost of frame sync SAT " << this->d_satellite << " preamble_diff_ms= " << preamble_diff_ms;
-                    if (preamble_diff > 6001)
-                        {
-                            LOG(INFO) << "Lost of frame sync SAT " << this->d_satellite << " preamble_diff= " << preamble_diff;
                                     d_stat = 0; // lost of frame sync
                                     d_flag_frame_sync = false;
                                     flag_TOW_set = false;
                                 }
                         }
                 }
+        }
 
     //******* SYMBOL TO BIT *******
-    d_symbol_accumulator += in[0][d_samples_per_bit*8 - 1].Prompt_I; // accumulate the input value in d_symbol_accumulator
+
-    d_symbol_accumulator_counter++;
+    if (in[0][0].Flag_valid_symbol_output == true)
+        {
+            // extended correlation to bit period is enabled in tracking!
+            d_symbol_accumulator += in[0][0].Prompt_I; // accumulate the input value in d_symbol_accumulator
+            d_symbol_accumulator_counter += in[0][0].correlation_length_ms;
+        }
     if (d_symbol_accumulator_counter == 20)
         {
             if (d_symbol_accumulator > 0)
@@ -356,7 +339,7 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i
                     tmp_double = d_TOW_at_Preamble;
                     d_dump_file.write((char*)&tmp_double, sizeof(double));
             }
-            catch (std::ifstream::failure e)
+            catch (const std::ifstream::failure & e)
             {
                     LOG(WARNING) << "Exception writing observables dump file " << e.what();
             }
@@ -425,4 +408,3 @@ void gps_l1_ca_telemetry_decoder_cc::set_channel(int channel)
                 }
         }
 }
-

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.h

@@ -100,13 +100,12 @@ private:
     // class private vars
 
     int *d_preambles_symbols;
-    unsigned int d_samples_per_bit;
-    long unsigned int d_sample_counter;
-    long unsigned int d_preamble_index;
     unsigned int d_stat;
     bool d_flag_frame_sync;
 
     // symbols
+    std::deque<double> d_symbol_history;
+    std::deque<int> d_correlation_length_ms_history;
     double d_symbol_accumulator;
     short int d_symbol_accumulator_counter;
 
@@ -132,16 +131,10 @@ private:
     Gnss_Satellite d_satellite;
     int d_channel;
 
-    //std::deque<double> d_prn_start_sample_history;
-
     double d_preamble_time_seconds;
 
     double d_TOW_at_Preamble;
     double d_TOW_at_current_symbol;
-    std::deque<double> d_symbol_TOW_queue_s;
-    // Doppler and Phase accumulator queue for interpolation in Observables
-    std::deque<double> d_carrier_doppler_queue_hz;
-    std::deque<double> d_acc_carrier_phase_queue_rads;
 
     double Prn_timestamp_at_preamble_ms;
     bool flag_TOW_set;

src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2_m_telemetry_decoder_cc.cc

@@ -63,6 +63,8 @@ gps_l2_m_telemetry_decoder_cc::gps_l2_m_telemetry_decoder_cc(
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry Bit transition synchronization port out
+    this->message_port_register_out(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_dump = dump;
     d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());

src/algorithms/telemetry_decoder/gnuradio_blocks/sbas_l1_telemetry_decoder_cc.cc

@@ -63,6 +63,8 @@ sbas_l1_telemetry_decoder_cc::sbas_l1_telemetry_decoder_cc(
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry Bit transition synchronization port out
+    this->message_port_register_out(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_dump = dump;
     d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());

src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_c_aid_tracking.cc

@@ -60,7 +60,9 @@ GpsL1CaDllPllCAidTracking::GpsL1CaDllPllCAidTracking(
     std::string dump_filename;
     std::string default_item_type = "gr_complex";
     float pll_bw_hz;
+    float pll_bw_narrow_hz;
     float dll_bw_hz;
+    float dll_bw_narrow_hz;
     float early_late_space_chips;
     item_type_ = configuration->property(role + ".item_type", default_item_type);
     //vector_length = configuration->property(role + ".vector_length", 2048);
@@ -69,6 +71,11 @@ GpsL1CaDllPllCAidTracking::GpsL1CaDllPllCAidTracking(
     dump = configuration->property(role + ".dump", false);
     pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0);
     dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0);
+    pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 20.0);
+    dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 2.0);
+    int extend_correlation_ms;
+    extend_correlation_ms = configuration->property(role + ".extend_correlation_ms", 1);
+
     early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.5);
     std::string default_dump_filename = "./track_ch";
     dump_filename = configuration->property(role + ".dump_filename",
@@ -88,6 +95,9 @@ GpsL1CaDllPllCAidTracking::GpsL1CaDllPllCAidTracking(
                     dump_filename,
                     pll_bw_hz,
                     dll_bw_hz,
+                    pll_bw_narrow_hz,
+                    dll_bw_narrow_hz,
+                    extend_correlation_ms,
                     early_late_space_chips);
             DLOG(INFO) << "tracking(" << tracking_cc->unique_id() << ")";
     }else if(item_type_.compare("cshort") == 0)
@@ -102,6 +112,8 @@ GpsL1CaDllPllCAidTracking::GpsL1CaDllPllCAidTracking(
                 dump_filename,
                 pll_bw_hz,
                 dll_bw_hz,
+                pll_bw_narrow_hz,
+                dll_bw_narrow_hz,
                 early_late_space_chips);
         DLOG(INFO) << "tracking(" << tracking_sc->unique_id() << ")";
     }else

src/algorithms/tracking/gnuradio_blocks/galileo_e1_dll_pll_veml_tracking_cc.cc

@@ -41,9 +41,8 @@
 #include <sstream>
 #include <boost/lexical_cast.hpp>
 #include <gnuradio/io_signature.h>
-#include <gnuradio/fxpt.h>  // fixed point sine and cosine
 #include <glog/logging.h>
-#include <volk/volk.h>
+#include <volk_gnsssdr/volk_gnsssdr.h>
 #include "galileo_e1_signal_processing.h"
 #include "tracking_discriminators.h"
 #include "lock_detectors.h"
@@ -105,6 +104,8 @@ galileo_e1_dll_pll_veml_tracking_cc::galileo_e1_dll_pll_veml_tracking_cc(
         gr::block("galileo_e1_dll_pll_veml_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
     this->set_relative_rate(1.0 / vector_length);
     // initialize internal vars
     d_queue = queue;
@@ -128,11 +129,11 @@ galileo_e1_dll_pll_veml_tracking_cc::galileo_e1_dll_pll_veml_tracking_cc(
 
     // Initialization of local code replica
     // Get space for a vector with the sinboc(1,1) replica sampled 2x/chip
-    d_ca_code = static_cast<gr_complex*>(volk_malloc((2*Galileo_E1_B_CODE_LENGTH_CHIPS) * sizeof(gr_complex), volk_get_alignment()));
+    d_ca_code = static_cast<gr_complex*>(volk_gnsssdr_malloc((2*Galileo_E1_B_CODE_LENGTH_CHIPS) * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
 
     // correlator outputs (scalar)
     d_n_correlator_taps = 5; // Very-Early, Early, Prompt, Late, Very-Late
-    d_correlator_outs = static_cast<gr_complex*>(volk_malloc(d_n_correlator_taps*sizeof(gr_complex), volk_get_alignment()));
+    d_correlator_outs = static_cast<gr_complex*>(volk_gnsssdr_malloc(d_n_correlator_taps*sizeof(gr_complex), volk_gnsssdr_get_alignment()));
     for (int n = 0; n < d_n_correlator_taps; n++)
         {
             d_correlator_outs[n] = gr_complex(0,0);
@@ -144,7 +145,7 @@ galileo_e1_dll_pll_veml_tracking_cc::galileo_e1_dll_pll_veml_tracking_cc(
     d_Late = &d_correlator_outs[3];
     d_Very_Late = &d_correlator_outs[4];
 
-    d_local_code_shift_chips = static_cast<float*>(volk_malloc(d_n_correlator_taps*sizeof(float), volk_get_alignment()));
+    d_local_code_shift_chips = static_cast<float*>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment()));
     // Set TAPs delay values [chips]
     d_local_code_shift_chips[0] = - d_very_early_late_spc_chips * 2.0;
     d_local_code_shift_chips[1] = - d_very_early_late_spc_chips;
@@ -252,9 +253,9 @@ galileo_e1_dll_pll_veml_tracking_cc::~galileo_e1_dll_pll_veml_tracking_cc()
 {
     d_dump_file.close();
 
-    volk_free(d_local_code_shift_chips);
+    volk_gnsssdr_free(d_local_code_shift_chips);
-    volk_free(d_correlator_outs);
+    volk_gnsssdr_free(d_correlator_outs);
-    volk_free(d_ca_code);
+    volk_gnsssdr_free(d_ca_code);
 
     delete[] d_Prompt_buffer;
     multicorrelator_cpu.free();

src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc

@@ -108,6 +108,9 @@ Galileo_E1_Tcp_Connector_Tracking_cc::Galileo_E1_Tcp_Connector_Tracking_cc(
         gr::block("Galileo_E1_Tcp_Connector_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+	// Telemetry bit synchronization message port input
+	this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
+
     this->set_relative_rate(1.0/vector_length);
     // initialize internal vars
     d_queue = queue;

src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc

@@ -108,6 +108,9 @@ Galileo_E5a_Dll_Pll_Tracking_cc::Galileo_E5a_Dll_Pll_Tracking_cc(
         gr::block("Galileo_E5a_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
+
     this->set_relative_rate(1.0 / vector_length);
     // initialize internal vars
     d_queue = queue;

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_fll_pll_tracking_cc.cc

@@ -72,7 +72,6 @@ gps_l1_ca_dll_fll_pll_tracking_cc_sptr gps_l1_ca_dll_fll_pll_make_tracking_cc(
         float dll_bw_hz,
         float early_late_space_chips)
 {
-
     return gps_l1_ca_dll_fll_pll_tracking_cc_sptr(new Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc(if_freq,
             fs_in, vector_length, queue, dump, dump_filename, order, fll_bw_hz, pll_bw_hz,dll_bw_hz,
             early_late_space_chips));
@@ -105,6 +104,8 @@ Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc::Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc(
         gr::block("Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;
@@ -289,17 +290,6 @@ void Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc::update_local_code()
 
     memcpy(d_prompt_code, &d_early_code[early_late_spc_samples], d_current_prn_length_samples * sizeof(gr_complex));
     memcpy(d_late_code, &d_early_code[early_late_spc_samples*2], d_current_prn_length_samples * sizeof(gr_complex));
-
-    //    for (int i=0; i<d_current_prn_length_samples; i++)
-    //        {
-    //            associated_chip_index = 1 + round(fmod(tcode_chips - d_early_late_spc_chips, code_length_chips));
-    //            d_early_code[i] = d_ca_code[associated_chip_index];
-    //            associated_chip_index = 1 + round(fmod(tcode_chips, code_length_chips));
-    //            d_prompt_code[i] = d_ca_code[associated_chip_index];
-    //            associated_chip_index = 1 + round(fmod(tcode_chips + d_early_late_spc_chips, code_length_chips));
-    //            d_late_code[i] = d_ca_code[associated_chip_index];
-    //            tcode_chips = tcode_chips + code_phase_step_chips;
-    //        }
 }
 
 
@@ -340,7 +330,6 @@ Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc::~Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc()
 
 
 
-
 int Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_int &ninput_items,
         gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
 {
@@ -555,6 +544,8 @@ int Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc::general_work (int noutput_items, gr_vecto
             current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
             current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
             current_synchro_data.Flag_valid_tracking = true;
+            current_synchro_data.Flag_valid_symbol_output = true;
+            current_synchro_data.correlation_length_ms = 1;
              current_synchro_data.Flag_valid_pseudorange = false;
             *out[0] = current_synchro_data;
         }
@@ -583,6 +574,7 @@ int Gps_L1_Ca_Dll_Fll_Pll_Tracking_cc::general_work (int noutput_items, gr_vecto
 
             Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; //block output streams pointer
             d_acquisition_gnss_synchro->Flag_valid_pseudorange = false;
+            d_acquisition_gnss_synchro->Flag_valid_symbol_output = false;
             *out[0] = *d_acquisition_gnss_synchro;
         }
 

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_cc.cc

@@ -34,7 +34,9 @@
 #include <memory>
 #include <sstream>
 #include <boost/lexical_cast.hpp>
+#include <boost/bind.hpp>
 #include <gnuradio/io_signature.h>
+#include <pmt/pmt.h>
 #include <volk/volk.h>
 #include <glog/logging.h>
 #include "gps_sdr_signal_processing.h"
@@ -65,14 +67,16 @@ gps_l1_ca_dll_pll_c_aid_make_tracking_cc(
         std::string dump_filename,
         float pll_bw_hz,
         float dll_bw_hz,
+        float pll_bw_narrow_hz,
+        float dll_bw_narrow_hz,
+        int extend_correlation_ms,
         float early_late_space_chips)
 {
     return gps_l1_ca_dll_pll_c_aid_tracking_cc_sptr(new gps_l1_ca_dll_pll_c_aid_tracking_cc(if_freq,
-            fs_in, vector_length, queue, dump, dump_filename, pll_bw_hz, dll_bw_hz, early_late_space_chips));
+            fs_in, vector_length, queue, dump, dump_filename, pll_bw_hz, dll_bw_hz,pll_bw_narrow_hz, dll_bw_narrow_hz, extend_correlation_ms, early_late_space_chips));
 }
 
 
-
 void gps_l1_ca_dll_pll_c_aid_tracking_cc::forecast (int noutput_items,
         gr_vector_int &ninput_items_required)
 {
@@ -83,6 +87,18 @@ void gps_l1_ca_dll_pll_c_aid_tracking_cc::forecast (int noutput_items,
 }
 
 
+void gps_l1_ca_dll_pll_c_aid_tracking_cc::msg_handler_preamble_index(pmt::pmt_t msg)
+{
+    //pmt::print(msg);
+    DLOG(INFO) << "Extended correlation enabled for Tracking CH " << d_channel <<  ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN);
+    if (d_enable_extended_integration == false) //avoid re-setting preamble indicator
+        {
+            d_preamble_timestamp_s = pmt::to_double(msg);
+            d_enable_extended_integration = true;
+            d_preamble_synchronized = false;
+        }
+}
+
 
 gps_l1_ca_dll_pll_c_aid_tracking_cc::gps_l1_ca_dll_pll_c_aid_tracking_cc(
         long if_freq,
@@ -93,10 +109,20 @@ gps_l1_ca_dll_pll_c_aid_tracking_cc::gps_l1_ca_dll_pll_c_aid_tracking_cc(
         std::string dump_filename,
         float pll_bw_hz,
         float dll_bw_hz,
+        float pll_bw_narrow_hz,
+        float dll_bw_narrow_hz,
+        int extend_correlation_ms,
         float early_late_space_chips) :
         gr::block("gps_l1_ca_dll_pll_c_aid_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
+
+    this->set_msg_handler(pmt::mp("preamble_timestamp_s"),
+            boost::bind(&gps_l1_ca_dll_pll_c_aid_tracking_cc::msg_handler_preamble_index, this, _1));
+
+
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;
@@ -107,8 +133,13 @@ gps_l1_ca_dll_pll_c_aid_tracking_cc::gps_l1_ca_dll_pll_c_aid_tracking_cc(
     d_correlation_length_samples = static_cast<int>(d_vector_length);
 
     // Initialize tracking  ==========================================
-    d_code_loop_filter.set_DLL_BW(dll_bw_hz);
+    d_pll_bw_hz = pll_bw_hz;
-    d_carrier_loop_filter.set_params(10.0, pll_bw_hz,2);
+    d_dll_bw_hz = dll_bw_hz;
+    d_pll_bw_narrow_hz = pll_bw_narrow_hz;
+    d_dll_bw_narrow_hz = dll_bw_narrow_hz;
+    d_extend_correlation_ms = extend_correlation_ms;
+    d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
+    d_carrier_loop_filter.set_params(10.0, d_pll_bw_hz,2);
 
     //--- DLL variables --------------------------------------------------------
     d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
@@ -141,7 +172,8 @@ gps_l1_ca_dll_pll_c_aid_tracking_cc::gps_l1_ca_dll_pll_c_aid_tracking_cc(
     d_rem_carrier_phase_rad = 0.0;
 
     // sample synchronization
-    d_sample_counter = 0;
+    d_sample_counter = 0; //(from trk to tlm)
+
     //d_sample_counter_seconds = 0;
     d_acq_sample_stamp = 0;
 
@@ -168,6 +200,7 @@ gps_l1_ca_dll_pll_c_aid_tracking_cc::gps_l1_ca_dll_pll_c_aid_tracking_cc(
     d_acq_code_phase_samples = 0.0;
     d_acq_carrier_doppler_hz = 0.0;
     d_carrier_doppler_hz = 0.0;
+    d_code_error_filt_chips_Ti = 0.0;
     d_acc_carrier_phase_cycles = 0.0;
     d_code_phase_samples = 0.0;
 
@@ -175,6 +208,8 @@ gps_l1_ca_dll_pll_c_aid_tracking_cc::gps_l1_ca_dll_pll_c_aid_tracking_cc(
     d_rem_code_phase_chips = 0.0;
     d_code_phase_step_chips = 0.0;
     d_carrier_phase_step_rad = 0.0;
+    d_enable_extended_integration = false;
+    d_preamble_synchronized = false;
     //set_min_output_buffer((long int)300);
 }
 
@@ -254,11 +289,11 @@ void gps_l1_ca_dll_pll_c_aid_tracking_cc::start_tracking()
     std::cout << "Tracking start on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl;
     LOG(INFO) << "Starting tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel;
 
-
     // enable tracking
     d_pull_in = true;
     d_enable_tracking = true;
-
+    d_enable_extended_integration=false;
+    d_preamble_synchronized=false;
     LOG(INFO) << "PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz
               << " Code Phase correction [samples]=" << delay_correction_samples
               << " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
@@ -290,13 +325,10 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
     Gnss_Synchro current_synchro_data = Gnss_Synchro();
 
     // process vars
-    double code_error_chips_Ti = 0.0;
-    double code_error_filt_chips = 0.0;
     double code_error_filt_secs_Ti = 0.0;
-    double CURRENT_INTEGRATION_TIME_S;
+    double CURRENT_INTEGRATION_TIME_S = 0.0;
-    double CORRECTED_INTEGRATION_TIME_S;
+    double CORRECTED_INTEGRATION_TIME_S = 0.0;
     double dll_code_error_secs_Ti = 0.0;
-    double carr_phase_error_secs_Ti = 0.0;
     double old_d_rem_code_phase_samples;
     if (d_enable_tracking == true)
         {
@@ -313,6 +345,8 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
                     d_pull_in = false;
                     // Fill the acquisition data
                     current_synchro_data = *d_acquisition_gnss_synchro;
+                    current_synchro_data.correlation_length_ms = 1;
+                    current_synchro_data.Flag_valid_symbol_output = false;
                     *out[0] = current_synchro_data;
                     consume_each(samples_offset); //shift input to perform alignment with local replica
                     return 1;
@@ -326,17 +360,108 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
             multicorrelator_cpu.set_input_output_vectors(d_correlator_outs,in);
             multicorrelator_cpu.Carrier_wipeoff_multicorrelator_resampler(d_rem_carrier_phase_rad, d_carrier_phase_step_rad, d_rem_code_phase_chips, d_code_phase_step_chips, d_correlation_length_samples);
 
+            // ####### coherent intergration extension
+            // keep the last symbols
+            d_E_history.push_back(d_correlator_outs[0]); // save early output
+            d_P_history.push_back(d_correlator_outs[1]); // save prompt output
+            d_L_history.push_back(d_correlator_outs[2]); // save late output
+
+            if (static_cast<int>(d_P_history.size()) > d_extend_correlation_ms)
+                {
+                    d_E_history.pop_front();
+                    d_P_history.pop_front();
+                    d_L_history.pop_front();
+                }
+
+            bool enable_dll_pll;
+            if (d_enable_extended_integration == true)
+                {
+                    long int symbol_diff = round(1000.0*((static_cast<double>(d_sample_counter) + d_rem_code_phase_samples) / static_cast<double>(d_fs_in)-d_preamble_timestamp_s));
+                    if (symbol_diff>0 and symbol_diff % d_extend_correlation_ms == 0)
+                        {
+                            // compute coherent integration and enable tracking loop
+                            // perform coherent integration using correlator output history
+                            //std::cout<<"##### RESET COHERENT INTEGRATION ####"<<std::endl;
+                            d_correlator_outs[0] = gr_complex(0.0,0.0);
+                            d_correlator_outs[1] = gr_complex(0.0,0.0);
+                            d_correlator_outs[2] = gr_complex(0.0,0.0);
+                            for (int n = 0; n < d_extend_correlation_ms; n++)
+                                {
+                                    d_correlator_outs[0] += d_E_history.at(n);
+                                    d_correlator_outs[1] += d_P_history.at(n);
+                                    d_correlator_outs[2] += d_L_history.at(n);
+                                }
+
+                            if (d_preamble_synchronized == false)
+                                {
+                                    d_code_loop_filter.set_DLL_BW(d_dll_bw_narrow_hz);
+                                    d_carrier_loop_filter.set_params(10.0, d_pll_bw_narrow_hz,2);
+                                    d_preamble_synchronized = true;
+                                    std::cout << "Enabled extended correlator for CH "<< d_channel <<" : Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
+                                              <<" dll_narrow_bw=" << d_dll_bw_narrow_hz << " pll_narrow_bw=" << d_pll_bw_narrow_hz << std::endl;
+                                }
+                            // UPDATE INTEGRATION TIME
+                            CURRENT_INTEGRATION_TIME_S = static_cast<double>(d_extend_correlation_ms) * GPS_L1_CA_CODE_PERIOD;
+                            enable_dll_pll = true;
+
+                        }
+                    else
+                        {
+                            if(d_preamble_synchronized == true)
+                                {
+                                    // continue extended coherent correlation
+                                    //remnant carrier phase [rads]
+                                    d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GPS_TWO_PI);
+
+                                    // Compute the next buffer length based on the period of the PRN sequence and the code phase error estimation
+                                    double T_chip_seconds = 1 / d_code_freq_chips;
+                                    double T_prn_seconds = T_chip_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS;
+                                    double T_prn_samples = T_prn_seconds * static_cast<double>(d_fs_in);
+                                    int K_prn_samples = round(T_prn_samples);
+                                    double K_T_prn_error_samples = K_prn_samples - T_prn_samples;
+
+                                    d_rem_code_phase_samples = d_rem_code_phase_samples - K_T_prn_error_samples;
+                                    d_rem_code_phase_integer_samples = round(d_rem_code_phase_samples);
+                                    d_correlation_length_samples = K_prn_samples + d_rem_code_phase_integer_samples; //round to a discrete samples
+                                    d_rem_code_phase_samples = d_rem_code_phase_samples - d_rem_code_phase_integer_samples;
+                                    //code phase step (Code resampler phase increment per sample) [chips/sample]
+                                    d_code_phase_step_chips = d_code_freq_chips / static_cast<double>(d_fs_in);
+                                    //remnant code phase [chips]
+                                    d_rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / static_cast<double>(d_fs_in));
+
+                                    // UPDATE ACCUMULATED CARRIER PHASE
+                                    CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
+                                    d_acc_carrier_phase_cycles -= d_carrier_doppler_hz * CORRECTED_INTEGRATION_TIME_S;
+
+                                    // disable tracking loop and inform telemetry decoder
+                                    enable_dll_pll = false;
+                                }
+                            else
+                                {
+                                    //  perform basic (1ms) correlation
                                     // UPDATE INTEGRATION TIME
                                     CURRENT_INTEGRATION_TIME_S = static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in);
+                                    enable_dll_pll = true;
+                                }
+                        }
+                }
+            else
+                {
+                    // UPDATE INTEGRATION TIME
+                    CURRENT_INTEGRATION_TIME_S = static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in);
+                    enable_dll_pll = true;
+                }
 
+            if (enable_dll_pll == true)
+                {
                     // ################## PLL ##########################################################
                     // Update PLL discriminator [rads/Ti -> Secs/Ti]
-            carr_phase_error_secs_Ti = pll_cloop_two_quadrant_atan(d_correlator_outs[1]) / GPS_TWO_PI; //prompt output
+                    d_carr_phase_error_secs_Ti = pll_cloop_two_quadrant_atan(d_correlator_outs[1]) / GPS_TWO_PI; //prompt output
                     // Carrier discriminator filter
                     // NOTICE: The carrier loop filter includes the Carrier Doppler accumulator, as described in Kaplan
                     //d_carrier_doppler_hz = d_acq_carrier_doppler_hz + carr_phase_error_filt_secs_ti/INTEGRATION_TIME;
                     // Input [s/Ti] -> output [Hz]
-            d_carrier_doppler_hz = d_carrier_loop_filter.get_carrier_error(0.0, carr_phase_error_secs_Ti, CURRENT_INTEGRATION_TIME_S);
+                    d_carrier_doppler_hz = d_carrier_loop_filter.get_carrier_error(0.0, d_carr_phase_error_secs_Ti, CURRENT_INTEGRATION_TIME_S);
                     // PLL to DLL assistance [Secs/Ti]
                     d_pll_to_dll_assist_secs_Ti = (d_carrier_doppler_hz * CURRENT_INTEGRATION_TIME_S) / GPS_L1_FREQ_HZ;
                     // code Doppler frequency update
@@ -344,31 +469,36 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
 
                     // ################## DLL ##########################################################
                     // DLL discriminator
-            code_error_chips_Ti = dll_nc_e_minus_l_normalized(d_correlator_outs[0], d_correlator_outs[2]); //[chips/Ti] //early and late
+                    d_code_error_chips_Ti = dll_nc_e_minus_l_normalized(d_correlator_outs[0], d_correlator_outs[2]); //[chips/Ti] //early and late
                     // Code discriminator filter
-            code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips_Ti); //input [chips/Ti] -> output [chips/second]
+                    d_code_error_filt_chips_s = d_code_loop_filter.get_code_nco(d_code_error_chips_Ti); //input [chips/Ti] -> output [chips/second]
-            code_error_filt_secs_Ti = code_error_filt_chips*CURRENT_INTEGRATION_TIME_S/d_code_freq_chips; // [s/Ti]
+                    d_code_error_filt_chips_Ti = d_code_error_filt_chips_s * CURRENT_INTEGRATION_TIME_S;
+                    code_error_filt_secs_Ti = d_code_error_filt_chips_Ti / d_code_freq_chips; // [s/Ti]
                     // DLL code error estimation [s/Ti]
-            // TODO: PLL carrier aid to DLL is disabled. Re-enable it and measure performance
+                    // PLL to DLL assistance is disable due to the use of a fractional resampler that allows the correction of the code Doppler effect.
-            dll_code_error_secs_Ti = - code_error_filt_secs_Ti + d_pll_to_dll_assist_secs_Ti;
+                    dll_code_error_secs_Ti = - code_error_filt_secs_Ti; // + d_pll_to_dll_assist_secs_Ti;
 
                     // ################## CARRIER AND CODE NCO BUFFER ALIGNEMENT #######################
+
                     // keep alignment parameters for the next input buffer
                     double T_chip_seconds;
                     double T_prn_seconds;
                     double T_prn_samples;
-            double K_blk_samples;
+                    double K_prn_samples;
                     // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation
                     T_chip_seconds = 1 / d_code_freq_chips;
                     T_prn_seconds = T_chip_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS;
                     T_prn_samples = T_prn_seconds * static_cast<double>(d_fs_in);
-            K_blk_samples = T_prn_samples + d_rem_code_phase_samples - dll_code_error_secs_Ti * static_cast<double>(d_fs_in);
+                    K_prn_samples = round(T_prn_samples);
+                    double K_T_prn_error_samples = K_prn_samples - T_prn_samples;
 
-            d_correlation_length_samples = round(K_blk_samples); //round to a discrete samples
                     old_d_rem_code_phase_samples = d_rem_code_phase_samples;
-            d_rem_code_phase_samples = K_blk_samples - static_cast<double>(d_correlation_length_samples); //rounding error < 1 sample
+                    d_rem_code_phase_samples = d_rem_code_phase_samples - K_T_prn_error_samples - dll_code_error_secs_Ti * static_cast<double>(d_fs_in);
+                    d_rem_code_phase_integer_samples = round(d_rem_code_phase_samples);
+                    d_correlation_length_samples = K_prn_samples + d_rem_code_phase_integer_samples; //round to a discrete samples
+                    d_rem_code_phase_samples = d_rem_code_phase_samples - d_rem_code_phase_integer_samples;
 
-            // UPDATE REMNANT CARRIER PHASE
+                    // UPDATE ACCUMULATED CARRIER PHASE
                     CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
                     //remnant carrier phase [rad]
                     d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + GPS_TWO_PI * d_carrier_doppler_hz * CORRECTED_INTEGRATION_TIME_S, GPS_TWO_PI);
@@ -422,7 +552,6 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
                                     d_enable_tracking = false; // TODO: check if disabling tracking is consistent with the channel state machine
                                 }
                         }
-
                     // ########### Output the tracking data to navigation and PVT ##########
                     current_synchro_data.Prompt_I = static_cast<double>((d_correlator_outs[1]).real());
                     current_synchro_data.Prompt_Q = static_cast<double>((d_correlator_outs[1]).imag());
@@ -434,7 +563,33 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
                     current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
                     current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
                     current_synchro_data.Flag_valid_pseudorange = false;
+                    current_synchro_data.Flag_valid_symbol_output = true;
+                    if (d_preamble_synchronized == true)
+                        {
+                            current_synchro_data.correlation_length_ms = d_extend_correlation_ms;
+                        }
+                    else
+                        {
+                            current_synchro_data.correlation_length_ms = 1;
+                        }
                     *out[0] = current_synchro_data;
+                }
+            else
+                {
+                    current_synchro_data.Prompt_I = static_cast<double>((d_correlator_outs[1]).real());
+                    current_synchro_data.Prompt_Q = static_cast<double>((d_correlator_outs[1]).imag());
+                    // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!)
+                    current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + d_rem_code_phase_samples) / static_cast<double>(d_fs_in);
+                    // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0
+                    current_synchro_data.Code_phase_secs = 0;
+                    current_synchro_data.Carrier_phase_rads = GPS_TWO_PI * d_acc_carrier_phase_cycles;
+                    current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;// todo: project the carrier doppler
+                    current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
+                    current_synchro_data.Flag_valid_pseudorange = false;
+                    current_synchro_data.Flag_valid_symbol_output = false;
+                    current_synchro_data.correlation_length_ms = 1;
+                    *out[0] = current_synchro_data;
+                }
 
             // ########## DEBUG OUTPUT
             /*!
@@ -448,7 +603,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
                             d_last_seg = floor(d_sample_counter / d_fs_in);
                             std::cout << "Current input signal time = " << d_last_seg << " [s]" << std::endl;
                             DLOG(INFO)  << "GPS L1 C/A Tracking CH " << d_channel <<  ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
-                                              << ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]" << std::endl;
+                                        << ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]";
                             //if (d_last_seg==5) d_carrier_lock_fail_counter=500; //DEBUG: force unlock!
                         }
                 }
@@ -488,6 +643,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
 
             current_synchro_data.System = {'G'};
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.correlation_length_ms = 1;
             *out[0] = current_synchro_data;
         }
 
@@ -523,19 +679,19 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
                     d_dump_file.write(reinterpret_cast<char*>(&d_code_freq_chips), sizeof(double));
 
                     //PLL commands
-                    d_dump_file.write(reinterpret_cast<char*>(&carr_phase_error_secs_Ti), sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_carr_phase_error_secs_Ti), sizeof(double));
                     d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(double));
 
                     //DLL commands
-                    d_dump_file.write(reinterpret_cast<char*>(&code_error_chips_Ti), sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_code_error_chips_Ti), sizeof(double));
-                    d_dump_file.write(reinterpret_cast<char*>(&code_error_filt_chips), sizeof(double));
+                    d_dump_file.write(reinterpret_cast<char*>(&d_code_error_filt_chips_Ti), sizeof(double));
 
                     // CN0 and carrier lock test
                     d_dump_file.write(reinterpret_cast<char*>(&d_CN0_SNV_dB_Hz), sizeof(double));
                     d_dump_file.write(reinterpret_cast<char*>(&d_carrier_lock_test), sizeof(double));
 
                     // AUX vars (for debug purposes)
-                    tmp_double = d_rem_code_phase_samples;
+                    tmp_double = d_code_error_chips_Ti*CURRENT_INTEGRATION_TIME_S;
                     d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
                     tmp_double = static_cast<double>(d_sample_counter + d_correlation_length_samples);
                     d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
@@ -556,6 +712,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_cc::general_work (int noutput_items, gr_vec
     return 1; //output tracking result ALWAYS even in the case of d_enable_tracking==false
 }
 
+
 void gps_l1_ca_dll_pll_c_aid_tracking_cc::set_channel(unsigned int channel)
 {
     d_channel = channel;
@@ -581,11 +738,13 @@ void gps_l1_ca_dll_pll_c_aid_tracking_cc::set_channel(unsigned int channel)
         }
 }
 
+
 void gps_l1_ca_dll_pll_c_aid_tracking_cc::set_channel_queue(concurrent_queue<int> *channel_internal_queue)
 {
     d_channel_internal_queue = channel_internal_queue;
 }
 
+
 void gps_l1_ca_dll_pll_c_aid_tracking_cc::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
 {
     d_acquisition_gnss_synchro = p_gnss_synchro;

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_cc.h

@@ -39,13 +39,16 @@
 
 #include <fstream>
 #include <map>
+#include <deque>
 #include <string>
 #include <gnuradio/block.h>
 #include <gnuradio/msg_queue.h>
+#include <pmt/pmt.h>
 #include "concurrent_queue.h"
 #include "gnss_synchro.h"
 #include "tracking_2nd_DLL_filter.h"
 #include "tracking_FLL_PLL_filter.h"
+#include "tracking_loop_filter.h"
 #include "cpu_multicorrelator.h"
 
 class gps_l1_ca_dll_pll_c_aid_tracking_cc;
@@ -62,6 +65,9 @@ gps_l1_ca_dll_pll_c_aid_make_tracking_cc(long if_freq,
                                    std::string dump_filename,
                                    float pll_bw_hz,
                                    float dll_bw_hz,
+                                   float pll_bw_narrow_hz,
+                                   float dll_bw_narrow_hz,
+                                   int extend_correlation_ms,
                                    float early_late_space_chips);
 
 
@@ -94,6 +100,9 @@ private:
             std::string dump_filename,
             float pll_bw_hz,
             float dll_bw_hz,
+            float pll_bw_narrow_hz,
+            float dll_bw_narrow_hz,
+            int extend_correlation_ms,
             float early_late_space_chips);
 
     gps_l1_ca_dll_pll_c_aid_tracking_cc(long if_freq,
@@ -104,6 +113,9 @@ private:
             std::string dump_filename,
             float pll_bw_hz,
             float dll_bw_hz,
+            float pll_bw_narrow_hz,
+            float dll_bw_narrow_hz,
+            int extend_correlation_ms,
             float early_late_space_chips);
 
     // tracking configuration vars
@@ -130,8 +142,10 @@ private:
     double d_rem_code_phase_samples;
     double d_rem_code_phase_chips;
     double d_rem_carrier_phase_rad;
+    int d_rem_code_phase_integer_samples;
 
     // PLL and DLL filter library
+    //Tracking_2nd_DLL_filter d_code_loop_filter;
     Tracking_2nd_DLL_filter d_code_loop_filter;
     Tracking_FLL_PLL_filter d_carrier_loop_filter;
 
@@ -140,6 +154,10 @@ private:
     double d_acq_carrier_doppler_hz;
 
     // tracking vars
+    float d_dll_bw_hz;
+    float d_pll_bw_hz;
+    float d_dll_bw_narrow_hz;
+    float d_pll_bw_narrow_hz;
     double d_code_freq_chips;
     double d_code_phase_step_chips;
     double d_carrier_doppler_hz;
@@ -147,6 +165,21 @@ private:
     double d_acc_carrier_phase_cycles;
     double d_code_phase_samples;
     double d_pll_to_dll_assist_secs_Ti;
+    double d_code_error_chips_Ti;
+    double d_code_error_filt_chips_s;
+    double d_code_error_filt_chips_Ti;
+    double d_carr_phase_error_secs_Ti;
+
+    // symbol history to detect bit transition
+    std::deque<gr_complex> d_E_history;
+    std::deque<gr_complex> d_P_history;
+    std::deque<gr_complex> d_L_history;
+    double d_preamble_timestamp_s;
+    int d_extend_correlation_ms;
+    bool d_enable_extended_integration;
+    bool d_preamble_synchronized;
+    int d_correlation_symbol_counter;
+    void msg_handler_preamble_index(pmt::pmt_t msg);
 
     //Integration period in samples
     int d_correlation_length_samples;

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_sc.cc

@@ -66,10 +66,12 @@ gps_l1_ca_dll_pll_c_aid_make_tracking_sc(
         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)
 {
     return gps_l1_ca_dll_pll_c_aid_tracking_sc_sptr(new gps_l1_ca_dll_pll_c_aid_tracking_sc(if_freq,
-            fs_in, vector_length, queue, dump, dump_filename, pll_bw_hz, dll_bw_hz, early_late_space_chips));
+            fs_in, vector_length, queue, dump, dump_filename, pll_bw_hz, dll_bw_hz, pll_bw_narrow_hz, dll_bw_narrow_hz, early_late_space_chips));
 }
 
 
@@ -94,10 +96,14 @@ gps_l1_ca_dll_pll_c_aid_tracking_sc::gps_l1_ca_dll_pll_c_aid_tracking_sc(
         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) :
         gr::block("gps_l1_ca_dll_pll_c_aid_tracking_sc", gr::io_signature::make(1, 1, sizeof(lv_16sc_t)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;
@@ -108,6 +114,10 @@ gps_l1_ca_dll_pll_c_aid_tracking_sc::gps_l1_ca_dll_pll_c_aid_tracking_sc(
     d_correlation_length_samples = static_cast<int>(d_vector_length);
 
     // Initialize tracking  ==========================================
+    d_pll_bw_hz=pll_bw_hz;
+    d_dll_bw_hz=dll_bw_hz;
+    d_pll_bw_narrow_hz = pll_bw_narrow_hz;
+    d_dll_bw_narrow_hz = dll_bw_narrow_hz;
     d_code_loop_filter.set_DLL_BW(dll_bw_hz);
     d_carrier_loop_filter.set_params(10.0, pll_bw_hz,2);
 
@@ -259,7 +269,6 @@ void gps_l1_ca_dll_pll_c_aid_tracking_sc::start_tracking()
     std::cout << "Tracking start on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl;
     LOG(INFO) << "Starting tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel;
 
-
     // enable tracking
     d_pull_in = true;
     d_enable_tracking = true;
@@ -329,19 +338,9 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items, gr_vec
 
             // ################# CARRIER WIPEOFF AND CORRELATORS ##############################
             // perform carrier wipe-off and compute Early, Prompt and Late correlation
-
-            //volk_gnsssdr_32fc_convert_16ic(d_in_16sc,in,d_correlation_length_samples);
-            //std::cout << std::fixed << std::setw( 11 ) << std::setprecision( 6 );
-            //std::cout<<"in="<<in[0]<<std::endl;
-
             multicorrelator_cpu_16sc.set_input_output_vectors(d_correlator_outs_16sc, in);
             multicorrelator_cpu_16sc.Carrier_wipeoff_multicorrelator_resampler(d_rem_carrier_phase_rad, d_carrier_phase_step_rad, d_rem_code_phase_chips, d_code_phase_step_chips, d_correlation_length_samples);
 
-            //std::cout<<"E 16sc="<<d_correlator_outs_16sc[0]<<std::endl;
-            //std::cout<<"P 16sc="<<d_correlator_outs_16sc[1]<<std::endl;
-            //std::cout<<"L 16sc="<<d_correlator_outs_16sc[2]<<std::endl;
-
-            //std::cout<<std::endl;
             // UPDATE INTEGRATION TIME
             CURRENT_INTEGRATION_TIME_S = static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in);
 
@@ -450,6 +449,8 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items, gr_vec
             current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
             current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = true;
+            current_synchro_data.correlation_length_ms = 1;
             *out[0] = current_synchro_data;
 
             // ########## DEBUG OUTPUT
@@ -504,6 +505,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items, gr_vec
 
             current_synchro_data.System = {'G'};
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = false;
             *out[0] = current_synchro_data;
         }
 
@@ -572,6 +574,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_sc::general_work (int noutput_items, gr_vec
     return 1; //output tracking result ALWAYS even in the case of d_enable_tracking==false
 }
 
+
 void gps_l1_ca_dll_pll_c_aid_tracking_sc::set_channel(unsigned int channel)
 {
     d_channel = channel;
@@ -597,11 +600,13 @@ void gps_l1_ca_dll_pll_c_aid_tracking_sc::set_channel(unsigned int channel)
         }
 }
 
+
 void gps_l1_ca_dll_pll_c_aid_tracking_sc::set_channel_queue(concurrent_queue<int> *channel_internal_queue)
 {
     d_channel_internal_queue = channel_internal_queue;
 }
 
+
 void gps_l1_ca_dll_pll_c_aid_tracking_sc::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
 {
     d_acquisition_gnss_synchro = p_gnss_synchro;

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_sc.h

@@ -67,6 +67,8 @@ gps_l1_ca_dll_pll_c_aid_make_tracking_sc(long if_freq,
                                    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);
 
 
@@ -99,6 +101,8 @@ private:
             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);
 
     gps_l1_ca_dll_pll_c_aid_tracking_sc(long if_freq,
@@ -109,6 +113,8 @@ private:
             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);
 
     // tracking configuration vars
@@ -148,6 +154,10 @@ private:
     double d_acq_carrier_doppler_hz;
 
     // tracking vars
+    float d_dll_bw_hz;
+    float d_pll_bw_hz;
+    float d_dll_bw_narrow_hz;
+    float d_pll_bw_narrow_hz;
     double d_code_freq_chips;
     double d_code_phase_step_chips;
     double d_carrier_doppler_hz;

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc

@@ -104,6 +104,8 @@ Gps_L1_Ca_Dll_Pll_Tracking_cc::Gps_L1_Ca_Dll_Pll_Tracking_cc(
         gr::block("Gps_L1_Ca_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;
@@ -309,8 +311,6 @@ void Gps_L1_Ca_Dll_Pll_Tracking_cc::update_local_carrier()
             d_carr_sign[i] = std::complex<float>(cos_f, -sin_f);
             phase_rad_i += phase_step_rad_i;
         }
-    //d_rem_carr_phase_rad = fmod(phase_rad, GPS_TWO_PI);
-    //d_acc_carrier_phase_rad = d_acc_carrier_phase_rad + d_rem_carr_phase_rad;
 }
 
 
@@ -362,11 +362,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in
                     acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
                     acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast<float>(acq_to_trk_delay_samples), static_cast<float>(d_current_prn_length_samples));
                     samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
-                    // /todo: Check if the sample counter sent to the next block as a time reference should be incremented AFTER sended or BEFORE
-                    //d_sample_counter_seconds = d_sample_counter_seconds + (((double)samples_offset) / static_cast<double>(d_fs_in));
                     d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples
                     d_pull_in = false;
-                    //std::cout<<" samples_offset="<<samples_offset<<"\r\n";
                     // Fill the acquisition data
                     current_synchro_data = *d_acquisition_gnss_synchro;
                     *out[0] = current_synchro_data;
@@ -493,11 +490,6 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in
             current_synchro_data.Prompt_I = static_cast<double>((*d_Prompt).real());
             current_synchro_data.Prompt_Q = static_cast<double>((*d_Prompt).imag());
 
-            // Tracking_timestamp_secs is aligned with the NEXT PRN start sample (Hybridization problem!)
-            //compute remnant code phase samples BEFORE the Tracking timestamp
-            //d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample
-            //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter + (double)d_current_prn_length_samples + (double)d_rem_code_phase_samples)/static_cast<double>(d_fs_in);
-
             // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!, but some glitches??)
             current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + static_cast<double>(d_rem_code_phase_samples)) / static_cast<double>(d_fs_in);
             //compute remnant code phase samples AFTER the Tracking timestamp
@@ -510,6 +502,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in
             current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
             current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = true;
+            current_synchro_data.correlation_length_ms=1;
             *out[0] = current_synchro_data;
 
             // ########## DEBUG OUTPUT
@@ -563,6 +557,7 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in
 
             current_synchro_data.System = {'G'};
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = false;
             *out[0] = current_synchro_data;
         }
 
@@ -616,7 +611,7 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in
                 tmp_double = static_cast<double>(d_sample_counter + d_current_prn_length_samples);
                 d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
             }
-            catch (std::ifstream::failure e)
+            catch (const std::ifstream::failure &e)
             {
                     LOG(WARNING) << "Exception writing trk dump file " << e.what();
             }
@@ -651,7 +646,7 @@ void Gps_L1_Ca_Dll_Pll_Tracking_cc::set_channel(unsigned int channel)
                             d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
                             LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str() << std::endl;
                     }
-                    catch (std::ifstream::failure e)
+                    catch (const std::ifstream::failure &e)
                     {
                             LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what() << std::endl;
                     }

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_gpu_cc.cc

@@ -99,6 +99,8 @@ Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc(
         gr::block("Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;
@@ -451,6 +453,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::general_work (int noutput_items, gr_vecto
             current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
             current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = true;
+            current_synchro_data.correlation_length_ms=1;
             *out[0] = current_synchro_data;
 
             // ########## DEBUG OUTPUT
@@ -505,6 +509,7 @@ int Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::general_work (int noutput_items, gr_vecto
 
             current_synchro_data.System = {'G'};
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = false;
             *out[0] = current_synchro_data;
         }
 

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_gpu_cc_old.cc

@@ -1,606 +0,0 @@
-/*!
- * \file gps_l1_ca_dll_pll_tracking_gpu_cc.cc
- * \brief Implementation of a code DLL + carrier PLL tracking block, GPU ACCELERATED
- * \author Javier Arribas, 2015. jarribas(at)cttc.es
- *
- * Code DLL + carrier PLL according to the algorithms described in:
- * [1] K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen,
- * A Software-Defined GPS and Galileo Receiver. A Single-Frequency
- * Approach, Birkhauser, 2007
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2015  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
-
-#include "gps_l1_ca_dll_pll_tracking_gpu_cc.h"
-#include <cmath>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <boost/lexical_cast.hpp>
-#include <gnuradio/io_signature.h>
-#include <glog/logging.h>
-#include "gnss_synchro.h"
-#include "gps_sdr_signal_processing.h"
-#include "tracking_discriminators.h"
-#include "lock_detectors.h"
-#include "GPS_L1_CA.h"
-#include "control_message_factory.h"
-#include <volk/volk.h> //volk_alignement
-// includes
-#include <cuda_profiler_api.h>
-
-
-/*!
- * \todo Include in definition header file
- */
-#define CN0_ESTIMATION_SAMPLES 20
-#define MINIMUM_VALID_CN0 25
-#define MAXIMUM_LOCK_FAIL_COUNTER 50
-#define CARRIER_LOCK_THRESHOLD 0.85
-
-
-using google::LogMessage;
-
-gps_l1_ca_dll_pll_tracking_gpu_cc_sptr
-gps_l1_ca_dll_pll_make_tracking_gpu_cc(
-        long if_freq,
-        long fs_in,
-        unsigned int vector_length,
-        boost::shared_ptr<gr::msg_queue> queue,
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float early_late_space_chips)
-{
-    return gps_l1_ca_dll_pll_tracking_gpu_cc_sptr(new Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc(if_freq,
-            fs_in, vector_length, queue, dump, dump_filename, pll_bw_hz, dll_bw_hz, early_late_space_chips));
-}
-
-
-void Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::forecast (int noutput_items,
-        gr_vector_int &ninput_items_required)
-{
-    ninput_items_required[0] = static_cast<int>(d_vector_length) * 2; //set the required available samples in each call
-}
-
-
-
-Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc(
-        long if_freq,
-        long fs_in,
-        unsigned int vector_length,
-        boost::shared_ptr<gr::msg_queue> queue,
-        bool dump,
-        std::string dump_filename,
-        float pll_bw_hz,
-        float dll_bw_hz,
-        float early_late_space_chips) :
-        gr::block("Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
-                gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
-{
-    // initialize internal vars
-    d_queue = queue;
-    d_dump = dump;
-    d_if_freq = if_freq;
-    d_fs_in = fs_in;
-    d_vector_length = vector_length;
-    d_dump_filename = dump_filename;
-
-    // Initialize tracking  ==========================================
-    d_code_loop_filter.set_DLL_BW(dll_bw_hz);
-    d_carrier_loop_filter.set_PLL_BW(pll_bw_hz);
-
-    //--- DLL variables --------------------------------------------------------
-    d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
-
-    // Set GPU flags
-    cudaSetDeviceFlags(cudaDeviceMapHost);
-    //allocate host memory
-    //pinned memory mode - use special function to get OS-pinned memory
-    int N_CORRELATORS = 3;
-    // Get space for a vector with the C/A code replica sampled 1x/chip
-    cudaHostAlloc((void**)&d_ca_code, (GPS_L1_CA_CODE_LENGTH_CHIPS* sizeof(gr_complex)), cudaHostAllocMapped || cudaHostAllocWriteCombined);
-    // Get space for the resampled early / prompt / late local replicas
-    cudaHostAlloc((void**)&d_local_code_shift_chips, N_CORRELATORS * sizeof(float),  cudaHostAllocMapped || cudaHostAllocWriteCombined);
-    cudaHostAlloc((void**)&in_gpu, 2 * d_vector_length * sizeof(gr_complex), cudaHostAllocMapped || cudaHostAllocWriteCombined);
-    // correlator outputs (scalar)
-    cudaHostAlloc((void**)&d_corr_outs_gpu ,sizeof(gr_complex)*N_CORRELATORS, cudaHostAllocMapped ||  cudaHostAllocWriteCombined );
-
-    //map to EPL pointers
-    d_Early = &d_corr_outs_gpu[0];
-    d_Prompt =  &d_corr_outs_gpu[1];
-    d_Late = &d_corr_outs_gpu[2];
-
-    //--- Perform initializations ------------------------------
-    multicorrelator_gpu = new cuda_multicorrelator();
-    //local code resampler on GPU
-    multicorrelator_gpu->init_cuda_integrated_resampler(2 * d_vector_length, GPS_L1_CA_CODE_LENGTH_CHIPS, 3);
-    multicorrelator_gpu->set_input_output_vectors(d_corr_outs_gpu, in_gpu);
-
-    // define initial code frequency basis of NCO
-    d_code_freq_chips = GPS_L1_CA_CODE_RATE_HZ;
-    // define residual code phase (in chips)
-    d_rem_code_phase_samples = 0.0;
-    // define residual carrier phase
-    d_rem_carr_phase_rad = 0.0;
-
-    // sample synchronization
-    d_sample_counter = 0;
-    //d_sample_counter_seconds = 0;
-    d_acq_sample_stamp = 0;
-
-    d_enable_tracking = false;
-    d_pull_in = false;
-    d_last_seg = 0;
-
-    d_current_prn_length_samples = static_cast<int>(d_vector_length);
-
-    // CN0 estimation and lock detector buffers
-    d_cn0_estimation_counter = 0;
-    d_Prompt_buffer = new gr_complex[CN0_ESTIMATION_SAMPLES];
-    d_carrier_lock_test = 1;
-    d_CN0_SNV_dB_Hz = 0;
-    d_carrier_lock_fail_counter = 0;
-    d_carrier_lock_threshold = CARRIER_LOCK_THRESHOLD;
-
-    systemName["G"] = std::string("GPS");
-    systemName["S"] = std::string("SBAS");
-
-
-    set_relative_rate(1.0/((double)d_vector_length*2));
-
-    d_channel_internal_queue = 0;
-    d_acquisition_gnss_synchro = 0;
-    d_channel = 0;
-    d_acq_code_phase_samples = 0.0;
-    d_acq_carrier_doppler_hz = 0.0;
-    d_carrier_doppler_hz = 0.0;
-    d_acc_carrier_phase_rad = 0.0;
-    d_code_phase_samples = 0.0;
-    d_acc_code_phase_secs = 0.0;
-    //set_min_output_buffer((long int)300);
-}
-
-
-void Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::start_tracking()
-{
-    /*
-     *  correct the code phase according to the delay between acq and trk
-     */
-    d_acq_code_phase_samples = d_acquisition_gnss_synchro->Acq_delay_samples;
-    d_acq_carrier_doppler_hz = d_acquisition_gnss_synchro->Acq_doppler_hz;
-    d_acq_sample_stamp =  d_acquisition_gnss_synchro->Acq_samplestamp_samples;
-
-    long int acq_trk_diff_samples;
-    double acq_trk_diff_seconds;
-    acq_trk_diff_samples = static_cast<long int>(d_sample_counter) - static_cast<long int>(d_acq_sample_stamp);//-d_vector_length;
-    DLOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples;
-    acq_trk_diff_seconds = static_cast<double>(acq_trk_diff_samples) / static_cast<double>(d_fs_in);
-    //doppler effect
-    // Fd=(C/(C+Vr))*F
-    double radial_velocity = (GPS_L1_FREQ_HZ + d_acq_carrier_doppler_hz) / GPS_L1_FREQ_HZ;
-    // new chip and prn sequence periods based on acq Doppler
-    double T_chip_mod_seconds;
-    double T_prn_mod_seconds;
-    double T_prn_mod_samples;
-    d_code_freq_chips = radial_velocity * GPS_L1_CA_CODE_RATE_HZ;
-    T_chip_mod_seconds = 1.0/d_code_freq_chips;
-    T_prn_mod_seconds = T_chip_mod_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS;
-    T_prn_mod_samples = T_prn_mod_seconds * static_cast<double>(d_fs_in);
-
-    d_current_prn_length_samples = round(T_prn_mod_samples);
-
-    double T_prn_true_seconds = GPS_L1_CA_CODE_LENGTH_CHIPS / GPS_L1_CA_CODE_RATE_HZ;
-    double T_prn_true_samples = T_prn_true_seconds * static_cast<double>(d_fs_in);
-    double T_prn_diff_seconds=  T_prn_true_seconds - T_prn_mod_seconds;
-    double N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds;
-    double corrected_acq_phase_samples, delay_correction_samples;
-    corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * static_cast<double>(d_fs_in)), T_prn_true_samples);
-    if (corrected_acq_phase_samples < 0)
-        {
-            corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples;
-        }
-    delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples;
-
-    d_acq_code_phase_samples = corrected_acq_phase_samples;
-
-    d_carrier_doppler_hz = d_acq_carrier_doppler_hz;
-
-    // DLL/PLL filter initialization
-    d_carrier_loop_filter.initialize(); // initialize the carrier filter
-    d_code_loop_filter.initialize();    // initialize the code filter
-
-    // generate local reference ALWAYS starting at chip 1 (1 sample per chip)
-    gps_l1_ca_code_gen_complex(d_ca_code, d_acquisition_gnss_synchro->PRN, 0);
-
-    d_local_code_shift_chips[0] = - d_early_late_spc_chips;
-    d_local_code_shift_chips[1] = 0.0;
-    d_local_code_shift_chips[2] = d_early_late_spc_chips;
-
-    multicorrelator_gpu->set_local_code_and_taps(GPS_L1_CA_CODE_LENGTH_CHIPS, d_ca_code, d_local_code_shift_chips, 3);
-
-    d_carrier_lock_fail_counter = 0;
-    d_rem_code_phase_samples = 0;
-    d_rem_carr_phase_rad = 0;
-    d_acc_carrier_phase_rad = 0;
-    d_acc_code_phase_secs = 0;
-
-    d_code_phase_samples = d_acq_code_phase_samples;
-
-    std::string sys_ = &d_acquisition_gnss_synchro->System;
-    sys = sys_.substr(0,1);
-
-    // DEBUG OUTPUT
-    std::cout << "Tracking start on channel " << d_channel << " for satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << std::endl;
-    LOG(INFO) << "Starting tracking of satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << " on channel " << d_channel;
-
-
-    // enable tracking
-    d_pull_in = true;
-    d_enable_tracking = true;
-
-    LOG(INFO) << "PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz
-            << " Code Phase correction [samples]=" << delay_correction_samples
-            << " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
-}
-
-
-Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::~Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc()
-{
-    d_dump_file.close();
-    cudaFreeHost(in_gpu);
-    cudaFreeHost(d_corr_outs_gpu);
-    cudaFreeHost(d_local_code_shift_chips);
-    cudaFreeHost(d_ca_code);
-    multicorrelator_gpu->free_cuda();
-    delete(multicorrelator_gpu);
-    delete[] d_Prompt_buffer;
-}
-
-
-
-int Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::general_work (int noutput_items, gr_vector_int &ninput_items,
-        gr_vector_const_void_star &input_items, gr_vector_void_star &output_items)
-{
-    // process vars
-	double carr_error_hz=0.0;
-	double carr_error_filt_hz=0.0;
-	double code_error_chips=0.0;
-	double code_error_filt_chips=0.0;
-
-    // Block input data and block output stream pointers
-    const gr_complex* in = (gr_complex*) input_items[0];
-    Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0];
-
-    // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
-    Gnss_Synchro current_synchro_data = Gnss_Synchro();
-
-    if (d_enable_tracking == true)
-        {
-            // Receiver signal alignment
-            if (d_pull_in == true)
-                {
-					int samples_offset;
-					double acq_trk_shif_correction_samples;
-					int acq_to_trk_delay_samples;
-					acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
-					acq_trk_shif_correction_samples = d_current_prn_length_samples - fmod(static_cast<float>(acq_to_trk_delay_samples), static_cast<float>(d_current_prn_length_samples));
-					samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
-					// /todo: Check if the sample counter sent to the next block as a time reference should be incremented AFTER sended or BEFORE
-					//d_sample_counter_seconds = d_sample_counter_seconds + (((double)samples_offset) / static_cast<double>(d_fs_in));
-					d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples
-					d_pull_in = false;
-					//std::cout<<" samples_offset="<<samples_offset<<"\r\n";
-					// Fill the acquisition data
-					current_synchro_data = *d_acquisition_gnss_synchro;
-					*out[0] = current_synchro_data;
-					consume_each(samples_offset); //shift input to perform alignment with local replica
-					return 1;
-                }
-
-            // Fill the acquisition data
-            current_synchro_data = *d_acquisition_gnss_synchro;
-
-            // UPDATE NCO COMMAND
-            double phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz / static_cast<double>(d_fs_in);
-
-        	//code resampler on GPU (new)
-            double code_phase_step_chips = d_code_freq_chips / static_cast<double>(d_fs_in);
-            double rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / d_fs_in);
-
-            std::cout<<"rem_code_phase_chips="<<rem_code_phase_chips<<" d_current_prn_length_samples="<<d_current_prn_length_samples<<std::endl;
-            memcpy(in_gpu, in, sizeof(gr_complex) * d_current_prn_length_samples);
-            cudaProfilerStart();
-            multicorrelator_gpu->Carrier_wipeoff_multicorrelator_resampler_cuda( static_cast<float>(d_rem_carr_phase_rad),
-            		static_cast<float>(phase_step_rad),
-            		static_cast<float>(code_phase_step_chips),
-            		static_cast<float>(rem_code_phase_chips),
-            		d_current_prn_length_samples, 3);
-            cudaProfilerStop();
-
-            // ################## PLL ##########################################################
-            // PLL discriminator
-            carr_error_hz = pll_cloop_two_quadrant_atan(*d_Prompt) / GPS_TWO_PI;
-            // Carrier discriminator filter
-            carr_error_filt_hz = d_carrier_loop_filter.get_carrier_nco(carr_error_hz);
-            // New carrier Doppler frequency estimation
-            d_carrier_doppler_hz = d_acq_carrier_doppler_hz + carr_error_filt_hz;
-            // New code Doppler frequency estimation
-            d_code_freq_chips = GPS_L1_CA_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L1_CA_CODE_RATE_HZ) / GPS_L1_FREQ_HZ);
-            //carrier phase accumulator for (K) doppler estimation
-            d_acc_carrier_phase_rad -= GPS_TWO_PI * d_carrier_doppler_hz * GPS_L1_CA_CODE_PERIOD;
-            //remanent carrier phase to prevent overflow in the code NCO
-            d_rem_carr_phase_rad = d_rem_carr_phase_rad + GPS_TWO_PI * d_carrier_doppler_hz * GPS_L1_CA_CODE_PERIOD;
-            d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, GPS_TWO_PI);
-
-            // ################## DLL ##########################################################
-            // DLL discriminator
-            code_error_chips = dll_nc_e_minus_l_normalized(*d_Early, *d_Late); //[chips/Ti]
-            // Code discriminator filter
-            code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips); //[chips/second]
-            //Code phase accumulator
-            double code_error_filt_secs;
-            code_error_filt_secs = (GPS_L1_CA_CODE_PERIOD * code_error_filt_chips) / GPS_L1_CA_CODE_RATE_HZ; //[seconds]
-            d_acc_code_phase_secs = d_acc_code_phase_secs + code_error_filt_secs;
-
-            // ################## CARRIER AND CODE NCO BUFFER ALIGNEMENT #######################
-            // keep alignment parameters for the next input buffer
-            double T_chip_seconds;
-            double T_prn_seconds;
-            double T_prn_samples;
-            double K_blk_samples;
-            // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation
-            T_chip_seconds = 1 / static_cast<double>(d_code_freq_chips);
-            T_prn_seconds = T_chip_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS;
-            T_prn_samples = T_prn_seconds * static_cast<double>(d_fs_in);
-            K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * static_cast<double>(d_fs_in);
-            d_current_prn_length_samples = round(K_blk_samples); //round to a discrete samples
-            //d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample
-
-            // ####### CN0 ESTIMATION AND LOCK DETECTORS ######
-            if (d_cn0_estimation_counter < CN0_ESTIMATION_SAMPLES)
-                {
-                    // fill buffer with prompt correlator output values
-                    d_Prompt_buffer[d_cn0_estimation_counter] = *d_Prompt;
-                    d_cn0_estimation_counter++;
-                }
-            else
-                {
-                    d_cn0_estimation_counter = 0;
-                    // Code lock indicator
-                    d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES, d_fs_in, GPS_L1_CA_CODE_LENGTH_CHIPS);
-                    // Carrier lock indicator
-                    d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES);
-                    // Loss of lock detection
-                    if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < MINIMUM_VALID_CN0)
-                        {
-                            d_carrier_lock_fail_counter++;
-                        }
-                    else
-                        {
-                            if (d_carrier_lock_fail_counter > 0) d_carrier_lock_fail_counter--;
-                        }
-                    if (d_carrier_lock_fail_counter > MAXIMUM_LOCK_FAIL_COUNTER)
-                        {
-                            std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl;
-                            LOG(INFO) << "Loss of lock in channel " << d_channel << "!";
-                            std::unique_ptr<ControlMessageFactory> cmf(new ControlMessageFactory());
-                            if (d_queue != gr::msg_queue::sptr())
-                                {
-                                    d_queue->handle(cmf->GetQueueMessage(d_channel, 2));
-                                }
-                            d_carrier_lock_fail_counter = 0;
-                            d_enable_tracking = false; // TODO: check if disabling tracking is consistent with the channel state machine
-                        }
-                }
-            // ########### Output the tracking data to navigation and PVT ##########
-            current_synchro_data.Prompt_I = static_cast<double>((*d_Prompt).real());
-            current_synchro_data.Prompt_Q = static_cast<double>((*d_Prompt).imag());
-
-            // Tracking_timestamp_secs is aligned with the NEXT PRN start sample (Hybridization problem!)
-            //compute remnant code phase samples BEFORE the Tracking timestamp
-            //d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample
-            //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter + (double)d_current_prn_length_samples + (double)d_rem_code_phase_samples)/static_cast<double>(d_fs_in);
-
-            // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!, but some glitches??)
-            current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + d_rem_code_phase_samples) / static_cast<double>(d_fs_in);
-            //compute remnant code phase samples AFTER the Tracking timestamp
-            d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample
-
-            //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter)/static_cast<double>(d_fs_in);
-            // This tracking block aligns the Tracking_timestamp_secs with the start sample of the PRN, thus, Code_phase_secs=0
-            current_synchro_data.Code_phase_secs = 0;
-            current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad;
-            current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
-            current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
-            current_synchro_data.Flag_valid_pseudorange = false;
-            *out[0] = current_synchro_data;
-
-            // ########## DEBUG OUTPUT
-            /*!
-             *  \todo The stop timer has to be moved to the signal source!
-             */
-            // debug: Second counter in channel 0
-            if (d_channel == 0)
-                {
-                    if (floor(d_sample_counter / d_fs_in) != d_last_seg)
-                        {
-                            d_last_seg = floor(d_sample_counter / d_fs_in);
-                            std::cout << "Current input signal time = " << d_last_seg << " [s]" << std::endl;
-                            DLOG(INFO) << "GPS L1 C/A Tracking CH " << d_channel <<  ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
-                                      << ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]" << std::endl;
-                            //if (d_last_seg==5) d_carrier_lock_fail_counter=500; //DEBUG: force unlock!
-                        }
-                }
-            else
-                {
-                    if (floor(d_sample_counter / d_fs_in) != d_last_seg)
-                        {
-                            d_last_seg = floor(d_sample_counter / d_fs_in);
-                            DLOG(INFO) << "Tracking CH " << d_channel <<  ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
-                                       << ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]";
-                        }
-                }
-        }
-    else
-        {
-            // ########## DEBUG OUTPUT (TIME ONLY for channel 0 when tracking is disabled)
-            /*!
-             *  \todo The stop timer has to be moved to the signal source!
-             */
-            // stream to collect cout calls to improve thread safety
-            std::stringstream tmp_str_stream;
-            if (floor(d_sample_counter / d_fs_in) != d_last_seg)
-                {
-                    d_last_seg = floor(d_sample_counter / d_fs_in);
-
-                    if (d_channel == 0)
-                        {
-                            // debug: Second counter in channel 0
-                            tmp_str_stream << "Current input signal time = " << d_last_seg << " [s]" << std::endl << std::flush;
-                            std::cout << tmp_str_stream.rdbuf() << std::flush;
-                        }
-                }
-            *d_Early = gr_complex(0,0);
-            *d_Prompt = gr_complex(0,0);
-            *d_Late = gr_complex(0,0);
-
-            current_synchro_data.System = {'G'};
-            current_synchro_data.Flag_valid_pseudorange = false;
-            *out[0] = current_synchro_data;
-        }
-
-    if(d_dump)
-        {
-            // MULTIPLEXED FILE RECORDING - Record results to file
-            float prompt_I;
-            float prompt_Q;
-            float tmp_E, tmp_P, tmp_L;
-            float tmp_float;
-            double tmp_double;
-            prompt_I = (*d_Prompt).real();
-            prompt_Q = (*d_Prompt).imag();
-            tmp_E = std::abs<float>(*d_Early);
-            tmp_P = std::abs<float>(*d_Prompt);
-            tmp_L = std::abs<float>(*d_Late);
-            try
-            {
-
-                // EPR
-                d_dump_file.write((char*)&tmp_E, sizeof(float));
-                d_dump_file.write((char*)&tmp_P, sizeof(float));
-                d_dump_file.write((char*)&tmp_L, sizeof(float));
-                // PROMPT I and Q (to analyze navigation symbols)
-                d_dump_file.write((char*)&prompt_I, sizeof(float));
-                d_dump_file.write((char*)&prompt_Q, sizeof(float));
-                // PRN start sample stamp
-                //tmp_float=(float)d_sample_counter;
-                d_dump_file.write((char*)&d_sample_counter, sizeof(unsigned long int));
-                // accumulated carrier phase
-                tmp_float = d_acc_carrier_phase_rad;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-
-                // carrier and code frequency
-                tmp_float = d_carrier_doppler_hz;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-                tmp_float = d_code_freq_chips;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-
-                //PLL commands
-                tmp_float = carr_error_hz;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-                tmp_float = carr_error_filt_hz;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-
-                //DLL commands
-                tmp_float = code_error_chips;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-                tmp_float = code_error_filt_chips;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-
-                // CN0 and carrier lock test
-                tmp_float = d_CN0_SNV_dB_Hz;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-                tmp_float = d_carrier_lock_test;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-
-                // AUX vars (for debug purposes)
-                tmp_float = d_rem_code_phase_samples;
-                d_dump_file.write((char*)&tmp_float, sizeof(float));
-                tmp_double = (double)(d_sample_counter + d_current_prn_length_samples);
-                d_dump_file.write((char*)&tmp_double, sizeof(double));
-            }
-            catch (std::ifstream::failure e)
-            {
-                    LOG(WARNING) << "Exception writing trk dump file " << e.what();
-            }
-        }
-
-    consume_each(d_current_prn_length_samples); // this is necessary in gr::block derivates
-    d_sample_counter += d_current_prn_length_samples; //count for the processed samples
-    //LOG(INFO)<<"GPS tracking output end on CH="<<this->d_channel << " SAMPLE STAMP="<<d_sample_counter<<std::endl;
-    return 1; //output tracking result ALWAYS even in the case of d_enable_tracking==false
-}
-
-
-
-void Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::set_channel(unsigned int channel)
-{
-    d_channel = channel;
-    LOG(INFO) << "Tracking Channel set to " << d_channel;
-    // ############# ENABLE DATA FILE LOG #################
-    if (d_dump == true)
-        {
-            if (d_dump_file.is_open() == false)
-                {
-                    try
-                    {
-                            d_dump_filename.append(boost::lexical_cast<std::string>(d_channel));
-                            d_dump_filename.append(".dat");
-                            d_dump_file.exceptions (std::ifstream::failbit | std::ifstream::badbit);
-                            d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
-                            LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str() << std::endl;
-                    }
-                    catch (std::ifstream::failure e)
-                    {
-                            LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what() << std::endl;
-                    }
-                }
-        }
-}
-
-
-
-void Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::set_channel_queue(concurrent_queue<int> *channel_internal_queue)
-{
-    d_channel_internal_queue = channel_internal_queue;
-}
-
-
-void Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
-{
-    d_acquisition_gnss_synchro = p_gnss_synchro;
-}

src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc

@@ -106,6 +106,8 @@ Gps_L1_Ca_Tcp_Connector_Tracking_cc::Gps_L1_Ca_Tcp_Connector_Tracking_cc(
         gr::block("Gps_L1_Ca_Tcp_Connector_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;
@@ -434,7 +436,7 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items, gr_vec
                     current_synchro_data.CN0_dB_hz = 0.0;
                     current_synchro_data.Flag_valid_tracking = false;
                     current_synchro_data.Flag_valid_pseudorange = false;
-
+                    current_synchro_data.Flag_valid_symbol_output = true;
                     *out[0] = current_synchro_data;
 
                     return 1;
@@ -547,6 +549,8 @@ int Gps_L1_Ca_Tcp_Connector_Tracking_cc::general_work (int noutput_items, gr_vec
             current_synchro_data.Code_phase_secs = (double)d_code_phase_samples * (1/(float)d_fs_in);
             current_synchro_data.CN0_dB_hz = (double)d_CN0_SNV_dB_Hz;
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = true;
+            current_synchro_data.correlation_length_ms=1;
             *out[0] = current_synchro_data;
 
             // ########## DEBUG OUTPUT

src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc

@@ -103,6 +103,8 @@ gps_l2_m_dll_pll_tracking_cc::gps_l2_m_dll_pll_tracking_cc(
         gr::block("gps_l2_m_dll_pll_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
                 gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
 {
+    // Telemetry bit synchronization message port input
+    this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
     // initialize internal vars
     d_queue = queue;
     d_dump = dump;
@@ -311,8 +313,6 @@ void gps_l2_m_dll_pll_tracking_cc::update_local_carrier()
             d_carr_sign[i] = gr_complex(cos(phase_rad), -sin(phase_rad));
             phase_rad += phase_step_rad;
         }
-    //d_rem_carr_phase_rad = fmod(phase_rad, GPS_L2_TWO_PI);
-    //d_acc_carrier_phase_rad = d_acc_carrier_phase_rad + d_rem_carr_phase_rad;
 }
 
 
@@ -414,7 +414,7 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items, gr_vector_int
                     current_synchro_data.CN0_dB_hz = 0.0;
                     current_synchro_data.Flag_valid_tracking = false;
                     current_synchro_data.Flag_valid_pseudorange = false;
-
+                    current_synchro_data.Flag_valid_symbol_output = false;
                     *out[0] = current_synchro_data;
 
                     return 1;
@@ -499,11 +499,6 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items, gr_vector_int
             current_synchro_data.Prompt_I = static_cast<double>((*d_Prompt).real());
             current_synchro_data.Prompt_Q = static_cast<double>((*d_Prompt).imag());
 
-            // Tracking_timestamp_secs is aligned with the NEXT PRN start sample (Hybridization problem!)
-            //compute remnant code phase samples BEFORE the Tracking timestamp
-            //d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample
-            //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter + (double)d_current_prn_length_samples + (double)d_rem_code_phase_samples)/static_cast<double>(d_fs_in);
-
             // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!, but some glitches??)
             current_synchro_data.Tracking_timestamp_secs = (static_cast<double>(d_sample_counter) + d_rem_code_phase_samples) / static_cast<double>(d_fs_in);
             //compute remnant code phase samples AFTER the Tracking timestamp
@@ -516,6 +511,8 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items, gr_vector_int
             current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
             current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
             current_synchro_data.Flag_valid_tracking = true;
+            current_synchro_data.Flag_valid_symbol_output = true;
+            current_synchro_data.correlation_length_ms=1;
             *out[0] = current_synchro_data;
 
             // ########## DEBUG OUTPUT
@@ -570,6 +567,7 @@ int gps_l2_m_dll_pll_tracking_cc::general_work (int noutput_items, gr_vector_int
             *d_Late = gr_complex(0,0);
 
             current_synchro_data.Flag_valid_pseudorange = false;
+            current_synchro_data.Flag_valid_symbol_output = false;
             *out[0] = current_synchro_data;
         }
 

src/algorithms/tracking/libs/cpu_multicorrelator.cc

@@ -35,7 +35,6 @@
 #include "cpu_multicorrelator.h"
 #include <cmath>
 #include <iostream>
-#include <volk/volk.h>
 #include <volk_gnsssdr/volk_gnsssdr.h>
 
 
@@ -68,10 +67,10 @@ bool cpu_multicorrelator::init(
     // ALLOCATE MEMORY FOR INTERNAL vectors
     size_t size = max_signal_length_samples * sizeof(std::complex<float>);
 
-    d_local_codes_resampled = static_cast<std::complex<float>**>(volk_malloc(n_correlators * sizeof(std::complex<float>), volk_get_alignment()));
+    d_local_codes_resampled = static_cast<std::complex<float>**>(volk_gnsssdr_malloc(n_correlators * sizeof(std::complex<float>), volk_gnsssdr_get_alignment()));
     for (int n = 0; n < n_correlators; n++)
         {
-            d_local_codes_resampled[n] = static_cast<std::complex<float>*>(volk_malloc(size, volk_get_alignment()));
+            d_local_codes_resampled[n] = static_cast<std::complex<float>*>(volk_gnsssdr_malloc(size, volk_gnsssdr_get_alignment()));
         }
     d_n_correlators = n_correlators;
     return true;
@@ -103,18 +102,14 @@ bool cpu_multicorrelator::set_input_output_vectors(std::complex<float>* corr_out
 
 void cpu_multicorrelator::update_local_code(int correlator_length_samples, float rem_code_phase_chips, float code_phase_step_chips)
 {
-    float local_code_chip_index;
+    volk_gnsssdr_32fc_xn_resampler_32fc_xn(d_local_codes_resampled,
-    for (int current_correlator_tap = 0; current_correlator_tap < d_n_correlators; current_correlator_tap++)
+            d_local_code_in,
-        {
+            rem_code_phase_chips,
-            for (int n = 0; n < correlator_length_samples; n++)
+            code_phase_step_chips,
-                {
+            d_shifts_chips,
-                    // resample code for current tap
+            correlator_length_samples,
-                    local_code_chip_index = std::fmod(code_phase_step_chips * static_cast<float>(n) + d_shifts_chips[current_correlator_tap] - rem_code_phase_chips, d_code_length_chips);
+            d_n_correlators,
-                    //Take into account that in multitap correlators, the shifts can be negative!
+            d_code_length_chips);
-                    if (local_code_chip_index < 0.0) local_code_chip_index += d_code_length_chips;
-                    d_local_codes_resampled[current_correlator_tap][n] = d_local_code_in[static_cast<int>(round(local_code_chip_index))];
-                }
-        }
 }
 
 
@@ -140,9 +135,9 @@ bool cpu_multicorrelator::free()
     // Free memory
     for (int n = 0; n < d_n_correlators; n++)
         {
-            volk_free(d_local_codes_resampled[n]);
+            volk_gnsssdr_free(d_local_codes_resampled[n]);
         }
-    volk_free(d_local_codes_resampled);
+    volk_gnsssdr_free(d_local_codes_resampled);
     return true;
 }
 

src/algorithms/tracking/libs/lock_detectors.cc

@@ -67,21 +67,22 @@
  */
 float cn0_svn_estimator(gr_complex* Prompt_buffer, int length, long fs_in, double code_length)
 {
-    float SNR = 0;
+	double SNR = 0;
-    float SNR_dB_Hz = 0;
+	double SNR_dB_Hz = 0;
-    float Psig = 0;
+    double Psig = 0;
-    float Ptot = 0;
+    double Ptot = 0;
     for (int i=0; i<length; i++)
         {
-            Psig += std::abs(Prompt_buffer[i].real());
+            Psig += std::abs(static_cast<double>(Prompt_buffer[i].real()));
-            Ptot += Prompt_buffer[i].imag() * Prompt_buffer[i].imag() + Prompt_buffer[i].real() * 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 / (float)length;
+    Psig = Psig / static_cast<double>(length);
     Psig = Psig * Psig;
-    Ptot = Ptot / (float)length;
+    Ptot = Ptot / static_cast<double>(length);
     SNR = Psig / (Ptot - Psig);
-    SNR_dB_Hz = 10 * log10(SNR) + 10 * log10(fs_in/2) - 10 * log10((float)code_length);
+    SNR_dB_Hz = 10 * log10(SNR) + 10 * log10(static_cast<double>(fs_in)/2) - 10 * log10(code_length);
-    return SNR_dB_Hz;
+    return static_cast<float>(SNR_dB_Hz);
 }
 
 

src/core/system_parameters/GPS_L1_CA.h

@@ -74,12 +74,15 @@ const int GPS_L1_CA_HISTORY_DEEP = 100;
 
 #define GPS_PREAMBLE {1, 0, 0, 0, 1, 0, 1, 1}
 const int GPS_CA_PREAMBLE_LENGTH_BITS = 8;
+const int GPS_CA_PREAMBLE_LENGTH_SYMBOLS = 160;
 const int GPS_CA_TELEMETRY_RATE_BITS_SECOND = 50;   //!< NAV message bit rate [bits/s]
-const int GPS_CA_TELEMETRY_RATE_SYMBOLS_SECOND = GPS_CA_TELEMETRY_RATE_BITS_SECOND*20;   //!< NAV message bit rate [symbols/s]
+const int GPS_CA_TELEMETRY_SYMBOLS_PER_BIT = 20;
+const int GPS_CA_TELEMETRY_RATE_SYMBOLS_SECOND = GPS_CA_TELEMETRY_RATE_BITS_SECOND*GPS_CA_TELEMETRY_SYMBOLS_PER_BIT;   //!< NAV message bit rate [symbols/s]
 const int GPS_WORD_LENGTH = 4;                      //!< CRC + GPS WORD (-2 -1 0 ... 29) Bits = 4 bytes
 const int GPS_SUBFRAME_LENGTH = 40;                 //!< GPS_WORD_LENGTH x 10 = 40 bytes
 const int GPS_SUBFRAME_BITS = 300;                  //!< Number of bits per subframe in the NAV message [bits]
 const int GPS_SUBFRAME_SECONDS = 6;                 //!< Subframe duration [seconds]
+const int GPS_SUBFRAME_MS = 6000;                 //!< Subframe duration [seconds]
 const int GPS_WORD_BITS = 30;                       //!< Number of bits per word in the NAV message [bits]
 
 // GPS NAVIGATION MESSAGE STRUCTURE

src/core/system_parameters/gnss_synchro.h

@@ -61,6 +61,9 @@ public:
     double Tracking_timestamp_secs; //!< Set by Tracking processing block
     bool Flag_valid_tracking;
 
+    bool Flag_valid_symbol_output;
+    int correlation_length_ms; //!< Set by Tracking processing block
+
     //Telemetry Decoder
     double Prn_timestamp_ms;             //!< Set by Telemetry Decoder processing block
     double Prn_timestamp_at_preamble_ms; //!< Set by Telemetry Decoder processing block