Merge branch 'galileo_e5a' of https://github.com/marc-sales/gnss-sdr

into next

Conflicts:
	src/core/receiver/gnss_block_factory.cc
	src/core/receiver/gnss_flowgraph.cc

conf/gnss-sdr_GPS_L1_nsr.conf

@@ -31,7 +31,7 @@ GNSS-SDR.SUPL_CI=0x31b0
 SignalSource.implementation=Nsr_File_Signal_Source
 
 ;#filename: path to file with the captured GNSS signal samples to be processed
-SignalSource.filename=/Volumes/BOOTCAMP/signals/ifen/E1L1_FE0_Band0.stream
+SignalSource.filename=../../../Documents/workspace/code2/trunk/data/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

conf/gnss-sdr_Galileo_E1_short.conf

@@ -17,7 +17,7 @@ ControlThread.wait_for_flowgraph=false
 SignalSource.implementation=File_Signal_Source
 
 ;#filename: path to file with the captured GNSS signal samples to be processed
-SignalSource.filename=/Volumes/BOOTCAMP/signals/2013_09_11_GNSS_SIGNAL_at_CTTC_SPAIN/2013_09_11_GNSS_SIGNAL_at_CTTC_SPAIN_run2.dat
+SignalSource.filename=../../../Documents/workspace/code2/trunk/data/2013_04_04_GNSS_SIGNAL_at_CTTC_SPAIN.dat
 
 ;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
 SignalSource.item_type=short

conf/gnss-sdr_Galileo_E5a.conf

@@ -0,0 +1,433 @@
+; Default configuration file
+; 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=32000000
+
+;######### CONTROL_THREAD CONFIG ############
+ControlThread.wait_for_flowgraph=false
+
+;######### SUPL RRLP GPS assistance configuration #####
+;GNSS-SDR.SUPL_gps_enabled=false
+;GNSS-SDR.SUPL_read_gps_assistance_xml=false
+;GNSS-SDR.SUPL_gps_ephemeris_server=supl.nokia.com
+;GNSS-SDR.SUPL_gps_ephemeris_port=7275
+;GNSS-SDR.SUPL_gps_acquisition_server=supl.google.com
+;GNSS-SDR.SUPL_gps_acquisition_port=7275
+;GNSS-SDR.SUPL_MCC=244
+;GNSS-SDR.SUPL_MNS=5
+;GNSS-SDR.SUPL_LAC=0x59e2
+;GNSS-SDR.SUPL_CI=0x31b0
+
+;######### SIGNAL_SOURCE CONFIG ############
+;#implementation: Use [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=/home/marc/E5a_acquisitions/signal_source_5X_primary.dat
+;SignalSource.filename=/home/marc/E5a_acquisitions/galileo_E5_8M_r2_upsampled_12.dat
+;SignalSource.filename=/home/marc/E5a_acquisitions/Tiered_sim_4sat_stup4_2s_up.dat
+;SignalSource.filename=/home/marc/E5a_acquisitions/signal_source_sec21M_long.dat
+SignalSource.filename=/home/marc/E5a_acquisitions/32MS_complex.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=32000000
+
+;#freq: RF front-end center frequency in [Hz]
+SignalSource.freq=1176450000
+
+;#gain: Front-end Gain in [dB]
+SignalSource.gain=50
+
+;#subdevice: UHD subdevice specification (for USRP1 use A:0 or B:0)
+SignalSource.subdevice=B:0
+
+;#samples: Number of samples to be processed. Notice that 0 indicates the entire file.
+SignalSource.samples=0
+
+;#repeat: Repeat the processing file. Disable this option in this version
+SignalSource.repeat=false
+
+;#dump: Dump the Signal source data to a file. Disable this option in this version
+SignalSource.dump=false
+
+SignalSource.dump_filename=../data/signal_source.dat
+
+
+;#enable_throttle_control: Enabling this option tells the signal source to keep the delay between samples in post processing.
+; it helps to not overload the CPU, but the processing time will be longer.
+SignalSource.enable_throttle_control=false
+
+
+;######### SIGNAL_CONDITIONER CONFIG ############
+;## It holds blocks to change data type, filter and resample input data.
+
+;#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.
+;#implementation: [Pass_Through] disables this block
+DataTypeAdapter.implementation=Pass_Through
+
+;######### 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
+;#[Fir_Filter] enables a FIR Filter
+;#[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.
+InputFilter.dump=false
+
+;#dump_filename: Log path and filename.
+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.
+
+;#input_item_type: Type and resolution for input signal samples. Use only gr_complex in this version.
+InputFilter.input_item_type=gr_complex
+
+;#outut_item_type: Type and resolution for output filtered signal samples. Use only gr_complex in this version.
+InputFilter.output_item_type=gr_complex
+
+;#taps_item_type: Type and resolution for the taps of the filter. Use only float in this version.
+InputFilter.taps_item_type=float
+
+;#number_of_taps: Number of taps in the filter. Increasing this parameter increases the processing time
+InputFilter.number_of_taps=5
+
+;#number_of _bands: Number of frequency bands in the filter.
+InputFilter.number_of_bands=2
+
+;#bands: frequency at the band edges [ b1 e1 b2 e2 b3 e3 ...].
+;#Frequency is in the range [0, 1], with 1 being the Nyquist frequency (Fs/2)
+;#The number of band_begin and band_end elements must match the number of bands
+
+InputFilter.band1_begin=0.0
+InputFilter.band1_end=0.45
+InputFilter.band2_begin=0.55
+InputFilter.band2_end=1.0
+
+;#ampl: desired amplitude at the band edges [ a(b1) a(e1) a(b2) a(e2) ...].
+;#The number of ampl_begin and ampl_end elements must match the number of bands
+
+InputFilter.ampl1_begin=1.0
+InputFilter.ampl1_end=1.0
+InputFilter.ampl2_begin=0.0
+InputFilter.ampl2_end=0.0
+
+;#band_error: weighting applied to each band (usually 1).
+;#The number of band_error elements must match the number of bands
+InputFilter.band1_error=1.0
+InputFilter.band2_error=1.0
+
+;#filter_type: one of "bandpass", "hilbert" or "differentiator"
+InputFilter.filter_type=bandpass
+
+;#grid_density: determines how accurately the filter will be constructed.
+;The minimum value is 16; higher values are slower to compute the filter.
+InputFilter.grid_density=16
+
+;#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=32000000
+InputFilter.IF=0
+
+
+
+;######### RESAMPLER CONFIG ############
+;## Resamples the input data.
+
+;#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
+
+
+;######### CHANNELS GLOBAL CONFIG ############
+;#count: Number of available satellite channels.
+Channels.count=1
+;#in_acquisition: Number of channels simultaneously acquiring
+Channels.in_acquisition=1
+;#system: GPS, GLONASS, Galileo, SBAS or Compass
+;#if the option is disabled by default is assigned GPS
+Channel.system=Galileo
+
+;#signal:
+;# "1C" GPS L1 C/A
+;# "1P" GPS L1 P
+;# "1W" GPS L1 Z-tracking and similar (AS on)
+;# "1Y" GPS L1 Y
+;# "1M" GPS L1 M
+;# "1N" GPS L1 codeless
+;# "2C" GPS L2 C/A
+;# "2D" GPS L2 L1(C/A)+(P2-P1) semi-codeless
+;# "2S" GPS L2 L2C (M)
+;# "2L" GPS L2 L2C (L)
+;# "2X" GPS L2 L2C (M+L)
+;# "2P" GPS L2 P
+;# "2W" GPS L2 Z-tracking and similar (AS on)
+;# "2Y" GPS L2 Y
+;# "2M" GPS GPS L2 M
+;# "2N" GPS L2 codeless
+;# "5I" GPS L5 I
+;# "5Q" GPS L5 Q
+;# "5X" GPS L5 I+Q
+;# "1C" GLONASS G1 C/A
+;# "1P" GLONASS G1 P
+;# "2C" GLONASS G2 C/A (Glonass M)
+;# "2P" GLONASS G2 P
+;# "1A" GALILEO E1 A (PRS)
+;# "1B" GALILEO E1 B (I/NAV OS/CS/SoL)
+;# "1C" GALILEO E1 C (no data)
+;# "1X" GALILEO E1 B+C
+;# "1Z" GALILEO E1 A+B+C
+;# "5I" GALILEO E5a I (F/NAV OS)
+;# "5Q" GALILEO E5a Q (no data)
+;# "5X" GALILEO E5a I+Q
+;# "7I" GALILEO E5b I
+;# "7Q" GALILEO E5b Q
+;# "7X" GALILEO E5b I+Q
+;# "8I" GALILEO E5 I
+;# "8Q" GALILEO E5 Q
+;# "8X" GALILEO E5 I+Q
+;# "6A" GALILEO E6 A
+;# "6B" GALILEO E6 B
+;# "6C" GALILEO E6 C
+;# "6X" GALILEO E6 B+C
+;# "6Z" GALILEO E6 A+B+C
+;# "1C" SBAS L1 C/A
+;# "5I" SBAS L5 I
+;# "5Q" SBAS L5 Q
+;# "5X" SBAS L5 I+Q
+;# "2I" COMPASS E2 I
+;# "2Q" COMPASS E2 Q
+;# "2X" COMPASS E2 IQ
+;# "7I" COMPASS E5b I
+;# "7Q" COMPASS E5b Q
+;# "7X" COMPASS E5b IQ
+;# "6I" COMPASS E6 I
+;# "6Q" COMPASS E6 Q
+;# "6X" COMPASS E6 IQ
+;#if the option is disabled by default is assigned "1C" GPS L1 C/A
+Channel.signal=5X
+
+;######### SPECIFIC CHANNELS CONFIG ######
+;#The following options are specific to each channel and overwrite the generic options
+
+;######### CHANNEL 0 CONFIG ############
+
+Channel0.system=Galileo
+Channel0.signal=5X
+
+;#satellite: Satellite PRN ID for this channel. Disable this option to random search
+Channel0.satellite=19
+;Channel0.repeat_satellite=true
+
+;######### CHANNEL 1 CONFIG ############
+
+;Channel1.system=Galileo
+;Channel1.signal=5Q
+;Channel1.satellite=12
+
+;######### CHANNEL 2 CONFIG ############
+
+;Channel2.system=Galileo
+;Channel2.signal=5Q
+;Channel2.satellite=11
+
+;######### CHANNEL 3 CONFIG ############
+
+;Channel3.system=Galileo
+;Channel3.signal=5Q
+;Channel3.satellite=20
+
+;######### ACQUISITION GLOBAL CONFIG ############
+
+;#dump: Enable or disable the acquisition internal data file logging [true] or [false]
+Acquisition.dump=true
+;#filename: Log path and filename
+Acquisition.dump_filename=./acq_dump.dat
+;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
+Acquisition.item_type=gr_complex
+;#if: Signal intermediate frequency in [Hz]
+Acquisition.if=0
+;#sampled_ms: Signal block duration for the acquisition signal detection [ms]
+Acquisition.coherent_integration_time_ms=1
+;#implementation: Acquisition algorithm selection for this channel: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
+Acquisition.implementation=Galileo_E5a_Noncoherent_IQ_Acquisition_CAF
+;#threshold: Acquisition threshold. It will be ignored if pfa is defined.
+Acquisition.threshold=0.001
+;#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.pfa=0.0003
+;#doppler_max: Maximum expected Doppler shift [Hz]
+Acquisition.doppler_max=10000
+;#doppler_max: Doppler step in the grid search [Hz]
+Acquisition.doppler_step=250
+;#bit_transition_flag: Enable or disable a strategy to deal with bit transitions in GPS signals: process two dwells and take
+;maximum test statistics. Only use with implementation: [GPS_L1_CA_PCPS_Acquisition] (should not be used for Galileo_E1_PCPS_Ambiguous_Acquisition])
+Acquisition.bit_transition_flag=false
+;#max_dwells: Maximum number of consecutive dwells to be processed. It will be ignored if bit_transition_flag=true
+Acquisition.max_dwells=1
+
+;#CAF filter: **Only for E5a** Resolves doppler ambiguity averaging the specified BW in the winner code delay. If set to 0 CAF filter is desactivated. Recommended value 3000 Hz
+Acquisition.CAF_window_hz=0
+;#Zero_padding: **Only for E5a** Avoids power loss and doppler ambiguity in bit transitions by correlating one code with twice the input data length, ensuring that at least one full code is present without transitions.
+;#If set to 1 it is ON, if set to 0 it is OFF.
+Acquisition.Zero_padding=0
+
+;######### ACQUISITION CHANNELS CONFIG ######
+;#The following options are specific to each channel and overwrite the generic options
+
+;######### ACQUISITION CH 0 CONFIG ############
+;Acquisition0.implementation=GPS_L1_CA_PCPS_Acquisition
+;Acquisition0.threshold=0.005
+;Acquisition0.pfa=0.001
+;Acquisition0.doppler_max=10000
+;Acquisition0.doppler_step=250
+
+;#repeat_satellite: Use only jointly with the satellite PRN ID option. The default value is false
+;Acquisition0.repeat_satellite = false
+
+;######### ACQUISITION CH 1 CONFIG ############
+;Acquisition1.implementation=GPS_L1_CA_PCPS_Acquisition
+;Acquisition1.threshold=0.005
+;Acquisition1.pfa=0.001
+;Acquisition1.doppler_max=10000
+;Acquisition1.doppler_step=250
+;Acquisition1.repeat_satellite = false
+
+;######### TRACKING GLOBAL CONFIG ############
+
+;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking]
+Tracking.implementation=Galileo_E5a_DLL_PLL_Tracking
+;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version.
+Tracking.item_type=gr_complex
+
+;#sampling_frequency: Signal Intermediate Frequency in [Hz]
+Tracking.if=0
+
+;#dump: Enable or disable the Tracking internal binary data file logging [true] or [false]
+Tracking.dump=true
+
+;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number.
+Tracking.dump_filename=./tracking_ch_
+
+;#pll_bw_hz_init: **Only for E5a** PLL loop filter bandwidth during initialization [Hz]
+Tracking.pll_bw_hz_init=20.0;
+;#dll_bw_hz_init: **Only for E5a** DLL loop filter bandwidth during initialization [Hz]
+Tracking.dll_bw_hz_init=20.0;
+;#dll_ti_ms: **Only for E5a** loop filter integration time after initialization (secondary code delay search)[ms]
+;Tracking.ti_ms=3;
+Tracking.ti_ms=1;
+
+;#pll_bw_hz: PLL loop filter bandwidth [Hz]
+;Tracking.pll_bw_hz=5.0;
+Tracking.pll_bw_hz=20.0;
+
+;#dll_bw_hz: DLL loop filter bandwidth [Hz]
+;Tracking.dll_bw_hz=2.0;
+Tracking.dll_bw_hz=20.0;
+
+;#fll_bw_hz: FLL loop filter bandwidth [Hz]
+;Tracking.fll_bw_hz=10.0;
+
+;#order: PLL/DLL loop filter order [2] or [3]
+Tracking.order=2;
+
+;#early_late_space_chips: correlator early-late space [chips]. Use [0.5]
+Tracking.early_late_space_chips=0.5;
+
+;######### TELEMETRY DECODER CONFIG ############
+;#implementation: Use [GPS_L1_CA_Telemetry_Decoder] for GPS L1 C/A.
+TelemetryDecoder.implementation=Galileo_E5a_Telemetry_Decoder
+TelemetryDecoder.dump=false
+
+;######### OBSERVABLES CONFIG ############
+;#implementation: Use [GPS_L1_CA_Observables] for GPS L1 C/A.
+;Use [Galileo_E1B_Observables] for E5a also.
+Observables.implementation=Galileo_E1B_Observables
+
+;#dump: Enable or disable the Observables internal binary data file logging [true] or [false]
+Observables.dump=false
+
+;#dump_filename: Log path and filename.
+Observables.dump_filename=./observables.dat
+
+
+;######### PVT CONFIG ############
+;#implementation: Position Velocity and Time (PVT) implementation algorithm: Use [GPS_L1_CA_PVT] in this version.
+;Use [GALILEO_E1_PVT] for E5a also.
+PVT.implementation=GALILEO_E1_PVT
+
+;#averaging_depth: Number of PVT observations in the moving average algorithm
+PVT.averaging_depth=100
+
+;#flag_average: Enables the PVT averaging between output intervals (arithmetic mean) [true] or [false]
+PVT.flag_averaging=true
+
+;#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=100
+
+;#display_rate_ms: Position console print (std::out) interval [ms]. Notice that output_rate_ms<=display_rate_ms.
+PVT.display_rate_ms=500
+
+;# RINEX, KML, and NMEA output configuration
+
+;#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=true;
+
+;#nmea_dump_devname: serial device descriptor for NMEA logging
+PVT.nmea_dump_devname=/dev/pts/4
+
+
+;#dump: Enable or disable the PVT internal binary data file logging [true] or [false]
+PVT.dump=false
+
+;######### OUTPUT_FILTER CONFIG ############
+;# Receiver output filter: Leave this block disabled in this version
+OutputFilter.implementation=Null_Sink_Output_Filter
+OutputFilter.filename=data/gnss-sdr.dat
+OutputFilter.item_type=gr_complex

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=/Volumes/BOOTCAMP/signals/ifen/E1L1_FE0_Band0.stream
+SignalSource.filename=../../../Documents/workspace/code2/trunk/data/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

conf/gnss-sdr_SBAS_short.conf

@@ -17,7 +17,7 @@ ControlThread.wait_for_flowgraph=false
 SignalSource.implementation=File_Signal_Source
 
 ;#filename: path to file with the captured GNSS signal samples to be processed
-SignalSource.filename=/Volumes/BOOTCAMP/signals/2013_09_11_GNSS_SIGNAL_at_CTTC_SPAIN/2013_09_11_GNSS_SIGNAL_at_CTTC_SPAIN_run2.dat
+SignalSource.filename=../../../Documents/workspace/code2/trunk/data/2013_09_11_GNSS_SIGNAL_at_CTTC_SPAIN_run2.dat
 
 ;#item_type: Type and resolution for each of the signal samples. 
 ;#Use gr_complex for 32 bits float I/Q or short for I/Q interleaved short integer.

src/algorithms/acquisition/adapters/CMakeLists.txt

@@ -30,6 +30,7 @@ if(OPENCL_FOUND)
          galileo_e1_pcps_quicksync_ambiguous_acquisition.cc
          galileo_e1_pcps_tong_ambiguous_acquisition.cc
          galileo_e1_pcps_8ms_ambiguous_acquisition.cc
+         galileo_e5a_noncoherent_iq_acquisition_caf.cc
     )
 else(OPENCL_FOUND)
     set(ACQ_ADAPTER_SOURCES
@@ -44,6 +45,7 @@ else(OPENCL_FOUND)
          galileo_e1_pcps_quicksync_ambiguous_acquisition.cc
          galileo_e1_pcps_tong_ambiguous_acquisition.cc
          galileo_e1_pcps_8ms_ambiguous_acquisition.cc
+         galileo_e5a_noncoherent_iq_acquisition_caf.cc
     )
 endif(OPENCL_FOUND)
 

src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc

@@ -0,0 +1,328 @@
+/*!
+ * \file galileo_e5a_noncoherent_iq_acquisition_caf.cc
+ * \brief Adapts a PCPS acquisition block to an AcquisitionInterface for
+ *  Galileo E5a data and pilot Signals
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          <li> Marc Molina, 2013. marc.molina.pena@gmail.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e5a_noncoherent_iq_acquisition_caf.h"
+#include <iostream>
+#include <boost/lexical_cast.hpp>
+#include <stdexcept>
+#include <boost/math/distributions/exponential.hpp>
+#include <glog/logging.h>
+#include <gnuradio/msg_queue.h>
+#include "galileo_e5_signal_processing.h"
+#include "Galileo_E5a.h"
+#include "configuration_interface.h"
+
+using google::LogMessage;
+
+GalileoE5aNoncoherentIQAcquisitionCaf::GalileoE5aNoncoherentIQAcquisitionCaf(
+        ConfigurationInterface* configuration, std::string role,
+        unsigned int in_streams, unsigned int out_streams,
+        boost::shared_ptr<gr::msg_queue> queue) :
+    role_(role), in_streams_(in_streams), out_streams_(out_streams), queue_(queue)
+{
+    configuration_ = configuration;
+    std::string default_item_type = "gr_complex";
+    std::string default_dump_filename = "../data/acquisition.dat";
+
+    DLOG(INFO) << "role " << role;
+
+    item_type_ = configuration_->property(role + ".item_type",
+	        default_item_type);
+
+    fs_in_ = configuration_->property("GNSS-SDR.internal_fs_hz", 32000000);
+    if_ = configuration_->property(role + ".ifreq", 0);
+    dump_ = configuration_->property(role + ".dump", false);
+    shift_resolution_ = configuration_->property(role + ".doppler_max", 15);
+    CAF_window_hz_ = configuration_->property(role + ".CAF_window_hz",0);
+    Zero_padding = configuration_->property(role + ".Zero_padding",0);
+    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1);
+    if (sampled_ms_ > 3)
+	{
+	    sampled_ms_=3;
+	    DLOG(INFO) << "Coherent integration time should be 3 ms or less. Changing to 3ms ";
+	    std::cout<<"Too high coherent integration time. Changing to 3ms" << std::endl;
+	}
+    if (Zero_padding > 0)
+	{
+	    sampled_ms_ = 2;
+	    DLOG(INFO) << "Zero padding activated. Changing to 1ms code + 1ms zero padding ";
+	    std::cout<<"Zero padding activated. Changing to 1ms code + 1ms zero padding" << std::endl;
+	}
+
+    max_dwells_ = configuration_->property(role + ".max_dwells", 1);
+
+    dump_filename_ = configuration_->property(role + ".dump_filename",
+            default_dump_filename);
+
+    //--- Find number of samples per spreading code (1ms)-------------------------
+    code_length_ = round(fs_in_/ Galileo_E5a_CODE_CHIP_RATE_HZ*Galileo_E5a_CODE_LENGTH_CHIPS);
+
+    vector_length_=code_length_ * sampled_ms_;
+
+    codeI_= new gr_complex[vector_length_];
+    codeQ_= new gr_complex[vector_length_];
+    both_signal_components = false;
+
+    std::string sig_ = configuration_->property("Channel.signal", std::string("5X"));
+    if (sig_.at(0) == '5' && sig_.at(1) == 'X')
+	{
+	    both_signal_components = true;
+	}
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            item_size_ = sizeof(gr_complex);
+            acquisition_cc_ = galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(sampled_ms_, max_dwells_,
+                    shift_resolution_, if_, fs_in_, code_length_, code_length_,
+                    bit_transition_flag_, queue_, dump_, dump_filename_, both_signal_components, CAF_window_hz_,Zero_padding);
+        }
+        else
+        {
+            LOG(WARNING) << item_type_
+                    << " unknown acquisition item type";
+        }
+
+}
+
+GalileoE5aNoncoherentIQAcquisitionCaf::~GalileoE5aNoncoherentIQAcquisitionCaf()
+{
+	delete[] codeI_;
+	delete[] codeQ_;
+}
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::set_channel(unsigned int channel)
+{
+    channel_ = channel;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel(channel_);
+        }
+}
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::set_threshold(float threshold)
+{
+
+	float pfa = configuration_->property(role_+ boost::lexical_cast<std::string>(channel_) + ".pfa", 0.0);
+
+	if(pfa==0.0) pfa = configuration_->property(role_+".pfa", 0.0);
+
+	if(pfa==0.0)
+        {
+            threshold_ = threshold;
+        }
+	else
+        {
+            threshold_ = calculate_threshold(pfa);
+        }
+
+	DLOG(INFO) <<"Channel "<<channel_<<" Threshold = " << threshold_;
+
+	if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_threshold(threshold_);
+        }
+}
+
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::set_doppler_max(unsigned int doppler_max)
+{
+    doppler_max_ = doppler_max;
+
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_doppler_max(doppler_max_);
+        }
+}
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::set_doppler_step(unsigned int doppler_step)
+{
+    doppler_step_ = doppler_step;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_doppler_step(doppler_step_);
+        }
+}
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::set_channel_queue(
+        concurrent_queue<int> *channel_internal_queue)
+{
+    channel_internal_queue_ = channel_internal_queue;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel_queue(channel_internal_queue_);
+        }
+}
+
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::set_gnss_synchro(
+        Gnss_Synchro* gnss_synchro)
+{
+    gnss_synchro_ = gnss_synchro;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_gnss_synchro(gnss_synchro_);
+        }
+}
+
+
+signed int GalileoE5aNoncoherentIQAcquisitionCaf::mag()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            return acquisition_cc_->mag();
+        }
+    else
+        {
+            return 0;
+        }
+}
+
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::init()
+{
+    acquisition_cc_->init();
+    set_local_code();
+}
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::set_local_code()
+{
+	if (item_type_.compare("gr_complex")==0)
+	{
+
+		std::complex<float>* codeI = new std::complex<float>[code_length_];
+		std::complex<float>* codeQ = new std::complex<float>[code_length_];
+
+		if (gnss_synchro_->Signal[0] == '5' && gnss_synchro_->Signal[1] == 'X')
+		    {
+			char a[3];
+			strcpy(a,"5I");
+			galileo_e5_a_code_gen_complex_sampled(codeI, a,
+			                                      gnss_synchro_->PRN, fs_in_, 0);
+
+			strcpy(a,"5Q");
+			galileo_e5_a_code_gen_complex_sampled(codeQ, a,
+			                                      gnss_synchro_->PRN, fs_in_, 0);
+		    }
+		else
+		    {
+			galileo_e5_a_code_gen_complex_sampled(codeI, gnss_synchro_->Signal,
+						              gnss_synchro_->PRN, fs_in_, 0);
+		    }
+		// WARNING: 3ms are coherently integrated. Secondary sequence (1,1,1)
+		// is generated, and modulated in the 'block'.
+		if (Zero_padding == 0) // if no zero_padding
+		    {
+			for (unsigned int i = 0; i < sampled_ms_; i++)
+			    {
+			        memcpy(&(codeI_[i*code_length_]), codeI,
+			             sizeof(gr_complex)*code_length_);
+				if (gnss_synchro_->Signal[0] == '5' && gnss_synchro_->Signal[1] == 'X')
+				    {
+					memcpy(&(codeQ_[i*code_length_]), codeQ,
+					       sizeof(gr_complex)*code_length_);
+				    }
+			    }
+		    }
+		else
+		    {
+			// 1ms code + 1ms zero padding
+		        memcpy(&(codeI_[0]), codeI,
+		             sizeof(gr_complex)*code_length_);
+			if (gnss_synchro_->Signal[0] == '5' && gnss_synchro_->Signal[1] == 'X')
+			    {
+				memcpy(&(codeQ_[0]), codeQ,
+				       sizeof(gr_complex)*code_length_);
+			    }
+		    }
+
+		acquisition_cc_->set_local_code(codeI_,codeQ_);
+		delete[] codeI;
+		delete[] codeQ;
+
+	}
+
+}
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::reset()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_active(true);
+        }
+}
+
+
+float GalileoE5aNoncoherentIQAcquisitionCaf::calculate_threshold(float pfa)
+{
+    //Calculate the threshold
+    unsigned int frequency_bins = 0;
+    for (int doppler = (int)(-doppler_max_); doppler <= (int)doppler_max_; doppler += doppler_step_)
+        {
+            frequency_bins++;
+        }
+    DLOG(INFO) << "Channel " << channel_<< "  Pfa = " << pfa;
+    unsigned int ncells = vector_length_*frequency_bins;
+    double exponent = 1/(double)ncells;
+    double val = pow(1.0 - pfa, exponent);
+    double lambda = double(vector_length_);
+    boost::math::exponential_distribution<double> mydist (lambda);
+    float threshold = (float)quantile(mydist,val);
+
+    return threshold;
+}
+
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::connect(gr::top_block_sptr top_block)
+{
+    // Nothing to connect internally
+}
+
+
+void GalileoE5aNoncoherentIQAcquisitionCaf::disconnect(gr::top_block_sptr top_block)
+{
+    // Nothing to disconnect internally
+}
+
+gr::basic_block_sptr GalileoE5aNoncoherentIQAcquisitionCaf::get_left_block()
+{
+    return acquisition_cc_;
+}
+
+
+gr::basic_block_sptr GalileoE5aNoncoherentIQAcquisitionCaf::get_right_block()
+{
+    return acquisition_cc_;
+}

src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.h

@@ -0,0 +1,165 @@
+/*!
+ * \file galileo_e5a_noncoherent_iq_acquisition_caf.h
+ * \brief Adapts a PCPS acquisition block to an AcquisitionInterface for
+ *  Galileo E5a data and pilot Signals
+  * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          <li> Marc Molina, 2013. marc.molina.pena@gmail.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (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 GALILEO_E5A_NONCOHERENT_IQ_ACQUISITION_CAF_H_
+#define GALILEO_E5A_NONCOHERENT_IQ_ACQUISITION_CAF_H_
+
+#include <string>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/blocks/stream_to_vector.h>
+#include "gnss_synchro.h"
+#include "acquisition_interface.h"
+#include "galileo_e5a_noncoherent_iq_acquisition_caf_cc.h"
+
+class ConfigurationInterface;
+
+class GalileoE5aNoncoherentIQAcquisitionCaf: public AcquisitionInterface
+{
+public:
+    GalileoE5aNoncoherentIQAcquisitionCaf(ConfigurationInterface* configuration,
+            std::string role, unsigned int in_streams,
+            unsigned int out_streams, boost::shared_ptr<gr::msg_queue> queue);
+
+	virtual ~GalileoE5aNoncoherentIQAcquisitionCaf();
+
+	std::string role()
+	    {
+	        return role_;
+	    }
+	/*!
+	 * \brief Returns "Galileo_E5a_Noncoherent_IQ_Acquisition_CAF"
+	 */
+	 std::string implementation()
+	    {
+	        return "Galileo_E5a_Noncoherent_IQ_Acquisition_CAF";
+	    }
+	 size_t item_size()
+	    {
+	        return item_size_;
+	    }
+
+	 void connect(gr::top_block_sptr top_block);
+	 void disconnect(gr::top_block_sptr top_block);
+	 gr::basic_block_sptr get_left_block();
+	 gr::basic_block_sptr get_right_block();
+
+	 /*!
+	  * \brief Set acquisition/tracking common Gnss_Synchro object pointer
+	  * to efficiently exchange synchronization data between acquisition and
+	  *  tracking blocks
+	  */
+	 void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro);
+
+	 /*!
+	  * \brief Set acquisition channel unique ID
+	  */
+	 void set_channel(unsigned int channel);
+
+	 /*!
+	  * \brief Set statistics threshold of PCPS algorithm
+	  */
+	 void set_threshold(float threshold);
+
+	 /*!
+	  * \brief Set maximum Doppler off grid search
+	  */
+	 void set_doppler_max(unsigned int doppler_max);
+
+	 /*!
+	  * \brief Set Doppler steps for the grid search
+	  */
+	 void set_doppler_step(unsigned int doppler_step);
+
+	 /*!
+	  * \brief Set tracking channel internal queue
+	  */
+	 void set_channel_queue(concurrent_queue<int> *channel_internal_queue);
+
+	 /*!
+	  * \brief Initializes acquisition algorithm.
+	  */
+	 void init();
+
+	 /*!
+	  * \brief Sets local Galileo E5a code for PCPS acquisition algorithm.
+	  */
+	 void set_local_code();
+
+	 /*!
+	  * \brief Returns the maximum peak of grid search
+	  */
+	 signed int mag();
+
+	 /*!
+	  * \brief Restart acquisition algorithm
+	  */
+	 void reset();
+
+private:
+	 ConfigurationInterface* configuration_;
+	 galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr acquisition_cc_;
+	 gr::blocks::stream_to_vector::sptr stream_to_vector_;
+	 size_t item_size_;
+	 std::string item_type_;
+	 unsigned int vector_length_;
+	 unsigned int code_length_;
+	 bool bit_transition_flag_;
+	 unsigned int channel_;
+	 float threshold_;
+	 unsigned int doppler_max_;
+	 unsigned int doppler_step_;
+	 unsigned int shift_resolution_;
+	 unsigned int sampled_ms_;
+	 unsigned int max_dwells_;
+	 long fs_in_;
+	 long if_;
+	 bool dump_;
+	 std::string dump_filename_;
+	 int Zero_padding;
+	 int CAF_window_hz_;
+	 std::complex<float> * codeI_;
+	 std::complex<float> * codeQ_;
+	 bool both_signal_components;
+	 Gnss_Synchro * gnss_synchro_;
+	 std::string role_;
+	 unsigned int in_streams_;
+	 unsigned int out_streams_;
+	 boost::shared_ptr<gr::msg_queue> queue_;
+	 concurrent_queue<int> *channel_internal_queue_;
+	 float calculate_threshold(float pfa);
+};
+#endif /* GALILEO_E5A_NONCOHERENT_IQ_ACQUISITION_CAF_H_ */

src/algorithms/acquisition/gnuradio_blocks/CMakeLists.txt

@@ -26,6 +26,7 @@ if(OPENCL_FOUND)
             pcps_cccwsr_acquisition_cc.cc
             pcps_quicksync_acquisition_cc.cc
             galileo_pcps_8ms_acquisition_cc.cc
+            galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc
             pcps_opencl_acquisition_cc.cc # Needs OpenCL
     )
 else(OPENCL_FOUND)
@@ -38,6 +39,7 @@ else(OPENCL_FOUND)
             pcps_cccwsr_acquisition_cc.cc
             pcps_quicksync_acquisition_cc.cc
             galileo_pcps_8ms_acquisition_cc.cc
+            galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc
     )
 endif(OPENCL_FOUND)
 

src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc

@@ -0,0 +1,781 @@
+/*!
+ * \file galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc
+ * \brief Adapts a PCPS acquisition block to an AcquisitionInterface for
+ *  Galileo E5a data and pilot Signals
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          <li> Marc Molina, 2013. marc.molina.pena@gmail.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e5a_noncoherent_iq_acquisition_caf_cc.h"
+#include <sys/time.h>
+#include <sstream>
+#include <gnuradio/io_signature.h>
+#include <glog/logging.h>
+#include <volk/volk.h>
+#include "gnss_signal_processing.h"
+#include "control_message_factory.h"
+
+using google::LogMessage;
+
+galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(
+				 unsigned int sampled_ms,
+                                 unsigned int max_dwells,
+                                 unsigned int doppler_max, long freq, long fs_in,
+                                 int samples_per_ms, int samples_per_code,
+                                 bool bit_transition_flag,
+                                 gr::msg_queue::sptr queue, bool dump,
+                                 std::string dump_filename,
+                                 bool both_signal_components_,
+                                 int CAF_window_hz_,
+                                 int Zero_padding_)
+{
+
+    return galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr(
+            new galileo_e5a_noncoherentIQ_acquisition_caf_cc(sampled_ms, max_dwells, doppler_max, freq, fs_in, samples_per_ms,
+                                     samples_per_code, bit_transition_flag, queue, dump, dump_filename, both_signal_components_, CAF_window_hz_, Zero_padding_));
+}
+
+galileo_e5a_noncoherentIQ_acquisition_caf_cc::galileo_e5a_noncoherentIQ_acquisition_caf_cc(
+			 unsigned int sampled_ms,
+			 unsigned int max_dwells,
+                         unsigned int doppler_max, long freq, long fs_in,
+                         int samples_per_ms, int samples_per_code,
+                         bool bit_transition_flag,
+                         gr::msg_queue::sptr queue, bool dump,
+                         std::string dump_filename,
+                         bool both_signal_components_,
+                         int CAF_window_hz_,
+                         int Zero_padding_) :
+    gr::block("galileo_e5a_noncoherentIQ_acquisition_caf_cc",
+		gr::io_signature::make(1, 1, sizeof(gr_complex)),
+		gr::io_signature::make(0, 0, sizeof(gr_complex)))
+{
+    d_sample_counter = 0;    // SAMPLE COUNTER
+    d_active = false;
+    d_state = 0;
+    d_queue = queue;
+    d_freq = freq;
+    d_fs_in = fs_in;
+    d_samples_per_ms = samples_per_ms;
+    d_samples_per_code = samples_per_code;
+    d_max_dwells = max_dwells;
+    d_well_count = 0;
+    d_doppler_max = doppler_max;
+    if (Zero_padding_ > 0)
+	{
+	    d_sampled_ms = 1;
+	}
+    else
+	{
+	    d_sampled_ms = sampled_ms;
+	}
+    d_fft_size = sampled_ms * d_samples_per_ms;
+    d_mag = 0;
+    d_input_power = 0.0;
+    d_num_doppler_bins = 0;
+    d_bit_transition_flag = bit_transition_flag;
+    d_buffer_count=0;
+    d_both_signal_components = both_signal_components_;
+    d_CAF_window_hz = CAF_window_hz_;
+
+    //todo: do something if posix_memalign fails
+    if (posix_memalign((void**)&d_inbuffer, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_fft_code_I_A, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_magnitudeIA, 16, d_fft_size * sizeof(float)) == 0){};
+
+    if (d_both_signal_components == true)
+	{
+	    if (posix_memalign((void**)&d_fft_code_Q_A, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+	    if (posix_memalign((void**)&d_magnitudeQA, 16, d_fft_size * sizeof(float)) == 0){};
+	}
+    // IF COHERENT INTEGRATION TIME > 1
+    if (d_sampled_ms > 1)
+	{
+	    if (posix_memalign((void**)&d_fft_code_I_B, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+	    if (posix_memalign((void**)&d_magnitudeIB, 16, d_fft_size * sizeof(float)) == 0){};
+	    if (d_both_signal_components == true)
+		{
+		    if (posix_memalign((void**)&d_fft_code_Q_B, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+		    if (posix_memalign((void**)&d_magnitudeQB, 16, d_fft_size * sizeof(float)) == 0){};
+		}
+	}
+
+//    if (posix_memalign((void**)&d_fft_code_Q_A, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+//    if (posix_memalign((void**)&d_magnitudeQA, 16, d_fft_size * sizeof(float)) == 0){};
+//    if (posix_memalign((void**)&d_fft_code_I_B, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+//    if (posix_memalign((void**)&d_magnitudeIB, 16, d_fft_size * sizeof(float)) == 0){};
+//    if (posix_memalign((void**)&d_fft_code_Q_B, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+//    if (posix_memalign((void**)&d_magnitudeQB, 16, d_fft_size * sizeof(float)) == 0){};
+
+    // Direct FFT
+    d_fft_if = new gr::fft::fft_complex(d_fft_size, true);
+
+    // Inverse FFT
+    d_ifft = new gr::fft::fft_complex(d_fft_size, false);
+
+    // For dumping samples into a file
+    d_dump = dump;
+    d_dump_filename = dump_filename;
+}
+
+galileo_e5a_noncoherentIQ_acquisition_caf_cc::~galileo_e5a_noncoherentIQ_acquisition_caf_cc()
+{
+    if (d_num_doppler_bins > 0)
+        {
+            for (unsigned int i = 0; i < d_num_doppler_bins; i++)
+                {
+                    free(d_grid_doppler_wipeoffs[i]);
+                }
+            delete[] d_grid_doppler_wipeoffs;
+        }
+
+    free(d_fft_code_I_A);
+    free(d_magnitudeIA);
+    if (d_both_signal_components == true)
+	{
+	    free(d_fft_code_Q_A);
+	    free(d_magnitudeQA);
+	}
+    // IF INTEGRATION TIME > 1
+    if (d_sampled_ms > 1)
+	{
+	    free(d_fft_code_I_B);
+	    free(d_magnitudeIB);
+	    if (d_both_signal_components == true)
+		{
+		    free(d_fft_code_Q_B);
+		    free(d_magnitudeQB);
+		}
+	}
+
+    delete d_fft_if;
+    delete d_ifft;
+
+
+    if (d_dump)
+        {
+            d_dump_file.close();
+        }
+}
+
+
+void galileo_e5a_noncoherentIQ_acquisition_caf_cc::set_local_code(std::complex<float> * codeI, std::complex<float> * codeQ )
+{
+    // DATA SIGNAL
+    // Three replicas of data primary code. CODE A: (1,1,1)
+    memcpy(d_fft_if->get_inbuf(), codeI, sizeof(gr_complex)*d_fft_size);
+
+    d_fft_if->execute(); // We need the FFT of local code
+
+    //Conjugate the local code
+    if (is_unaligned())
+        {
+            volk_32fc_conjugate_32fc_u(d_fft_code_I_A,d_fft_if->get_outbuf(),d_fft_size);
+        }
+    else
+        {
+            volk_32fc_conjugate_32fc_a(d_fft_code_I_A,d_fft_if->get_outbuf(),d_fft_size);
+        }
+    // SAME FOR PILOT SIGNAL
+    if (d_both_signal_components == true)
+	{
+	    // Three replicas of pilot primary code. CODE A: (1,1,1)
+	    memcpy(d_fft_if->get_inbuf(), codeQ, sizeof(gr_complex)*d_fft_size);
+
+	    d_fft_if->execute(); // We need the FFT of local code
+
+	    //Conjugate the local code
+	    if (is_unaligned())
+	        {
+	            volk_32fc_conjugate_32fc_u(d_fft_code_Q_A,d_fft_if->get_outbuf(),d_fft_size);
+	        }
+	    else
+	        {
+	            volk_32fc_conjugate_32fc_a(d_fft_code_Q_A,d_fft_if->get_outbuf(),d_fft_size);
+	        }
+	}
+    // IF INTEGRATION TIME > 1 code, we need to evaluate the other possible combination
+    // Note: max integration time allowed = 3ms (dealt in adapter)
+    if (d_sampled_ms > 1)
+	{
+	    // DATA CODE B: First replica is inverted (0,1,1)
+	    volk_32fc_s32fc_multiply_32fc_a(&(d_fft_if->get_inbuf())[0],
+	                                    &codeI[0], gr_complex(-1,0),
+	                                    d_samples_per_code);
+	    d_fft_if->execute(); // We need the FFT of local code
+
+	    //Conjugate the local code
+	    if (is_unaligned())
+		{
+		    volk_32fc_conjugate_32fc_u(d_fft_code_I_B,d_fft_if->get_outbuf(),d_fft_size);
+		}
+	    else
+		{
+		    volk_32fc_conjugate_32fc_a(d_fft_code_I_B,d_fft_if->get_outbuf(),d_fft_size);
+		}
+	    if (d_both_signal_components == true)
+		{
+		    // PILOT CODE B: First replica is inverted (0,1,1)
+		    volk_32fc_s32fc_multiply_32fc_a(&(d_fft_if->get_inbuf())[0],
+		                                    &codeQ[0], gr_complex(-1,0),
+		                                    d_samples_per_code);
+		    d_fft_if->execute(); // We need the FFT of local code
+
+		    //Conjugate the local code
+		    if (is_unaligned())
+		        {
+		            volk_32fc_conjugate_32fc_u(d_fft_code_Q_B,d_fft_if->get_outbuf(),d_fft_size);
+		        }
+		    else
+		        {
+		            volk_32fc_conjugate_32fc_a(d_fft_code_Q_B,d_fft_if->get_outbuf(),d_fft_size);
+		        }
+		}
+	}
+}
+
+void galileo_e5a_noncoherentIQ_acquisition_caf_cc::init()
+{
+    d_gnss_synchro->Acq_delay_samples = 0.0;
+    d_gnss_synchro->Acq_doppler_hz = 0.0;
+    d_gnss_synchro->Acq_samplestamp_samples = 0;
+    d_mag = 0.0;
+    d_input_power = 0.0;
+
+    // Count the number of bins
+    d_num_doppler_bins = 0;
+    for (int doppler = (int)(-d_doppler_max);
+         doppler <= (int)d_doppler_max;
+         doppler += d_doppler_step)
+    {
+        d_num_doppler_bins++;
+    }
+
+    // Create the carrier Doppler wipeoff signals
+    d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins];
+    for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
+        {
+            if (posix_memalign((void**)&(d_grid_doppler_wipeoffs[doppler_index]), 16,
+                               d_fft_size * sizeof(gr_complex)) == 0){};
+
+            int doppler = -(int)d_doppler_max + d_doppler_step*doppler_index;
+            complex_exp_gen_conj(d_grid_doppler_wipeoffs[doppler_index],
+                                 d_freq + doppler, d_fs_in, d_fft_size);
+        }
+
+    /* CAF Filtering to resolve doppler ambiguity. Phase and quadrature must be processed
+     * separately before non-coherent integration */
+//    if (d_CAF_filter)
+    if (d_CAF_window_hz > 0)
+	{
+	    if (posix_memalign((void**)&d_CAF_vector, 16, d_num_doppler_bins * sizeof(float)) == 0){};
+	    if (posix_memalign((void**)&d_CAF_vector_I, 16, d_num_doppler_bins * sizeof(float)) == 0){};
+	    if (d_both_signal_components == true)
+		{
+		    if (posix_memalign((void**)&d_CAF_vector_Q, 16, d_num_doppler_bins * sizeof(float)) == 0){};
+		}
+	}
+}
+
+
+int galileo_e5a_noncoherentIQ_acquisition_caf_cc::general_work(int noutput_items,
+        gr_vector_int &ninput_items, gr_vector_const_void_star &input_items,
+        gr_vector_void_star &output_items)
+{
+    /*
+     * By J.Arribas, L.Esteve, M.Molina and M.Sales
+     * Acquisition strategy (Kay Borre book + CFAR threshold):
+     * 1. Compute the input signal power estimation
+     * 2. Doppler serial search loop
+     * 3. Perform the FFT-based circular convolution (parallel time search)
+     * 4. OPTIONAL: CAF filter to avoid doppler ambiguity
+     * 5. Record the maximum peak and the associated synchronization parameters
+     * 6. Compute the test statistics and compare to the threshold
+     * 7. Declare positive or negative acquisition using a message queue
+     */
+
+    int acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
+    /* States: 	0 Stop Channel
+     * 		1 Load the buffer until it reaches fft_size
+     * 		2 Acquisition algorithm
+     * 		3 Positive acquisition
+     * 		4 Negative acquisition
+     */
+    switch (d_state)
+    {
+	case 0:
+	    {
+		if (d_active)
+		    {
+			//restart acquisition variables
+			d_gnss_synchro->Acq_delay_samples = 0.0;
+			d_gnss_synchro->Acq_doppler_hz = 0.0;
+			d_gnss_synchro->Acq_samplestamp_samples = 0;
+			d_well_count = 0;
+			d_mag = 0.0;
+			d_input_power = 0.0;
+			d_test_statistics = 0.0;
+			d_state = 1;
+		    }
+		d_sample_counter += ninput_items[0]; // sample counter
+		consume_each(ninput_items[0]);
+
+		break;
+	    }
+	case 1:
+	    {
+		const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
+		unsigned int buff_increment;
+		if (ninput_items[0]+d_buffer_count <= d_fft_size)
+		    {
+			buff_increment = ninput_items[0];
+		    }
+		else
+		    {
+			buff_increment = (d_fft_size-d_buffer_count);
+		    }
+		memcpy(&d_inbuffer[d_buffer_count], in, sizeof(gr_complex)*buff_increment);
+		// If buffer will be full in next iteration
+		if (d_buffer_count >= d_fft_size-d_gr_stream_buffer)
+		    {
+			d_state=2;
+		    }
+		d_buffer_count += buff_increment;
+		d_sample_counter += buff_increment; // sample counter
+		consume_each(buff_increment);
+		break;
+	    }
+	case 2:
+	    {
+		// Fill last part of the buffer and reset counter
+		const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
+		if (d_buffer_count < d_fft_size)
+		    {
+			memcpy(&d_inbuffer[d_buffer_count], in, sizeof(gr_complex)*(d_fft_size-d_buffer_count));
+		    }
+		d_sample_counter += d_fft_size-d_buffer_count; // sample counter
+
+		// initialize acquisition algorithm
+		int doppler;
+		unsigned int indext = 0;
+		unsigned int indext_IA = 0;
+		unsigned int indext_IB = 0;
+		unsigned int indext_QA = 0;
+		unsigned int indext_QB = 0;
+		float magt = 0.0;
+		float magt_IA = 0.0;
+		float magt_IB = 0.0;
+		float magt_QA = 0.0;
+		float magt_QB = 0.0;
+		float fft_normalization_factor = (float)d_fft_size * (float)d_fft_size;
+		d_input_power = 0.0;
+		d_mag = 0.0;
+		d_well_count++;
+
+		DLOG(INFO) << "Channel: " << d_channel
+			<< " , doing acquisition of satellite: " << d_gnss_synchro->System << " "<< d_gnss_synchro->PRN
+			<< " ,sample stamp: " << d_sample_counter << ", threshold: "
+			<< d_threshold << ", doppler_max: " << d_doppler_max
+			<< ", doppler_step: " << d_doppler_step;
+
+		// 1- Compute the input signal power estimation
+		volk_32fc_magnitude_squared_32f_a(d_magnitudeIA, d_inbuffer, d_fft_size);
+		volk_32f_accumulator_s32f_a(&d_input_power, d_magnitudeIA, d_fft_size);
+		d_input_power /= (float)d_fft_size;
+
+		// 2- Doppler frequency search loop
+		for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+		    {
+			// doppler search steps
+
+			doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+
+			volk_32fc_x2_multiply_32fc_a(d_fft_if->get_inbuf(), d_inbuffer,
+			                             d_grid_doppler_wipeoffs[doppler_index], d_fft_size);
+
+			// 3- Perform the FFT-based convolution  (parallel time search)
+			// Compute the FFT of the carrier wiped--off incoming signal
+			d_fft_if->execute();
+
+			// CODE IA
+			// Multiply carrier wiped--off, Fourier transformed incoming signal
+			// with the local FFT'd code reference using SIMD operations with VOLK library
+			volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
+			                             d_fft_if->get_outbuf(), d_fft_code_I_A, d_fft_size);
+
+			// compute the inverse FFT
+			d_ifft->execute();
+
+			// Search maximum
+			volk_32fc_magnitude_squared_32f_a(d_magnitudeIA, d_ifft->get_outbuf(), d_fft_size);
+			volk_32f_index_max_16u_a(&indext_IA, d_magnitudeIA, d_fft_size);
+			// Normalize the maximum value to correct the scale factor introduced by FFTW
+			magt_IA = d_magnitudeIA[indext_IA] / (fft_normalization_factor * fft_normalization_factor);
+
+			if (d_both_signal_components == true)
+			    {
+				// REPEAT FOR ALL CODES. CODE_QA
+				volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
+				                             d_fft_if->get_outbuf(), d_fft_code_Q_A, d_fft_size);
+				d_ifft->execute();
+				volk_32fc_magnitude_squared_32f_a(d_magnitudeQA, d_ifft->get_outbuf(), d_fft_size);
+				volk_32f_index_max_16u_a(&indext_QA, d_magnitudeQA, d_fft_size);
+				magt_QA = d_magnitudeQA[indext_QA] / (fft_normalization_factor * fft_normalization_factor);
+			    }
+			if (d_sampled_ms > 1) // If Integration time > 1 code
+			    {
+				// REPEAT FOR ALL CODES. CODE_IB
+				volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
+				                             d_fft_if->get_outbuf(), d_fft_code_I_B, d_fft_size);
+				d_ifft->execute();
+				volk_32fc_magnitude_squared_32f_a(d_magnitudeIB, d_ifft->get_outbuf(), d_fft_size);
+				volk_32f_index_max_16u_a(&indext_IB, d_magnitudeIB, d_fft_size);
+				magt_IB = d_magnitudeIB[indext_IB] / (fft_normalization_factor * fft_normalization_factor);
+
+				if (d_both_signal_components == true)
+				    {
+					// REPEAT FOR ALL CODES. CODE_QB
+					volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
+					                             d_fft_if->get_outbuf(), d_fft_code_Q_B, d_fft_size);
+					d_ifft->execute();
+					volk_32fc_magnitude_squared_32f_a(d_magnitudeQB, d_ifft->get_outbuf(), d_fft_size);
+					volk_32f_index_max_16u_a(&indext_QB, d_magnitudeQB, d_fft_size);
+					magt_QB = d_magnitudeIB[indext_QB] / (fft_normalization_factor * fft_normalization_factor);
+				    }
+			    }
+
+			// Integrate noncoherently the two best combinations (I² + Q²)
+			// and store the result in the I channel.
+			// If CAF filter to resolve doppler ambiguity is needed,
+			// peak is stored before non-coherent integration.
+			if (d_sampled_ms > 1) // T_integration > 1 code
+			    {
+				if (magt_IA >= magt_IB)
+				    {
+//					if (d_CAF_filter) {d_CAF_vector_I[doppler_index] = magt_IA;}
+					if (d_CAF_window_hz > 0) {d_CAF_vector_I[doppler_index] = d_magnitudeIA[indext_IA];}
+					if (d_both_signal_components)
+					    {
+						// Integrate non-coherently I+Q
+						if (magt_QA >= magt_QB)
+						    {
+//							if (d_CAF_filter) {d_CAF_vector_Q[doppler_index] = magt_QA;}
+							if (d_CAF_window_hz > 0) {d_CAF_vector_Q[doppler_index] = d_magnitudeQA[indext_QA];}
+							for (unsigned int i=0; i<d_fft_size; i++)
+							    {
+								d_magnitudeIA[i] += d_magnitudeQA[i];
+							    }
+						    }
+						else
+						    {
+//							if (d_CAF_filter) {d_CAF_vector_Q[doppler_index] = magt_QB;}
+							if (d_CAF_window_hz > 0) {d_CAF_vector_Q[doppler_index] = d_magnitudeQB[indext_QB];}
+							for (unsigned int i=0; i<d_fft_size; i++)
+							    {
+								d_magnitudeIA[i] += d_magnitudeQB[i];
+							    }
+						    }
+					    }
+					volk_32f_index_max_16u_a(&indext, d_magnitudeIA, d_fft_size);
+					magt = d_magnitudeIA[indext] / (fft_normalization_factor * fft_normalization_factor);
+				    }
+				else
+				    {
+//					if (d_CAF_filter) {d_CAF_vector_I[doppler_index] = magt_IB;}
+					if (d_CAF_window_hz > 0) {d_CAF_vector_I[doppler_index] = d_magnitudeIB[indext_IB];}
+					if (d_both_signal_components)
+					    {
+						// Integrate non-coherently I+Q
+						if (magt_QA >= magt_QB)
+						    {
+							//if (d_CAF_filter) {d_CAF_vector_Q[doppler_index] = magt_QA;}
+							if (d_CAF_window_hz > 0) {d_CAF_vector_Q[doppler_index] = d_magnitudeQA[indext_QA];}
+							for (unsigned int i=0; i<d_fft_size; i++)
+							    {
+								d_magnitudeIB[i] += d_magnitudeQA[i];
+							    }
+						    }
+						else
+						    {
+//							if (d_CAF_filter) {d_CAF_vector_Q[doppler_index] = magt_QB;}
+							if (d_CAF_window_hz > 0) {d_CAF_vector_Q[doppler_index] = d_magnitudeQB[indext_QB];}
+							for (unsigned int i=0; i<d_fft_size; i++)
+							    {
+								d_magnitudeIB[i] += d_magnitudeQB[i];
+							    }
+						    }
+					    }
+					volk_32f_index_max_16u_a(&indext, d_magnitudeIB, d_fft_size);
+					magt = d_magnitudeIB[indext] / (fft_normalization_factor * fft_normalization_factor);
+				    }
+			    }
+			else
+			    {
+//				if (d_CAF_filter) {d_CAF_vector_I[doppler_index] = magt_IA;}
+				if (d_CAF_window_hz > 0) {d_CAF_vector_I[doppler_index] = d_magnitudeIA[indext_IA];}
+				if (d_both_signal_components)
+				    {
+//					if (d_CAF_filter) {d_CAF_vector_Q[doppler_index] = magt_QA;}
+					if (d_CAF_window_hz > 0) {d_CAF_vector_Q[doppler_index] = d_magnitudeQA[indext_QA];}
+					// NON-Coherent integration of only 1 code
+					for (unsigned int i=0; i<d_fft_size; i++)
+					    {
+						d_magnitudeIA[i] += d_magnitudeQA[i];
+					    }
+				    }
+				volk_32f_index_max_16u_a(&indext, d_magnitudeIA, d_fft_size);
+				magt = d_magnitudeIA[indext] / (fft_normalization_factor * fft_normalization_factor);
+			    }
+
+			// 4- record the maximum peak and the associated synchronization parameters
+			if (d_mag < magt)
+			    {
+				d_mag = magt;
+				// In case that d_bit_transition_flag = true, we compare the potentially
+				// new maximum test statistics (d_mag/d_input_power) with the value in
+				// d_test_statistics. When the second dwell is being processed, the value
+				// of d_mag/d_input_power could be lower than d_test_statistics (i.e,
+				// the maximum test statistics in the previous dwell is greater than
+				// current d_mag/d_input_power). Note that d_test_statistics is not
+				// restarted between consecutive dwells in multidwell operation.
+				if (d_test_statistics < (d_mag / d_input_power) || !d_bit_transition_flag)
+				    {
+					d_gnss_synchro->Acq_delay_samples = (double)(indext % d_samples_per_code);
+					d_gnss_synchro->Acq_doppler_hz = (double)doppler;
+					d_gnss_synchro->Acq_samplestamp_samples = d_sample_counter;
+
+					// 5- Compute the test statistics and compare to the threshold
+					d_test_statistics = d_mag / d_input_power;
+				    }
+			    }
+
+			// Record results to file if required
+			if (d_dump)
+			    {
+				std::stringstream filename;
+				std::streamsize n = sizeof(float) * (d_fft_size); // noncomplex file write
+				filename.str("");
+				filename << "../data/test_statistics_E5a_sat_"
+					<< d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
+				d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
+				if (d_sampled_ms > 1) // If integration time > 1 code
+				    {
+					if (magt_IA >= magt_IB)
+					    {
+						d_dump_file.write((char*)d_magnitudeIA, n);
+					    }
+					else
+					    {
+						d_dump_file.write((char*)d_magnitudeIB, n);
+					    }
+				    }
+				else
+				    {
+					d_dump_file.write((char*)d_magnitudeIA, n);
+				    }
+				d_dump_file.close();
+			    }
+		    }
+//		std::cout << "d_mag " << d_mag << ".d_sample_counter " << d_sample_counter << ". acq delay " << d_gnss_synchro->Acq_delay_samples<< " indext "<< indext << std::endl;
+		// 6 OPTIONAL: CAF filter to avoid Doppler ambiguity in bit transition.
+		if (d_CAF_window_hz > 0)
+		    {
+			int CAF_bins_half;
+			float* accum;
+//			double* accum;
+			if (posix_memalign((void**)&accum, 16, sizeof(float)) == 0){};
+			CAF_bins_half = d_CAF_window_hz/(2*d_doppler_step);
+			float weighting_factor;
+			weighting_factor = 0.5/(float)CAF_bins_half;
+//			weighting_factor = 0;
+//			std::cout << "weighting_factor " << weighting_factor << std::endl;
+			// Initialize first iterations
+			for (int doppler_index=0;doppler_index<CAF_bins_half;doppler_index++)
+			    {
+				d_CAF_vector[doppler_index] = 0;
+//				volk_32f_accumulator_s32f_a(&d_CAF_vector[doppler_index], d_CAF_vector_I, CAF_bins_half+doppler_index+1);
+				for (int i = 0; i < CAF_bins_half+doppler_index+1; i++)
+				    {
+					d_CAF_vector[doppler_index] += d_CAF_vector_I[i] * (1-weighting_factor*(unsigned int)(abs(doppler_index - i)));
+				    }
+//				d_CAF_vector[doppler_index] /= CAF_bins_half+doppler_index+1;
+				d_CAF_vector[doppler_index] /= 1+CAF_bins_half+doppler_index - weighting_factor*CAF_bins_half*(CAF_bins_half+1)/2 - weighting_factor*doppler_index*(doppler_index+1)/2; // triangles = [n*(n+1)/2]
+				if (d_both_signal_components)
+				    {
+					accum[0] = 0;
+//					volk_32f_accumulator_s32f_a(&accum[0], d_CAF_vector_Q, CAF_bins_half+doppler_index+1);
+					for (int i = 0; i < CAF_bins_half+doppler_index+1; i++)
+					    {
+						accum[0] += d_CAF_vector_Q[i] * (1-weighting_factor*(unsigned int)(abs(doppler_index - i)));
+					    }
+//					accum[0] /= CAF_bins_half+doppler_index+1;
+					accum[0] /= 1+CAF_bins_half+doppler_index - weighting_factor*CAF_bins_half*(CAF_bins_half+1)/2 - weighting_factor*doppler_index*(doppler_index+1)/2; // triangles = [n*(n+1)/2]
+					d_CAF_vector[doppler_index] += accum[0];
+				    }
+			    }
+			// Body loop
+			for (unsigned int doppler_index=CAF_bins_half;doppler_index<d_num_doppler_bins-CAF_bins_half;doppler_index++)
+			    {
+				d_CAF_vector[doppler_index] = 0;
+//				volk_32f_accumulator_s32f_a(&d_CAF_vector[doppler_index], &d_CAF_vector_I[doppler_index-CAF_bins_half], 2*CAF_bins_half+1);
+				for (int i = doppler_index-CAF_bins_half; i < doppler_index+CAF_bins_half+1; i++)
+				    {
+					d_CAF_vector[doppler_index] += d_CAF_vector_I[i] * (1-weighting_factor*(unsigned int)(abs(doppler_index - i)));
+				    }
+//				d_CAF_vector[doppler_index] /= 2*CAF_bins_half+1;
+				d_CAF_vector[doppler_index] /= 1+2*CAF_bins_half - 2*weighting_factor*CAF_bins_half*(CAF_bins_half+1)/2;
+				if (d_both_signal_components)
+				    {
+					accum[0] = 0;
+//					volk_32f_accumulator_s32f_a(&accum[0], &d_CAF_vector_Q[doppler_index-CAF_bins_half], 2*CAF_bins_half);
+					for (int i = doppler_index-CAF_bins_half; i < doppler_index+CAF_bins_half+1; i++)
+					    {
+						accum[0] += d_CAF_vector_Q[i] * (1-weighting_factor*(unsigned int)(abs(doppler_index - i)));
+					    }
+//					accum[0] /= 2*CAF_bins_half+1;
+					accum[0] /= 1+2*CAF_bins_half - 2*weighting_factor*CAF_bins_half*(CAF_bins_half+1)/2;
+					d_CAF_vector[doppler_index] += accum[0];
+				    }
+			    }
+			// Final iterations
+			for (unsigned int doppler_index=d_num_doppler_bins-CAF_bins_half;doppler_index<d_num_doppler_bins;doppler_index++)
+			    {
+				d_CAF_vector[doppler_index] = 0;
+//				volk_32f_accumulator_s32f_a(&d_CAF_vector[doppler_index], &d_CAF_vector_I[doppler_index-CAF_bins_half], CAF_bins_half + (d_num_doppler_bins-doppler_index));
+				for (int i = doppler_index-CAF_bins_half; i < d_num_doppler_bins; i++)
+				    {
+					d_CAF_vector[doppler_index] += d_CAF_vector_I[i] * (1-weighting_factor*(abs(doppler_index - i)));
+				    }
+//				d_CAF_vector[doppler_index] /= CAF_bins_half+(d_num_doppler_bins-doppler_index);
+				d_CAF_vector[doppler_index] /= 1+CAF_bins_half+(d_num_doppler_bins-doppler_index-1) -weighting_factor*CAF_bins_half*(CAF_bins_half+1)/2 -weighting_factor*(d_num_doppler_bins-doppler_index-1)*(d_num_doppler_bins-doppler_index)/2;
+				if (d_both_signal_components)
+				    {
+					accum[0] = 0;
+//					volk_32f_accumulator_s32f_a(&accum[0], &d_CAF_vector_Q[doppler_index-CAF_bins_half], CAF_bins_half + (d_num_doppler_bins-doppler_index));
+					for (int i = doppler_index-CAF_bins_half; i < d_num_doppler_bins; i++)
+					    {
+						accum[0] += d_CAF_vector_Q[i] * (1-weighting_factor*(abs(doppler_index - i)));
+					    }
+//					accum[0] /= CAF_bins_half+(d_num_doppler_bins-doppler_index);
+					accum[0] /= 1+CAF_bins_half+(d_num_doppler_bins-doppler_index-1) -weighting_factor*CAF_bins_half*(CAF_bins_half+1)/2 -weighting_factor*(d_num_doppler_bins-doppler_index-1)*(d_num_doppler_bins-doppler_index)/2;
+					d_CAF_vector[doppler_index] += accum[0];
+				    }
+			    }
+
+			// Recompute the maximum doppler peak
+			volk_32f_index_max_16u_a(&indext, d_CAF_vector, d_num_doppler_bins);
+			doppler=-(int)d_doppler_max+d_doppler_step*indext;
+			d_gnss_synchro->Acq_doppler_hz = (double)doppler;
+			// Dump if required, appended at the end of the file
+			if (d_dump)
+			    {
+				std::stringstream filename;
+				std::streamsize n = sizeof(float) * (d_num_doppler_bins); // noncomplex file write
+				filename.str("");
+				filename << "../data/test_statistics_E5a_sat_"
+					<< d_gnss_synchro->PRN << "_CAF.dat";
+				d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
+				d_dump_file.write((char*)d_CAF_vector, n);
+				d_dump_file.close();
+			    }
+		    }
+
+		if (d_well_count == d_max_dwells)
+		    {
+			if (d_test_statistics > d_threshold)
+			    {
+				d_state = 3; // Positive acquisition
+			    }
+			else
+			    {
+				d_state = 4; // Negative acquisition
+			    }
+		    }
+		else
+		    {
+			d_state = 1;
+		    }
+
+		consume_each(d_fft_size-d_buffer_count);
+		d_buffer_count = 0;
+		break;
+	    }
+	case 3:
+	    {
+		// 7.1- Declare positive acquisition using a message queue
+		DLOG(INFO) << "positive acquisition";
+		DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+		DLOG(INFO) << "sample_stamp " << d_sample_counter;
+		DLOG(INFO) << "test statistics value " << d_test_statistics;
+		DLOG(INFO) << "test statistics threshold " << d_threshold;
+		DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+		DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+		DLOG(INFO) << "magnitude " << d_mag;
+		DLOG(INFO) << "input signal power " << d_input_power;
+
+		d_active = false;
+		d_state = 0;
+
+
+		acquisition_message = 1;
+		d_channel_internal_queue->push(acquisition_message);
+		d_sample_counter += ninput_items[0]; // sample counter
+		consume_each(ninput_items[0]);
+		break;
+	    }
+	case 4:
+	    {
+		// 7.2- Declare negative acquisition using a message queue
+		DLOG(INFO) << "negative acquisition";
+		DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+		DLOG(INFO) << "sample_stamp " << d_sample_counter;
+		DLOG(INFO) << "test statistics value " << d_test_statistics;
+		DLOG(INFO) << "test statistics threshold " << d_threshold;
+		DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+		DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+		DLOG(INFO) << "magnitude " << d_mag;
+		DLOG(INFO) << "input signal power " << d_input_power;
+
+		d_active = false;
+		d_state = 0;
+
+		d_sample_counter += ninput_items[0]; // sample counter
+		consume_each(ninput_items[0]);
+		acquisition_message = 2;
+		d_channel_internal_queue->push(acquisition_message);
+		break;
+	    }
+    }
+
+    return 0;
+}
+

src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.h

@@ -0,0 +1,261 @@
+/*!
+ * \file galileo_e5a_noncoherent_iq_acquisition_caf_cc.h
+ * \brief Adapts a PCPS acquisition block to an AcquisitionInterface for
+ *  Galileo E5a data and pilot Signals
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          <li> Marc Molina, 2013. marc.molina.pena@gmail.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (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 GALILEO_E5A_NONCOHERENT_IQ_ACQUISITION_CAF_CC_H_
+#define GALILEO_E5A_NONCOHERENT_IQ_ACQUISITION_CAF_CC_H_
+
+#include <fstream>
+#include <queue>
+#include <string>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include <gnuradio/block.h>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/gr_complex.h>
+#include <gnuradio/fft/fft.h>
+#include "concurrent_queue.h"
+#include "gnss_synchro.h"
+
+class galileo_e5a_noncoherentIQ_acquisition_caf_cc;
+
+typedef boost::shared_ptr<galileo_e5a_noncoherentIQ_acquisition_caf_cc> galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr;
+
+galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr
+galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(unsigned int sampled_ms,
+			 unsigned int max_dwells,
+                         unsigned int doppler_max, long freq, long fs_in,
+                         int samples_per_ms, int samples_per_code,
+                         bool bit_transition_flag,
+                         gr::msg_queue::sptr queue, bool dump,
+                         std::string dump_filename,
+                         bool both_signal_components_,
+                         int CAF_window_hz_,
+                         int Zero_padding_);
+
+/*!
+ * \brief This class implements a Parallel Code Phase Search Acquisition.
+ *
+ * Check \ref Navitec2012 "An Open Source Galileo E1 Software Receiver",
+ * Algorithm 1, for a pseudocode description of this implementation.
+ */
+class galileo_e5a_noncoherentIQ_acquisition_caf_cc: public gr::block
+{
+private:
+    friend galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr
+    galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(
+	    unsigned int sampled_ms,
+	    unsigned int max_dwells,
+            unsigned int doppler_max, long freq, long fs_in,
+            int samples_per_ms, int samples_per_code,
+            bool bit_transition_flag,
+            gr::msg_queue::sptr queue, bool dump,
+            std::string dump_filename,
+            bool both_signal_components_,
+            int CAF_window_hz_,
+            int Zero_padding_);
+
+    galileo_e5a_noncoherentIQ_acquisition_caf_cc(
+	    unsigned int sampled_ms,
+	    unsigned int max_dwells,
+            unsigned int doppler_max, long freq, long fs_in,
+            int samples_per_ms, int samples_per_code,
+            bool bit_transition_flag,
+            gr::msg_queue::sptr queue, bool dump,
+            std::string dump_filename,
+            bool both_signal_components_,
+            int CAF_window_hz_,
+            int Zero_padding_);
+
+    void calculate_magnitudes(gr_complex* fft_begin, int doppler_shift,
+            int doppler_offset);
+    float estimate_input_power(gr_complex *in );
+
+    long d_fs_in;
+    long d_freq;
+    int d_samples_per_ms;
+    int d_sampled_ms;
+    int d_samples_per_code;
+    unsigned int d_doppler_resolution;
+    float d_threshold;
+    std::string d_satellite_str;
+    unsigned int d_doppler_max;
+    unsigned int d_doppler_step;
+    unsigned int d_max_dwells;
+    unsigned int d_well_count;
+    unsigned int d_fft_size;
+    unsigned long int d_sample_counter;
+    gr_complex** d_grid_doppler_wipeoffs;
+    unsigned int d_num_doppler_bins;
+    gr_complex* d_fft_code_I_A;
+    gr_complex* d_fft_code_I_B;
+    gr_complex* d_fft_code_Q_A;
+    gr_complex* d_fft_code_Q_B;
+    gr_complex* d_inbuffer;
+    gr::fft::fft_complex* d_fft_if;
+    gr::fft::fft_complex* d_ifft;
+    Gnss_Synchro *d_gnss_synchro;
+    unsigned int d_code_phase;
+    float d_doppler_freq;
+    float d_mag;
+    float* d_magnitudeIA;
+    float* d_magnitudeIB;
+    float* d_magnitudeQA;
+    float* d_magnitudeQB;
+    float d_input_power;
+    float d_test_statistics;
+    bool d_bit_transition_flag;
+    gr::msg_queue::sptr d_queue;
+    concurrent_queue<int> *d_channel_internal_queue;
+    std::ofstream d_dump_file;
+    bool d_active;
+    int d_state;
+    bool d_dump;
+    bool d_both_signal_components;
+//    bool d_CAF_filter;
+    int d_CAF_window_hz;
+    float* d_CAF_vector;
+    float* d_CAF_vector_I;
+    float* d_CAF_vector_Q;
+//    double* d_CAF_vector;
+//    double* d_CAF_vector_I;
+//    double* d_CAF_vector_Q;
+    unsigned int d_channel;
+    std::string d_dump_filename;
+    unsigned int d_buffer_count;
+    unsigned int d_gr_stream_buffer;
+
+public:
+    /*!
+     * \brief Default destructor.
+     */
+     ~galileo_e5a_noncoherentIQ_acquisition_caf_cc();
+
+     /*!
+      * \brief Set acquisition/tracking common Gnss_Synchro object pointer
+      * to exchange synchronization data between acquisition and tracking blocks.
+      * \param p_gnss_synchro Satellite information shared by the processing blocks.
+      */
+     void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
+     {
+         d_gnss_synchro = p_gnss_synchro;
+     }
+
+     /*!
+      * \brief Returns the maximum peak of grid search.
+      */
+     unsigned int mag()
+     {
+         return d_mag;
+     }
+
+     /*!
+      * \brief Initializes acquisition algorithm.
+      */
+     void init();
+
+     /*!
+      * \brief Sets local code for PCPS acquisition algorithm.
+      * \param code - Pointer to the PRN code.
+      */
+     void set_local_code(std::complex<float> * code, std::complex<float> * codeQ);
+
+     /*!
+      * \brief Starts acquisition algorithm, turning from standby mode to
+      * active mode
+      * \param active - bool that activates/deactivates the block.
+      */
+     void set_active(bool active)
+     {
+         d_active = active;
+     }
+
+     /*!
+      * \brief Set acquisition channel unique ID
+      * \param channel - receiver channel.
+      */
+     void set_channel(unsigned int channel)
+     {
+         d_channel = channel;
+     }
+
+     /*!
+      * \brief Set statistics threshold of PCPS algorithm.
+      * \param threshold - Threshold for signal detection (check \ref Navitec2012,
+      * Algorithm 1, for a definition of this threshold).
+      */
+     void set_threshold(float threshold)
+     {
+         d_threshold = threshold;
+     }
+
+     /*!
+      * \brief Set maximum Doppler grid search
+      * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz].
+      */
+     void set_doppler_max(unsigned int doppler_max)
+     {
+         d_doppler_max = doppler_max;
+     }
+
+     /*!
+      * \brief Set Doppler steps for the grid search
+      * \param doppler_step - Frequency bin of the search grid [Hz].
+      */
+     void set_doppler_step(unsigned int doppler_step)
+     {
+         d_doppler_step = doppler_step;
+     }
+
+
+     /*!
+      * \brief Set tracking channel internal queue.
+      * \param channel_internal_queue - Channel's internal blocks information queue.
+      */
+     void set_channel_queue(concurrent_queue<int> *channel_internal_queue)
+     {
+         d_channel_internal_queue = channel_internal_queue;
+     }
+
+     /*!
+      * \brief Parallel Code Phase Search Acquisition signal processing.
+      */
+     int general_work(int noutput_items, gr_vector_int &ninput_items,
+             gr_vector_const_void_star &input_items,
+             gr_vector_void_star &output_items);
+
+};
+#endif /* GALILEO_E5A_NONCOHERENT_IQ_ACQUISITION_CAF_CC_H_ */

src/algorithms/libs/CMakeLists.txt

@@ -27,6 +27,7 @@ if(OPENCL_FOUND)
          fft_execute.cc # Needs OpenCL
          fft_setup.cc # Needs OpenCL
          fft_kernelstring.cc # Needs OpenCL
+         galileo_e5_signal_processing.cc
     )
 else(OPENCL_FOUND)
     set(GNSS_SPLIBS_SOURCES
@@ -36,6 +37,7 @@ else(OPENCL_FOUND)
          gps_sdr_signal_processing.cc
          nco_lib.cc
          pass_through.cc
+         galileo_e5_signal_processing.cc
     )
 endif(OPENCL_FOUND)
 

src/algorithms/libs/galileo_e5_signal_processing.cc

@@ -0,0 +1,145 @@
+/*!
+ * \file galileo_e5_signal_processing.cc
+ * \brief This library implements various functions for Galileo E5 signals such
+ * as replica code generation
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ *
+ * Detailed description of the file here if needed.
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e5_signal_processing.h"
+
+void galileo_e5_a_code_gen_complex_primary(std::complex<float>* _dest, signed int _prn, char _Signal[3])
+{
+    unsigned int prn=_prn-1;
+    unsigned int index=0;
+    int a[4];
+    if ((_prn < 1) || (_prn > 50))
+	{
+	    return;
+	}
+    if (_Signal[0]=='5' && _Signal[1]=='Q')
+	{
+	    for (size_t i = 0; i < Galileo_E5a_Q_PRIMARY_CODE[prn].length()-1; i++)
+		{
+		    hex_to_binary_converter(a,
+		                            Galileo_E5a_Q_PRIMARY_CODE[prn].at(i));
+		    _dest[index]=std::complex<float>(0.0,float(a[0]));
+		    _dest[index+1]=std::complex<float>(0.0,float(a[1]));
+		    _dest[index+2]=std::complex<float>(0.0,float(a[2]));
+		    _dest[index+3]=std::complex<float>(0.0,float(a[3]));
+		    index = index + 4;
+		}
+	    // last 2 bits are filled up zeros
+	    hex_to_binary_converter(a,
+	    		 Galileo_E5a_Q_PRIMARY_CODE[prn].at(Galileo_E5a_Q_PRIMARY_CODE[prn].length()-1));
+	    _dest[index]=std::complex<float>(float(0.0),a[0]);
+	    _dest[index+1]=std::complex<float>(float(0.0),a[1]);
+	}
+    else if (_Signal[0]=='5' && _Signal[1]=='I')
+	{
+	    for (size_t i = 0; i < Galileo_E5a_I_PRIMARY_CODE[prn].length()-1; i++)
+		{
+		    hex_to_binary_converter(a,
+		                            Galileo_E5a_I_PRIMARY_CODE[prn].at(i));
+		    _dest[index]=std::complex<float>(float(a[0]),0.0);
+		    _dest[index+1]=std::complex<float>(float(a[1]),0.0);
+		    _dest[index+2]=std::complex<float>(float(a[2]),0.0);
+		    _dest[index+3]=std::complex<float>(float(a[3]),0.0);
+		    index = index + 4;
+		}
+	    // last 2 bits are filled up zeros
+	    hex_to_binary_converter(a,
+	    		 Galileo_E5a_I_PRIMARY_CODE[prn].at(Galileo_E5a_I_PRIMARY_CODE[prn].length()-1));
+	    _dest[index]=std::complex<float>(float(a[0]),0.0);
+	    _dest[index+1]=std::complex<float>(float(a[1]),0.0);
+	}
+    else if (_Signal[0]=='5' && _Signal[1]=='X')
+	{
+	    int b[4];
+	    for (size_t i = 0; i < Galileo_E5a_I_PRIMARY_CODE[prn].length()-1; i++)
+		{
+		    hex_to_binary_converter(a,
+		                            Galileo_E5a_I_PRIMARY_CODE[prn].at(i));
+		    hex_to_binary_converter(b,
+		                            Galileo_E5a_Q_PRIMARY_CODE[prn].at(i));
+		    _dest[index]=std::complex<float>(float(a[0]),float(b[0]));
+		    _dest[index+1]=std::complex<float>(float(a[1]),float(b[1]));
+		    _dest[index+2]=std::complex<float>(float(a[2]),float(b[2]));
+		    _dest[index+3]=std::complex<float>(float(a[3]),float(b[3]));
+		    index = index + 4;
+		}
+	    // last 2 bits are filled up zeros
+	    hex_to_binary_converter(a,
+	    		 Galileo_E5a_I_PRIMARY_CODE[prn].at(Galileo_E5a_I_PRIMARY_CODE[prn].length()-1));
+	    hex_to_binary_converter(b,
+	    		 Galileo_E5a_Q_PRIMARY_CODE[prn].at(Galileo_E5a_Q_PRIMARY_CODE[prn].length()-1));
+	    _dest[index]=std::complex<float>(float(a[0]),float(b[0]));
+	    _dest[index+1]=std::complex<float>(float(a[1]),float(b[1]));
+	}
+}
+
+void galileo_e5_a_code_gen_complex_sampled(std::complex<float>* _dest, char _Signal[3],
+		unsigned int _prn, signed int _fs, unsigned int _chip_shift)
+{
+    // This function is based on the GNU software GPS for MATLAB in the Kay Borre book
+
+    unsigned int _samplesPerCode;
+    unsigned int delay;
+    unsigned int _codeLength = Galileo_E5a_CODE_LENGTH_CHIPS;
+    const int _codeFreqBasis = Galileo_E5a_CODE_CHIP_RATE_HZ; //Hz
+
+
+    std::complex<float>* _code;
+    _code=new std::complex<float>[_codeLength];
+
+    galileo_e5_a_code_gen_complex_primary(_code , _prn , _Signal);
+
+    _samplesPerCode = round(_fs / (_codeFreqBasis / _codeLength));
+
+    delay = ((_codeLength - _chip_shift)
+	    % _codeLength) * _samplesPerCode / _codeLength;
+
+
+    if (_fs != _codeFreqBasis)
+        {
+        	std::complex<float>* _resampled_signal;
+        	if (posix_memalign((void**)&_resampled_signal, 16, _samplesPerCode * sizeof(gr_complex)) == 0){};
+        	resampler(_code, _resampled_signal, _codeFreqBasis, _fs,
+        	                    _codeLength, _samplesPerCode); //resamples code to fs
+        	delete[] _code;
+        	_code = _resampled_signal;
+        }
+
+    for (unsigned int i = 0; i < _samplesPerCode; i++)
+        {
+            _dest[(i+delay)%_samplesPerCode] = _code[i];
+        }
+
+    free(_code);
+
+}

src/algorithms/libs/galileo_e5_signal_processing.h

@@ -0,0 +1,60 @@
+/*!
+ * \file galileo_e5_signal_processing.cc
+ * \brief This library implements various functions for Galileo E5 signals such
+ * as replica code generation
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ *
+ * Detailed description of the file here if needed.
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_E5_SIGNAL_PROCESSING_H_
+#define GNSS_SDR_GALILEO_E5_SIGNAL_PROCESSING_H_
+
+#include <complex>
+#include <iostream>
+#include <gnuradio/math.h>
+#include "Galileo_E5a.h"
+#include "gnss_signal_processing.h"
+
+/*!
+ * \brief Generates Galileo E5a code at 1 sample/chip
+ * bool _pilot generates E5aQ code if true and E5aI (data signal) if false.
+ */
+void galileo_e5_a_code_gen_complex_primary(std::complex<float>* _dest, signed int _prn, char _Signal[3]);
+
+
+void galileo_e5_a_code_gen_tiered(std::complex<float>* _dest,std::complex<float>* _primary ,unsigned int _prn, char _Signal[3]);
+
+/*!
+ * \brief Generates Galileo E5a complex code, shifted to the desired chip and sampled at a frequency fs
+ * bool _pilot generates E5aQ code if true and E5aI (data signal) if false.
+ */
+void galileo_e5_a_code_gen_complex_sampled(std::complex<float>* _dest,
+		char _Signal[3], unsigned int _prn, signed int _fs, unsigned int _chip_shift);
+
+
+#endif /* GNSS_SDR_GALILEO_E5_SIGNAL_PROCESSING_H_ */

src/algorithms/libs/gnss_signal_processing.cc

@@ -180,20 +180,14 @@ void resampler(std::complex<float>* _from, std::complex<float>* _dest, float _fs
     //--- Find time constants --------------------------------------------------
     const float _t_in = 1/_fs_in;  // Incoming sampling  period in sec
     const float _t_out = 1/_fs_out;   // Out sampling period in sec
-    for (unsigned int i=0; i<_length_out; i++)
+    for (unsigned int i=0; i<_length_out-1; i++)
         {
             //=== Digitizing =======================================================
             //--- compute index array to read sampled values -------------------------
             _codeValueIndex = ceil((_t_out * ((float)i + 1)) / _t_in) - 1;
-            if (i == _length_out - 1)
-                {
-                    //--- Correct the last index (due to number rounding issues) -----------
-                    _dest[i] = _from[_length_in - 1];
-                }
-            else
-                {
-                    //if repeat the chip -> upsample by nearest neighborhood interpolation
-                    _dest[i] = _from[_codeValueIndex];
-                }
+            //if repeat the chip -> upsample by nearest neighborhood interpolation
+            _dest[i] = _from[_codeValueIndex];
         }
+    //--- Correct the last index (due to number rounding issues) -----------
+    _dest[_length_out-1] = _from[_length_in - 1];
 }

src/algorithms/signal_generator/adapters/signal_generator.cc

@@ -29,11 +29,13 @@
  * -------------------------------------------------------------------------
  */
 
+
 #include "signal_generator.h"
 #include <glog/logging.h>
 #include "configuration_interface.h"
 #include "Galileo_E1.h"
 #include "GPS_L1_CA.h"
+#include "Galileo_E5a.h"
 
 
 using google::LogMessage;
@@ -46,6 +48,7 @@ SignalGenerator::SignalGenerator(ConfigurationInterface* configuration,
     std::string default_item_type = "gr_complex";
     std::string default_dump_file = "./data/gen_source.dat";
     std::string default_system = "G";
+    std::string default_signal = "1C";
 
     item_type_ = configuration->property(role + ".item_type", default_item_type);
     dump_ = configuration->property(role + ".dump", false);
@@ -57,30 +60,42 @@ SignalGenerator::SignalGenerator(ConfigurationInterface* configuration,
     float BW_BB = configuration->property("SignalSource.BW_BB", 1.0);
     unsigned int num_satellites = configuration->property("SignalSource.num_satellites", 1);
 
+    std::vector<std::string> signal1;
     std::vector<std::string> system;
     std::vector<unsigned int> PRN;
     std::vector<float> CN0_dB;
     std::vector<float> doppler_Hz;
     std::vector<unsigned int> delay_chips;
+    std::vector<unsigned int> delay_sec;
 
     for (unsigned int sat_idx = 0; sat_idx < num_satellites; sat_idx++)
         {
             std::string sat = std::to_string(sat_idx);
+            signal1.push_back(configuration->property("SignalSource.signal_" + sat, default_signal));
             system.push_back(configuration->property("SignalSource.system_" + sat, default_system));
             PRN.push_back(configuration->property("SignalSource.PRN_" + sat, 1));
             CN0_dB.push_back(configuration->property("SignalSource.CN0_dB_" + sat, 10));
             doppler_Hz.push_back(configuration->property("SignalSource.doppler_Hz_" + sat, 0));
             delay_chips.push_back(configuration->property("SignalSource.delay_chips_" + sat, 0));
+            delay_sec.push_back(configuration->property("SignalSource.delay_sec_" + sat, 0));
         }
 
-    // If Galileo signal is present                             -> vector duration = 100 ms (25 * 4 ms)
+    // If Galileo signal is present -> vector duration = 100 ms (25 * 4 ms)
     // If there is only GPS signal (Galileo signal not present) -> vector duration = 1 ms
     unsigned int vector_length = 0;
     if (std::find(system.begin(), system.end(), "E") != system.end())
     {
-        vector_length = round((float)fs_in / (Galileo_E1_CODE_CHIP_RATE_HZ
-                                  / Galileo_E1_B_CODE_LENGTH_CHIPS))
-                                  * Galileo_E1_C_SECONDARY_CODE_LENGTH;
+	if (signal1[0].at(0)=='5')
+	    {
+		vector_length = round((float) fs_in / (Galileo_E5a_CODE_CHIP_RATE_HZ
+			/ Galileo_E5a_CODE_LENGTH_CHIPS));
+	    }
+	else
+	    {
+		vector_length = round((float)fs_in / (Galileo_E1_CODE_CHIP_RATE_HZ
+			/ Galileo_E1_B_CODE_LENGTH_CHIPS))
+                                	  * Galileo_E1_C_SECONDARY_CODE_LENGTH;
+	    }
     }
     else if (std::find(system.begin(), system.end(), "G") != system.end())
     {
@@ -92,7 +107,7 @@ SignalGenerator::SignalGenerator(ConfigurationInterface* configuration,
         {
             item_size_ = sizeof(gr_complex);
             DLOG(INFO) << "Item size " << item_size_;
-            gen_source_ = signal_make_generator_c(system, PRN, CN0_dB, doppler_Hz, delay_chips,
+            gen_source_ = signal_make_generator_c(signal1, system, PRN, CN0_dB, doppler_Hz, delay_chips, delay_sec,
                                              data_flag, noise_flag, fs_in, vector_length, BW_BB);
 
             vector_to_stream_ = gr::blocks::vector_to_stream::make(item_size_, vector_length);

src/algorithms/signal_generator/adapters/signal_generator.h

@@ -33,6 +33,7 @@
 #ifndef GNSS_SDR_SIGNAL_GENERATOR_H_
 #define GNSS_SDR_SIGNAL_GENERATOR_H_
 
+
 #include <string>
 #include <vector>
 #include <gnuradio/blocks/file_sink.h>
@@ -45,9 +46,9 @@
 class ConfigurationInterface;
 
 /*!
- * \brief This class generates synthesized GNSS signal.
- *
- */
+* \brief This class generates synthesized GNSS signal.
+*
+*/
 class SignalGenerator: public GNSSBlockInterface
 {
 public:
@@ -62,8 +63,8 @@ public:
     }
 
     /*!
-     * \brief Returns "GNSSSignalGenerator".
-     */
+* \brief Returns "GNSSSignalGenerator".
+*/
     std::string implementation()
     {
         return "GNSSSignalGenerator";
@@ -91,5 +92,4 @@ private:
     gr::blocks::file_sink::sptr file_sink_;
     boost::shared_ptr<gr::msg_queue> queue_;
 };
-
 #endif /*GNSS_SDR_SIGNAL_GENERATOR_H_*/

src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc

@@ -1,32 +1,32 @@
 /*!
- * \file signal_generator_c.cc
- * \brief GNU Radio source block that generates synthesized GNSS signal.
- * \author Marc Molina, 2013. marc.molina.pena@gmail.com
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2014  (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/>.
- *
- * -------------------------------------------------------------------------
- */
+* \file signal_generator_c.cc
+* \brief GNU Radio source block that generates synthesized GNSS signal.
+* \author Marc Molina, 2013. marc.molina.pena@gmail.com
+*
+* -------------------------------------------------------------------------
+*
+* Copyright (C) 2010-2014 (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 <gnuradio/io_signature.h>
 #include <volk/volk.h>
@@ -34,37 +34,41 @@
 #include "gps_sdr_signal_processing.h"
 #include "galileo_e1_signal_processing.h"
 #include "nco_lib.h"
-
-
+#include "galileo_e5_signal_processing.h"
+#include "Galileo_E5a.h"
+#include <iostream>
+#include <fstream>
 /*
- * Create a new instance of signal_generator_c and return
- * a boost shared_ptr.  This is effectively the public constructor.
- */
+* Create a new instance of signal_generator_c and return
+* a boost shared_ptr. This is effectively the public constructor.
+*/
 signal_generator_c_sptr
-signal_make_generator_c (std::vector<std::string> system, const std::vector<unsigned int> &PRN,
+signal_make_generator_c (std::vector<std::string> signal1, std::vector<std::string> system, const std::vector<unsigned int> &PRN,
                     const std::vector<float> &CN0_dB, const std::vector<float> &doppler_Hz,
-                    const std::vector<unsigned int> &delay_chips, bool data_flag, bool noise_flag,
+                    const std::vector<unsigned int> &delay_chips, const std::vector<unsigned int> &delay_sec,bool data_flag, bool noise_flag,
                     unsigned int fs_in, unsigned int vector_length, float BW_BB)
 {
-    return gnuradio::get_initial_sptr(new signal_generator_c(system, PRN, CN0_dB, doppler_Hz, delay_chips,
+    return gnuradio::get_initial_sptr(new signal_generator_c(signal1, system, PRN, CN0_dB, doppler_Hz, delay_chips,delay_sec,
                                                         data_flag, noise_flag, fs_in, vector_length, BW_BB));
 }
 
 /*
- * The private constructor
- */
-signal_generator_c::signal_generator_c (std::vector<std::string> system, const std::vector<unsigned int> &PRN,
+* The private constructor
+*/
+signal_generator_c::signal_generator_c (std::vector<std::string> signal1, std::vector<std::string> system, const std::vector<unsigned int> &PRN,
         const std::vector<float> &CN0_dB, const std::vector<float> &doppler_Hz,
-        const std::vector<unsigned int> &delay_chips, bool data_flag, bool noise_flag,
+        const std::vector<unsigned int> &delay_chips,const std::vector<unsigned int> &delay_sec ,bool data_flag, bool noise_flag,
         unsigned int fs_in, unsigned int vector_length, float BW_BB) :
 
           gr::block ("signal_gen_cc", gr::io_signature::make(0, 0, sizeof(gr_complex)),
                   gr::io_signature::make(1, 1, sizeof(gr_complex)*vector_length)),
+                  signal_(signal1),
                   system_(system),
                   PRN_(PRN),
                   CN0_dB_(CN0_dB),
                   doppler_Hz_(doppler_Hz),
                   delay_chips_(delay_chips),
+                  delay_sec_(delay_sec),
                   data_flag_(data_flag),
                   noise_flag_(noise_flag),
                   fs_in_(fs_in),
@@ -78,6 +82,8 @@ signal_generator_c::signal_generator_c (std::vector<std::string> system, const s
 
 void signal_generator_c::init()
 {
+    work_counter_ = 0;
+
     if (posix_memalign((void**)&complex_phase_, 16, vector_length_ * sizeof(gr_complex)) == 0){};
 
     // True if Galileo satellites are present
@@ -86,8 +92,12 @@ void signal_generator_c::init()
     for (unsigned int sat = 0; sat < num_sats_; sat++)
         {
             start_phase_rad_.push_back(0);
+            current_data_bit_int_.push_back(1);
             current_data_bits_.push_back(gr_complex(1, 0));
             ms_counter_.push_back(0);
+            data_modulation_.push_back((Galileo_E5a_I_SECONDARY_CODE.at(0)=='0' ? 1 : -1));
+            pilot_modulation_.push_back((Galileo_E5a_Q_SECONDARY_CODE[PRN_[sat]].at(0)=='0' ? 1 : -1));
+
 
             if (system_[sat] == "G")
                 {
@@ -99,35 +109,47 @@ void signal_generator_c::init()
                 }
             else if (system_[sat] == "E")
                 {
-                    samples_per_code_.push_back(round((float)fs_in_ / (Galileo_E1_CODE_CHIP_RATE_HZ
-                                        / Galileo_E1_B_CODE_LENGTH_CHIPS)));
+        	    if (signal_[sat].at(0)=='5')
+        		{
+        		    int codelen = (int)Galileo_E5a_CODE_LENGTH_CHIPS;
+        		    samples_per_code_.push_back(round((float)fs_in_ / (Galileo_E5a_CODE_CHIP_RATE_HZ
+        			    / codelen)));
+        		    num_of_codes_per_vector_.push_back(1);
 
-                    num_of_codes_per_vector_.push_back((int)Galileo_E1_C_SECONDARY_CODE_LENGTH);
-                    data_bit_duration_ms_.push_back(1e3/Galileo_E1_B_SYMBOL_RATE_BPS);
+        		    data_bit_duration_ms_.push_back(1e3/Galileo_E5a_SYMBOL_RATE_BPS);
+        		}
+        	    else
+        		{
+        		    samples_per_code_.push_back(round((float)fs_in_ / (Galileo_E1_CODE_CHIP_RATE_HZ
+        			    / Galileo_E1_B_CODE_LENGTH_CHIPS)));
+
+        		    num_of_codes_per_vector_.push_back((int)Galileo_E1_C_SECONDARY_CODE_LENGTH);
+        		    data_bit_duration_ms_.push_back(1e3/Galileo_E1_B_SYMBOL_RATE_BPS);
+        		}
                 }
         }
 
     random_ = new gr::random();
 
-//    std::cout << "fs_in: " << fs_in_ << std::endl;
-//    std::cout << "data_flag: " << data_flag_ << std::endl;
-//    std::cout << "noise_flag_: " << noise_flag_ << std::endl;
-//    std::cout << "num_sats_: " << num_sats_ << std::endl;
-//    std::cout << "vector_length_: " << vector_length_ << std::endl;
-//    std::cout << "BW_BB_: " << BW_BB_ << std::endl;
+// std::cout << "fs_in: " << fs_in_ << std::endl;
+// std::cout << "data_flag: " << data_flag_ << std::endl;
+// std::cout << "noise_flag_: " << noise_flag_ << std::endl;
+// std::cout << "num_sats_: " << num_sats_ << std::endl;
+// std::cout << "vector_length_: " << vector_length_ << std::endl;
+// std::cout << "BW_BB_: " << BW_BB_ << std::endl;
 
-//    for (unsigned int i = 0; i < num_sats_; i++)
-//    {
-//        std::cout << "Sat " << i << ": " << std::endl;
-//        std::cout << "  System " << system_[i] << ": " << std::endl;
-//        std::cout << "  PRN: " << PRN_[i] << std::endl;
-//        std::cout << "  CN0: " << CN0_dB_[i] << std::endl;
-//        std::cout << "  Doppler: " << doppler_Hz_[i] << std::endl;
-//        std::cout << "  Delay: " << delay_chips_[i] << std::endl;
-//        std::cout << "  Samples per code = " << samples_per_code_[i] << std::endl;
-//        std::cout << "  codes per vector = " << num_of_codes_per_vector_[i] << std::endl;
-//        std::cout << "  data_bit_duration = " << data_bit_duration_ms_[i] << std::endl;
-//    }
+// for (unsigned int i = 0; i < num_sats_; i++)
+// {
+// std::cout << "Sat " << i << ": " << std::endl;
+// std::cout << " System " << system_[i] << ": " << std::endl;
+// std::cout << " PRN: " << PRN_[i] << std::endl;
+// std::cout << " CN0: " << CN0_dB_[i] << std::endl;
+// std::cout << " Doppler: " << doppler_Hz_[i] << std::endl;
+// std::cout << " Delay: " << delay_chips_[i] << std::endl;
+// std::cout << " Samples per code = " << samples_per_code_[i] << std::endl;
+// std::cout << " codes per vector = " << num_of_codes_per_vector_[i] << std::endl;
+// std::cout << " data_bit_duration = " << data_bit_duration_ms_[i] << std::endl;
+// }
 }
 
 void signal_generator_c::generate_codes()
@@ -166,61 +188,87 @@ void signal_generator_c::generate_codes()
                 }
             else if (system_[sat] == "E")
                 {
-                    // Generate one code-period of E1B signal
-                    bool cboc = true;
-                    char signal[3];
-                    strcpy(signal, "1B");
+        	    if(signal_[sat].at(0)=='5')
+        		{
+        		    char signal[3];
+        		    strcpy(signal,"5X");
 
-                    galileo_e1_code_gen_complex_sampled(code, signal, cboc, PRN_[sat], fs_in_,
-                                    (int)Galileo_E1_B_CODE_LENGTH_CHIPS - delay_chips_[sat]);
+        		    if (posix_memalign((void**)&(sampled_code_data_[sat]), 16,
+        		                       vector_length_ * sizeof(gr_complex)) == 0){};
 
-                    // Obtain the desired CN0 assuming that Pn = 1.
-                    if (noise_flag_)
-                        {
-                            for (unsigned int i = 0; i < samples_per_code_[sat]; i++)
-                                {
-                                    code[i] *= sqrt(pow(10, CN0_dB_[sat] / 10) / BW_BB_ / 2);
-                                }
-                        }
 
-                    // Concatenate "num_of_codes_per_vector_" codes
-                    for (unsigned int i = 0; i < num_of_codes_per_vector_[sat]; i++)
-                        {
-                            memcpy(&(sampled_code_data_[sat][i*samples_per_code_[sat]]),
-                                   code, sizeof(gr_complex)*samples_per_code_[sat]);
-                        }
+        		    galileo_e5_a_code_gen_complex_sampled(sampled_code_data_[sat] , signal, PRN_[sat], fs_in_,
+        		                                          (int)Galileo_E5a_CODE_LENGTH_CHIPS-delay_chips_[sat]);
 
-                    // Generate E1C signal (25 code-periods, with secondary code)
-                    if (posix_memalign((void**)&(sampled_code_pilot_[sat]), 16,
-                                       vector_length_ * sizeof(gr_complex)) == 0){};
 
-                    strcpy(signal, "1C");
+        		    //noise
+        		    if (noise_flag_)
+        			{
+        			    for (unsigned int i = 0; i < vector_length_; i++)
+        				{
+        				    sampled_code_data_[sat][i] *= sqrt(pow(10, CN0_dB_[sat] / 10) / BW_BB_ / 2);
+        				}
+        			}
 
-                    galileo_e1_code_gen_complex_sampled(sampled_code_pilot_[sat], signal, cboc, PRN_[sat], fs_in_,
-                                                        (int)Galileo_E1_B_CODE_LENGTH_CHIPS-delay_chips_[sat], true);
+        		}
+        	    else
+        		{
+        		    // Generate one code-period of E1B signal
+        		    bool cboc = true;
+        		    char signal[3];
+        		    strcpy(signal, "1B");
 
-                    // Obtain the desired CN0 assuming that Pn = 1.
-                    if (noise_flag_)
-                        {
-                            for (unsigned int i = 0; i < vector_length_; i++)
-                                {
-                                    sampled_code_pilot_[sat][i] *= sqrt(pow(10, CN0_dB_[sat] / 10) / BW_BB_ / 2);
-                                }
-                        }
+        		    galileo_e1_code_gen_complex_sampled(code, signal, cboc, PRN_[sat], fs_in_,
+        		                                        (int)Galileo_E1_B_CODE_LENGTH_CHIPS - delay_chips_[sat]);
+
+        		    // Obtain the desired CN0 assuming that Pn = 1.
+        		    if (noise_flag_)
+        			{
+        			    for (unsigned int i = 0; i < samples_per_code_[sat]; i++)
+        				{
+        				    code[i] *= sqrt(pow(10, CN0_dB_[sat] / 10) / BW_BB_ / 2);
+        				}
+        			}
+
+        		    // Concatenate "num_of_codes_per_vector_" codes
+        		    for (unsigned int i = 0; i < num_of_codes_per_vector_[sat]; i++)
+        			{
+        			    memcpy(&(sampled_code_data_[sat][i*samples_per_code_[sat]]),
+        			           code, sizeof(gr_complex)*samples_per_code_[sat]);
+        			}
+
+        		    // Generate E1C signal (25 code-periods, with secondary code)
+        		    if (posix_memalign((void**)&(sampled_code_pilot_[sat]), 16,
+        		                       vector_length_ * sizeof(gr_complex)) == 0){};
+
+        		    strcpy(signal, "1C");
+
+        		    galileo_e1_code_gen_complex_sampled(sampled_code_pilot_[sat], signal, cboc, PRN_[sat], fs_in_,
+        		                                        (int)Galileo_E1_B_CODE_LENGTH_CHIPS-delay_chips_[sat], true);
+
+        		    // Obtain the desired CN0 assuming that Pn = 1.
+        		    if (noise_flag_)
+        			{
+        			    for (unsigned int i = 0; i < vector_length_; i++)
+        				{
+        				    sampled_code_pilot_[sat][i] *= sqrt(pow(10, CN0_dB_[sat] / 10) / BW_BB_ / 2);
+        				}
+        			}
+        		}
                 }
         }
 }
 
 
 /*
- * Our virtual destructor.
- */
+* Our virtual destructor.
+*/
 signal_generator_c::~signal_generator_c()
 {
     for (unsigned int sat = 0; sat < num_sats_; sat++)
         {
             free(sampled_code_data_[sat]);
-            if (system_[sat] == "E")
+            if (system_[sat] == "E" && signal_[sat].at(0)!='5')
                 {
                     free(sampled_code_pilot_[sat]);
                 }
@@ -232,11 +280,13 @@ signal_generator_c::~signal_generator_c()
 
 int signal_generator_c::general_work (int noutput_items,
                    gr_vector_int &ninput_items,
-			       gr_vector_const_void_star &input_items,
-			       gr_vector_void_star &output_items)
+gr_vector_const_void_star &input_items,
+gr_vector_void_star &output_items)
 {
     gr_complex *out = (gr_complex *) output_items[0];
 
+    work_counter_++;
+
     unsigned int out_idx = 0;
     unsigned int i = 0;
     unsigned int k = 0;
@@ -290,36 +340,74 @@ int signal_generator_c::general_work (int noutput_items,
 
             else if (system_[sat] == "E")
                 {
-                    unsigned int delay_samples = (delay_chips_[sat] % (int)Galileo_E1_B_CODE_LENGTH_CHIPS)
-                                                    * samples_per_code_[sat] / Galileo_E1_B_CODE_LENGTH_CHIPS;
+        	    if(signal_[sat].at(0)=='5')
+        		{
+        		    // EACH WORK outputs 1 modulated primary code
+        		    int codelen = (int)Galileo_E5a_CODE_LENGTH_CHIPS;
+        		    unsigned int delay_samples = (delay_chips_[sat] % codelen)
+        		                	      * samples_per_code_[sat] / codelen;
+			    for (k = 0; k < delay_samples; k++)
+				{
+				    out[out_idx] += (gr_complex(sampled_code_data_[sat][out_idx].real()*data_modulation_[sat] ,
+				                                sampled_code_data_[sat][out_idx].imag()*pilot_modulation_[sat]) )
+					    * complex_phase_[out_idx];
+				    out_idx++;
+				}
 
-                    for (i = 0; i < num_of_codes_per_vector_[sat]; i++)
-                        {
-                            for (k = 0; k < delay_samples; k++)
-                                {
-                                    out[out_idx] += (sampled_code_data_[sat][out_idx] * current_data_bits_[sat]
-                                                    -  sampled_code_pilot_[sat][out_idx])
-                                                    * complex_phase_[out_idx];
-                                    out_idx++;
-                                }
+			    if (ms_counter_[sat]%data_bit_duration_ms_[sat] == 0 && data_flag_)
+				{
+				    // New random data bit
+				    current_data_bit_int_[sat] = (rand()%2) == 0 ? 1 : -1;
+				}
+        		    data_modulation_[sat] = current_data_bit_int_[sat] * (Galileo_E5a_I_SECONDARY_CODE.at((ms_counter_[sat]+delay_sec_[sat])%20)=='0' ? 1 : -1);
+        		    pilot_modulation_[sat] = (Galileo_E5a_Q_SECONDARY_CODE[PRN_[sat]-1].at((ms_counter_[sat]+delay_sec_[sat])%100)=='0' ? 1 : -1);
 
-                            if (ms_counter_[sat] == 0 && data_flag_)
-                                {
-                                    // New random data bit
-                                    current_data_bits_[sat] = gr_complex((rand()%2) == 0 ? 1 : -1, 0);
-                                }
+        		    ms_counter_[sat] = ms_counter_[sat] + (int)round(1e3*GALILEO_E5a_CODE_PERIOD);
 
-                            for (k = delay_samples; k < samples_per_code_[sat]; k++)
-                                {
-                                    out[out_idx] += (sampled_code_data_[sat][out_idx] * current_data_bits_[sat]
-                                                    - sampled_code_pilot_[sat][out_idx])
-                                                    * complex_phase_[out_idx];
-                                    out_idx++;
-                                }
+			    for (k = delay_samples; k < samples_per_code_[sat]; k++)
+				{
+				    out[out_idx] += (gr_complex(sampled_code_data_[sat][out_idx].real()*data_modulation_[sat] ,
+				                                sampled_code_data_[sat][out_idx].imag()*pilot_modulation_[sat]) )
+					    * complex_phase_[out_idx];
+				    out_idx++;
+				}
 
-                            ms_counter_[sat] = (ms_counter_[sat] + (int)round(1e3*Galileo_E1_CODE_PERIOD))
-                                                % data_bit_duration_ms_[sat];
-                        }
+        		}
+        	    else
+        		{
+        		    unsigned int delay_samples = (delay_chips_[sat] % (int)Galileo_E1_B_CODE_LENGTH_CHIPS)
+        		                	      * samples_per_code_[sat] / Galileo_E1_B_CODE_LENGTH_CHIPS;
+
+        		    for (i = 0; i < num_of_codes_per_vector_[sat]; i++)
+        			{
+        			    for (k = 0; k < delay_samples; k++)
+        				{
+        				    out[out_idx] += (sampled_code_data_[sat][out_idx] * current_data_bits_[sat]
+        				                                                                           - sampled_code_pilot_[sat][out_idx])
+        				                                                                           * complex_phase_[out_idx];
+        				    out_idx++;
+        				}
+
+        			    if (ms_counter_[sat] == 0 && data_flag_)
+        				{
+        				    // New random data bit
+        				    current_data_bits_[sat] = gr_complex((rand()%2) == 0 ? 1 : -1, 0);
+        				}
+
+        			    for (k = delay_samples; k < samples_per_code_[sat]; k++)
+        				{
+        				    out[out_idx] += (sampled_code_data_[sat][out_idx] * current_data_bits_[sat]
+        				                                                                           - sampled_code_pilot_[sat][out_idx])
+        				                                                                           * complex_phase_[out_idx];
+        				    out_idx++;
+        				}
+
+
+        			    ms_counter_[sat] = (ms_counter_[sat] + (int)round(1e3*Galileo_E1_CODE_PERIOD))
+                        	                                        	   % data_bit_duration_ms_[sat];
+
+        			}
+        		}
                 }
         }
 
@@ -334,4 +422,3 @@ int signal_generator_c::general_work (int noutput_items,
     // Tell runtime system how many output items we produced.
     return 1;
 }
-

src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h

@@ -38,42 +38,39 @@
 #include <gnuradio/block.h>
 #include "gnss_signal.h"
 
-
-
-
 class signal_generator_c;
 
 /*
- * We use boost::shared_ptr's instead of raw pointers for all access
- * to gr_blocks (and many other data structures).  The shared_ptr gets
- * us transparent reference counting, which greatly simplifies storage
- * management issues.
- *
- * See http://www.boost.org/libs/smart_ptr/smart_ptr.htm
- *
- * As a convention, the _sptr suffix indicates a boost::shared_ptr
- */
+* We use boost::shared_ptr's instead of raw pointers for all access
+* to gr_blocks (and many other data structures). The shared_ptr gets
+* us transparent reference counting, which greatly simplifies storage
+* management issues.
+*
+* See http://www.boost.org/libs/smart_ptr/smart_ptr.htm
+*
+* As a convention, the _sptr suffix indicates a boost::shared_ptr
+*/
 typedef boost::shared_ptr<signal_generator_c> signal_generator_c_sptr;
 
 /*!
- * \brief Return a shared_ptr to a new instance of gen_source.
- *
- * To avoid accidental use of raw pointers, gen_source's
- * constructor is private. signal_make_generator_c is the public
- * interface for creating new instances.
- */
+* \brief Return a shared_ptr to a new instance of gen_source.
+*
+* To avoid accidental use of raw pointers, gen_source's
+* constructor is private. signal_make_generator_c is the public
+* interface for creating new instances.
+*/
 signal_generator_c_sptr
-signal_make_generator_c (std::vector<std::string> system, const std::vector<unsigned int> &PRN,
+signal_make_generator_c (std::vector<std::string> signal1, std::vector<std::string> system, const std::vector<unsigned int> &PRN,
                     const std::vector<float> &CN0_dB, const std::vector<float> &doppler_Hz,
-                    const std::vector<unsigned int> &delay_chips, bool data_flag, bool noise_flag,
+                    const std::vector<unsigned int> &delay_chips,const std::vector<unsigned int> &delay_sec, bool data_flag, bool noise_flag,
                     unsigned int fs_in, unsigned int vector_length, float BW_BB);
 
 /*!
- * \brief This class generates synthesized GNSS signal.
- * \ingroup block
- *
- * \sa gen_source for a version that subclasses gr_block.
- */
+* \brief This class generates synthesized GNSS signal.
+* \ingroup block
+*
+* \sa gen_source for a version that subclasses gr_block.
+*/
 class signal_generator_c : public gr::block
 {
 private:
@@ -82,24 +79,26 @@ private:
 
     /* Create the signal_generator_c object*/
     friend signal_generator_c_sptr
-    signal_make_generator_c (std::vector<std::string> system, const std::vector<unsigned int> &PRN,
+    signal_make_generator_c (std::vector<std::string> signal1, std::vector<std::string> system, const std::vector<unsigned int> &PRN,
             const std::vector<float> &CN0_dB, const std::vector<float> &doppler_Hz,
-            const std::vector<unsigned int> &delay_chips, bool data_flag, bool noise_flag,
+            const std::vector<unsigned int> &delay_chips,const std::vector<unsigned int> &delay_sec, bool data_flag, bool noise_flag,
             unsigned int fs_in, unsigned int vector_length, float BW_BB);
 
-    signal_generator_c (std::vector<std::string> system, const std::vector<unsigned int> &PRN,
+    signal_generator_c (std::vector<std::string> signal1, std::vector<std::string> system, const std::vector<unsigned int> &PRN,
             const std::vector<float> &CN0_dB, const std::vector<float> &doppler_Hz,
-            const std::vector<unsigned int> &delay_chips, bool data_flag, bool noise_flag,
+            const std::vector<unsigned int> &delay_chips,const std::vector<unsigned int> &delay_sec, bool data_flag, bool noise_flag,
             unsigned int fs_in, unsigned int vector_length, float BW_BB);
 
     void init();
     void generate_codes();
 
+    std::vector<std::string> signal_;
     std::vector<std::string> system_;
     std::vector<unsigned int> PRN_;
     std::vector<float> CN0_dB_;
     std::vector<float> doppler_Hz_;
     std::vector<unsigned int> delay_chips_;
+    std::vector<unsigned int> delay_sec_;
     bool data_flag_;
     bool noise_flag_;
     unsigned int fs_in_;
@@ -113,12 +112,17 @@ private:
     std::vector<unsigned int> ms_counter_;
     std::vector<float> start_phase_rad_;
     std::vector<gr_complex> current_data_bits_;
+    std::vector<signed int> current_data_bit_int_;
+    std::vector<signed int> data_modulation_;
+    std::vector<signed int> pilot_modulation_;
 
     boost::scoped_array<gr_complex*> sampled_code_data_;
     boost::scoped_array<gr_complex*> sampled_code_pilot_;
     gr::random* random_;
     gr_complex* complex_phase_;
 
+    unsigned int work_counter_;
+
 public:
     ~signal_generator_c ();	// public destructor
 
@@ -131,3 +135,4 @@ public:
 };
 
 #endif /* GNSS_SDR_SIGNAL_GENERATOR_C_H */
+

src/algorithms/telemetry_decoder/adapters/CMakeLists.txt

@@ -20,6 +20,7 @@ set(TELEMETRY_DECODER_ADAPTER_SOURCES
 	gps_l1_ca_telemetry_decoder.cc 
 	galileo_e1b_telemetry_decoder.cc
 	sbas_l1_telemetry_decoder.cc
+	galileo_e5a_telemetry_decoder.cc
 )
 
 include_directories(
@@ -29,6 +30,7 @@ include_directories(
      ${CMAKE_SOURCE_DIR}/src/core/receiver
      ${CMAKE_SOURCE_DIR}/src/algorithms/telemetry_decoder/gnuradio_blocks
      ${CMAKE_SOURCE_DIR}/src/algorithms/telemetry_decoder/libs
+     ${Boost_INCLUDE_DIRS}
      ${GLOG_INCLUDE_DIRS}
      ${GFlags_INCLUDE_DIRS}
      ${GNURADIO_RUNTIME_INCLUDE_DIRS}
@@ -37,4 +39,4 @@ include_directories(
 file(GLOB TELEMETRY_DECODER_ADAPTER_HEADERS "*.h")
 add_library(telemetry_decoder_adapters ${TELEMETRY_DECODER_ADAPTER_SOURCES} ${TELEMETRY_DECODER_ADAPTER_HEADERS})
 source_group(Headers FILES ${TELEMETRY_DECODER_ADAPTER_HEADERS})
-target_link_libraries(telemetry_decoder_adapters telemetry_decoder_gr_blocks)
+target_link_libraries(telemetry_decoder_adapters telemetry_decoder_gr_blocks ${GNURADIO_RUNTIME_LIBRARIES})

src/algorithms/telemetry_decoder/adapters/galileo_e1b_telemetry_decoder.h

@@ -38,6 +38,7 @@
 #include <gnuradio/msg_queue.h>
 #include "telemetry_decoder_interface.h"
 #include "galileo_e1b_telemetry_decoder_cc.h"
+#include "gnss_satellite.h"
 
 
 

src/algorithms/telemetry_decoder/adapters/galileo_e5a_telemetry_decoder.cc

@@ -0,0 +1,122 @@
+/*!
+ * \file galileo_e5a_telemetry_decoder.h
+ * \brief Interface of an adapter of a GALILEO E5a FNAV data decoder block
+ * to a TelemetryDecoderInterface
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          </ul>
+ *
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e5a_telemetry_decoder.h"
+#include <boost/shared_ptr.hpp>
+#include <gnuradio/io_signature.h>
+#include <glog/logging.h>
+#include "galileo_ephemeris.h"
+#include "galileo_almanac.h"
+#include "galileo_iono.h"
+#include "galileo_utc_model.h"
+#include "configuration_interface.h"
+#include "galileo_e5a_telemetry_decoder_cc.h"
+
+extern concurrent_queue<Galileo_Ephemeris> global_galileo_ephemeris_queue;
+extern concurrent_queue<Galileo_Iono> global_galileo_iono_queue;
+extern concurrent_queue<Galileo_Utc_Model> global_galileo_utc_model_queue;
+extern concurrent_queue<Galileo_Almanac> global_galileo_almanac_queue;
+
+
+using google::LogMessage;
+
+GalileoE5aTelemetryDecoder::GalileoE5aTelemetryDecoder(ConfigurationInterface* configuration,
+        std::string role,
+        unsigned int in_streams,
+        unsigned int out_streams,
+        boost::shared_ptr<gr::msg_queue> queue) :
+        role_(role),
+        in_streams_(in_streams),
+        out_streams_(out_streams),
+        queue_(queue)
+{
+    std::string default_item_type = "gr_complex";
+    std::string default_dump_filename = "./navigation.dat";
+    DLOG(INFO) << "role " << role;
+    DLOG(INFO) << "vector length " << vector_length_;
+    vector_length_ = configuration->property(role + ".vector_length", 2048);
+    dump_ = configuration->property(role + ".dump", false);
+    dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
+    int fs_in;
+    fs_in = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
+    // make telemetry decoder object
+    telemetry_decoder_ = galileo_e5a_make_telemetry_decoder_cc(satellite_, 0, (long)fs_in, vector_length_, queue_, dump_); // TODO fix me
+    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
+    // set the navigation msg queue;
+    telemetry_decoder_->set_ephemeris_queue(&global_galileo_ephemeris_queue);
+    telemetry_decoder_->set_iono_queue(&global_galileo_iono_queue);
+    telemetry_decoder_->set_almanac_queue(&global_galileo_almanac_queue);
+    telemetry_decoder_->set_utc_model_queue(&global_galileo_utc_model_queue);
+
+    DLOG(INFO) << "global navigation message queue assigned to telemetry_decoder ("<< telemetry_decoder_->unique_id() << ")";
+}
+
+
+GalileoE5aTelemetryDecoder::~GalileoE5aTelemetryDecoder()
+{}
+
+
+void GalileoE5aTelemetryDecoder::set_satellite(Gnss_Satellite satellite)
+{
+    satellite_ = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
+    telemetry_decoder_->set_satellite(satellite_);
+    DLOG(INFO) << "TELEMETRY DECODER: satellite set to " << satellite_;
+}
+
+
+void GalileoE5aTelemetryDecoder::connect(gr::top_block_sptr top_block)
+{
+    // Nothing to connect internally
+    DLOG(INFO) << "nothing to connect internally";
+}
+
+
+void GalileoE5aTelemetryDecoder::disconnect(gr::top_block_sptr top_block)
+{
+    // Nothing to disconnect
+}
+
+
+gr::basic_block_sptr GalileoE5aTelemetryDecoder::get_left_block()
+{
+    return telemetry_decoder_;
+}
+
+
+gr::basic_block_sptr GalileoE5aTelemetryDecoder::get_right_block()
+{
+    return telemetry_decoder_;
+}

src/algorithms/telemetry_decoder/adapters/galileo_e5a_telemetry_decoder.h

@@ -0,0 +1,102 @@
+/*!
+ * \file galileo_e5a_telemetry_decoder.h
+ * \brief Interface of an adapter of a GALILEO E5a FNAV data decoder block
+ * to a TelemetryDecoderInterface
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          </ul>
+ *
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_E5A_TELEMETRY_DECODER_H_
+#define GNSS_SDR_GALILEO_E5A_TELEMETRY_DECODER_H_
+
+#include <string>
+#include <gnuradio/msg_queue.h>
+#include "telemetry_decoder_interface.h"
+#include "galileo_e5a_telemetry_decoder_cc.h"
+
+
+class ConfigurationInterface;
+
+/*!
+ * \brief This class implements a NAV data decoder for Galileo INAV frames in E1B radio link
+ */
+class GalileoE5aTelemetryDecoder: public TelemetryDecoderInterface
+{
+public:
+	GalileoE5aTelemetryDecoder(ConfigurationInterface* configuration,
+            std::string role,
+            unsigned int in_streams,
+            unsigned int out_streams,
+            boost::shared_ptr<gr::msg_queue> queue);
+
+    virtual ~GalileoE5aTelemetryDecoder();
+    std::string role()
+    {
+        return role_;
+    }
+
+    /*!
+     * \brief Returns "Galileo_E5a_Telemetry_Decoder"
+     */
+    std::string implementation()
+    {
+        return "Galileo_E5A_Telemetry_Decoder";
+    }
+    void connect(gr::top_block_sptr top_block);
+    void disconnect(gr::top_block_sptr top_block);
+    gr::basic_block_sptr get_left_block();
+    gr::basic_block_sptr get_right_block();
+    void set_satellite(Gnss_Satellite satellite);
+    void set_channel(int channel){telemetry_decoder_->set_channel(channel);}
+    void reset()
+    {
+        return;
+    }
+    size_t item_size()
+    {
+        return 0;
+    }
+
+private:
+    galileo_e5a_telemetry_decoder_cc_sptr telemetry_decoder_;
+    Gnss_Satellite satellite_;
+    int channel_;
+    unsigned int vector_length_;
+    std::string item_type_;
+    bool dump_;
+    std::string dump_filename_;
+    std::string role_;
+    unsigned int in_streams_;
+    unsigned int out_streams_;
+    boost::shared_ptr<gr::msg_queue> queue_;
+};
+
+#endif /* GNSS_SDR_GALILEO_E5A_TELEMETRY_DECODER_H_ */

src/algorithms/telemetry_decoder/gnuradio_blocks/CMakeLists.txt

@@ -20,6 +20,7 @@ set(TELEMETRY_DECODER_GR_BLOCKS_SOURCES
      gps_l1_ca_telemetry_decoder_cc.cc
      galileo_e1b_telemetry_decoder_cc.cc
      sbas_l1_telemetry_decoder_cc.cc
+     galileo_e5a_telemetry_decoder_cc
 )
       
 include_directories(

src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_e5a_telemetry_decoder_cc.cc

@@ -0,0 +1,638 @@
+/*!
+ * \file galileo_e5a_telemetry_decoder_cc.cc
+ * \brief Implementation of a Galileo FNAV message demodulator block
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          </ul>
+ *
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e5a_telemetry_decoder_cc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <sstream>
+#include <boost/lexical_cast.hpp>
+#include <gnuradio/io_signature.h>
+#include <glog/logging.h>
+#include "control_message_factory.h"
+//#include "galileo_navigation_message.h"
+#include "galileo_fnav_message.h"
+#include "gnss_synchro.h"
+#include "convolutional.h"
+//#include <volk/volk.h>
+//#include "galileo_e1b_telemetry_decoder_cc.h"
+
+#define CRC_ERROR_LIMIT 6
+
+using google::LogMessage;
+
+
+galileo_e5a_telemetry_decoder_cc_sptr
+galileo_e5a_make_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, long fs_in, unsigned
+		int vector_length, boost::shared_ptr<gr::msg_queue> queue, bool dump)
+{
+    return galileo_e5a_telemetry_decoder_cc_sptr(new galileo_e5a_telemetry_decoder_cc(satellite, if_freq,
+            fs_in, vector_length, queue, dump));
+}
+
+void galileo_e5a_telemetry_decoder_cc::forecast (int noutput_items, gr_vector_int &ninput_items_required)
+{
+    //ninput_items_required[0] = GALILEO_FNAV_SAMPLES_PER_PAGE; // set the required sample history
+    ninput_items_required[0] = GALILEO_FNAV_CODES_PER_PREAMBLE;
+}
+
+void galileo_e5a_telemetry_decoder_cc::viterbi_decoder(double *page_part_symbols, int *page_part_bits)
+{
+//    int CodeLength = 240;
+    int CodeLength = 488;
+    int DataLength;
+    int nn, KK, mm, max_states;
+    int g_encoder[2];
+
+    nn = 2;             // Coding rate 1/n
+    KK = 7;             // Constraint Length
+    g_encoder[0] = 121; // Polynomial G1
+    g_encoder[1] = 91;  // Polynomial G2
+//    g_encoder[0] = 171; // Polynomial G1
+//    g_encoder[1] = 133;  // Polynomial G2
+
+    mm = KK - 1;
+    max_states = 1 << mm; // 2^mm
+    DataLength = (CodeLength/nn) - mm;
+
+    //create appropriate transition matrices
+
+    int *out0, *out1, *state0, *state1;
+    out0 = (int*)calloc( max_states, sizeof(int) );
+    out1 = (int*)calloc( max_states, sizeof(int) );
+    state0 = (int*)calloc( max_states, sizeof(int) );
+    state1 = (int*)calloc( max_states, sizeof(int) );
+
+    nsc_transit( out0, state0, 0, g_encoder, KK, nn );
+    nsc_transit( out1, state1, 1, g_encoder, KK, nn );
+
+    Viterbi(page_part_bits, out0, state0, out1, state1,
+            page_part_symbols, KK, nn, DataLength );
+
+    //Clean up memory
+    free( out0 );
+    free( out1 );
+    free( state0 );
+    free( state1 );
+}
+
+
+void galileo_e5a_telemetry_decoder_cc::deinterleaver(int rows, int cols, double *in, double *out)
+{
+    for (int r = 0; r < rows; r++)
+        {
+            for(int c = 0; c < cols; c++)
+                {
+                    out[c*rows + r] = in[r*cols + c];
+                }
+        }
+}
+
+void galileo_e5a_telemetry_decoder_cc::decode_word(double *page_symbols,int frame_length)
+{
+    double page_symbols_deint[frame_length];
+    // 1. De-interleave
+
+    galileo_e5a_telemetry_decoder_cc::deinterleaver(GALILEO_FNAV_INTERLEAVER_ROWS, GALILEO_FNAV_INTERLEAVER_COLS, page_symbols, page_symbols_deint);
+
+    // 2. Viterbi decoder
+    // 2.1 Take into account the NOT gate in G2 polynomial (Galileo ICD Figure 13, FEC encoder)
+    // 2.2 Take into account the possible inversion of the polarity due to PLL lock at 180<38>
+    for (int i = 0; i < frame_length; i++)
+        {
+            if ((i + 1) % 2 == 0)
+                {
+                    page_symbols_deint[i] = -page_symbols_deint[i];
+                }
+        }
+    int page_bits[frame_length/2];
+    galileo_e5a_telemetry_decoder_cc::viterbi_decoder(page_symbols_deint, page_bits);
+
+    // 3. Call the Galileo page decoder
+    std::string page_String;
+    for(int i = 0; i < frame_length; i++)
+        {
+            if (page_bits[i] > 0)
+                {
+                    page_String.push_back('1');
+                }
+            else
+                {
+                    page_String.push_back('0');
+                }
+        }
+
+    // DECODE COMPLETE WORD (even + odd) and TEST CRC
+    d_nav.split_page(page_String);
+    if(d_nav.flag_CRC_test == true)
+        {
+            LOG(INFO) << "Galileo CRC correct on channel " << d_channel;
+            std::cout << "Galileo CRC correct on channel " << d_channel << std::endl;
+        }
+    else
+        {
+            std::cout << "Galileo CRC error on channel " << d_channel << std::endl;
+            LOG(INFO)<< "Galileo CRC error on channel " << d_channel;
+        }
+
+    // 4. Push the new navigation data to the queues
+     if (d_nav.have_new_ephemeris() == true)
+         {
+             // get ephemeris object for this SV
+             Galileo_Ephemeris ephemeris = d_nav.get_ephemeris();//notice that the read operation will clear the valid flag
+             //std::cout<<"New Galileo Ephemeris received for SV "<<d_satellite.get_PRN()<<std::endl;
+             d_ephemeris_queue->push(ephemeris);
+         }
+     if (d_nav.have_new_iono_and_GST() == true)
+         {
+             Galileo_Iono iono = d_nav.get_iono(); //notice that the read operation will clear the valid flag
+             //std::cout<<"New Galileo IONO model (and UTC) received for SV "<<d_satellite.get_PRN()<<std::endl;
+             d_iono_queue->push(iono);
+         }
+     if (d_nav.have_new_utc_model() == true)
+         {
+             Galileo_Utc_Model utc_model = d_nav.get_utc_model(); //notice that the read operation will clear the valid flag
+             //std::cout<<"New Galileo UTC model received for SV "<<d_satellite.get_PRN()<<std::endl;
+             d_utc_model_queue->push(utc_model);
+         }
+
+}
+
+galileo_e5a_telemetry_decoder_cc::galileo_e5a_telemetry_decoder_cc(
+        Gnss_Satellite satellite,
+        long if_freq,
+        long fs_in,
+        unsigned
+        int vector_length,
+        boost::shared_ptr<gr::msg_queue> queue,
+        bool dump) :
+           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)))
+{
+    // initialize internal vars
+    d_queue = queue;
+    d_dump = dump;
+    d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
+    LOG(INFO) << "GALILEO E5A TELEMETRY PROCESSING: satellite " << d_satellite;
+    d_vector_length = vector_length;
+    //d_samples_per_symbol = ( Galileo_E5a_CODE_CHIP_RATE_HZ / Galileo_E5a_CODE_LENGTH_CHIPS ) / Galileo_E1_B_SYMBOL_RATE_BPS;
+    d_fs_in = fs_in;
+
+    // set the preamble
+    //unsigned short int preambles_bits[GALILEO_FNAV_PREAMBLE_LENGTH_BITS] = GALILEO_FNAV_PREAMBLE;
+    for (int i = 0; i < GALILEO_FNAV_PREAMBLE_LENGTH_BITS; i++)
+	{
+	    if (GALILEO_FNAV_PREAMBLE.at(i) == '0')
+		{
+		    d_preamble_bits[i] = 1;
+		}
+	    else
+		{
+		    d_preamble_bits[i] = -1;
+		}
+	}
+
+//    memcpy((unsigned short int*)this->d_preambles_bits, (unsigned short int*)preambles_bits, GALILEO_FNAV_PREAMBLE_LENGTH_BITS*sizeof(unsigned short int));
+
+//    // preamble bits to sampled symbols
+//    d_preambles_symbols = (signed int*)malloc(sizeof(signed int) * GALILEO_FNAV_SAMPLES_PER_PREAMBLE);
+//    int n = 0;
+//    for (int i = 0; i < GALILEO_FNAV_PREAMBLE_LENGTH_BITS; i++)
+//        {
+//            for (unsigned int j = 0; j < GALILEO_FNAV_SAMPLES_PER_SYMBOL; j++)
+//                {
+//                    if (d_preambles_bits[i] == 1)
+//                        {
+//                            d_preambles_symbols[n] = 1;
+//                        }
+//                    else
+//                        {
+//                            d_preambles_symbols[n] = -1;
+//                        }
+//                    n++;
+//                }
+//        }
+//
+    d_sample_counter = 0;
+    d_state = 0;
+    d_preamble_lock=false;
+    d_preamble_index = 0;
+    d_preamble_time_seconds = 0;
+    d_flag_frame_sync = false;
+    d_current_symbol = 0;
+    d_prompt_counter = 0;
+    d_symbol_counter = 0;
+
+    d_TOW_at_Preamble = 0;
+    d_TOW_at_current_symbol = 0;
+
+    d_CRC_error_counter = 0;
+    d_sign_init = 0;
+}
+
+galileo_e5a_telemetry_decoder_cc::~galileo_e5a_telemetry_decoder_cc()
+{
+    delete d_preamble_bits;
+    d_dump_file.close();
+}
+
+int galileo_e5a_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_int &ninput_items,
+        gr_vector_const_void_star &input_items,	gr_vector_void_star &output_items)
+{
+    //
+    const Gnss_Synchro **in = (const Gnss_Synchro **)  &input_items[0]; //Get the input samples pointer
+    Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0];
+
+    /* Terminology: 	Prompt: output from tracking Prompt correlator (Prompt samples)
+     * 			Symbol: encoded navigation bits. 1 symbol = 20 samples in E5a
+     * 			Bit: decoded navigation bits forming words as described in Galileo ICD
+     * States: 	0 Receiving dummy samples.
+     * 		1 Preamble not locked
+     * 		3 Preamble lock
+     */
+    switch (d_state)
+    {
+	case 0:
+	    {
+		if (in[0][0].Prompt_I != 0)
+		    {
+			d_current_symbol += in[0][0].Prompt_I;
+			if (d_prompt_counter == GALILEO_FNAV_CODES_PER_SYMBOL - 1)
+			    {
+				if (d_current_symbol > 0)
+				    {
+					d_page_symbols[d_symbol_counter] = 1;
+				    }
+				else
+				    {
+					d_page_symbols[d_symbol_counter] = -1;
+				    }
+				d_current_symbol = 0;
+				d_symbol_counter++;
+				d_prompt_counter = 0;
+				if (d_symbol_counter == GALILEO_FNAV_PREAMBLE_LENGTH_BITS-1)
+				    {
+					d_state = 1;
+				    }
+			    }
+			else
+			    {
+				d_prompt_counter++;
+			    }
+		    }
+		break;
+	    }
+	case 1:
+	    {
+		d_current_symbol += in[0][0].Prompt_I;
+		if (d_prompt_counter == GALILEO_FNAV_CODES_PER_SYMBOL - 1)
+		    {
+			if (d_current_symbol > 0)
+			    {
+				d_page_symbols[d_symbol_counter] = 1;
+			    }
+			else
+			    {
+				d_page_symbols[d_symbol_counter] = -1;
+			    }
+//			d_page_symbols[d_symbol_counter] = d_current_symbol_float/(float)GALILEO_FNAV_CODES_PER_SYMBOL;
+			d_current_symbol = 0;
+			d_symbol_counter++;
+			d_prompt_counter = 0;
+			// **** Attempt Preamble correlation ****
+			bool corr_flag=true;
+			int corr_sign = 0; // sequence can be found inverted
+//			corr_sign = d_preamble_bits[0] * d_page_symbols[d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS];
+//			for (int i = 1; i < GALILEO_FNAV_PREAMBLE_LENGTH_BITS; i++)
+//			    {
+//				if ((d_preamble_bits[i] * d_page_symbols[i + d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS]) != corr_sign)
+//				    {
+//					//exit for if one bit doesn't correlate
+//					corr_flag=false;
+//					break;
+//				    }
+//			    }
+			// check if the preamble starts positive correlated or negative correlated
+			if (d_page_symbols[d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS] < 0)	// symbols clipping
+			    {
+				corr_sign=-d_preamble_bits[0];
+			    }
+			else
+			    {
+				corr_sign=d_preamble_bits[0];
+			    }
+			// the preamble is fully correlated only if maintains corr_sign along the whole sequence
+			for (int i = 1; i < GALILEO_FNAV_PREAMBLE_LENGTH_BITS; i++)
+			    {
+				if (d_page_symbols[d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS + i] < 0 && d_preamble_bits[i]+corr_sign != 0)
+				    {
+					//exit for
+					corr_flag=false;
+					break;
+				    }
+				if (d_page_symbols[d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS + i] > 0 && d_preamble_bits[i]+corr_sign == 0)
+				    {
+					//exit for
+					corr_flag=false;
+					break;
+				    }
+			    }
+			//
+			if (corr_flag==true) // preamble fully correlates
+			    {
+				d_preamble_index = d_sample_counter - GALILEO_FNAV_CODES_PER_PREAMBLE;//record the preamble sample stamp. Remember correlation appears at the end of the preamble in this design
+				LOG(INFO) << "Preamble detection for Galileo SAT " << this->d_satellite << std::endl;
+				d_symbol_counter = 0; // d_page_symbols start right after preamble and finish at the end of next preamble.
+				d_state = 2; // preamble lock
+			    }
+			if (d_symbol_counter >= GALILEO_FNAV_SYMBOLS_PER_PAGE + GALILEO_FNAV_PREAMBLE_LENGTH_BITS)
+			    {
+				d_symbol_counter = GALILEO_FNAV_PREAMBLE_LENGTH_BITS; // prevents overflow
+			    }
+		    }
+		else
+		    {
+			d_prompt_counter++;
+		    }
+		break;
+	    }
+	case 2:
+	    {
+		d_current_symbol += in[0][0].Prompt_I;
+		if (d_prompt_counter == GALILEO_FNAV_CODES_PER_SYMBOL - 1)
+		    {
+			if (d_current_symbol > 0)
+			    {
+				d_page_symbols[d_symbol_counter] = 1;
+			    }
+			else
+			    {
+				d_page_symbols[d_symbol_counter] = -1;
+			    }
+//			d_page_symbols[d_symbol_counter] = d_current_symbol_float/(float)GALILEO_FNAV_CODES_PER_SYMBOL;
+			d_current_symbol = 0;
+			d_symbol_counter++;
+			d_prompt_counter = 0;
+			// At the right sample stamp, check preamble synchro
+			if (d_sample_counter == d_preamble_index + GALILEO_FNAV_CODES_PER_PAGE + GALILEO_FNAV_CODES_PER_PREAMBLE)
+			    {
+				// **** Attempt Preamble correlation ****
+				bool corr_flag = true;
+				int corr_sign = 0; // sequence can be found inverted
+//				corr_sign = d_preamble_bits[0] * d_page_symbols[d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS];
+//				for (int i = 1; i < GALILEO_FNAV_PREAMBLE_LENGTH_BITS; i++)
+//				    {
+//					if ((d_preamble_bits[i] * d_page_symbols[i + d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS]) != corr_sign)
+//					    {
+//						//exit for if one bit doesn't correlate
+//						corr_flag=false;
+//						break;
+//					    }
+//				    }
+				// check if the preamble starts positive correlated or negative correlated
+				if (d_page_symbols[d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS] < 0)	// symbols clipping
+				    {
+					corr_sign=-d_preamble_bits[0];
+				    }
+				else
+				    {
+					corr_sign=d_preamble_bits[0];
+				    }
+				// the preamble is fully correlated only if maintains corr_sign along the whole sequence
+				for (int i = 1; i < GALILEO_FNAV_PREAMBLE_LENGTH_BITS; i++)
+				    {
+					if (d_page_symbols[d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS + i] < 0 && d_preamble_bits[i]+corr_sign != 0)
+					    {
+						//exit for
+						corr_flag=false;
+						break;
+					    }
+					if (d_page_symbols[d_symbol_counter - GALILEO_FNAV_PREAMBLE_LENGTH_BITS + i] > 0 && d_preamble_bits[i]+corr_sign == 0)
+					    {
+						//exit for
+						corr_flag=false;
+						break;
+					    }
+				    }
+				//
+				if (corr_flag==true) // NEW PREAMBLE RECEIVED. DECODE PAGE
+				    {
+					d_preamble_index = d_sample_counter - GALILEO_FNAV_CODES_PER_PREAMBLE;//record the preamble sample stamp
+					// DECODE WORD
+					decode_word(d_page_symbols, GALILEO_FNAV_SYMBOLS_PER_PAGE - GALILEO_FNAV_PREAMBLE_LENGTH_BITS);
+					// CHECK CRC
+					if (d_nav.flag_CRC_test == true)
+					    {
+						d_CRC_error_counter = 0;
+						d_flag_preamble = true; //valid preamble indicator (initialized to false every work())
+						d_preamble_time_seconds = in[0][0].Tracking_timestamp_secs - ((double)(GALILEO_FNAV_CODES_PER_PAGE+GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD); //record the PRN start sample index associated to the preamble start.
+						if (!d_flag_frame_sync)
+						    {
+							d_flag_frame_sync = true;
+							LOG(INFO) <<" Frame sync SAT " << this->d_satellite << " with preamble start at " << d_preamble_time_seconds << " [s]";
+						    }
+						d_symbol_counter = 0; // d_page_symbols start right after preamble and finish at the end of next preamble.
+					    }
+					else
+					    {
+						d_CRC_error_counter++;
+						if (d_CRC_error_counter > CRC_ERROR_LIMIT)
+						    {
+							LOG(INFO) << "Lost of frame sync SAT " << this->d_satellite;
+							d_state = 1;
+							d_symbol_counter = GALILEO_FNAV_PREAMBLE_LENGTH_BITS; // prevents overflow
+							d_flag_frame_sync = false;
+						    }
+						else
+						    {
+							d_symbol_counter = 0; // d_page_symbols start right after preamble and finish at the end of next preamble.
+						    }
+					    }
+				    }
+			    }
+		    }
+		else
+		    {
+			d_prompt_counter++;
+		    }
+		break;
+	    }
+    }
+    consume_each(1);
+
+    // UPDATE GNSS SYNCHRO DATA
+    Gnss_Synchro current_synchro_data; //structure to save the synchronization information and send the output object to the next block
+    //1. Copy the current tracking output
+    current_synchro_data = in[0][0];
+    //2. Add the telemetry decoder information
+    if (this->d_flag_preamble == true and d_nav.flag_TOW_set == true)
+	//update TOW at the preamble instant
+	//We expect a preamble each 10 seconds (FNAV page period)
+	{
+	    Prn_timestamp_at_preamble_ms = d_preamble_time_seconds * 1000;
+	    //Prn_timestamp_at_preamble_ms = in[0][0].Tracking_timestamp_secs * 1000.0;
+	    if (d_nav.flag_TOW_1 == true)
+		{
+		    d_TOW_at_Preamble = d_nav.FNAV_TOW_1;
+		    d_TOW_at_current_symbol = d_TOW_at_Preamble + ((double)(GALILEO_FNAV_CODES_PER_PAGE+GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD);
+		    d_nav.flag_TOW_1 = false;
+		}
+	    if (d_nav.flag_TOW_2 == true)
+		{
+		    d_TOW_at_Preamble = d_nav.FNAV_TOW_2;
+		    d_TOW_at_current_symbol = d_TOW_at_Preamble + ((double)(GALILEO_FNAV_CODES_PER_PAGE+GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD);
+		    d_nav.flag_TOW_2 = false;
+		}
+	    if (d_nav.flag_TOW_3 == true)
+		{
+		    d_TOW_at_Preamble = d_nav.FNAV_TOW_3;
+		    d_TOW_at_current_symbol = d_TOW_at_Preamble + ((double)(GALILEO_FNAV_CODES_PER_PAGE+GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD);
+		    d_nav.flag_TOW_3 = false;
+		}
+	    if (d_nav.flag_TOW_4 == true)
+		{
+		    d_TOW_at_Preamble = d_nav.FNAV_TOW_4;
+		    d_TOW_at_current_symbol = d_TOW_at_Preamble + ((double)(GALILEO_FNAV_CODES_PER_PAGE+GALILEO_FNAV_CODES_PER_PREAMBLE) * GALILEO_E5a_CODE_PERIOD);
+		    d_nav.flag_TOW_4 = false;
+		}
+	    else
+		{
+		    //this page has no timming information
+		    d_TOW_at_Preamble = d_TOW_at_Preamble + GALILEO_FNAV_SECONDS_PER_PAGE;
+		    d_TOW_at_current_symbol =  d_TOW_at_current_symbol + GALILEO_E5a_CODE_PERIOD;
+		}
+
+	}
+    else //if there is not a new preamble, we define the TOW of the current symbol
+	{
+	    d_TOW_at_current_symbol = d_TOW_at_current_symbol + GALILEO_E5a_CODE_PERIOD;
+	}
+
+    //if (d_flag_frame_sync == true and d_nav.flag_TOW_set==true and d_nav.flag_CRC_test == true)
+    if (d_flag_frame_sync == true and d_nav.flag_TOW_set == true)
+	{
+	    current_synchro_data.Flag_valid_word = true;
+	}
+    else
+	{
+	    current_synchro_data.Flag_valid_word = false;
+	}
+
+    current_synchro_data.d_TOW = d_TOW_at_Preamble;
+    current_synchro_data.d_TOW_at_current_symbol = d_TOW_at_current_symbol;
+    current_synchro_data.Flag_preamble = d_flag_preamble;
+    current_synchro_data.Prn_timestamp_ms = in[0][0].Tracking_timestamp_secs * 1000.0;
+    current_synchro_data.Prn_timestamp_at_preamble_ms = Prn_timestamp_at_preamble_ms;
+
+    if(d_dump == true)
+	{
+	    // MULTIPLEXED FILE RECORDING - Record results to file
+	    try
+	    {
+		    double tmp_double;
+		    tmp_double = d_TOW_at_current_symbol;
+		    d_dump_file.write((char*)&tmp_double, sizeof(double));
+		    tmp_double = current_synchro_data.Prn_timestamp_ms;
+		    d_dump_file.write((char*)&tmp_double, sizeof(double));
+		    tmp_double = d_TOW_at_Preamble;
+		    d_dump_file.write((char*)&tmp_double, sizeof(double));
+	    }
+	    catch (const std::ifstream::failure& e)
+	    {
+		    LOG(WARNING) << "Exception writing observables dump file " << e.what();
+	    }
+	}
+    d_sample_counter++; //count for the processed samples
+    //3. Make the output (copy the object contents to the GNURadio reserved memory)
+    *out[0] = current_synchro_data;
+    return 1;
+}
+
+void galileo_e5a_telemetry_decoder_cc::set_satellite(Gnss_Satellite satellite)
+{
+    d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
+    DLOG(INFO) << "Setting decoder Finite State Machine to satellite " << d_satellite;
+    DLOG(INFO) << "Navigation Satellite set to " << d_satellite;
+}
+
+
+void galileo_e5a_telemetry_decoder_cc::set_channel(int channel)
+{
+    d_channel = channel;
+    LOG(INFO) << "Navigation channel set to " << channel;
+    // ############# ENABLE DATA FILE LOG #################
+    if (d_dump == true)
+        {
+            if (d_dump_file.is_open() == false)
+                {
+                    try
+                    {
+                            d_dump_filename = "telemetry";
+                            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) << "Telemetry decoder dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str();
+                    }
+                    catch (const std::ifstream::failure& e)
+                    {
+                            LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what();
+                    }
+                }
+        }
+}
+
+void galileo_e5a_telemetry_decoder_cc::set_ephemeris_queue(concurrent_queue<Galileo_Ephemeris> *ephemeris_queue)
+{
+    d_ephemeris_queue = ephemeris_queue;
+}
+
+
+void galileo_e5a_telemetry_decoder_cc::set_iono_queue(concurrent_queue<Galileo_Iono> *iono_queue)
+{
+    d_iono_queue = iono_queue;
+}
+
+
+void galileo_e5a_telemetry_decoder_cc::set_almanac_queue(concurrent_queue<Galileo_Almanac> *almanac_queue)
+{
+    d_almanac_queue = almanac_queue;
+}
+
+
+void galileo_e5a_telemetry_decoder_cc::set_utc_model_queue(concurrent_queue<Galileo_Utc_Model> *utc_model_queue)
+{
+    d_utc_model_queue = utc_model_queue;
+}

src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_e5a_telemetry_decoder_cc.h

@@ -0,0 +1,154 @@
+/*!
+ * \file galileo_e5a_telemetry_decoder_cc.cc
+ * \brief Implementation of a Galileo FNAV message demodulator block
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          </ul>
+ *
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_E5A_TELEMETRY_DECODER_CC_H_
+#define GNSS_SDR_GALILEO_E5A_TELEMETRY_DECODER_CC_H_
+
+#include <fstream>
+#include <string>
+#include <gnuradio/block.h>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/trellis/interleaver.h>
+#include <gnuradio/trellis/permutation.h>
+//#include <gnuradio/fec/viterbi.h>
+#include "Galileo_E5a.h"
+#include "concurrent_queue.h"
+#include "gnss_satellite.h"
+#include "galileo_fnav_message.h"
+#include "galileo_ephemeris.h"
+#include "galileo_almanac.h"
+#include "galileo_iono.h"
+#include "galileo_utc_model.h"
+
+//#include "convolutional.h"
+
+class galileo_e5a_telemetry_decoder_cc;
+
+typedef boost::shared_ptr<galileo_e5a_telemetry_decoder_cc> galileo_e5a_telemetry_decoder_cc_sptr;
+
+galileo_e5a_telemetry_decoder_cc_sptr galileo_e5a_make_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, long fs_in, unsigned
+    int vector_length, boost::shared_ptr<gr::msg_queue> queue, bool dump);
+
+
+/*!
+ * \brief This class implements a block that decodes the FNAV data defined in Galileo ICD
+ *
+ */
+class galileo_e5a_telemetry_decoder_cc : public gr::block
+{
+public:
+    ~galileo_e5a_telemetry_decoder_cc();
+    void set_satellite(Gnss_Satellite satellite);  //!< Set satellite PRN
+    void set_channel(int channel);                 //!< Set receiver's channel
+    void set_ephemeris_queue(concurrent_queue<Galileo_Ephemeris> *ephemeris_queue); //!< Set the satellite data queue
+    void set_iono_queue(concurrent_queue<Galileo_Iono> *iono_queue);                //!< Set the iono data queue
+    void set_almanac_queue(concurrent_queue<Galileo_Almanac> *almanac_queue);       //!< Set the almanac data queue
+    void set_utc_model_queue(concurrent_queue<Galileo_Utc_Model> *utc_model_queue); //!< Set the UTC model queue
+    /*!
+     * \brief This is where all signal processing takes place
+     */
+    int general_work (int noutput_items, gr_vector_int &ninput_items,
+            gr_vector_const_void_star &input_items, gr_vector_void_star &output_items);
+
+    /*!
+     * \brief Function which tells the scheduler how many input items
+     *        are required to produce noutput_items output items.
+     */
+    void forecast (int noutput_items, gr_vector_int &ninput_items_required);
+
+private:
+    friend galileo_e5a_telemetry_decoder_cc_sptr
+    galileo_e5a_make_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, long fs_in,unsigned
+            int vector_length, boost::shared_ptr<gr::msg_queue> queue, bool dump);
+    galileo_e5a_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, long fs_in, unsigned
+            int vector_length, boost::shared_ptr<gr::msg_queue> queue, bool dump);
+
+    void viterbi_decoder(double *page_part_symbols, int *page_part_bits);
+
+    void deinterleaver(int rows, int cols, double *in, double *out);
+
+    void decode_word(double *page_symbols,int frame_length);
+
+    signed int d_preamble_bits[GALILEO_FNAV_PREAMBLE_LENGTH_BITS];
+//    signed int d_page_symbols[GALILEO_FNAV_SYMBOLS_PER_PAGE + GALILEO_FNAV_PREAMBLE_LENGTH_BITS];
+    double d_page_symbols[GALILEO_FNAV_SYMBOLS_PER_PAGE + GALILEO_FNAV_PREAMBLE_LENGTH_BITS];
+    signed int *d_preamble_symbols;
+    double d_current_symbol;
+    long unsigned int d_symbol_counter;
+    int d_prompt_counter;
+    int d_sign_init;
+
+    long unsigned int d_sample_counter;
+    long unsigned int d_preamble_index;
+
+    bool d_preamble_lock;
+    bool d_flag_frame_sync;
+    int d_state;
+
+    bool d_flag_preamble;
+    int d_CRC_error_counter;
+
+    long d_fs_in;
+
+    // navigation message vars
+    Galileo_Fnav_Message d_nav;
+
+    // Galileo ephemeris queue
+    concurrent_queue<Galileo_Ephemeris> *d_ephemeris_queue;
+    // ionospheric parameters queue
+    concurrent_queue<Galileo_Iono> *d_iono_queue;
+    // UTC model parameters queue
+    concurrent_queue<Galileo_Utc_Model> *d_utc_model_queue;
+    // Almanac queue
+    concurrent_queue<Galileo_Almanac> *d_almanac_queue;
+
+    boost::shared_ptr<gr::msg_queue> d_queue;
+    unsigned int d_vector_length;
+    bool d_dump;
+    Gnss_Satellite d_satellite;
+    int d_channel;
+
+    double d_preamble_time_seconds;
+
+    double d_TOW_at_Preamble;
+    double d_TOW_at_current_symbol;
+    double Prn_timestamp_at_preamble_ms;
+    bool flag_TOW_set;
+
+    std::string d_dump_filename;
+    std::ofstream d_dump_file;
+};
+
+#endif /* GNSS_SDR_GALILEO_E5A_TELEMETRY_DECODER_CC_H_ */

src/algorithms/telemetry_decoder/libs/convolutional.h

@@ -37,7 +37,8 @@
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
-
+//#ifndef GNSS_SDR_CONVOLUTIONAL_H_
+//#define GNSS_SDR_CONVOLUTIONAL_H_
 /* define constants used throughout the library */
 #define MAXLOG 1e7  /* Define infinity */
 
@@ -49,9 +50,9 @@
  * \param[in] symbol  The integer-valued symbol
  * \param[in] length  The length of the binary vector
  *
- * This function is used by conv_encode()  
+ * This function is used by conv_encode()
  */
-void itob(int binvec_p[], int symbol, int length)
+static void itob(int binvec_p[], int symbol, int length)
 {
     int counter;
     /* Go through each bit in the vector */
@@ -73,9 +74,9 @@ void itob(int binvec_p[], int symbol, int length)
  * \param[in] symbol  The integer-valued symbol
  * \param[in] length  The highest bit position in the symbol
  *
- * This function is used by nsc_enc_bit(), rsc_enc_bit(), and rsc_tail()  
+ * This function is used by nsc_enc_bit(), rsc_enc_bit(), and rsc_tail()
  */
-int parity_counter(int symbol, int length)
+static int parity_counter(int symbol, int length)
 {
     int counter;
     int temp_parity = 0;
@@ -133,7 +134,7 @@ static int nsc_enc_bit(int state_out_p[],
 
 
 /*!
- * \brief  like nsc_enc_bit() but for a RSC code 
+ * \brief  like nsc_enc_bit() but for a RSC code
  */
 static int rsc_enc_bit(int state_out_p[],
                        int input,
@@ -380,7 +381,7 @@ static float Gamma(float  rec_array[],
             mask = mask << 1;
         }
     return(rm);
-} 
+}
 
 
 /*!
@@ -440,7 +441,7 @@ static void Viterbi(int output_u_int[],
     for (t = 0; t < LL + mm; t++)
         {
             for (i = 0; i < nn; i++)
-                rec_array[i] = (float)input_c[nn*t + i];
+        	    rec_array[i] = (float)input_c[nn*t + i];
 
             /* precompute all possible branch metrics */
             for (i = 0; i < number_symbols; i++)
@@ -657,3 +658,4 @@ static void ViterbiTb(int output_u_int[],
     free(rec_array);
     free(metric_c);
 }
+//#endif

src/algorithms/tracking/adapters/CMakeLists.txt

@@ -24,6 +24,7 @@ set(TRACKING_ADAPTER_SOURCES
      gps_l1_ca_dll_pll_optim_tracking.cc
      gps_l1_ca_dll_pll_tracking.cc
      gps_l1_ca_tcp_connector_tracking.cc
+     galileo_e5a_dll_pll_tracking.cc
 )
 
 include_directories(

src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc

@@ -0,0 +1,165 @@
+/*!
+ * \file galileo_e5a_dll_fll_pll_tracking.cc
+ * \brief Adapts a code DLL + carrier PLL
+ *  tracking block to a TrackingInterface for Galileo E5a signals
+ * \brief Adapts a PCPS acquisition block to an AcquisitionInterface for
+ *  Galileo E5a data and pilot Signals
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e5a_dll_pll_tracking.h"
+#include <glog/logging.h>
+#include "Galileo_E5a.h"
+#include "configuration_interface.h"
+
+
+using google::LogMessage;
+
+GalileoE5aDllPllTracking::GalileoE5aDllPllTracking(
+        ConfigurationInterface* configuration, std::string role,
+        unsigned int in_streams, unsigned int out_streams,
+        boost::shared_ptr<gr::msg_queue> queue) :
+                role_(role), in_streams_(in_streams), out_streams_(out_streams),
+                queue_(queue)
+{
+    DLOG(INFO) << "role " << role;
+    //################# CONFIGURATION PARAMETERS ########################
+    int fs_in;
+    int vector_length;
+    int f_if;
+    bool dump;
+    std::string dump_filename;
+    std::string item_type;
+    std::string default_item_type = "gr_complex";
+    float pll_bw_hz;
+    float dll_bw_hz;
+    float pll_bw_init_hz;
+    float dll_bw_init_hz;
+    int ti_ms;
+    float early_late_space_chips;
+    item_type = configuration->property(role + ".item_type", default_item_type);
+    //vector_length = configuration->property(role + ".vector_length", 2048);
+    fs_in = configuration->property("GNSS-SDR.internal_fs_hz", 12000000);
+    f_if = configuration->property(role + ".if", 0);
+    dump = configuration->property(role + ".dump", false);
+    pll_bw_hz = configuration->property(role + ".pll_bw_hz", 5.0);
+    dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0);
+    pll_bw_init_hz = configuration->property(role + ".pll_bw_init_hz", 20.0);
+    dll_bw_init_hz = configuration->property(role + ".dll_bw_init_hz", 20.0);
+    ti_ms = configuration->property(role + ".ti_ms", 3);
+
+    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",
+            default_dump_filename); //unused!
+    vector_length = std::round(fs_in / (Galileo_E5a_CODE_CHIP_RATE_HZ / Galileo_E5a_CODE_LENGTH_CHIPS));
+
+    //################# MAKE TRACKING GNURadio object ###################
+    if (item_type.compare("gr_complex") == 0)
+        {
+            item_size_ = sizeof(gr_complex);
+            tracking_ = galileo_e5a_dll_pll_make_tracking_cc(
+                    f_if,
+                    fs_in,
+                    vector_length,
+                    queue_,
+                    dump,
+                    dump_filename,
+                    pll_bw_hz,
+                    dll_bw_hz,
+                    pll_bw_init_hz,
+                    dll_bw_init_hz,
+                    ti_ms,
+                    early_late_space_chips);
+        }
+    else
+        {
+            LOG(WARNING) << item_type << " unknown tracking item type.";
+        }
+    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+}
+
+
+GalileoE5aDllPllTracking::~GalileoE5aDllPllTracking()
+{}
+
+
+void GalileoE5aDllPllTracking::start_tracking()
+{
+    tracking_->start_tracking();
+}
+
+/*
+ * Set tracking channel unique ID
+ */
+void GalileoE5aDllPllTracking::set_channel(unsigned int channel)
+{
+    channel_ = channel;
+    tracking_->set_channel(channel);
+}
+
+/*
+ * Set tracking channel internal queue
+ */
+void GalileoE5aDllPllTracking::set_channel_queue(
+        concurrent_queue<int> *channel_internal_queue)
+{
+    channel_internal_queue_ = channel_internal_queue;
+    tracking_->set_channel_queue(channel_internal_queue_);
+}
+
+void GalileoE5aDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
+{
+    tracking_->set_gnss_synchro(p_gnss_synchro);
+}
+
+void GalileoE5aDllPllTracking::connect(gr::top_block_sptr top_block)
+{
+    //nothing to connect, now the tracking uses gr_sync_decimator
+}
+
+void GalileoE5aDllPllTracking::disconnect(gr::top_block_sptr top_block)
+{
+    //nothing to disconnect, now the tracking uses gr_sync_decimator
+}
+
+gr::basic_block_sptr GalileoE5aDllPllTracking::get_left_block()
+{
+    return tracking_;
+}
+
+gr::basic_block_sptr GalileoE5aDllPllTracking::get_right_block()
+{
+    return tracking_;
+}
+
+

src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.h

@@ -0,0 +1,115 @@
+/*!
+ * \file galileo_e5a_dll_fll_pll_tracking.h
+ * \brief Adapts a code DLL + carrier PLL
+ *  tracking block to a TrackingInterface for Galileo E5a signals
+ * \brief Adapts a PCPS acquisition block to an AcquisitionInterface for
+ *  Galileo E5a data and pilot Signals
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_H_
+#define GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_H_
+
+#include <string>
+#include <gnuradio/msg_queue.h>
+#include "tracking_interface.h"
+#include "galileo_e5a_dll_pll_tracking_cc.h"
+
+
+class ConfigurationInterface;
+
+/*!
+ * \brief This class implements a code DLL + carrier PLL tracking loop
+ */
+class GalileoE5aDllPllTracking : public TrackingInterface
+{
+public:
+
+    GalileoE5aDllPllTracking(ConfigurationInterface* configuration,
+            std::string role,
+            unsigned int in_streams,
+            unsigned int out_streams,
+            boost::shared_ptr<gr::msg_queue> queue);
+
+    virtual ~GalileoE5aDllPllTracking();
+
+    std::string role()
+    {
+        return role_;
+    }
+
+    //! Returns "Galileo_E5a_DLL_PLL_Tracking"
+    std::string implementation()
+    {
+        return "Galileo_E5a_DLL_PLL_Tracking";
+    }
+    size_t item_size()
+    {
+        return item_size_;
+    }
+
+    void connect(gr::top_block_sptr top_block);
+    void disconnect(gr::top_block_sptr top_block);
+    gr::basic_block_sptr get_left_block();
+    gr::basic_block_sptr get_right_block();
+
+
+    /*!
+     * \brief Set tracking channel unique ID
+     */
+    void set_channel(unsigned int channel);
+
+    /*!
+     * \brief Set acquisition/tracking common Gnss_Synchro object pointer
+     * to efficiently exchange synchronization data between acquisition and tracking blocks
+     */
+    void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro);
+
+    /*!
+     * \brief Set tracking channel internal queue
+     */
+    void set_channel_queue(concurrent_queue<int> *channel_internal_queue);
+
+    void start_tracking();
+
+private:
+    galileo_e5a_dll_pll_tracking_cc_sptr tracking_;
+    size_t item_size_;
+    unsigned int channel_;
+    std::string role_;
+    unsigned int in_streams_;
+    unsigned int out_streams_;
+    boost::shared_ptr<gr::msg_queue> queue_;
+    concurrent_queue<int> *channel_internal_queue_;
+};
+
+#endif /* GNSS_SDR_GALILEO_E5A_DLL_PLL_TRACKING_H_ */

src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt

@@ -23,6 +23,7 @@ set(TRACKING_GR_BLOCKS_SOURCES
      gps_l1_ca_dll_pll_optim_tracking_cc.cc
      gps_l1_ca_dll_pll_tracking_cc.cc
      gps_l1_ca_tcp_connector_tracking_cc.cc
+     galileo_e5a_dll_pll_tracking_cc.cc
 )
       
 include_directories(

src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.cc

@@ -0,0 +1,817 @@
+/*!
+ * \file galileo_e5a_dll_fll_pll_tracking_cc.h
+ * \brief Implementation of a code DLL + carrier PLL
+ *  tracking block for Galileo E5a signals
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e5a_dll_pll_tracking_cc.h"
+#include <cmath>
+#include <iostream>
+#include <sstream>
+#include <boost/lexical_cast.hpp>
+#include <gnuradio/io_signature.h>
+#include <glog/logging.h>
+#include "gnss_synchro.h"
+#include "galileo_e5_signal_processing.h"
+#include "tracking_discriminators.h"
+#include "lock_detectors.h"
+#include "Galileo_E5a.h"
+#include "Galileo_E1.h"
+#include "control_message_factory.h"
+
+
+/*!
+ * \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;
+
+galileo_e5a_dll_pll_tracking_cc_sptr
+galileo_e5a_dll_pll_make_tracking_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 pll_bw_init_hz,
+        float dll_bw_init_hz,
+        int ti_ms,
+        float early_late_space_chips)
+{
+    return galileo_e5a_dll_pll_tracking_cc_sptr(new Galileo_E5a_Dll_Pll_Tracking_cc(if_freq,
+            fs_in, vector_length, queue, dump, dump_filename, pll_bw_hz, dll_bw_hz,pll_bw_init_hz, dll_bw_init_hz, ti_ms, early_late_space_chips));
+}
+
+
+
+void Galileo_E5a_Dll_Pll_Tracking_cc::forecast (int noutput_items,
+        gr_vector_int &ninput_items_required)
+{
+    ninput_items_required[0] = (int)d_vector_length*2; //set the required available samples in each call
+}
+
+Galileo_E5a_Dll_Pll_Tracking_cc::Galileo_E5a_Dll_Pll_Tracking_cc(
+        long if_freq,
+        long fs_in,
+        unsigned int vector_length,
+        boost::shared_ptr<gr::msg_queue> queue,
+        bool dump,
+        std::string dump_filename,
+        float pll_bw_hz,
+        float dll_bw_hz,
+        float pll_bw_init_hz,
+        float dll_bw_init_hz,
+        int ti_ms,
+        float early_late_space_chips) :
+        gr::block("Galileo_E5a_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
+                gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
+{
+    this->set_relative_rate(1.0/vector_length);
+    // 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;
+    d_code_loop_filter = Tracking_2nd_DLL_filter(GALILEO_E5a_CODE_PERIOD);
+    d_carrier_loop_filter = Tracking_2nd_PLL_filter(GALILEO_E5a_CODE_PERIOD);
+    d_current_ti_ms = 1; // initializes with 1ms of integration time until secondary code lock
+    d_ti_ms = ti_ms;
+    d_dll_bw_hz = dll_bw_hz;
+    d_pll_bw_hz = pll_bw_hz;
+    d_dll_bw_init_hz = dll_bw_init_hz;
+    d_pll_bw_init_hz = pll_bw_init_hz;
+
+    // Initialize tracking  ==========================================
+    d_code_loop_filter.set_DLL_BW(d_dll_bw_init_hz);
+    d_carrier_loop_filter.set_PLL_BW(d_pll_bw_init_hz);
+
+    //--- DLL variables --------------------------------------------------------
+    d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
+
+    // Initialization of local code replica
+    // Get space for a vector with the E5a primary code replicas sampled 1x/chip
+    d_codeQ = new gr_complex[(int)Galileo_E5a_CODE_LENGTH_CHIPS + 2];
+    d_codeI = new gr_complex[(int)Galileo_E5a_CODE_LENGTH_CHIPS + 2];
+
+    /* If an array is partitioned for more than one thread to operate on,
+     * having the sub-array boundaries unaligned to cache lines could lead
+     * to performance degradation. Here we allocate memory
+     * (gr_comlex array of size 2*d_vector_length) aligned to cache of 16 bytes
+     */
+    // todo: do something if posix_memalign fails
+    // Get space for the resampled early / prompt / late local replicas
+    if (posix_memalign((void**)&d_early_code, 16, d_vector_length * sizeof(gr_complex) * 2) == 0){};
+    if (posix_memalign((void**)&d_late_code, 16, d_vector_length * sizeof(gr_complex) * 2) == 0){};
+    if (posix_memalign((void**)&d_prompt_code, 16, d_vector_length * sizeof(gr_complex) * 2) == 0){};
+    if (posix_memalign((void**)&d_prompt_data_code, 16, d_vector_length * sizeof(gr_complex) * 2) == 0){};
+    // space for carrier wipeoff and signal baseband vectors
+    if (posix_memalign((void**)&d_carr_sign, 16, d_vector_length * sizeof(gr_complex) * 2) == 0){};
+    if (posix_memalign((void**)&d_Early, 16, sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_Prompt, 16, sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_Late, 16, sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_Prompt_data, 16, sizeof(gr_complex)) == 0){};
+    //--- Perform initializations ------------------------------
+    // define initial code frequency basis of NCO
+    d_code_freq_chips = Galileo_E5a_CODE_CHIP_RATE_HZ;
+    // define residual code phase (in chips)
+    d_rem_code_phase_samples = 0.0;
+    // define residual carrier phase
+    d_rem_carr_phase_rad = 0.0;
+
+    //Filter error vars
+    d_code_error_filt_secs = 0.0;
+
+
+    // sample synchronization
+    d_sample_counter = 0;
+    d_acq_sample_stamp = 0;
+
+    d_last_seg = 0;
+    d_first_transition = false;
+
+    d_secondary_lock=false;
+    d_secondary_delay=0;
+    d_integration_counter = 0;
+
+    d_current_prn_length_samples = (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["R"] = std::string("GLONASS");
+    systemName["S"] = std::string("SBAS");
+    systemName["E"] = std::string("Galileo");
+    systemName["C"] = std::string("Compass");
+
+}
+
+Galileo_E5a_Dll_Pll_Tracking_cc::~Galileo_E5a_Dll_Pll_Tracking_cc ()
+{
+    d_dump_file.close();
+
+    free(d_prompt_code);
+    free(d_late_code);
+    free(d_early_code);
+    free(d_carr_sign);
+
+    delete[] d_codeQ;
+    delete[] d_codeI;
+    delete[] d_Prompt_buffer;
+}
+
+void Galileo_E5a_Dll_Pll_Tracking_cc::start_tracking()
+{
+    /*
+     *  correct the code phase according to the delay between acq and trk
+     */
+    d_acq_code_phase_samples = d_acquisition_gnss_synchro->Acq_delay_samples;
+    d_acq_carrier_doppler_hz = d_acquisition_gnss_synchro->Acq_doppler_hz;
+    d_acq_sample_stamp =  d_acquisition_gnss_synchro->Acq_samplestamp_samples;
+
+    long int acq_trk_diff_samples;
+    float acq_trk_diff_seconds;
+    acq_trk_diff_samples = (long int)d_sample_counter - (long int)d_acq_sample_stamp;//-d_vector_length;
+    LOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples;
+    acq_trk_diff_seconds = (float)acq_trk_diff_samples / (float)d_fs_in;
+    //doppler effect
+    // Fd=(C/(C+Vr))*F
+    float radial_velocity;
+    radial_velocity = (Galileo_E5a_FREQ_HZ + d_acq_carrier_doppler_hz)/Galileo_E5a_FREQ_HZ;
+    // new chip and prn sequence periods based on acq Doppler
+    float T_chip_mod_seconds;
+    float T_prn_mod_seconds;
+    float T_prn_mod_samples;
+    d_code_freq_chips = radial_velocity * Galileo_E5a_CODE_CHIP_RATE_HZ;
+    T_chip_mod_seconds = 1/d_code_freq_chips;
+    T_prn_mod_seconds = T_chip_mod_seconds * Galileo_E5a_CODE_LENGTH_CHIPS;
+    T_prn_mod_samples = T_prn_mod_seconds * (float)d_fs_in;
+
+    d_current_prn_length_samples = round(T_prn_mod_samples);
+
+    float T_prn_true_seconds = Galileo_E5a_CODE_LENGTH_CHIPS / Galileo_E5a_CODE_CHIP_RATE_HZ;
+    float T_prn_true_samples = T_prn_true_seconds * (float)d_fs_in;
+    float T_prn_diff_seconds;
+    T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds;
+    float N_prn_diff;
+    N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds;
+    float corrected_acq_phase_samples, delay_correction_samples;
+    corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * (float)d_fs_in), T_prn_true_samples);
+    if (corrected_acq_phase_samples < 0)
+        {
+            corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples;
+        }
+    delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples;
+
+    d_acq_code_phase_samples = corrected_acq_phase_samples;
+
+    d_carrier_doppler_hz = d_acq_carrier_doppler_hz;
+
+    // DLL/PLL filter initialization
+    d_carrier_loop_filter.initialize(); // initialize the carrier filter
+    d_code_loop_filter.initialize();    // initialize the code filter
+
+    // generate local reference ALWAYS starting at chip 1 (1 sample per chip)
+    char sig[3];
+    strcpy(sig,"5Q");
+    galileo_e5_a_code_gen_complex_primary(&d_codeQ[1], d_acquisition_gnss_synchro->PRN, sig);
+    d_codeQ[0] = d_codeQ[(int)Galileo_E5a_CODE_LENGTH_CHIPS];
+    d_codeQ[(int)Galileo_E5a_CODE_LENGTH_CHIPS + 1] = d_codeQ[1];
+
+    strcpy(sig,"5I");
+    galileo_e5_a_code_gen_complex_primary(&d_codeI[1], d_acquisition_gnss_synchro->PRN, sig);
+    d_codeI[0] = d_codeI[(int)Galileo_E5a_CODE_LENGTH_CHIPS];
+    d_codeI[(int)Galileo_E5a_CODE_LENGTH_CHIPS + 1] = d_codeI[1];
+
+    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_state = 1;
+
+    LOG(INFO) << "PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz
+            << " Code Phase correction [samples]=" << delay_correction_samples
+            << " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
+}
+
+void Galileo_E5a_Dll_Pll_Tracking_cc::acquire_secondary()
+{
+    // 1. Transform replica to 1 and -1
+    int sec_code_signed[Galileo_E5a_Q_SECONDARY_CODE_LENGTH];
+    for (unsigned int i=0; i<Galileo_E5a_Q_SECONDARY_CODE_LENGTH; i++)
+	{
+	    if (Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN-1].at(i) == '0')
+		{
+		    sec_code_signed[i]=1;
+		}
+	    else
+		{
+		    sec_code_signed[i]=-1;
+		}
+	}
+    // 2. Transform buffer to 1 and -1
+    int in_corr[CN0_ESTIMATION_SAMPLES];
+    for (unsigned int i=0; i<CN0_ESTIMATION_SAMPLES; i++)
+	{
+	    if (d_Prompt_buffer[i].real() >0)
+		{
+		    in_corr[i]=1;
+		}
+	    else
+		{
+		    in_corr[i]=-1;
+		}
+	}
+    // 3. Serial search
+    int out_corr;
+    int current_best_=0;
+    for (unsigned int i=0; i<Galileo_E5a_Q_SECONDARY_CODE_LENGTH; i++)
+	{
+	    out_corr=0;
+	    for (unsigned int j=0; j<CN0_ESTIMATION_SAMPLES; j++)
+		{
+		    //reverse replica sign since i*i=-1 (conjugated complex)
+		    out_corr += in_corr[j] * -sec_code_signed[(j+i)%Galileo_E5a_Q_SECONDARY_CODE_LENGTH];
+		}
+	    if (abs(out_corr) > current_best_)
+		{
+		    current_best_ = abs(out_corr);
+		    d_secondary_delay=i;
+		}
+	}
+    if (current_best_ == CN0_ESTIMATION_SAMPLES) // all bits correlate
+	{
+	    d_secondary_lock = true;
+	    d_secondary_delay = (d_secondary_delay+CN0_ESTIMATION_SAMPLES-1)%Galileo_E5a_Q_SECONDARY_CODE_LENGTH;
+	}
+}
+
+void Galileo_E5a_Dll_Pll_Tracking_cc::update_local_code()
+{
+    double tcode_chips;
+    double rem_code_phase_chips;
+    int associated_chip_index;
+    int associated_chip_index_data;
+    int code_length_chips = (int)Galileo_E5a_CODE_LENGTH_CHIPS;
+    double code_phase_step_chips;
+    int early_late_spc_samples;
+    int epl_loop_length_samples;
+
+    // unified loop for E, P, L code vectors
+    code_phase_step_chips = ((double)d_code_freq_chips) / ((double)d_fs_in);
+    rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / d_fs_in);
+    tcode_chips = -rem_code_phase_chips;
+
+    // Alternative EPL code generation (40% of speed improvement!)
+    early_late_spc_samples = round(d_early_late_spc_chips / code_phase_step_chips);
+    epl_loop_length_samples = d_current_prn_length_samples + early_late_spc_samples*2;
+
+    for (int i = 0; i < epl_loop_length_samples; i++)
+        {
+            associated_chip_index = 1 + round(fmod(tcode_chips - d_early_late_spc_chips, code_length_chips));
+            associated_chip_index_data = 1 + round(fmod(tcode_chips, code_length_chips));
+            d_early_code[i] = d_codeQ[associated_chip_index];
+            d_prompt_data_code[i] = d_codeI[associated_chip_index_data];
+            tcode_chips = tcode_chips + code_phase_step_chips;
+        }
+    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));
+
+}
+
+void Galileo_E5a_Dll_Pll_Tracking_cc::update_local_carrier()
+{
+    float phase_rad, phase_step_rad;
+
+    phase_step_rad = (float)2*GALILEO_PI*d_carrier_doppler_hz / (float)d_fs_in;
+    phase_rad = d_rem_carr_phase_rad;
+    for(int i = 0; i < d_current_prn_length_samples; i++)
+        {
+            d_carr_sign[i] = gr_complex(cos(phase_rad), -sin(phase_rad));
+            phase_rad += phase_step_rad;
+        }
+}
+
+int Galileo_E5a_Dll_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)
+{
+    // process vars
+    float carr_error_hz;
+    float carr_error_filt_hz;
+    float code_error_chips;
+    float code_error_filt_chips;
+    // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
+    Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; //block output streams pointer
+
+    // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder
+    Gnss_Synchro current_synchro_data;
+    // Fill the acquisition data
+    current_synchro_data = *d_acquisition_gnss_synchro;
+
+    /* States: 	0 Tracking not enabled
+     * 		1 Pull-in of primary code (alignment).
+     * 		3 Tracking algorithm. Correlates EPL each loop and accumulates the result
+     * 					until it reaches integration time.
+     */
+    switch (d_state)
+    {
+	case 0:
+	    {
+		// ########## 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);
+		d_Prompt_data = gr_complex(0,0);
+
+		*out[0] = *d_acquisition_gnss_synchro;
+
+		break;
+	    }
+	case 1:
+	    {
+		int samples_offset;
+		float 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((float)acq_to_trk_delay_samples, (float)d_current_prn_length_samples);
+		samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
+		d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples
+		std::cout<<" samples_offset="<<samples_offset<<"\r\n";
+		d_state = 2; // start in Ti = 1 code, until secondary code lock.
+
+		// make an output to not stop the rest of the processing blocks
+		current_synchro_data.Prompt_I = 0.0;
+		current_synchro_data.Prompt_Q = 0.0;
+		current_synchro_data.Tracking_timestamp_secs = (double)d_sample_counter/d_fs_in;
+		current_synchro_data.Carrier_phase_rads = 0.0;
+		current_synchro_data.Code_phase_secs = 0.0;
+		current_synchro_data.CN0_dB_hz = 0.0;
+		current_synchro_data.Flag_valid_tracking = false;
+
+		*out[0] = current_synchro_data;
+		consume_each(samples_offset); //shift input to perform alignment with local replica
+		return 1;
+	    }
+	case 2:
+	    {
+		// Block input data and block output stream pointers
+		const gr_complex* in = (gr_complex*) input_items[0]; //PRN start block alignment
+		gr_complex sec_sign_Q;
+		gr_complex sec_sign_I;
+		// Secondary code Chip
+		if (d_secondary_lock)
+		    {
+//			sec_sign_Q = gr_complex((Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN-1].at(d_secondary_delay)=='0' ? 1 : -1),0);
+//			sec_sign_I = gr_complex((Galileo_E5a_I_SECONDARY_CODE.at(d_secondary_delay%Galileo_E5a_I_SECONDARY_CODE_LENGTH)=='0' ? 1 : -1),0);
+			sec_sign_Q = gr_complex((Galileo_E5a_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN-1].at(d_secondary_delay)=='0' ? -1 : 1),0);
+			sec_sign_I = gr_complex((Galileo_E5a_I_SECONDARY_CODE.at(d_secondary_delay%Galileo_E5a_I_SECONDARY_CODE_LENGTH)=='0' ? -1 : 1),0);
+		    }
+		else
+		    {
+			sec_sign_Q = gr_complex(1.0,0.0);
+			sec_sign_I = gr_complex(1.0,0.0);
+		    }
+		// Reset integration counter
+		if (d_integration_counter == d_current_ti_ms)
+		    {
+			d_integration_counter = 0;
+		    }
+		//Generate local code and carrier replicas (using \hat{f}_d(k-1))
+		if (d_integration_counter == 0)
+		    {
+			update_local_code();
+			update_local_carrier();
+			// Reset accumulated values
+			d_Early = gr_complex(0,0);
+			d_Prompt = gr_complex(0,0);
+			d_Late = gr_complex(0,0);
+		    }
+		gr_complex single_early;
+		gr_complex single_prompt;
+		gr_complex single_late;
+
+		// perform carrier wipe-off and compute Early, Prompt and Late
+		// correlation of 1 primary code
+		d_correlator.Carrier_wipeoff_and_EPL_volk_IQ(d_current_prn_length_samples,
+		                                             in,
+		                                             d_carr_sign,
+		                                             d_early_code,
+		                                             d_prompt_code,
+		                                             d_late_code,
+		                                             d_prompt_data_code,
+		                                             &single_early,
+		                                             &single_prompt,
+		                                             &single_late,
+		                                             &d_Prompt_data,
+		                                             is_unaligned());
+
+		// Accumulate results (coherent integration since there are no bit transitions in pilot signal)
+		d_Early += single_early * sec_sign_Q;
+		d_Prompt += single_prompt * sec_sign_Q;
+		d_Late += single_late * sec_sign_Q;
+		d_Prompt_data *= sec_sign_I;
+		d_integration_counter++;
+
+		// check for samples consistency (this should be done before in the receiver / here only if the source is a file)
+		if (std::isnan((d_Prompt).real()) == true or std::isnan((d_Prompt).imag()) == true ) // or std::isinf(in[i].real())==true or std::isinf(in[i].imag())==true)
+		    {
+			const int samples_available = ninput_items[0];
+			d_sample_counter = d_sample_counter + samples_available;
+			LOG(WARNING) << "Detected NaN samples at sample number " << d_sample_counter;
+			consume_each(samples_available);
+
+			// make an output to not stop the rest of the processing blocks
+			current_synchro_data.Prompt_I = 0.0;
+			current_synchro_data.Prompt_Q = 0.0;
+			current_synchro_data.Tracking_timestamp_secs = (double)d_sample_counter/(double)d_fs_in;
+			current_synchro_data.Carrier_phase_rads = 0.0;
+			current_synchro_data.Code_phase_secs = 0.0;
+			current_synchro_data.CN0_dB_hz = 0.0;
+			current_synchro_data.Flag_valid_tracking = false;
+
+			*out[0] = current_synchro_data;
+
+			return 1;
+		    }
+		// ################## PLL ##########################################################
+		// PLL discriminator
+		if (d_integration_counter == d_current_ti_ms)
+		    {
+			if (d_secondary_lock == true)
+			    {
+				carr_error_hz = pll_four_quadrant_atan(d_Prompt) / (float)GALILEO_PI*2;
+			    }
+			else
+			    {
+				carr_error_hz = pll_cloop_two_quadrant_atan(d_Prompt) / (float)GALILEO_PI*2;
+			    }
+
+			// Carrier discriminator filter
+			carr_error_filt_hz = d_carrier_loop_filter.get_carrier_nco(carr_error_hz);
+			// New carrier Doppler frequency estimation
+			d_carrier_doppler_hz = d_acq_carrier_doppler_hz + carr_error_filt_hz;
+			// New code Doppler frequency estimation
+			d_code_freq_chips = Galileo_E5a_CODE_CHIP_RATE_HZ + ((d_carrier_doppler_hz * Galileo_E5a_CODE_CHIP_RATE_HZ) / Galileo_E5a_FREQ_HZ);
+		    }
+		//carrier phase accumulator for (K) doppler estimation
+		d_acc_carrier_phase_rad = d_acc_carrier_phase_rad + 2*GALILEO_PI*d_carrier_doppler_hz*GALILEO_E5a_CODE_PERIOD;
+		//remanent carrier phase to prevent overflow in the code NCO
+		d_rem_carr_phase_rad = d_rem_carr_phase_rad+2*GALILEO_PI*d_carrier_doppler_hz*GALILEO_E5a_CODE_PERIOD;
+		d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, 2*GALILEO_PI);
+
+		// ################## DLL ##########################################################
+		if (d_integration_counter == d_current_ti_ms)
+		    {
+			// DLL discriminator
+			code_error_chips = dll_nc_e_minus_l_normalized(d_Early, d_Late); //[chips/Ti]
+			// Code discriminator filter
+			code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips); //[chips/second]
+			//Code phase accumulator
+			d_code_error_filt_secs = (GALILEO_E5a_CODE_PERIOD*code_error_filt_chips)/Galileo_E5a_CODE_CHIP_RATE_HZ; //[seconds]
+		    }
+		d_acc_code_phase_secs = d_acc_code_phase_secs + d_code_error_filt_secs;
+
+		// ################## CARRIER AND CODE NCO BUFFER ALIGNMENT #######################
+		// keep alignment parameters for the next input buffer
+		double T_chip_seconds;
+		double T_prn_seconds;
+//		float T_prn_samples;
+//		float K_blk_samples;
+		//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 / (double)d_code_freq_chips;
+		T_prn_seconds = T_chip_seconds * Galileo_E5a_CODE_LENGTH_CHIPS;
+		T_prn_samples = T_prn_seconds * (double)d_fs_in;
+		K_blk_samples = T_prn_samples + d_rem_code_phase_samples + d_code_error_filt_secs*(float)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-1)
+		    {
+			// fill buffer with prompt correlator output values
+			d_Prompt_buffer[d_cn0_estimation_counter] = d_Prompt;
+			d_cn0_estimation_counter++;
+		    }
+		else
+		    {
+			d_Prompt_buffer[d_cn0_estimation_counter] = d_Prompt;
+			// ATTEMPT SECONDARY CODE ACQUISITION
+			if (d_secondary_lock == false)
+			    {
+				acquire_secondary(); // changes d_secondary_lock and d_secondary_delay
+				if (d_secondary_lock == true)
+				    {
+					std::cout << "Secondary code locked." << std::endl;
+					d_current_ti_ms = d_ti_ms;
+					// Change loop parameters ==========================================
+					d_code_loop_filter.set_pdi(d_current_ti_ms * GALILEO_E5a_CODE_PERIOD);
+					d_carrier_loop_filter.set_pdi(d_current_ti_ms * GALILEO_E5a_CODE_PERIOD);
+//					d_code_loop_filter.initialize();
+//					d_carrier_loop_filter.initialize();
+					d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
+					d_carrier_loop_filter.set_PLL_BW(d_pll_bw_hz);
+				    }
+				else
+				    {
+					std::cout << "Secondary code delay couldn't be resolved." << std::endl;
+					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 << "!";
+						ControlMessageFactory* cmf = new ControlMessageFactory();
+						if (d_queue != gr::msg_queue::sptr())
+						    {
+							d_queue->handle(cmf->GetQueueMessage(d_channel, 2));
+						    }
+						delete cmf;
+						d_carrier_lock_fail_counter = 0;
+						d_state = 0; // TODO: check if disabling tracking is consistent with the channel state machine
+					    }
+				    }
+			    }
+			else // Secondary lock achieved, monitor carrier lock.
+			    {
+				// Code lock indicator
+				d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES, d_fs_in,d_current_ti_ms * Galileo_E5a_CODE_LENGTH_CHIPS);
+				// Carrier lock indicator
+				d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, 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 << "!";
+						ControlMessageFactory* cmf = new ControlMessageFactory();
+						if (d_queue != gr::msg_queue::sptr())
+						    {
+							d_queue->handle(cmf->GetQueueMessage(d_channel, 2));
+						    }
+						delete cmf;
+						d_carrier_lock_fail_counter = 0;
+						d_state = 0;
+					    }
+				    }
+			    }
+			d_cn0_estimation_counter = 0;
+		    }
+		if (d_secondary_lock && (d_secondary_delay%Galileo_E5a_I_SECONDARY_CODE_LENGTH)==0)
+		    {
+			d_first_transition = true;
+		    }
+		// ########### Output the tracking data to navigation and PVT ##########
+		// The first Prompt output not equal to 0 is synchronized with the transition of a navigation data bit.
+		if (d_secondary_lock && d_first_transition)
+		    {
+			current_synchro_data.Prompt_I = (double)(d_Prompt_data.real());
+			current_synchro_data.Prompt_Q = (double)(d_Prompt_data.imag());
+			// Tracking_timestamp_secs is aligned with the PRN start sample
+			current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter + (double)d_current_prn_length_samples + (double)d_rem_code_phase_samples)/(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 = (double)d_acc_carrier_phase_rad;
+			current_synchro_data.Carrier_Doppler_hz = (double)d_carrier_doppler_hz;
+			current_synchro_data.CN0_dB_hz = (double)d_CN0_SNV_dB_Hz;
+		    }
+		else
+		    {
+
+			// make an output to not stop the rest of the processing blocks
+			current_synchro_data.Prompt_I = 0.0;
+			current_synchro_data.Prompt_Q = 0.0;
+			current_synchro_data.Tracking_timestamp_secs = (double)d_sample_counter/d_fs_in;
+			current_synchro_data.Carrier_phase_rads = 0.0;
+			current_synchro_data.Code_phase_secs = 0.0;
+			current_synchro_data.CN0_dB_hz = 0.0;
+			current_synchro_data.Flag_valid_tracking = false;
+		    }
+		*out[0] = current_synchro_data;
+	    }
+    }
+
+    if(d_dump)
+        {
+            // MULTIPLEXED FILE RECORDING - Record results to file
+            float prompt_I;
+            float prompt_Q;
+            float tmp_float;
+            double tmp_double;
+            prompt_I = d_Prompt_data.real();
+            prompt_Q = d_Prompt_data.imag();
+	    if (d_integration_counter == d_current_ti_ms)
+        	{
+        	    tmp_E = std::abs<float>(d_Early);
+        	    tmp_P = std::abs<float>(d_Prompt);
+        	    tmp_L = std::abs<float>(d_Late);
+        	}
+            try
+            {
+        	// EPR
+        	d_dump_file.write((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
+        	d_dump_file.write((char*)&d_sample_counter, sizeof(unsigned long int));
+        	// accumulated carrier phase
+        	d_dump_file.write((char*)&d_acc_carrier_phase_rad, sizeof(float));
+
+        	// carrier and code frequency
+        	d_dump_file.write((char*)&d_carrier_doppler_hz, sizeof(float));
+        	d_dump_file.write((char*)&d_code_freq_chips, sizeof(float));
+
+        	//PLL commands
+        	d_dump_file.write((char*)&carr_error_hz, sizeof(float));
+        	d_dump_file.write((char*)&carr_error_filt_hz, sizeof(float));
+
+        	//DLL commands
+        	d_dump_file.write((char*)&code_error_chips, sizeof(float));
+        	d_dump_file.write((char*)&code_error_filt_chips, sizeof(float));
+
+        	// CN0 and carrier lock test
+        	d_dump_file.write((char*)&d_CN0_SNV_dB_Hz, sizeof(float));
+        	d_dump_file.write((char*)&d_carrier_lock_test, 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();
+            }
+        }
+
+    d_secondary_delay = (d_secondary_delay + 1)%Galileo_E5a_Q_SECONDARY_CODE_LENGTH;
+    d_sample_counter += d_current_prn_length_samples; //count for the processed samples
+    consume_each(d_current_prn_length_samples); // this is necessary in gr::block derivates
+    return 1; //output tracking result ALWAYS even in the case of d_enable_tracking==false
+}
+
+void Galileo_E5a_Dll_Pll_Tracking_cc::set_channel(unsigned int channel)
+{
+    d_channel = channel;
+    LOG(INFO) << "Tracking Channel set to " << d_channel;
+    // ############# ENABLE DATA FILE LOG #################
+    if (d_dump == true)
+        {
+            if (d_dump_file.is_open() == false)
+                {
+                    try
+                    {
+                            d_dump_filename.append(boost::lexical_cast<std::string>(d_channel));
+                            d_dump_filename.append(".dat");
+                            d_dump_file.exceptions (std::ifstream::failbit | std::ifstream::badbit);
+                            d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
+                            LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str() << std::endl;
+                    }
+                    catch (std::ifstream::failure e)
+                    {
+                            LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what() << std::endl;
+                    }
+                }
+        }
+}
+
+
+
+void Galileo_E5a_Dll_Pll_Tracking_cc::set_channel_queue(concurrent_queue<int> *channel_internal_queue)
+{
+    d_channel_internal_queue = channel_internal_queue;
+}
+
+
+void Galileo_E5a_Dll_Pll_Tracking_cc::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
+{
+    d_acquisition_gnss_synchro = p_gnss_synchro;
+}
+

src/algorithms/tracking/gnuradio_blocks/galileo_e5a_dll_pll_tracking_cc.h

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

src/algorithms/tracking/libs/correlator.cc

@@ -113,6 +113,80 @@ void Correlator::Carrier_wipeoff_and_EPL_volk(int signal_length_samples, const g
     //}
 }
 
+//void Correlator::Carrier_wipeoff_and_EPL_volk_IQ(int prn_length_samples,int integration_time ,const gr_complex* input, gr_complex* carrier, gr_complex* E_code, gr_complex* P_code, gr_complex* L_code, gr_complex* P_data_code, gr_complex* E_out, gr_complex* P_out, gr_complex* L_out, gr_complex* P_data_out, bool input_vector_unaligned)
+//{
+//    gr_complex* bb_signal;
+//    //gr_complex* input_aligned;
+//
+//    //todo: do something if posix_memalign fails
+//    if (posix_memalign((void**)&bb_signal, 16, integration_time * prn_length_samples * sizeof(gr_complex)) == 0) {};
+//
+//    if (input_vector_unaligned == true)
+//        {
+//            //todo: do something if posix_memalign fails
+//            //if (posix_memalign((void**)&input_aligned, 16, signal_length_samples * sizeof(gr_complex)) == 0){};
+//            //memcpy(input_aligned,input,signal_length_samples * sizeof(gr_complex));
+//
+//            volk_32fc_x2_multiply_32fc_u(bb_signal, input, carrier, integration_time * prn_length_samples);
+//        }
+//    else
+//        {
+//            /*
+//             * todo: There is a problem with the aligned version of volk_32fc_x2_multiply_32fc_a.
+//             * It crashes even if the is_aligned() work function returns true. Im keeping the unaligned version in both cases..
+//             */
+//            //use directly the input vector
+//            volk_32fc_x2_multiply_32fc_u(bb_signal, input, carrier, integration_time * prn_length_samples);
+//        }
+//
+//    volk_32fc_x2_dot_prod_32fc_a(E_out, bb_signal, E_code, integration_time * prn_length_samples);
+//    volk_32fc_x2_dot_prod_32fc_a(P_out, bb_signal, P_code, integration_time * prn_length_samples);
+//    volk_32fc_x2_dot_prod_32fc_a(L_out, bb_signal, L_code, integration_time * prn_length_samples);
+//    // Vector of Prompts of I code
+//    for (int i = 0; i < integration_time; i++)
+//	{
+//	    volk_32fc_x2_dot_prod_32fc_a(&P_data_out[i], &bb_signal[i*prn_length_samples], P_data_code, prn_length_samples);
+//	}
+//
+//    free(bb_signal);
+//
+//}
+void Correlator::Carrier_wipeoff_and_EPL_volk_IQ(int signal_length_samples ,const gr_complex* input, gr_complex* carrier, gr_complex* E_code, gr_complex* P_code, gr_complex* L_code, gr_complex* P_data_code, gr_complex* E_out, gr_complex* P_out, gr_complex* L_out, gr_complex* P_data_out, bool input_vector_unaligned)
+{
+    gr_complex* bb_signal;
+    //gr_complex* input_aligned;
+
+    //todo: do something if posix_memalign fails
+    if (posix_memalign((void**)&bb_signal, 16, signal_length_samples * sizeof(gr_complex)) == 0) {};
+
+    if (input_vector_unaligned == true)
+        {
+            //todo: do something if posix_memalign fails
+            //if (posix_memalign((void**)&input_aligned, 16, signal_length_samples * sizeof(gr_complex)) == 0){};
+            //memcpy(input_aligned,input,signal_length_samples * sizeof(gr_complex));
+
+            volk_32fc_x2_multiply_32fc_u(bb_signal, input, carrier, signal_length_samples);
+        }
+    else
+        {
+            /*
+             * todo: There is a problem with the aligned version of volk_32fc_x2_multiply_32fc_a.
+             * It crashes even if the is_aligned() work function returns true. Im keeping the unaligned version in both cases..
+             */
+            //use directly the input vector
+            volk_32fc_x2_multiply_32fc_u(bb_signal, input, carrier, signal_length_samples);
+        }
+
+    volk_32fc_x2_dot_prod_32fc_a(E_out, bb_signal, E_code, signal_length_samples);
+    volk_32fc_x2_dot_prod_32fc_a(P_out, bb_signal, P_code, signal_length_samples);
+    volk_32fc_x2_dot_prod_32fc_a(L_out, bb_signal, L_code, signal_length_samples);
+    volk_32fc_x2_dot_prod_32fc_a(P_data_out, bb_signal, P_data_code, signal_length_samples);
+
+
+    free(bb_signal);
+
+}
+
 void Correlator::Carrier_wipeoff_and_EPL_volk_custom(int signal_length_samples, const gr_complex* input, gr_complex* carrier,gr_complex* E_code, gr_complex* P_code, gr_complex* L_code, gr_complex* E_out, gr_complex* P_out, gr_complex* L_out, bool input_vector_unaligned)
 {
     volk_cw_epl_corr_u(input, carrier, E_code, P_code, L_code, E_out, P_out, L_out, signal_length_samples);

src/algorithms/tracking/libs/correlator.h

@@ -57,6 +57,8 @@ public:
     void Carrier_wipeoff_and_EPL_volk(int signal_length_samples, const gr_complex* input, gr_complex* carrier, gr_complex* E_code, gr_complex* P_code, gr_complex* L_code, gr_complex* E_out, gr_complex* P_out, gr_complex* L_out, bool input_vector_unaligned);
     void Carrier_wipeoff_and_EPL_volk_custom(int signal_length_samples, const gr_complex* input, gr_complex* carrier, gr_complex* E_code, gr_complex* P_code, gr_complex* L_code, gr_complex* E_out, gr_complex* P_out, gr_complex* L_out, bool input_vector_unaligned);
     void Carrier_wipeoff_and_VEPL_volk(int signal_length_samples, const gr_complex* input, gr_complex* carrier, gr_complex* VE_code, gr_complex* E_code, gr_complex* P_code, gr_complex* L_code, gr_complex* VL_code, gr_complex* VE_out, gr_complex* E_out, gr_complex* P_out, gr_complex* L_out, gr_complex* VL_out, bool input_vector_unaligned);
+//    void Carrier_wipeoff_and_EPL_volk_IQ(int prn_length_samples,int integration_time ,const gr_complex* input, gr_complex* carrier, gr_complex* E_code, gr_complex* P_code, gr_complex* L_code, gr_complex* P_data_code, gr_complex* E_out, gr_complex* P_out, gr_complex* L_out, gr_complex* P_data_out, bool input_vector_unaligned);
+    void Carrier_wipeoff_and_EPL_volk_IQ(int signal_length_samples, const gr_complex* input, gr_complex* carrier, gr_complex* E_code, gr_complex* P_code, gr_complex* L_code, gr_complex* P_data_code, gr_complex* E_out, gr_complex* P_out, gr_complex* L_out, gr_complex* P_data_out, bool input_vector_unaligned);
     Correlator();
     ~Correlator();
 private:

src/algorithms/tracking/libs/tracking_2nd_DLL_filter.cc

@@ -71,7 +71,8 @@ void Tracking_2nd_DLL_filter::initialize()
 float Tracking_2nd_DLL_filter::get_code_nco(float DLL_discriminator)
 {
     float code_nco;
-    code_nco = d_old_code_nco + (d_tau2_code/d_tau1_code)*(DLL_discriminator - d_old_code_error) + DLL_discriminator * (d_pdi_code/d_tau1_code);
+    code_nco = d_old_code_nco + (d_tau2_code/d_tau1_code)*(DLL_discriminator - d_old_code_error) + (DLL_discriminator+d_old_code_error) * (d_pdi_code/(2*d_tau1_code));
+    //code_nco = d_old_code_nco + (d_tau2_code/d_tau1_code)*(DLL_discriminator - d_old_code_error) + DLL_discriminator * (d_pdi_code/d_tau1_code);
     d_old_code_nco   = code_nco;
     d_old_code_error = DLL_discriminator; //[chips]
     return code_nco;
@@ -92,3 +93,7 @@ Tracking_2nd_DLL_filter::Tracking_2nd_DLL_filter ()
 Tracking_2nd_DLL_filter::~Tracking_2nd_DLL_filter ()
 {}
 
+void Tracking_2nd_DLL_filter::set_pdi(float pdi_code)
+{
+    d_pdi_code = pdi_code; // Summation interval for code
+}

src/algorithms/tracking/libs/tracking_2nd_DLL_filter.h

@@ -60,6 +60,7 @@ private:
 
 public:
     void set_DLL_BW(float dll_bw_hz);                //! Set DLL filter bandwidth [Hz]
+    void set_pdi(float pdi_code); //! Set Summation interval for code [s]
     void initialize(); //! Start tracking with acquisition information
     float get_code_nco(float DLL_discriminator);     //! Numerically controlled oscillator
     Tracking_2nd_DLL_filter(float pdi_code);

src/algorithms/tracking/libs/tracking_2nd_PLL_filter.cc

@@ -74,7 +74,8 @@ void Tracking_2nd_PLL_filter::initialize()
 float Tracking_2nd_PLL_filter::get_carrier_nco(float PLL_discriminator)
 {
     float carr_nco;
-    carr_nco = d_old_carr_nco + (d_tau2_carr/d_tau1_carr)*(PLL_discriminator - d_old_carr_error) + PLL_discriminator * (d_pdi_carr/d_tau1_carr);
+    carr_nco = d_old_carr_nco + (d_tau2_carr/d_tau1_carr)*(PLL_discriminator - d_old_carr_error) + (PLL_discriminator + d_old_carr_error) * (d_pdi_carr/(2*d_tau1_carr));
+    //carr_nco = d_old_carr_nco + (d_tau2_carr/d_tau1_carr)*(PLL_discriminator - d_old_carr_error) + PLL_discriminator * (d_pdi_carr/d_tau1_carr);
     d_old_carr_nco   = carr_nco;
     d_old_carr_error = PLL_discriminator;
     return carr_nco;
@@ -84,7 +85,8 @@ Tracking_2nd_PLL_filter::Tracking_2nd_PLL_filter (float pdi_carr)
 {
     //--- PLL variables --------------------------------------------------------
     d_pdi_carr = pdi_carr;// Summation interval for carrier
-    d_plldampingratio = 0.65;
+    //d_plldampingratio = 0.65;
+    d_plldampingratio = 0.7;
 }
 
 
@@ -100,3 +102,8 @@ Tracking_2nd_PLL_filter::Tracking_2nd_PLL_filter ()
 
 Tracking_2nd_PLL_filter::~Tracking_2nd_PLL_filter ()
 {}
+
+void Tracking_2nd_PLL_filter::set_pdi(float pdi_carr)
+{
+    d_pdi_carr = pdi_carr; // Summation interval for code
+}

src/algorithms/tracking/libs/tracking_2nd_PLL_filter.h

@@ -62,6 +62,7 @@ private:
 
 public:
 	void set_PLL_BW(float pll_bw_hz);  //! Set PLL loop bandwidth [Hz]
+	void set_pdi(float pdi_carr); //! Set Summation interval for code [s]
 	void initialize();
 	float get_carrier_nco(float PLL_discriminator);
         Tracking_2nd_PLL_filter(float pdi_carr);

src/core/receiver/gnss_block_factory.cc

@@ -67,14 +67,17 @@
 #include "galileo_e1_pcps_tong_ambiguous_acquisition.h"
 #include "galileo_e1_pcps_cccwsr_ambiguous_acquisition.h"
 #include "galileo_e1_pcps_quicksync_ambiguous_acquisition.h"
+#include "galileo_e5a_noncoherent_iq_acquisition_caf.h"
 #include "gps_l1_ca_dll_pll_tracking.h"
 #include "gps_l1_ca_dll_pll_optim_tracking.h"
 #include "gps_l1_ca_dll_fll_pll_tracking.h"
 #include "gps_l1_ca_tcp_connector_tracking.h"
 #include "galileo_e1_dll_pll_veml_tracking.h"
 #include "galileo_e1_tcp_connector_tracking.h"
+#include "galileo_e5a_dll_pll_tracking.h"
 #include "gps_l1_ca_telemetry_decoder.h"
 #include "galileo_e1b_telemetry_decoder.h"
+#include "galileo_e5a_telemetry_decoder.h"
 #include "sbas_l1_telemetry_decoder.h"
 #include "gps_l1_ca_observables.h"
 #include "galileo_e1_observables.h"
@@ -526,6 +529,14 @@ std::unique_ptr<GNSSBlockInterface> GNSSBlockFactory::GetBlock(
                     out_streams, queue));
             block = std::move(block_);
         }
+    else if (implementation.compare("Galileo_E5a_Noncoherent_IQ_Acquisition_CAF") == 0)
+        {
+            std::unique_ptr<GNSSBlockInterface> block_(new GalileoE5aNoncoherentIQAcquisitionCaf(configuration.get(), role, in_streams,
+                    out_streams, queue));
+            block = std::move(block_);
+        }
+
+
     else if (implementation.compare("Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition") == 0)
         {
             std::unique_ptr<GNSSBlockInterface> block_( new GalileoE1PcpsQuickSyncAmbiguousAcquisition(configuration.get(), role, in_streams,
@@ -533,6 +544,14 @@ std::unique_ptr<GNSSBlockInterface> GNSSBlockFactory::GetBlock(
             block = std::move(block_);
         }
 
+    else if (implementation.compare("Galileo_E5a_Noncoherent_IQ_Acquisition_CAF") == 0)
+        {
+            std::unique_ptr<GNSSBlockInterface> block_(new GalileoE5aNoncoherentIQAcquisitionCaf(configuration.get(), role, in_streams,
+                    out_streams, queue));
+            block = std::move(block_);
+        }
+
+
     // TRACKING BLOCKS -------------------------------------------------------------
     else if (implementation.compare("GPS_L1_CA_DLL_PLL_Tracking") == 0)
         {
@@ -570,6 +589,12 @@ std::unique_ptr<GNSSBlockInterface> GNSSBlockFactory::GetBlock(
                     out_streams, queue));
             block = std::move(block_);
         }
+    else if (implementation.compare("Galileo_E5a_DLL_PLL_Tracking") == 0)
+        {
+            std::unique_ptr<GNSSBlockInterface> block_(new GalileoE5aDllPllTracking(configuration.get(), role, in_streams,
+                    out_streams, queue));
+            block = std::move(block_);
+        }
 
     // TELEMETRY DECODERS ----------------------------------------------------------
     else if (implementation.compare("GPS_L1_CA_Telemetry_Decoder") == 0)
@@ -590,6 +615,12 @@ std::unique_ptr<GNSSBlockInterface> GNSSBlockFactory::GetBlock(
                     out_streams, queue));
             block = std::move(block_);
         }
+    else if (implementation.compare("Galileo_E5a_Telemetry_Decoder") == 0)
+        {
+            std::unique_ptr<GNSSBlockInterface> block_(new GalileoE5aTelemetryDecoder(configuration.get(), role, in_streams,
+                    out_streams, queue));
+            block = std::move(block_);
+        }
 
     // OBSERVABLES -----------------------------------------------------------------
     else if (implementation.compare("GPS_L1_CA_Observables") == 0)
@@ -738,12 +769,19 @@ std::unique_ptr<AcquisitionInterface> GNSSBlockFactory::GetAcqBlock(
                     out_streams, queue));
             block = std::move(block_);
         }
+
     else if (implementation.compare("Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition") == 0)
         {
             std::unique_ptr<AcquisitionInterface> block_( new GalileoE1PcpsQuickSyncAmbiguousAcquisition(configuration.get(), role, in_streams,
                     out_streams, queue));
             block = std::move(block_);
         }
+    else if (implementation.compare("Galileo_E5a_Noncoherent_IQ_Acquisition_CAF") == 0)
+        {
+            std::unique_ptr<AcquisitionInterface> block_(new GalileoE5aNoncoherentIQAcquisitionCaf(configuration.get(), role, in_streams,
+                    out_streams, queue));
+            block = std::move(block_);
+        }
     else
         {
             // Log fatal. This causes execution to stop.
@@ -798,6 +836,12 @@ std::unique_ptr<TrackingInterface> GNSSBlockFactory::GetTrkBlock(
                     out_streams, queue));
             block = std::move(block_);
         }
+    else if (implementation.compare("Galileo_E5a_DLL_PLL_Tracking") == 0)
+        {
+            std::unique_ptr<TrackingInterface> block_(new GalileoE5aDllPllTracking(configuration.get(), role, in_streams,
+                    out_streams, queue));
+            block = std::move(block_);
+        }
     else
         {
             // Log fatal. This causes execution to stop.
@@ -834,6 +878,12 @@ std::unique_ptr<TelemetryDecoderInterface> GNSSBlockFactory::GetTlmBlock(
                     out_streams, queue));
             block = std::move(block_);
         }
+    else if (implementation.compare("Galileo_E5a_Telemetry_Decoder") == 0)
+        {
+            std::unique_ptr<TelemetryDecoderInterface> block_(new GalileoE5aTelemetryDecoder(configuration.get(), role, in_streams,
+                    out_streams, queue));
+            block = std::move(block_);
+        }
     else
         {
             // Log fatal. This causes execution to stop.

src/core/receiver/gnss_flowgraph.cc

@@ -332,6 +332,9 @@ void GNSSFlowgraph::connect()
     top_block_->dump();
 }
 
+
+
+
 void GNSSFlowgraph::wait()
 {
     if (!running_)
@@ -344,6 +347,10 @@ void GNSSFlowgraph::wait()
     running_ = false;
 }
 
+
+
+
+
 /*
  * Applies an action to the flowgraph
  *
@@ -493,15 +500,16 @@ void GNSSFlowgraph::set_signals_list()
      */
 
     /*
-     * Read GNSS-SDR default GNSS system
+     * Read GNSS-SDR default GNSS system and signal
      */
     std::string default_system = configuration_->property("Channel.system", std::string("GPS"));
+    std::string default_signal = configuration_->property("Channel.signal", std::string("1C"));
 
     /*
      * Loop to create the list of GNSS Signals
      * To add signals from other systems, add another loop 'for'
      */
-    if (default_system.find(std::string("GPS")) != std::string::npos)
+    if (default_system.compare(std::string("GPS")) == 0 )
         {
             /*
              * Loop to create GPS L1 C/A signals
@@ -520,7 +528,7 @@ void GNSSFlowgraph::set_signals_list()
         }
 
 
-    if (default_system.find(std::string("SBAS")) != std::string::npos)
+    if (default_system.compare(std::string("SBAS")) == 0 )
         {
             /*
              * Loop to create SBAS L1 C/A signals
@@ -537,7 +545,7 @@ void GNSSFlowgraph::set_signals_list()
         }
 
 
-    if (default_system.find(std::string("Galileo")) != std::string::npos)
+    if (default_system.find(std::string("Galileo")) )
         {
             /*
              * Loop to create the list of Galileo E1 B signals
@@ -550,15 +558,16 @@ void GNSSFlowgraph::set_signals_list()
                     available_gnss_prn_iter != available_galileo_prn.end();
                     available_gnss_prn_iter++)
                 {
+//                    available_GNSS_signals_.push_back(Gnss_Signal(Gnss_Satellite(std::string("Galileo"),
+//                            *available_gnss_prn_iter), std::string("1B")));
                     available_GNSS_signals_.push_back(Gnss_Signal(Gnss_Satellite(std::string("Galileo"),
-                            *available_gnss_prn_iter), std::string("1B")));
+                            *available_gnss_prn_iter), default_signal));
                 }
         }
 
     /*
      * Ordering the list of signals from configuration file
      */
-    std::string default_signal = configuration_->property("Channel.signal", std::string("1C"));
 
     std::list<Gnss_Signal>::iterator gnss_it = available_GNSS_signals_.begin();
 
@@ -589,16 +598,19 @@ void GNSSFlowgraph::set_signals_list()
                     available_GNSS_signals_.insert(gnss_it, signal_value);
                 }
         }
-    //    **** FOR DEBUGGING THE LIST OF GNSS SIGNALS ****
-    //
-    std::cout<<"default_system="<<default_system<<std::endl;
-    std::cout<<"default_signal="<<default_signal<<std::endl;
-        std::list<Gnss_Signal>::iterator available_gnss_list_iter;
-        for (available_gnss_list_iter = available_GNSS_signals_.begin(); available_gnss_list_iter
-        != available_GNSS_signals_.end(); available_gnss_list_iter++)
-        {
-          std::cout << *available_gnss_list_iter << std::endl;
-        }
+
+
+//    **** FOR DEBUGGING THE LIST OF GNSS SIGNALS ****
+
+//    std::cout<<"default_system="<<default_system<<std::endl;
+//    std::cout<<"default_signal="<<default_signal<<std::endl;
+//        std::list<Gnss_Signal>::iterator available_gnss_list_iter;
+//        for (available_gnss_list_iter = available_GNSS_signals_.begin(); available_gnss_list_iter
+//        != available_GNSS_signals_.end(); available_gnss_list_iter++)
+//        {
+//          std::cout << *available_gnss_list_iter << std::endl;
+//        }
+
 }
 
 

src/core/system_parameters/CMakeLists.txt

@@ -36,6 +36,7 @@ set(SYSTEM_PARAMETERS_SOURCES
 	 sbas_ionospheric_correction.cc
 	 sbas_satellite_correction.cc
 	 sbas_telemetry_data.cc
+	 galileo_fnav_message.cc
 )
 
 

src/core/system_parameters/Galileo_E5a.h

@@ -0,0 +1,380 @@
+/*
+ * \file Galileo_E5a.h
+ * \brief  Defines system parameters for Galileo E5a signal and NAV data
+ * \author Marc Sales, 2014. marcsales92@gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_E5A_H_
+#define GNSS_SDR_GALILEO_E5A_H_
+
+#include <complex>
+#include <gnss_satellite.h>
+#include <string>
+#include <vector>
+#include <utility> // std::pair
+#include "MATH_CONSTANTS.h"
+
+// Physical constants already defined in E1
+
+// Carrier and code frequencies
+const double Galileo_E5a_FREQ_HZ = 1.176450e9;             //!< Galileo E5a carrier frequency [Hz]
+const double Galileo_E5a_CODE_CHIP_RATE_HZ = 1.023e7;     //!< Galileo E5a code rate [chips/s]
+const double Galileo_E5a_I_TIERED_CODE_PERIOD = 0.020;             //!< Galileo E5a-I tiered code period [s]
+const double Galileo_E5a_Q_TIERED_CODE_PERIOD = 0.100;             //!< Galileo E5a-Q tiered code period [s]
+const int Galileo_E5a_CODE_LENGTH_CHIPS = 10230;    //!< Galileo E5a primary code length [chips]
+const int Galileo_E5a_I_SECONDARY_CODE_LENGTH = 20;  //!< Galileo E5a-I secondary code length [chips]
+const int Galileo_E5a_Q_SECONDARY_CODE_LENGTH = 100;  //!< Galileo E5a-Q secondary code length [chips]
+const double GALILEO_E5a_CODE_PERIOD = 0.001;
+const int Galileo_E5a_SYMBOL_RATE_BPS = 50;       //!< Galileo E5a symbol rate [bits/second]
+const int Galileo_E5a_NUMBER_OF_CODES = 50;
+
+// F/NAV message structure
+
+const int GALILEO_FNAV_PREAMBLE_LENGTH_BITS = 12;
+const std::string GALILEO_FNAV_PREAMBLE = {"101101110000"};
+const int GALILEO_FNAV_CODES_PER_SYMBOL = 20; // (chip rate/ code length)/telemetry bps
+const int GALILEO_FNAV_CODES_PER_PREAMBLE = 240; // bits preamble * codes/symbol
+const int GALILEO_FNAV_SYMBOLS_PER_PAGE = 500; //Total symbols per page including preamble. See Galileo ICD 4.2.2
+const int GALILEO_FNAV_SECONDS_PER_PAGE = 10;
+const int GALILEO_FNAV_CODES_PER_PAGE = 10000; // symbols * codes/symbol, where code stands for primary code
+
+const int GALILEO_FNAV_INTERLEAVER_ROWS = 8;
+const int GALILEO_FNAV_INTERLEAVER_COLS = 61;
+const int GALILEO_FNAV_PAGE_TYPE_BITS = 6;
+
+const int GALILEO_FNAV_DATA_FRAME_BITS = 214;
+const int GALILEO_FNAV_DATA_FRAME_BYTES = 27;
+
+const std::vector<std::pair<int,int>> FNAV_PAGE_TYPE_bit({{1,6}});
+
+/* WORD 1 iono corrections. FNAV (Galileo E5a message)*/
+const std::vector<std::pair<int,int>> FNAV_SV_ID_PRN_1_bit({{6,6}});
+const std::vector<std::pair<int,int>> FNAV_IODnav_1_bit({{12,10}});
+const std::vector<std::pair<int,int>> FNAV_t0c_1_bit({{22,14}});
+const double FNAV_t0c_1_LSB = 60;
+const std::vector<std::pair<int,int>> FNAV_af0_1_bit({{36,31}});
+const double FNAV_af0_1_LSB = TWO_N34;
+const std::vector<std::pair<int,int>> FNAV_af1_1_bit({{67,21}});
+const double FNAV_af1_1_LSB = TWO_N46;
+const std::vector<std::pair<int,int>> FNAV_af2_1_bit({{88,6}});
+const double FNAV_af2_1_LSB = TWO_N59;
+const std::vector<std::pair<int,int>> FNAV_SISA_1_bit({{94,8}});
+const std::vector<std::pair<int,int>> FNAV_ai0_1_bit({{102,11}});
+const double FNAV_ai0_1_LSB = TWO_N2;
+const std::vector<std::pair<int,int>> FNAV_ai1_1_bit({{113,11}});
+const double FNAV_ai1_1_LSB = TWO_N8;
+const std::vector<std::pair<int,int>> FNAV_ai2_1_bit({{124,14}});
+const double FNAV_ai2_1_LSB = TWO_N15;
+const std::vector<std::pair<int,int>> FNAV_region1_1_bit({{138,1}});
+const std::vector<std::pair<int,int>> FNAV_region2_1_bit({{139,1}});
+const std::vector<std::pair<int,int>> FNAV_region3_1_bit({{140,1}});
+const std::vector<std::pair<int,int>> FNAV_region4_1_bit({{141,1}});
+const std::vector<std::pair<int,int>> FNAV_region5_1_bit({{142,1}});
+const std::vector<std::pair<int,int>> FNAV_BGD_1_bit({{143,10}});
+const double FNAV_BGD_1_LSB = TWO_N32;
+const std::vector<std::pair<int,int>> FNAV_E5ahs_1_bit({{153,2}});
+const std::vector<std::pair<int,int>> FNAV_WN_1_bit({{155,12}});
+const std::vector<std::pair<int,int>> FNAV_TOW_1_bit({{167,20}});
+const std::vector<std::pair<int,int>> FNAV_E5advs_1_bit({{187,1}});
+
+// WORD 2 Ephemeris (1/3)
+const std::vector<std::pair<int,int>> FNAV_IODnav_2_bit({{6,10}});
+const std::vector<std::pair<int,int>> FNAV_M0_2_bit({{16,32}});
+const double FNAV_M0_2_LSB = PI_TWO_N31;
+const std::vector<std::pair<int,int>> FNAV_omegadot_2_bit({{48,24}});
+const double FNAV_omegadot_2_LSB = PI_TWO_N43;
+const std::vector<std::pair<int,int>> FNAV_e_2_bit({{72,32}});
+const double FNAV_e_2_LSB = TWO_N33;
+const std::vector<std::pair<int,int>> FNAV_a12_2_bit({{104,32}});
+const double FNAV_a12_2_LSB = TWO_N19;
+const std::vector<std::pair<int,int>> FNAV_omega0_2_bit({{136,32}});
+const double FNAV_omega0_2_LSB = PI_TWO_N31;
+const std::vector<std::pair<int,int>> FNAV_idot_2_bit({{168,14}});
+const double FNAV_idot_2_LSB = PI_TWO_N43;
+const std::vector<std::pair<int,int>> FNAV_WN_2_bit({{182,12}});
+const std::vector<std::pair<int,int>> FNAV_TOW_2_bit({{194,20}});
+
+// WORD 3 Ephemeris (2/3)
+const std::vector<std::pair<int,int>> FNAV_IODnav_3_bit({{6,10}});
+const std::vector<std::pair<int,int>> FNAV_i0_3_bit({{16,32}});
+const double FNAV_i0_3_LSB = PI_TWO_N31;
+const std::vector<std::pair<int,int>> FNAV_w_3_bit({{48,32}});
+const double FNAV_w_3_LSB = PI_TWO_N31;
+const std::vector<std::pair<int,int>> FNAV_deltan_3_bit({{80,16}});
+const double FNAV_deltan_3_LSB = PI_TWO_N43;
+const std::vector<std::pair<int,int>> FNAV_Cuc_3_bit({{96,16}});
+const double FNAV_Cuc_3_LSB = TWO_N29;
+const std::vector<std::pair<int,int>> FNAV_Cus_3_bit({{112,16}});
+const double FNAV_Cus_3_LSB = TWO_N29;
+const std::vector<std::pair<int,int>> FNAV_Crc_3_bit({{128,16}});
+const double FNAV_Crc_3_LSB = TWO_N5;
+const std::vector<std::pair<int,int>> FNAV_Crs_3_bit({{144,16}});
+const double FNAV_Crs_3_LSB = TWO_N5;
+const std::vector<std::pair<int,int>> FNAV_t0e_3_bit({{160,14}});
+const double FNAV_t0e_3_LSB = 60;
+const std::vector<std::pair<int,int>> FNAV_WN_3_bit({{174,12}});
+const std::vector<std::pair<int,int>> FNAV_TOW_3_bit({{186,20}});
+
+// WORD 4 Ephemeris (3/3)
+const std::vector<std::pair<int,int>> FNAV_IODnav_4_bit({{6,10}});
+const std::vector<std::pair<int,int>> FNAV_Cic_4_bit({{16,16}});
+const double FNAV_Cic_4_LSB = TWO_N29;
+const std::vector<std::pair<int,int>> FNAV_Cis_4_bit({{32,16}});
+const double FNAV_Cis_4_LSB = TWO_N29;
+const std::vector<std::pair<int,int>> FNAV_A0_4_bit({{48,32}});
+const double FNAV_A0_4_LSB = TWO_N30;
+const std::vector<std::pair<int,int>> FNAV_A1_4_bit({{80,24}});
+const double FNAV_A1_4_LSB = TWO_N50;
+const std::vector<std::pair<int,int>> FNAV_deltatls_4_bit({{104,8}});
+const std::vector<std::pair<int,int>> FNAV_t0t_4_bit({{112,8}});
+const double FNAV_t0t_4_LSB = 3600;
+const std::vector<std::pair<int,int>> FNAV_WNot_4_bit({{120,8}});
+const std::vector<std::pair<int,int>> FNAV_WNlsf_4_bit({{128,8}});
+const std::vector<std::pair<int,int>> FNAV_DN_4_bit({{136,3}});
+const std::vector<std::pair<int,int>> FNAV_deltatlsf_4_bit({{139,8}});
+const std::vector<std::pair<int,int>> FNAV_t0g_4_bit({{147,8}});
+const double FNAV_t0g_4_LSB = 3600;
+const std::vector<std::pair<int,int>> FNAV_A0g_4_bit({{155,16}});
+const double FNAV_A0g_4_LSB = TWO_N35;
+const std::vector<std::pair<int,int>> FNAV_A1g_4_bit({{171,12}});
+const double FNAV_A1g_4_LSB = TWO_N51;
+const std::vector<std::pair<int,int>> FNAV_WN0g_4_bit({{183,6}});
+const std::vector<std::pair<int,int>> FNAV_TOW_4_bit({{189,20}});
+
+// WORD 5 Almanac SVID1 SVID2(1/2)
+const std::vector<std::pair<int,int>> FNAV_IODa_5_bit({{6,4}});
+const std::vector<std::pair<int,int>> FNAV_WNa_5_bit({{10,2}});
+const std::vector<std::pair<int,int>> FNAV_t0a_5_bit({{12,10}});
+const double FNAV_t0a_5_LSB = 600;
+const std::vector<std::pair<int,int>> FNAV_SVID1_5_bit({{22,6}});
+const std::vector<std::pair<int,int>> FNAV_Deltaa12_1_5_bit({{28,13}});
+const double FNAV_Deltaa12_5_LSB = TWO_N9;
+const std::vector<std::pair<int,int>> FNAV_e_1_5_bit({{41,11}});
+const double FNAV_e_5_LSB = TWO_N16;
+const std::vector<std::pair<int,int>> FNAV_w_1_5_bit({{52,16}});
+const double FNAV_w_5_LSB = TWO_N15;
+const std::vector<std::pair<int,int>> FNAV_deltai_1_5_bit({{68,11}});
+const double FNAV_deltai_5_LSB = TWO_N14;
+const std::vector<std::pair<int,int>> FNAV_Omega0_1_5_bit({{79,16}});
+const double FNAV_Omega0_5_LSB = TWO_N15;
+const std::vector<std::pair<int,int>> FNAV_Omegadot_1_5_bit({{95,11}});
+const double FNAV_Omegadot_5_LSB = TWO_N33;
+const std::vector<std::pair<int,int>> FNAV_M0_1_5_bit({{106,16}});
+const double FNAV_M0_5_LSB = TWO_N15;
+const std::vector<std::pair<int,int>> FNAV_af0_1_5_bit({{122,16}});
+const double FNAV_af0_5_LSB = TWO_N19;
+const std::vector<std::pair<int,int>> FNAV_af1_1_5_bit({{138,13}});
+const double FNAV_af1_5_LSB = TWO_N38;
+const std::vector<std::pair<int,int>> FNAV_E5ahs_1_5_bit({{151,2}});
+const std::vector<std::pair<int,int>> FNAV_SVID2_5_bit({{153,6}});
+const std::vector<std::pair<int,int>> FNAV_Deltaa12_2_5_bit({{159,13}});
+const std::vector<std::pair<int,int>> FNAV_e_2_5_bit({{172,11}});
+const std::vector<std::pair<int,int>> FNAV_w_2_5_bit({{183,16}});
+const std::vector<std::pair<int,int>> FNAV_deltai_2_5_bit({{199,11}});
+//const std::vector<std::pair<int,int>> FNAV_Omega012_2_5_bit({{210,4}});
+
+// WORD 6 Almanac SVID2(1/2) SVID3
+const std::vector<std::pair<int,int>> FNAV_IODa_6_bit({{6,4}});
+//const std::vector<std::pair<int,int>> FNAV_Omega022_2_6_bit({{10,12}});
+const std::vector<std::pair<int,int>> FNAV_Omegadot_2_6_bit({{22,11}});
+const std::vector<std::pair<int,int>> FNAV_M0_2_6_bit({{33,16}});
+const std::vector<std::pair<int,int>> FNAV_af0_2_6_bit({{49,16}});
+const std::vector<std::pair<int,int>> FNAV_af1_2_6_bit({{65,13}});
+const std::vector<std::pair<int,int>> FNAV_E5ahs_2_6_bit({{78,2}});
+const std::vector<std::pair<int,int>> FNAV_SVID3_6_bit({{80,6}});
+const std::vector<std::pair<int,int>> FNAV_Deltaa12_3_6_bit({{86,13}});
+const std::vector<std::pair<int,int>> FNAV_e_3_6_bit({{99,11}});
+const std::vector<std::pair<int,int>> FNAV_w_3_6_bit({{110,16}});
+const std::vector<std::pair<int,int>> FNAV_deltai_3_6_bit({{126,11}});
+const std::vector<std::pair<int,int>> FNAV_Omega0_3_6_bit({{137,16}});
+const std::vector<std::pair<int,int>> FNAV_Omegadot_3_6_bit({{153,11}});
+const std::vector<std::pair<int,int>> FNAV_M0_3_6_bit({{164,16}});
+const std::vector<std::pair<int,int>> FNAV_af0_3_6_bit({{180,16}});
+const std::vector<std::pair<int,int>> FNAV_af1_3_6_bit({{196,13}});
+const std::vector<std::pair<int,int>> FNAV_E5ahs_3_6_bit({{209,2}});
+
+// Galileo E5a-I primary codes
+const std::string Galileo_E5a_I_PRIMARY_CODE[Galileo_E5a_NUMBER_OF_CODES] = {
+		"3CEA9DA7B07B13A6CC0AE53DAD1EE2A0FCC70009338C08AC0EE457F76A1690815C3C940AB722487CC8F3D1F4C428828E7FD2A21230E42A3BBDF1E792165F644D0E0335F95EBDC93D6005CC0C680DB7B0E1B8C4946B7974319F9816141DB9E01011E4F20DA8F1B8E15A6F618CF599C3F5C1A1B276D51318ED4119BCE0ACD0332F3DD8F88EC5215AB311C51FF4987DA93B09A43BA84CF08032F6CB28F43043C54586811D870AD6FA27AA63785345C8BCDD3DA26A0134738BC7E08461D5409FF0B791D8574CE797FC5EF7821055028CB4AF92AE1088F8806CD55F0E5FDFCD8D74ED801B2B44AD5D79D1924D41DDC6AB2070B5360CB64CCF487FE517420348CC39BF50BDF78BE7DA91542FEAB689457B3EE69E43C75FADC303F31032FD96B7DC70A88C3B7BAC7322B285D9CFB3A93AC8B890165F23848FAD8477DBDD3D0AA4CB3CD73A48000B6D134DA2DA70B56E590A101AEE78864DA0C64A7BCC6B37CD6F31E9AFF10CA4D47630752D253944632DF6EC60AECDCD223F29399CDA3B74D1DFA5471277EE6C814464A8C55D3C0B83B36B6AC9FA90CE876ACDF65E3EA3FD61D309EB71ED29A3D510B2F4C0B6D6C5B57EC9060CFBE48389DCB17CBB2284E7F578565B91503B06F49CF3E8534870AEB6AD9707265A9A1E6E2E5E6DF6DAA367239A96EF5B02C19A4543D537EB4D9D73966C09E9B52B4706F57B3E0987885EB84DEA26F7823D895F62015188ED38C04CC6714F797FDB0BC713E3D0208462F9A68E3872A167BF1BF9791AEE8BB73CF527C50975B55C4E5C2F2E95B677F833ECC878D1764839608CC1108A75EE9E58FFCFE4CB52884E7AF15EE0632E0729DA1CF5B7A227028CFE1E08F8B881E1A743D52DD27BED33DE0EE75DC031B4864CF192DFEAF64F726D73321363A233F81C57232432D2B0A5A4C44F4320847A9C143F378F204185D2B571482FE45D6BCA152E6EA7223BFC6DCE06CEF90CE9114623EAB9B1EC789B2051B4AB711DABF5B16FCD970F437B8860313B4F1F14D384EE3976B7E55D2FDCB7E1BD9BE18B722E37C853ADC7E1CC2870A02881F95B78487780E1D1C296415109CF07AB63D0782A9F451CBEB3E8B919917AEDBCA8A8E563AD3784639793E0F25CC9CC62240FA04B2F141E71BF5C84EAC56431159556B8BCE077A51469A87737D3D6F06D97DD479FCC35129F4499C19EF98BDCEA9D4941B3756CDE1997C3AFCAE62B6D9E23341E11CD05A7FFF52F5814011A84D737E1264109006BEF5F19E3C6A9C7521B44741A8282755A8F0DC2FA0E1F6CA4FB34D8CD5FAA27E18808868725B9634376137C1BBC46934F83958112D03082DDD6148F353BD1DD24B9F8FD7AD89C40DA0A92A8DBE3608038CD56FFC4ACA35241D76FAC4CAE1211AAD9D73D51C81C59BCE05F71C345730D3A2C670F8F533A950EF24B00EFE6A3F1354694ABCC6FD9EC4E74DDE1F287AD4F847A297ECCCC39AF029EFCDDDB19932D906B9CEDFCBE0D422CEE305DD05E407340F28EEEA866664D60AF293A45D5D6D5C0000B05F79463DB513ED488DE7BD4EC9EACFEF973B23CE4E9539EFCB797456CF5FD1EC54FDCEE80B39063C48B91A5C2D2BEBC81B9B46D0AD6503BE5AACED2BA5EBE81F630B4E07510356E8229F7FC5EA532B8729CDB819E066A15379AC6942CD4BC5E97C6791E098105C323A3A3DA3880D5EE5562ABBA2BDC9906F4486B51ACF8AA4405E9D7A63DB9E3058782DD9AF3995FFB3D34AEF98234A0B3DC62C339325B60706C068F0198BD8FA658396D06931B069155217690C7F88FD230CDB38E3E48530BD47722FC",
+		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
+		"45D1C8FF162EE106CC87C3EBF6A837930F8CC797EC7A446E8A213ABD239582350636B19B5BE428A9C13F980B7AF5CD7F32630AFE8693CDF0EC0BC2C84F2472F5B86576E8C43136C14717A24705953D392BAC96C1055B782C7941D82FEA357E5FDEFF772FB9F3DF248455CADEAC4CBA2EBA9C91184006D1680E000D59E4BC8FBE2C2F7CC2E78BFA5B60EB292F244E6CF497D5A287432F2520B31B9D9FEC1210923299EDFF043CE077195509E92372F5959AAB4666AE486DEFA400D81463C388CD05C677BFD4953D2627105B0A776960FEE916C75D53981D30DC689581B7E8E0723D65949662ECFAA6FCC9F0CE8892E367721718F906207663F9AD450AE98D75DF004080FC15DC2CD7A1DCE013A0E547ADDC29A397ECB9E7FA02035327AC40240E2091098708D424563AB7C5867F3F2D78EE3EF5B658FDDBD49435060CA2EA3D559CDE957B7E48B98DB41CF875F7B3D9EBDF6547B4EDD98DF4B747B0793152FA8CC07C6D9EE5A2002464566D86466C2EDE54A2BF4BBE823049E57364C127A14BFE1B88ECF70EFB81EB831BBF50F6AE124E5F6A775F3F2620E91D489CCF24811C0890EF905E9E2ACD399E13DC81333A54BDD295B872EB74E412E2FB654A9874854FBC3A68C73434C5FC5CED27534B2B13C316205FF4E432FAFC13A7B5B7A7FFA9FEEDB5AE69036F8F2955DA124CE5856E8C53F24E609F7D3386DC5212B2E78B5AA23B59D45FE98AA08E9CFAA9D52ED260A36AF07522C047ED43808A39D7019E444EDF84D885A9AC84092A0F6BFED562F3E0D79FB5CF62F98E67EF219FA3F5AEB7D4E344642D3D4B1A7EEA18464F6CE8D4CB3181D9EBF6F4122751B54D0D7F3FC470A91B547148AAB1CA0DF59872120190640555A7561B0F2C11280768F74B1A56674FD5480B0F510491431810D99CECBC6DB85888BACBE2B020FB8B3D78039773229714156494EAEC3A2D0A59E718F72205747D69C05DDF1C678E2E154A1F84EF0CA2E24DC4A6A996F0850A396D2432596EAE84AEC0935B8C25D5C65B52A32722F01D281C4F753EE03EB10020E9FA02462CA303DA39560669637532D381EB78AE5EC0F6DBF6273EC979442E6243F65FC51F26C6C9554C6C0E3EFF33BC4EAB6A27CAB9383BE7DDDE4218C4998033B47919503E1C9A789711EBEAAD6C0298B3DC563F54D28675260F6D896F1B8D4FD0001C429210398E9544B3DAA12C31F7EE82EF4D2234E26F873610B76756DDACD24B6132BCFFE735FE75513ED527DD04D7DC6D24059F85706679DCD1474A9DB9571426BE17E6DEBA58B33B708567697F471CA8B78E8FA73B0E18CB6F88BF9E4F442F0FC21FAB89305484828F18B65F9D373A6A2B380D73F5924F80DA234C1DD87416D025E4E663C96F287B0C83DC92C2164D81830781B715209FD11A65E64962D805389BAAA91DFBB990D3511E506A8EC101131C5B7284252F861D047DB2C2027DBAAD487ABFE429CA21CBEA7671350618E441F4D62F2D579CAE29D97023A8873869B553293D9F54D4A929E252AF132325A6E3BCBF7B36D0DAFA1E56A39A5D801FD0D5A41111017BF62AAF8346C7D424FE007C32B437ADE60AAA9540AA5078FE6C3C3CCEA53EE863086646C976FE6C79434A0AA4F53B2E9E2C3B4CF9C9C4015391E27CDFF5C1FCCCC00BBF5B99715A1265F591E294D530DB14DFD485AD34BBCEA32E5B5D0EED15F88BF5D96D058E6D70BB1A232597E35A625E5E8C2EF5E7031A71F70309019A0591BA0A50E87C839498255A3602C0FAE53166BE5E49E29D24AEC47002B698F80FC49E718B66A8959259ACC540",
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		"446D385D09A3464D1ABDC6D6CCB015280BBE7DCF00078634371D7F327322DD720E8DBD7B8CD97FB9505A118B469762ACA10C4E135ED782FC905EF30F9FBA82F11AE679431F270351F70F0508BA998AD9A71D2BE05F55348B275A0E537C63699C96DD8AB8E0645CA2606E35805F66CE586C81B4A65E2EF036697A18DA49C36CB22404497577107924DC02FD87072490D7EC8D5B376D0C3370F9753E0E7C781952C03D844490370D6853FCA49E12139805C24FE9C9914E3CF91464D332C934570DCD5D1C3C609C6984E28C9BFCBA3669B75452478DA4099CFE0F6311FF782D1D0123A120F657CB536A3810984871B69D25913C305117A7E51D199A56387C2777E349748B9C2C40DECC03DE7235F7237CF43FD421039743CA72361DFEF2491953A3C3F0091FE3EE064B838BD73E9E6EDF8FD90235CDB374892BFC42759792E5636D031795C0DCC70D7DB86C161FE7059CE17B6926FE5D024D6B1B9DD5608839DF85C7802F5655525B633BDAD0803CE14649095C0A7F870F66888C072C410E0E0854238BA7FB259901CAFE3570D398B621518193BBDD75258BCB53AF2789EC66DBE2311DACDC1F9CDB6DBD4BCDCD15F9C2E77E0D2736CD191D2B83389A71B1804A0FB5F2480E38343CA48EC6D1830BA3466E53FC51C4EF05F4D10711A78AB215650462E9A26D9301EFDF15A3CD5EEE14DDAFEFA45171BA3A757CD6FAA5887A5D5A98045BEC7FEB331D01A997282910B6B946CADF0AEA57973520EF0561B233BCF798805B3B048751EA086FA71BCAAE15F8BEB837CD2974EB3E54D3B6D3F99A51F88313FB64218610CD1831E2E6E18EADCFCBE72BE5818B4AE4F3780BAA7D8C4A55DAFC10ACA3EE7AB7D1337506C485C83EB0C41748C668705B4D41D926221D33C31BE7D56B42BAC7E9240FE4C2287B5B41FE88F9B9E19970D0E4569DBFF167EC42BAA2566676EB055B69D159358D23DABFFC86A917490B4942A220038CDADBE24C335DEB895F3472F0D22778BC79B169D1EDA9FD18B31DA66F0246359DB3EBA36269EC5F92E5A1A89560C7DEEFA121A7035EC2501C553854724C5176AE60F87004F6FAEA907B91D1C58837C9FE25BD9C32F66257BD78169B1A4B8ADEBA72B5699D4C2D14F67BB347EC8A96B04278AD9F97A9B40DBB56E7593CF4B3C905108F10968F0AE6A2E7F1D214FC7B45637A256ADA5EEB70E03C02DA2ABF86C36E581A31032DFFEF4343C3E59EC7A2A715E9C199DAFD3BF8C9B43C1D016DCD33E2590A20EC8B657C08E5C0C0BB4F159A07206504780715A252D1F4F5DC65ACCC43E3CDC255123A77792685C9B68AF281863AC89ADBD5F778733E95050ACF781FFA386B3EBCD633D6E8E6D4A42EA85F005AA80A4597D40738A8E8823FE3C84B10CEF044E9651E45D1ECDF59C537AACA58D2BE42655259DFE6CFFFBDAED252254B732EDC93B4D610C50DC81B576C5A5C5BBCAC0BAFD7BDD7771EF1A19C29D7A82E448AFA07E7FAA8651C11D1BD550DDC69F4C9C6A44435034D80B47B512155E5141378A94CD277D4BE11B2A383B1539AC9731079624E81D3A3404F5325F5D2EFBC0929F510529C84B1BC3E7C08F661640E55AC49452C00256BEB49B7A52DA23EFFD85B8C303C6EEDD2202768ECABBFBEE87FBF1DAA992C8439602B1645C462D3297DDA1AD941617B508E481A28D1540212CB281B5388A3691A26AD7D3CEF52FEEE9F59F477EC98AFCFE38034B762B9D4B5DF3BB312758C4238EFFF94BD16D9C39655CF07263CD6DBA96D1C0EA425610C1FC81061FAAC5C0F8E6AA9591EDE2FAA1AAB8F76EE18",
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		"E0DAFB980D888AA2580DB37930D1942D6D088FDC706871A90D887B5F2CA6B21911BBB8BFEE1376F48428238607AF7CF82C3B3C9223746BA9A5F01523B20889ED8F139EA3D505D55D766BD056416193CACA6D5D6175C16C38BF44D7F89D4A5E3406C7944AD05D86C310E1EC78E0C8AD80FA0DB202AB1768AD446AC7FEC60B30D741114B45857FA5223E64AF32476319F16DE15C04F34F4730AB31F4F6BB13252D706F0B3BD5860BEB864618353CE62469E25CF4AED50D8BDE9633CF18F76AB1EA5552614D4AC3848A0CFFFDFD51F17A4E744533DC52979D7012AE53E9B08C4980AF8876ED2FD8A6F174B3AF651517BDDA1965264F1CCF0EEC8E3A9969D1359C5C9FD20CAD8698F3E28ACE77001F563BF456B5A46FC747E5D7EFED93314F7AA87CFA60405F968A4F9774E30E2266938BB19E9265FB71BE0D40FE6BF14FE02E36FE10FF110D63E02145C78B73217EED9DD87F70077E4229572E6547DD71828C773E46462E30B497F9F5F99D723D657E17A288DC98724B11AE87B7E56D33386A7FDEE0698353CD46409FE8D2236958B166B1C697BB8A42946D66E390A045775A6FE7DEE4BE260490B69C56476B894383091C827D02E960D9359E8D3E151F50EB87FABAEE8ACC6E325B36674D9C7CE249B879B3FDC6AF95E92FAE53047BC211757FD12564EDDA4DDB6AE8C94DD3305C21970E90BE05ABBAF912ACC52C77714F87C2B059A9E21005D8903A604D82EC22192C46CEB63C588A219CBF755B5D44CC0E918CA6705156CB497FAABFF63745C826FE16F65582D4820141DEBE3B949C29EEC6D99C2A4EF34DC878DD82D0FE6D5ACA302ADFB897DAE78EB0BD28A938D6FD5A3535CADEDD7C521E45AF4BA92FD40DDB009E35C21254A6DB959698303D56B59D8F319F18E688F9A20DAC8058E0496E0E46BD01880F3C78EEFE98A511768919116A288CD3CD28098BF5D4719EB64D548A6D791F1A9A9A3E9B08E7184AEFE60A3D7D7179CE47562E9133068789BBE0297FDA2B2D6F4248B288CD899BF3231EB360ED45F769C0167284319D2C2B11375C2B18E5B67594CF499A6AF2687E0C1AAF09F4161F3AA8369BDBA68AB022459A2DA9DEEA13E509AF3A68D011998D9C30BEBEBD04BC9983F36FA549BFF3E3D323722B2136AFCE0A2CC8E593B370C7B48635926B9575A77AD7C0DA18E94FF1C8FABFB57B25981288E1771465360E2D619272CF3F56268B7EE130FD07DE29215FBD5D0A72B73081869F60CB149A1E4871150778A2229F3C886200E0DC2C76AE049231FD3171E49FF44BDADE185883198D21629CE0AB252C7451398E0D411CB01A66BC5B141CB150BA9CFA9F9F46339625E1D5127998302AFD19D5B2D85F3F0B2B354C7CFAACA3D4E7C7B7DF44E22EC2C226178DDD480DF7787EB28F0285B1F973DC47B094491DDDC12BF1CAEB99E0E13781FE8A64DCB0A05A30763A055A6ADFE5434D7694A0F6A0366B5D74E73227F3D503E6B989C5BBF9E6D81EDA7C46D890FB2C5CB439C5B49FE16A9BEB14B12B08C47713331E8932D4AF6B85444E3F848C5AFDC095E984449F0D126EF711F8B43831755BC0FAE8D9FC79E894CEC183DC24B1E3C81FAF6A546E464AF8C0307263680CEAD9ED6E80217F98CA82458BEE59D2A4FA76BD7D4425E0C77164A50A2933972108661820C75EB51C8A0ABDDDEB30F31F2E575AB9DB723DD084656691096B72193C52053EBB8B72C6B30C49185166FC39F3D9F3497606D15E8D696CDC256DCBDB6D01DD2C33C0249D6069788DEC09802630597C13EB1AE152E8E84F6A4BF60BB09E049EEC",
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+};
+// Galileo E5a-Q primary codes
+const std::string Galileo_E5a_Q_PRIMARY_CODE[Galileo_E5a_NUMBER_OF_CODES] = {
+		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
+		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
+		"58B2E58A13D4D5F84F37A389E6B01DFA66DBC6A25338B2884EF08056BF0A9124DA29254AA79CDF1B0944DDED4BC7FE683EF7A3C7A1C359E61E959471E30F9D534F43EEF274AC6535C616ADC7455BFBFF43ABF268F7C995CE020CEC73BDBD04007562F2710498AD1A324F25A6233B2DF2D9A429F1C39943E45F934986D1979D293F90CFBEBE01665C98C0D72D09A382348136980B31F5D4696B85C3F42D5C445996804159CD4C4CE7547C4A3FB718AB62D9E9826D05C44C6BD21D708CABB01F46514F29FBE7352866EDBFABD0ADBB6093E1A519D0E11E27737239A07866752B6D864686AF1E308481C53C635046C0756E8008D3CD26DB970C5D6EF8CB9DE6BC4339EE9F88EA45D11B74A1525E2F1B9F91567A78E403F7ECD47A99E95C098870B928E1B0DAA984CCECA13C6857F350E808BBF66AB4EDFB0F369F6F009268D19DEEB377F7D0C4ED6414EF6D23A0A5F37A25AAD3CD62C2115CB70409049CF0CE6D4DBCC5C96767614C6FAF73E9A76C7550BB970AB3D3ACE0C07FAA9F36F1935DFCD5228427BBEB5FC7A2F951D9210A5BC32ACCA7E78AFD5FD460CE2A79348714E5542BF2D453680B070E85F3244E8A6B4EB6ED49F803E60B8A383C8BE6283B1C4DF79E0C4A23D5DAFCB26DFC5DF1D1520FB6CDA23A05A1513F751EBD0143C2B9F5494BAA74F9F95F189C5767C6F5623559D9F20CC9B9C9ADFE285FA4E1BBDA481A52ABAB36A5393370091A49A59B968CFAE89BEAF33BCA5C2A9BCC1758CEEFC2D0A175C8A5CAD5C7E3FA706C2FEA55F4971A7B8A0C5D1F22A26D7DA9A70603AC34566E4929AE78C8F1926239950EC0A6E1B37D919E24431E53FB08B2F7DCDCA2EF4177BD7D2F81BFC784FBEA0471831CDCBB9E11D60C53D0E062E8BB8D98B8EE5A40960EBE10FA642751B96E1407B38A024DC64D5C2005E71198EF394673A4A0097187D2475CF27B3EAA7955AD9F412A89B36AFB27FDF7FE699B2CC8C03F7FA40549178DF8A3C1A39441EAE869BBC89D583ECB18E310885F33B95B719045CA6955720CA75D5CF0B29E5F1B9E9EAC5EC92980B2D37EF6509CCA6E67544A8116494AC7EB9032E1E8CDB053B5AC0F60DE59BBFB78E3491D50C7ADED95042A8885FE284E90C04FFC0370B92B68379B2E7D52392A42FEB26B2419CC64412BFFC036C01109B9EAEC5FAF485F0D61C37A703EAD02127611F9D25E4EC515CABE21247156F0779CAB57C35581646BB71E87941AB5D06FB3C06C423E9E83E0C07E611C89CB000344AF49498EF5C30305DDC8958F45A45E1218837269DEEDBB0AE51D2AD8B41BE425EB7AB798856911B6F0DC721756A8154B9D1CCD61092D16A3E9E1CD5E1D7C2C45D236C9B21A0ED64AD4C0660FE42FC0B543A34FB545B0D88D42F696D53BF54A1A259486846E81B44C16EF146310AEFB3933BA9F9D4497E74AFE1449D69105B9F295DB24B4563C3FC0166CB70F104B3360BC0998EFEBABC6276F570F7679865036DB59B51AD2F91C0CCD3BCF5C07492765D480494AB5B87E83FD04B75A35F88656D3329AA5FD550DBF493B0CD2C19DEBE4358661C72A71FB17C812F75BEB61302AAAA1F757288C1D8626461F4162A2EC6296B3CCABE21B4F0695F2D2CB02B86035251FC9C5F2FB5BBF28237417DC56471629B3B4C25AFEDC4C9CD108ADAD9DB1330AB680E4998C5B3D99BCE8F08156B630A63EF36A51C813CE22A6B178683EDA389ACF58653582BC2AE8170ADEC4BE03C04CBA603C0E4572A74BD9599A8442E894EB504F7703F2353A8A3525EC5535E750303AC07E08D952755F97AF236014",
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		"CB9F5B3A549646C4555D2FBDAF2A79F9921C54C6FEA316D7713D64FD790325A87A30DEDBDF0ADE3B7BEA52A0E319A57084A79DD706228989642E78BF51B7F1246BEF6F1B8724C57B0A3633FCF4440E9D57DAEEB343283D642710266386DED8FFCFD68B32949FAC691E66FE9B8D736EBCA6F4551B39E79557154E9AF590B6F5CA1C6A0ACA82FF4B839B6F9C555CC57255F96B2C963536E48EC9B5BCBD270110EAF7C64AD9DAB53BC791CB111189117A34A74B4F23A8573A59886BF974528D17B31CA9B6A6B7EF7F923B8915B640C599D2453941CD16633383F36F9849C0165D94698D793A58A7869AAC8B4C007CB9E43D8DD100E9504B1942CEABBA733A242599D5B8C60AA42F4C8BE7F040877DA2648D083A2272A46A90D215D96DB2FF1ACA6CE24A2936C18B7A283615E8E6B729602D018174276E2ADCBC869C43879B6BD0CF22CC0601F7491862971F65D3E0BB2474549FA18964B14D9EF81429F08383F77E8880E858B3F350076B709046284A4BF500A6C7D9D694F03ADC9753852285075197FE5F30F5FEA91C7740AF38CBF5B984ED852C99FD27113F690CA7BD5CA46DCA330A7E30E7AA3AEE8CB62251DDDD62DDCC29C94D79759357FD92855279A8516ED0B07D8F2CF6509DEB6C180AFFE120B1C06A4DFB1CB76B9DF3113B08BE85A50BF76480D2FE05E75A4F77909E0D146EDF0D751A1099EB2BD019525048BA145C7E0B3FEBE21A13A41A9BACED48E1A4ED32A57FA061243EE840ECA69191B1BCDC0358A86DDC98920C45F1FD193D529C85B33E0135DCF2B81C7FEED32E07A2431755F3EF3EA685577A6884041C6600CCAEE0E4182CF54EEC1B078D74A18D8C81E0678A7D1309E494938083786C67436FE55FA955D3281F7F6C145B7C769D9019AE1B8666834B51AE95BEE2A8D606825C7609FD3F24057425B27D01573FF353771BD47902A9BBC41B2016086A3F9E366F96DA8AE3C62123DF05113980D8FDEAC5B2C828D44C69F2D1420BF8E7913E59FCB88845A7FA6A84AA296875CA6D2FA21A4FDF8E75B5CDF0E1C0D84FEE983A469FEC80F02923695640FA0858E9B91812DD4D91AF0DFD97655C7FDC60EFEB19DB5AD7D7D0A5F93FC88A2AC1205D1BB60DB2F3BCE203C802752350B5E8240B6FEF4A38D8F35AE5868498DCCF1BA047DC56D67F15E3C3807BD5638A9494DDC268378DDED39A910A6C7A59E6738DC68D1A531C7EFA68BE06AD20BAC86BC36083E45AB0A314ADAAB741C6E24A530B3E3FE318E4A1B3827057F944918664A96277528D185E821093D392012803ADB63A4DDB14983E844392542F2C5A978F1911A2720E201FBB862AE98C3CCDA720A244B5B58AE601C1ED814B0753FCE5F51E7ED797AAA98FCC833EA272D86A238524C07349F5DD0BA4A2F6281B2EC2D29EB546EF52F07B832053AA433A7E8BF81C6C9F562B603421787BCFF621A69ECA5CF07CE8512BEF945DC744AF403B9DF0FDD48AFFF264D4AAEDBD8702863B5A345A733328466B22FFEB20906543639F0F6F85F3F7DBBD28034019F4D517676C5D8C8CABD4118768B10158D83BFF569D3B71F30AB57B8337C50674E2290C950E9D48D6527E885A0F7CF580717CF467759CA0D41CD03A91B75648DFCEC5C5BDCEFC2EB2007AEF2F01651A328DE030546933C1BF88F34AF14D0C1F0F37FC8FF4E015DA5D25D4A1D52EEC44DA8E832F01BB1D9FF6D067021D4703E8F2D511E73ADCE564EB53A048864D191F21C759F0B629E0053845D7049900924832DB7831CCB80B36644BF23EC71847286C959BF54C6CF9EF075B1EB7F43898",
+		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
+		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
+		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
+		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
+		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
+		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
+		"DCD55CF8406A7CC9BA0A5224797D74777689C4FBC0D202DEA8B9773A0F20DB0438BEFD40A996EB2E3F49CBE2E475DEEF73F112FF742269A701AB43D8E47EF94DA4056086D86B1FAD636D89929C60238133A5B61DC4B7F8DFC765CF0C8C7206F3E0DD3DA13407CA75EA20F172AC38C42ACADC946B3B18BBB30DF871905777CFE0D3BE5363574D2545D0214D6A43E2D34B50D7FF7D9F2DAE7053736B71FAAECFC2C355C1DA645A995981E1D617BDDD14EB9AB230D10085DA1AE55D1C9E55C225997D128CC2393D6E5BE9F1BDE1543DCAE918B38AFD5FAE6031E105BA12EA4162F7E24572688C54291A61635C9DA26BB367348473D4DD4AEF9A5C4E8A6512AB149D62F625D8D45576FAA4CE28E5C3D52D293A0D5C48821E1F5CDAD7257C97B3C1A6DD83A4ABB55F780D09964D4B3940D36B6709D00094B89F319E1C2CBBB3EC33A6F0398880B8079E6A39DE697D76803B04C230EE980765604929D60733BBB6382B4CA4B13AD3FC48AC9F944B97133C5AE6C3B9D295A760D786DDBFF346C873C2DCF3D2591926116A318F63835783A33A17C452AA6C620284BA99DEAF023972082AD2B370CF3016F0739103A518B25AE8D59BB017C8199ECCAF3E908F9F144C778E0F5F47FA06FE8A22E3B2CE3493EAA8745478D653F8D3711F832D9212D060A7F0B0B62AB9A3C9BF012B61A9B5E6DBAF4B48D9031250419627E96076925AF95E2B238E8CD227A0F3D8C9C3BC68D5990952D6CB62803B8D193FB06120BCA9B195E92B995B86B92C455A6145D3F77898E457E1B938183E1D76FF61C163057A4D70697507BE020CC28BE6527CE306A5D2506B86152B5E3B954D5A660C79CDAABB2EEF0D135C0D4AACC7FC3EB5A3575D95070B168FCEF4F9B36FC3D55B84DDBEF10DF6BA659F70CB2AB82FA001D51ED0F040F9DAD4129C324BE8B44316C0E3E15B27C2A8D54A948585834C2DBD40337B61F58F3AB99B3303D56EC1D30ED82F29CF6A68208B07DA120AC4073F102F4D796E38628D344384551810998F6211A082BA225A1B7D63C9A3E8703DD945BE1D979677FEBE715396988A873B88EBCB10209E4DAFF939776AD14C5DC90BBE9C1A57581A145BE0D4BB47CF50721EFECCB50C96E824DF93D675B1A1B4D920CB1EE82B0369094DD84FAB4A3FA94F152F87525ED6D17A800EDB1BAA6C13A2EDB5C9B7C5A82AE5824AE9BA63156EDF78517AE2B357C1A1E8EF6CB12DA415A914FB69FA633527B8A1659292D079B580DEC210231BCA77465BC6A9516F2917226957DDDD9787313FA599BC2BDD14DEC9DCAF0F2520318A85C55DF40881FF65E4AC21F2C9EA3CC06651309E1F89982D45FD6EB5BD588B647A80D27433EF85080A7AB2FFDBFC7D2B54B215E7D27A333D4942CD23D53142F04976093CC0344C19F9CB3A5A4D522E26B7E2C1C85C1ABAE1B4A360945A46D097A1F3676A80E3BB9CBED0BD363CB70C2B250EA053B183CFD1EDF2F6A211CE618F70EA1AB535E96CDD0B2FAB7CB7F0396B6DEB59745C1BDBCD452FFD70C95E45B88325A82CF07EFEAD7176FAF04C8C3E0CC4458540BED99ABB9F52AFBE48E42C636DD076A37C07C8E4EB6830FAC011936EC047F6D5B5857AAF90F80B5D33B502A116828BD27E30B3A69F351E22D943A482BC6BC41BE7BF941F3AA7BF85A2BA5C38FC930680FDE5A4E174AEC4156A755E7650CE488620D6CC62BF9D085FE1782EADB11541A5C19C9061734513316B9CA608A6E48D333A110B57BA5128E9331E6266174B85F7B7D1DB264361B1C6C044A8274A7C8DB19C253BF8DAB819E85130E920",
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		"D50CD8EB871C5F371648DC07E20BE84263CD676282D56EA5374E21B52752DBE416DB787BCE232226568621ED792A9135A59849451A4A4D8A1DCF3C804AF966881FE5156FB761B3736F4282240FC0BBE72F51F0122D96B3755109E7CDFC70F9DD04C58B4A51C00B4FC0EF252B05ED76440C97DABA04079C121351CD43BCDDD4AA2D2495B49B908A9AF815DEE1405C3CE9CEC7D5BA9919621E8C4E920E08061D228038F73F8E5DD66BAB806D2DD953C6FA5360487957912249DE009655658BE8CACF00E6E0621739648A7A75EA06E93946987E62EDC270B266BBBCEF61D7CC63013AD797589A7CA62B65D4127E701BC95D45C74DBCBFF498D3F87CBD1B288D6012EC392B901A3DDFF16EF1E1685EA1F92B1F32DFED2F9076EF9CB1ADD8B04953E5509B24C48977FFEE6044B8C5B80F9DED6FA7110C3A2EA42EEE8A83F4A28FE78B27E84AAE7B3FABA56C1A4D2414E0341C69C40A43D65E16583A151826F7C7CC0CF0A5999A1016BE6912F067913AEFB525EE41F1B9C82881054E9624C03DECE74976228B119974BC546F823A597C7486DD594F1FEB2B6D0330918936DCBC12E3752A7072C5FD7B145571DC4A22C770E00F24B8C91E27F2C727FB049D04BCA813948D2F7B531C906F2018F51C9EF8B7642C0F1CC06AD338BEDE17683E0BD2A90D4D4746189F792952037E4918D2D6E61C1C8A8B6C437075ABC38913C250BBE6EDDA5CD24B630AB8FE9123B08D5E8FB8B71BC95BDA4AF1A71D5E54BE98B16D7D3083AB1649CBBBF44B3D5DC33B77DC1171A66F6F40E75EB86801EAA36E02D138093F28ECC6DA4CE4B128DAFB8D49A17C683FFAA8E6910B8BB7B832B3A3D0765DE2ECDA9D7BFF0A822F5FD389A04B660F832687CD67F7E1E1C3F5257C6FEB27B763AC7327DE8FDB989413B6D002FDFFB1DE5A80F1C5E39F06E6D716A69ABEF37B2DA9783FC494574689948DB51F78C8812E09367E6C8D70F5FC4139C64B96C71ED851D171AFA69D2A646ABA85279B7D3D31D268A2E8A272C91902F12C49D07D74E82728AD61BBABDA333DE7138A976A2267DCAB1A02E19B0685F64B608E3DA41108D54A07D4BDD24D79D293830C04209C98F037283BAEC00B1923CF404E1F21584F515F9D59B53FA9B4774FA8D3B34B7C66907BA127A095CD8CBB23375CB188CF9DF22CFB4CEC528C581DB63598DDD9A53438409D72507D2CEB5BD45DB5C760415A5E3B3A909EEDA73B7FE122DF04CB1E9F29E7A5A7385F632AEF63771A4CA2164B9B3FAC3C13911DBE9668D1127DB02A94CDCE2C8C7B66F0C21601781552B384DF0FA002DE08892D0881174CA1F6DE80B98BAE545237C5CEF9E1655F9EF8F8293D644CB47963734197F1976600CF2767A59FD56B9B67659168ECD57C485E5726C150DEC6C302456AFD4F12B2F2D1F36B03E100E109827726020BDBA970A6B768C580E34116DD0011299B4DEAAB8B04DE1DCC5FFCCBE57254CA79743D6B00D119CBB2C0B0BBB2FB8FB0B0EC97204E1720F99D16A3257846D09BF8EAE02DB21FCABF03CB0989FB4D99B6D71D5E64C6FCACCABDE63B223A91D1278D676839E1A5CE6C5EE05AB4F10EEC511C366DBFD7AA1E139AF671CBEDB3160A775E5214C862E95C3A7993E508D8F8B7ABD68213A531B5C648C537FA2674346FA0B3AB43A7B58B4F83B36D58C506C188DAF72381DE53F83AD4D9E6C6B1F5D689AE24CD158BB2898F06AA28C8FFAB1703871A6A6FE41ABB6B8B9188C90EEF88E7DA3338F119770B31167E3AB541371FF7F98A2D59D3557438DEAD71C96B97F3839F5E28DA6227E5B4",
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+		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
+};
+// Galileo E5a-I secondary code
+const std::string Galileo_E5a_I_SECONDARY_CODE = "10000100001011101001";
+// Galileo E5a-Q secondary codes
+const std::string Galileo_E5a_Q_SECONDARY_CODE[Galileo_E5a_NUMBER_OF_CODES] = {
+		"1000001111110110111101101001110110001111011011100001010101000001000111111011100011001001101100011100",
+		"0110011001010101100010111101001111001110000011000111011110010010111010000011001101010000010100100101",
+		"0101100110100000001001011010100111000001101011110000011001010001101101110111100110101000001110000001",
+		"1101001110100011001001100100000001111000001011110111101100011000111001001101111101110101010010110111",
+		"1011100100011111110010101101011101110110000011000010000110001111101001011001001101001000101010010011",
+		"1011101011000111011111101001001100111010011101111001000101000000111100001001010011111011111110011000",
+		"0101001101110111100001011101111000101000000010010010011111000110101101011000101110100110011101110110",
+		"1110111111001010101101001011011001011111001110000101001100011110110010100010001000100101011111100010",
+		"0111100111111000110010101110100000111000010001110101111010100101010110000100101111101111110010011011",
+		"1100101001010001011100001111111010100011101010000001000011101100011000000110101101100110010010010100",
+		"0001111111000011001001000001000001100101001010100010110001001001101111011000010001011110010101100111",
+		"1111111000001010100110100111101011111101101011000100010011100100001011001011100101011101001001100001",
+		"1011000000110000011000101101110000101011011100011001100101011101010110101101100010110111110110111110",
+		"1111011011000011100110001001100100111111010110011000111000101101111101000010001101011101001111010101",
+		"0001101110110010111110111000101101011011111100100100001110010101110000101110111100111100010110100001",
+		"0010111110010010000001101000011111010010001110001100110001110000010001101110111101101010111111001001",
+		"0011010000010110001110001000011011111100010011101101011111110010101010010010111011111101101110111000",
+		"0110011010101000011100101100111001000111100000110011111110110010110111111101010101100010010110101101",
+		"1001100111010101101001110000000101100010110010010010000010100100101110111001110111100001110010101000",
+		"1000000111010111000110111101011011100000011010011010011110101100110010111110110111000110011011001010",
+		"1010011001010100010100100100000001110100101010011110011001111000000011011011100111010011111011000110",
+		"1100001100111001011010100001000000011011111011011010111101100010001111001111110001011011101100110111",
+		"1100001111010100101010110010000100011101111100110110111100100001000100011111001000010100000111001101",
+		"0011110111111111001001011110101011100111011000010111001110010010011001011010111100010100010111000001",
+		"1001100101001001000010011110000001110101011111010111000011001101111000111000100100010000001010110101",
+		"1011100100111000010100110101010100100010110100010001100111110100000011000010010111111101101011101100",
+		"1100011100011010101101010100100111000000010010010001010100110111000000100110101100111001000010110111",
+		"0000110011011011100011001001111001111011010100111111010101011111010110110000101000000101100101111011",
+		"0110000111000101111110100010010100101111000110101111100000010001010001000111011001100100100101001111",
+		"0110001001100000001001110111011110001111110100111100011010111011010010111010101001111010010110011101",
+		"1110011101000101010000010010111111110101001111011110101111010000001111110001110010011010011000110011",
+		"0011010110010010101011000000100000111111001100010111010111111010011100100100011000111001000010011000",
+		"0101001000101000010011011001010000011100001111011100101011110010011100100001110111011011000111111101",
+		"0111001110110011110110001111000010101101010101011101111101001111111010000001010011101101100010010000",
+		"1001010010111111000101101100100000111011110101110100011000101111011001001001100011100000001010000010",
+		"1010100011000011110111100001101011000110011010000000100010011011000010110100010110110011010101111001",
+		"0010001011010110111000101010011101101000111001011111001101011111111111001000111000000001011110010110",
+		"0010010100110001000010100000011001100111010111101011001001110001111100101010000010011110101000011101",
+		"1001111101111001100100111100011000100001110101001011111011001000000110100000010100110101011100000011",
+		"1101011000101001100110011110101011001111000111001001100100001000001111000000101101001010010000010111",
+		"1111011001100101101001111110101001000100000110111010101001001110101000001101000000010000011110001100",
+		"0100011011110011110100110000010000111111001001001100110111101010101111010110111101111001010101000011",
+		"1110001011100011111010000010010101000110000101101011110110010110110011101111110010100110010100011010",
+		"1110010101001000001000110001101010000010111110011010000000011010000110011101101101011110000110110010",
+		"0010011001011100011111111001000010100001011011110100100111101101111000101010101001110000011011001000",
+		"0011011001001010001110101001111010110000111100000100100000011101101000000001100110011101011111101010",
+		"1001100000010000101001111010100010011000100101100001001001100011101000001111011101001001111101010110",
+};
+
+
+#endif /* GNSS_SDR_GALILEO_E5A_H_ */

src/core/system_parameters/galileo_almanac.h

@@ -59,6 +59,7 @@ public:
     double af1_8;
     double E5b_HS_8;
     double E1B_HS_8;
+    double E5a_HS_8;
     int SVID2_8;
     double DELTA_A_8;
     double e_8;
@@ -76,6 +77,7 @@ public:
     double af1_9;
     double E5b_HS_9;
     double E1B_HS_9;
+    double E5a_HS_9;
     int SVID3_9;
     double DELTA_A_9;
     double e_9;
@@ -91,6 +93,7 @@ public:
     double af1_10;
     double E5b_HS_10;
     double E1B_HS_10;
+    double E5a_HS_10;
 
     /*GPS to Galileo GST conversion parameters*/
     double A_0G_10 = 0;

src/core/system_parameters/galileo_fnav_message.cc

@@ -0,0 +1,719 @@
+/*!
+ * \file galileo_fnav_message.h
+ * \brief  Implementation of a Galileo F/NAV Data message
+ *         as described in Galileo OS SIS ICD Issue 1.1 (Sept. 2010)
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          </ul>
+ *
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_fnav_message.h"
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/crc.hpp>      // for boost::crc_basic, boost::crc_optimal
+#include <boost/dynamic_bitset.hpp>
+#include <glog/logging.h>
+#include <iostream>
+#include <cstring>
+#include <string>
+
+typedef boost::crc_optimal<24, 0x1864CFBu, 0x0, 0x0, false, false> CRC_Galileo_FNAV_type;
+
+void Galileo_Fnav_Message::reset()
+{
+    flag_CRC_test = false;
+    flag_all_ephemeris = false;  //!< Flag indicating that all words containing ephemeris have been received
+    flag_ephemeris_1 = false;    //!< Flag indicating that ephemeris 1/3 (word 2) have been received
+    flag_ephemeris_2 = false;    //!< Flag indicating that ephemeris 2/3 (word 3) have been received
+    flag_ephemeris_3 = false;    //!< Flag indicating that ephemeris 3/3 (word 4) have been received
+
+    flag_iono_and_GST = false;   //!< Flag indicating that ionospheric and GST parameters (word 1) have been received
+    flag_TOW_1 = false;
+    flag_TOW_2 = false;
+    flag_TOW_3 = false;
+    flag_TOW_4 = false;
+    flag_TOW_set = false; 	      //!< it is true when page 1,2,3 or 4 arrives
+    flag_utc_model = false;      //!< Flag indicating that utc model parameters (word 4) have been received
+
+    flag_all_almanac = false;    //!< Flag indicating that all almanac have been received
+    flag_almanac_1 = false;      //!< Flag indicating that almanac 1/2 (word 5) have been received
+    flag_almanac_2 = false;      //!< Flag indicating that almanac 2/2 (word 6) have been received
+
+    IOD_ephemeris = 0;
+
+    page_type = 0;
+    /* WORD 1 SVID, Clock correction, SISA, Ionospheric correction, BGD, GST, Signal
+     * health and Data validity status*/
+    FNAV_SV_ID_PRN_1 = 0;
+    FNAV_IODnav_1 = 0;
+    FNAV_t0c_1 = 0;
+    FNAV_af0_1 = 0;
+    FNAV_af1_1 = 0;
+    FNAV_af2_1 = 0;
+    FNAV_SISA_1 = 0;
+    FNAV_ai0_1 = 0;
+    FNAV_ai1_1 = 0;
+    FNAV_ai2_1 = 0;
+    FNAV_region1_1 = 0;
+    FNAV_region2_1 = 0;
+    FNAV_region3_1 = 0;
+    FNAV_region4_1 = 0;
+    FNAV_region5_1 = 0;
+    FNAV_BGD_1 = 0;
+    FNAV_E5ahs_1 = 0;
+    FNAV_WN_1 = 0;
+    FNAV_TOW_1 = 0;
+    FNAV_E5advs_1 = 0;
+
+    // WORD 2 Ephemeris (1/3) and GST
+    FNAV_IODnav_2 = 0;
+    FNAV_M0_2 = 0;
+    FNAV_omegadot_2 = 0;
+    FNAV_e_2 = 0;
+    FNAV_a12_2 = 0;
+    FNAV_omega0_2 = 0;
+    FNAV_idot_2 = 0;
+    FNAV_WN_2 = 0;
+    FNAV_TOW_2 = 0;
+
+    // WORD 3 Ephemeris (2/3) and GST
+    FNAV_IODnav_3 = 0;
+    FNAV_i0_3 = 0;
+    FNAV_w_3 = 0;
+    FNAV_deltan_3 = 0;
+    FNAV_Cuc_3 = 0;
+    FNAV_Cus_3 = 0;
+    FNAV_Crc_3 = 0;
+    FNAV_Crs_3 = 0;
+    FNAV_t0e_3 = 0;
+    FNAV_WN_3 = 0;
+    FNAV_TOW_3 = 0;
+
+    /* WORD 4 Ephemeris (3/3), GST-UTC conversion, GST-GPS conversion and TOW.
+    Note that the clock is repeated in this page type*/
+    FNAV_IODnav_4 = 0;
+    FNAV_Cic_4 = 0;
+    FNAV_Cis_4 = 0;
+    FNAV_A0_4 = 0;
+    FNAV_A1_4 = 0;
+    FNAV_deltatls_4 = 0;
+    FNAV_t0t_4 = 0;
+    FNAV_WNot_4 = 0;
+    FNAV_WNlsf_4 = 0;
+    FNAV_DN_4 = 0;
+    FNAV_deltatlsf_4 = 0;
+    FNAV_t0g_4 = 0;
+    FNAV_A0g_4 = 0;
+    FNAV_A1g_4 = 0;
+    FNAV_WN0g_4 = 0;
+    FNAV_TOW_4 = 0;
+
+    // WORD 5 Almanac (SVID1 and SVID2(1/2)), Week Number and almanac reference time
+    FNAV_IODa_5 = 0;
+    FNAV_WNa_5 = 0;
+    FNAV_t0a_5 = 0;
+    FNAV_SVID1_5 = 0;
+    FNAV_Deltaa12_1_5 = 0;
+    FNAV_e_1_5 = 0;
+    FNAV_w_1_5 = 0;
+    FNAV_deltai_1_5 = 0;
+    FNAV_Omega0_1_5 = 0;
+    FNAV_Omegadot_1_5 = 0;
+    FNAV_M0_1_5 = 0;
+    FNAV_af0_1_5 = 0;
+    FNAV_af1_1_5 = 0;
+    FNAV_E5ahs_1_5 = 0;
+    FNAV_SVID2_5 = 0;
+    FNAV_Deltaa12_2_5 = 0;
+    FNAV_e_2_5 = 0;
+    FNAV_w_2_5 = 0;
+    FNAV_deltai_2_5 = 0;
+
+    // WORD 6 Almanac (SVID2(2/2) and SVID3)
+    FNAV_IODa_6 = 0;
+    FNAV_Omega0_2_6 = 0;
+    FNAV_Omegadot_2_6 = 0;
+    FNAV_M0_2_6 = 0;
+    FNAV_af0_2_6 = 0;
+    FNAV_af1_2_6 = 0;
+    FNAV_E5ahs_2_6 = 0;
+    FNAV_SVID3_6 = 0;
+    FNAV_Deltaa12_3_6 = 0;
+    FNAV_e_3_6 = 0;
+    FNAV_w_3_6 = 0;
+    FNAV_deltai_3_6 = 0;
+    FNAV_Omega0_3_6 = 0;
+    FNAV_Omegadot_3_6 = 0;
+    FNAV_M0_3_6 = 0;
+    FNAV_af0_3_6 = 0;
+    FNAV_af1_3_6 = 0;
+    FNAV_E5ahs_3_6 = 0;
+}
+
+Galileo_Fnav_Message::Galileo_Fnav_Message()
+{
+    reset();
+}
+//int Galileo_Fnav_Message::toInt(std::string bitString)
+//{
+//    int tempInt;
+//    int num=0;
+//    int sLength = bitString.length();
+//    for(int i=0; i<sLength; i++)
+//	{
+//	    num |= (1 << (sLength-1-i))*tempInt;
+//	}
+//
+//    return num;
+//}
+void Galileo_Fnav_Message::split_page(std::string page_string)
+{
+    std::string message_word = page_string.substr(0,214);
+    std::string CRC_data = page_string.substr(214,24);
+    std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> Word_for_CRC_bits(message_word);
+    std::bitset<24> checksum(CRC_data);
+    if (_CRC_test(Word_for_CRC_bits, checksum.to_ulong()) == true)
+        {
+            flag_CRC_test = true;
+            // CRC correct: Decode word
+            decode_page(message_word);
+        }
+    else
+	{
+	    flag_CRC_test = false;
+	}
+}
+
+bool Galileo_Fnav_Message::_CRC_test(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> bits,boost::uint32_t checksum)
+{
+    CRC_Galileo_FNAV_type CRC_Galileo;
+
+    boost::uint32_t crc_computed;
+    // Galileo FNAV frame for CRC is not an integer multiple of bytes
+    // it needs to be filled with zeroes at the start of the frame.
+    // This operation is done in the transformation from bits to bytes
+    // using boost::dynamic_bitset.
+    // ToDo: Use boost::dynamic_bitset for all the bitset operations in this class
+
+    boost::dynamic_bitset<unsigned char> frame_bits(std::string(bits.to_string()));
+
+    std::vector<unsigned char> bytes;
+    boost::to_block_range(frame_bits, std::back_inserter(bytes));
+    std::reverse(bytes.begin(),bytes.end());
+
+    CRC_Galileo.process_bytes( bytes.data(), GALILEO_FNAV_DATA_FRAME_BYTES );
+
+    crc_computed = CRC_Galileo.checksum();
+    if (checksum == crc_computed)
+        {
+            return true;
+        }
+    else
+        {
+            return false;
+        }
+}
+void Galileo_Fnav_Message::decode_page(std::string data)
+{
+    std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> data_bits(data);
+    page_type = read_navigation_unsigned(data_bits,FNAV_PAGE_TYPE_bit);
+    switch(page_type)
+    {
+	case 1: // SVID, Clock correction, SISA, Ionospheric correction, BGD, GST, Signal health and Data validity status
+	    FNAV_SV_ID_PRN_1=(int)read_navigation_unsigned(data_bits,FNAV_SV_ID_PRN_1_bit);
+	    FNAV_IODnav_1=(int)read_navigation_unsigned(data_bits,FNAV_IODnav_1_bit);
+	    FNAV_t0c_1=(double)read_navigation_unsigned(data_bits,FNAV_t0c_1_bit);
+	    FNAV_t0c_1 *= FNAV_t0c_1_LSB;
+	    FNAV_af0_1=(double)read_navigation_signed(data_bits,FNAV_af0_1_bit);
+	    FNAV_af0_1 *= FNAV_af0_1_LSB;
+	    FNAV_af1_1=(double)read_navigation_signed(data_bits,FNAV_af1_1_bit);
+	    FNAV_af1_1 *= FNAV_af1_1_LSB;
+	    FNAV_af2_1=(double)read_navigation_signed(data_bits,FNAV_af2_1_bit);
+	    FNAV_af2_1 *= FNAV_af2_1_LSB;
+	    FNAV_SISA_1=(double)read_navigation_unsigned(data_bits,FNAV_SISA_1_bit);
+	    FNAV_ai0_1=(double)read_navigation_unsigned(data_bits,FNAV_ai0_1_bit);
+	    FNAV_ai0_1 *= FNAV_ai0_1_LSB;
+	    FNAV_ai1_1=(double)read_navigation_signed(data_bits,FNAV_ai1_1_bit);
+	    FNAV_ai1_1 *= FNAV_ai1_1_LSB;
+	    FNAV_ai2_1=(double)read_navigation_signed(data_bits,FNAV_ai2_1_bit);
+	    FNAV_ai2_1 *= FNAV_ai2_1_LSB;
+	    FNAV_region1_1=(bool)read_navigation_unsigned(data_bits,FNAV_region1_1_bit);
+	    FNAV_region2_1=(bool)read_navigation_unsigned(data_bits,FNAV_region2_1_bit);
+	    FNAV_region3_1=(bool)read_navigation_unsigned(data_bits,FNAV_region3_1_bit);
+	    FNAV_region4_1=(bool)read_navigation_unsigned(data_bits,FNAV_region4_1_bit);
+	    FNAV_region5_1=(bool)read_navigation_unsigned(data_bits,FNAV_region5_1_bit);
+	    FNAV_BGD_1=(double)read_navigation_signed(data_bits,FNAV_BGD_1_bit);
+	    FNAV_BGD_1 *= FNAV_BGD_1_LSB;
+	    FNAV_E5ahs_1=(double)read_navigation_unsigned(data_bits,FNAV_E5ahs_1_bit);
+	    FNAV_WN_1=(double)read_navigation_unsigned(data_bits,FNAV_WN_1_bit);
+	    FNAV_TOW_1=(double)read_navigation_unsigned(data_bits,FNAV_TOW_1_bit);
+	    FNAV_E5advs_1=(double)read_navigation_unsigned(data_bits,FNAV_E5advs_1_bit);
+
+	    flag_TOW_1=true;
+	    flag_TOW_set=true;
+	    flag_iono_and_GST = true; //set to false externally
+	    break;
+	case 2: // Ephemeris (1/3) and GST
+	    FNAV_IODnav_2=(int)read_navigation_unsigned(data_bits,FNAV_IODnav_2_bit);
+	    FNAV_M0_2=(double)read_navigation_unsigned(data_bits,FNAV_M0_2_bit);
+	    FNAV_M0_2 *= FNAV_M0_2_LSB;
+	    FNAV_omegadot_2=(double)read_navigation_signed(data_bits,FNAV_omegadot_2_bit);
+	    FNAV_omegadot_2 *= FNAV_omegadot_2_LSB;
+	    FNAV_e_2=(double)read_navigation_unsigned(data_bits,FNAV_e_2_bit);
+	    FNAV_e_2 *= FNAV_e_2_LSB;
+	    FNAV_a12_2=(double)read_navigation_unsigned(data_bits,FNAV_a12_2_bit);
+	    FNAV_a12_2 *= FNAV_a12_2_LSB;
+	    FNAV_omega0_2=(double)read_navigation_signed(data_bits,FNAV_omega0_2_bit);
+	    FNAV_omega0_2 *= FNAV_omega0_2_LSB;
+	    FNAV_idot_2=(double)read_navigation_signed(data_bits,FNAV_idot_2_bit);
+	    FNAV_idot_2 *= FNAV_idot_2_LSB;
+	    FNAV_WN_2=(double)read_navigation_unsigned(data_bits,FNAV_WN_2_bit);
+	    FNAV_TOW_2=(double)read_navigation_unsigned(data_bits,FNAV_TOW_2_bit);
+
+	    flag_TOW_2=true;
+	    flag_TOW_set=true;
+	    flag_ephemeris_1=true;
+	    break;
+	case 3: // Ephemeris (2/3) and GST
+	    FNAV_IODnav_3=(int)read_navigation_unsigned(data_bits,FNAV_IODnav_3_bit);
+	    FNAV_i0_3=(double)read_navigation_signed(data_bits,FNAV_i0_3_bit);
+	    FNAV_i0_3 *= FNAV_i0_3_LSB;
+	    FNAV_w_3=(double)read_navigation_signed(data_bits,FNAV_w_3_bit);
+	    FNAV_w_3 *= FNAV_w_3_LSB;
+	    FNAV_deltan_3=(double)read_navigation_unsigned(data_bits,FNAV_deltan_3_bit);
+	    FNAV_deltan_3 *= FNAV_deltan_3_LSB;
+	    FNAV_Cuc_3=(double)read_navigation_signed(data_bits,FNAV_Cuc_3_bit);
+	    FNAV_Cuc_3 *= FNAV_Cuc_3_LSB;
+	    FNAV_Cus_3=(double)read_navigation_signed(data_bits,FNAV_Cus_3_bit);
+	    FNAV_Cus_3 *= FNAV_Cus_3_LSB;
+	    FNAV_Crc_3=(double)read_navigation_signed(data_bits,FNAV_Crc_3_bit);
+	    FNAV_Crc_3 *= FNAV_Crc_3_LSB;
+	    FNAV_Crs_3=(double)read_navigation_signed(data_bits,FNAV_Crs_3_bit);
+	    FNAV_Crs_3 *= FNAV_Crs_3_LSB;
+	    FNAV_t0e_3=(double)read_navigation_unsigned(data_bits,FNAV_t0e_3_bit);
+	    FNAV_t0e_3 *= FNAV_t0e_3_LSB;
+	    FNAV_WN_3=(double)read_navigation_unsigned(data_bits,FNAV_WN_3_bit);
+	    FNAV_TOW_3=(double)read_navigation_unsigned(data_bits,FNAV_TOW_3_bit);
+
+	    flag_TOW_3=true;
+	    flag_TOW_set=true;
+	    flag_ephemeris_2=true;
+	    break;
+	case 4: // Ephemeris (3/3), GST-UTC conversion, GST-GPS conversion and TOW
+	    FNAV_IODnav_4=(int)read_navigation_unsigned(data_bits,FNAV_IODnav_4_bit);
+	    FNAV_Cic_4=(double)read_navigation_unsigned(data_bits,FNAV_Cic_4_bit);
+	    FNAV_Cic_4 *= FNAV_Cic_4_LSB;
+	    FNAV_Cis_4=(double)read_navigation_unsigned(data_bits,FNAV_Cis_4_bit);
+	    FNAV_Cis_4 *= FNAV_Cis_4_LSB;
+	    FNAV_A0_4=(double)read_navigation_unsigned(data_bits,FNAV_A0_4_bit);
+	    FNAV_A0_4 *= FNAV_A0_4_LSB;
+	    FNAV_A1_4=(double)read_navigation_unsigned(data_bits,FNAV_A1_4_bit);
+	    FNAV_A1_4 *= FNAV_A1_4_LSB;
+	    FNAV_deltatls_4=(double)read_navigation_signed(data_bits,FNAV_deltatls_4_bit);
+	    FNAV_t0t_4=(double)read_navigation_unsigned(data_bits,FNAV_t0t_4_bit);
+	    FNAV_t0t_4 *= FNAV_t0t_4_LSB;
+	    FNAV_WNot_4=(double)read_navigation_unsigned(data_bits,FNAV_WNot_4_bit);
+	    FNAV_WNlsf_4=(double)read_navigation_unsigned(data_bits,FNAV_WNlsf_4_bit);
+	    FNAV_DN_4=(double)read_navigation_unsigned(data_bits,FNAV_DN_4_bit);
+	    FNAV_deltatlsf_4=(double)read_navigation_signed(data_bits,FNAV_deltatlsf_4_bit);
+	    FNAV_t0g_4=(double)read_navigation_unsigned(data_bits,FNAV_t0g_4_bit);
+	    FNAV_t0g_4 *= FNAV_t0g_4_LSB;
+	    FNAV_A0g_4=(double)read_navigation_signed(data_bits,FNAV_A0g_4_bit);
+	    FNAV_A0g_4 *= FNAV_A0g_4_LSB;
+	    FNAV_A1g_4=(double)read_navigation_signed(data_bits,FNAV_A1g_4_bit);
+	    FNAV_A1g_4 *= FNAV_A1g_4_LSB;
+	    FNAV_WN0g_4=(double)read_navigation_unsigned(data_bits,FNAV_WN0g_4_bit);
+	    FNAV_TOW_4=(double)read_navigation_unsigned(data_bits,FNAV_TOW_4_bit);
+
+	    flag_TOW_4=true;
+	    flag_TOW_set=true;
+	    flag_ephemeris_3=true;
+	    flag_utc_model = true; //set to false externally
+	    break;
+	case 5: // Almanac (SVID1 and SVID2(1/2)), Week Number and almanac reference time
+	    FNAV_IODa_5=(int)read_navigation_unsigned(data_bits,FNAV_IODa_5_bit);
+	    FNAV_WNa_5=(double)read_navigation_unsigned(data_bits,FNAV_WNa_5_bit);
+	    FNAV_t0a_5=(double)read_navigation_unsigned(data_bits,FNAV_t0a_5_bit);
+	    FNAV_t0a_5 *= FNAV_t0a_5_LSB;
+	    FNAV_SVID1_5=(int)read_navigation_unsigned(data_bits,FNAV_SVID1_5_bit);
+	    FNAV_Deltaa12_1_5=(double)read_navigation_signed(data_bits,FNAV_Deltaa12_1_5_bit);
+	    FNAV_Deltaa12_1_5 *= FNAV_Deltaa12_5_LSB;
+	    FNAV_e_1_5=(double)read_navigation_unsigned(data_bits,FNAV_e_1_5_bit);
+	    FNAV_e_1_5 *= FNAV_e_5_LSB;
+	    FNAV_w_1_5=(double)read_navigation_signed(data_bits,FNAV_w_1_5_bit);
+	    FNAV_w_1_5 *= FNAV_w_5_LSB;
+	    FNAV_deltai_1_5=(double)read_navigation_signed(data_bits,FNAV_deltai_1_5_bit);
+	    FNAV_deltai_1_5 *= FNAV_deltai_5_LSB;
+	    FNAV_Omega0_1_5=(double)read_navigation_signed(data_bits,FNAV_Omega0_1_5_bit);
+	    FNAV_Omega0_1_5 *= FNAV_Omega0_5_LSB;
+	    FNAV_Omegadot_1_5=(double)read_navigation_signed(data_bits,FNAV_Omegadot_1_5_bit);
+	    FNAV_Omegadot_1_5 *= FNAV_Omegadot_5_LSB;
+	    FNAV_M0_1_5=(double)read_navigation_signed(data_bits,FNAV_M0_1_5_bit);
+	    FNAV_M0_1_5 *= FNAV_M0_5_LSB;
+	    FNAV_af0_1_5=(double)read_navigation_signed(data_bits,FNAV_af0_1_5_bit);
+	    FNAV_af0_1_5 *= FNAV_af0_5_LSB;
+	    FNAV_af1_1_5=(double)read_navigation_signed(data_bits,FNAV_af1_1_5_bit);
+	    FNAV_af1_1_5 *= FNAV_af1_5_LSB;
+	    FNAV_E5ahs_1_5=(double)read_navigation_unsigned(data_bits,FNAV_E5ahs_1_5_bit);
+	    FNAV_SVID2_5=(int)read_navigation_unsigned(data_bits,FNAV_SVID2_5_bit);
+	    FNAV_Deltaa12_2_5=(double)read_navigation_signed(data_bits,FNAV_Deltaa12_2_5_bit);
+	    FNAV_Deltaa12_2_5 *= FNAV_Deltaa12_5_LSB;
+	    FNAV_e_2_5=(double)read_navigation_unsigned(data_bits,FNAV_e_2_5_bit);
+	    FNAV_e_2_5 *= FNAV_e_5_LSB;
+	    FNAV_w_2_5=(double)read_navigation_signed(data_bits,FNAV_w_2_5_bit);
+	    FNAV_w_2_5 *= FNAV_w_5_LSB;
+	    FNAV_deltai_2_5=(double)read_navigation_signed(data_bits,FNAV_deltai_2_5_bit);
+	    FNAV_deltai_2_5 *= FNAV_deltai_5_LSB;
+	    //TODO check this
+	    // Omega0_2 must be decoded when the two pieces are joined
+	    omega0_1=data.substr(210,4);
+	    //omega_flag=true;
+	    //
+	    //FNAV_Omega012_2_5=(double)read_navigation_signed(data_bits,FNAV_Omega012_2_5_bit);
+
+	    flag_almanac_1=true;
+	    break;
+	case 6: // Almanac (SVID2(2/2) and SVID3)
+	    FNAV_IODa_6=(int)read_navigation_unsigned(data_bits,FNAV_IODa_6_bit);
+
+            /* Don't worry about omega pieces. If page 5 has not been received, all_ephemeris
+	     * flag will be set to false and the data won't be recorded.*/
+	    std::string omega0_2 = data.substr(10,12);
+	    std::string Omega0 = omega0_1 + omega0_2;
+            std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> omega_bits(Omega0);
+	    const std::vector<std::pair<int,int>> om_bit({{0,12}});
+	    FNAV_Omega0_2_6=(double)read_navigation_signed(omega_bits,om_bit);
+	    FNAV_Omega0_2_6 *= FNAV_Omega0_5_LSB;
+	    //
+	    FNAV_Omegadot_2_6=(double)read_navigation_signed(data_bits,FNAV_Omegadot_2_6_bit);
+	    FNAV_Omegadot_2_6 *= FNAV_Omegadot_5_LSB;
+	    FNAV_M0_2_6=(double)read_navigation_signed(data_bits,FNAV_M0_2_6_bit);
+	    FNAV_M0_2_6 *= FNAV_M0_5_LSB;
+	    FNAV_af0_2_6=(double)read_navigation_signed(data_bits,FNAV_af0_2_6_bit);
+	    FNAV_af0_2_6 *= FNAV_af0_5_LSB;
+	    FNAV_af1_2_6=(double)read_navigation_signed(data_bits,FNAV_af1_2_6_bit);
+	    FNAV_af1_2_6 *= FNAV_af1_5_LSB;
+	    FNAV_E5ahs_2_6=(double)read_navigation_unsigned(data_bits,FNAV_E5ahs_2_6_bit);
+	    FNAV_SVID3_6=(int)read_navigation_unsigned(data_bits,FNAV_SVID3_6_bit);
+	    FNAV_Deltaa12_3_6=(double)read_navigation_signed(data_bits,FNAV_Deltaa12_3_6_bit);
+	    FNAV_Deltaa12_3_6 *= FNAV_Deltaa12_5_LSB;
+	    FNAV_e_3_6=(double)read_navigation_unsigned(data_bits,FNAV_e_3_6_bit);
+	    FNAV_e_3_6 *= FNAV_e_5_LSB;
+	    FNAV_w_3_6=(double)read_navigation_signed(data_bits,FNAV_w_3_6_bit);
+	    FNAV_w_3_6 *= FNAV_w_5_LSB;
+	    FNAV_deltai_3_6=(double)read_navigation_signed(data_bits,FNAV_deltai_3_6_bit);
+	    FNAV_deltai_3_6 *= FNAV_deltai_5_LSB;
+	    FNAV_Omega0_3_6=(double)read_navigation_signed(data_bits,FNAV_Omega0_3_6_bit);
+	    FNAV_Omega0_3_6 *= FNAV_Omega0_5_LSB;
+	    FNAV_Omegadot_3_6=(double)read_navigation_signed(data_bits,FNAV_Omegadot_3_6_bit);
+	    FNAV_Omegadot_3_6 *= FNAV_Omegadot_5_LSB;
+	    FNAV_M0_3_6=(double)read_navigation_signed(data_bits,FNAV_M0_3_6_bit);
+	    FNAV_M0_3_6 *= FNAV_M0_5_LSB;
+	    FNAV_af0_3_6=(double)read_navigation_signed(data_bits,FNAV_af0_3_6_bit);
+	    FNAV_af0_3_6 *= FNAV_af0_5_LSB;
+	    FNAV_af1_3_6=(double)read_navigation_signed(data_bits,FNAV_af1_3_6_bit);
+	    FNAV_af1_3_6 *= FNAV_af1_5_LSB;
+	    FNAV_E5ahs_3_6=(double)read_navigation_unsigned(data_bits,FNAV_E5ahs_3_6_bit);
+
+	    flag_almanac_2=true;
+	    break;
+    }
+
+}
+
+unsigned long int Galileo_Fnav_Message::read_navigation_unsigned(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> bits, const std::vector<std::pair<int,int>> parameter)
+{
+    unsigned long int value = 0;
+    int num_of_slices = parameter.size();
+    for (int i=0; i<num_of_slices; i++)
+        {
+            for (int j=0; j<parameter[i].second; j++)
+                {
+                    value <<= 1; //shift left
+                    if (bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[i].first - j] == 1)
+                        {
+                            value += 1; // insert the bit
+                        }
+                }
+        }
+    return value;
+}
+
+
+
+
+
+signed long int Galileo_Fnav_Message::read_navigation_signed(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> bits, const std::vector<std::pair<int,int>> parameter)
+{
+    signed long int value = 0;
+    int num_of_slices = parameter.size();
+    // Discriminate between 64 bits and 32 bits compiler
+    int long_int_size_bytes = sizeof(signed long int);
+    if (long_int_size_bytes == 8) // if a long int takes 8 bytes, we are in a 64 bits system
+        {
+            // read the MSB and perform the sign extension
+            if (bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[0].first] == 1)
+                {
+                    value ^= 0xFFFFFFFFFFFFFFFF; //64 bits variable
+                }
+            else
+                {
+                    value &= 0;
+                }
+
+            for (int i=0; i<num_of_slices; i++)
+                {
+                    for (int j=0; j<parameter[i].second; j++)
+                        {
+                            value <<= 1; //shift left
+                            value &= 0xFFFFFFFFFFFFFFFE; //reset the corresponding bit (for the 64 bits variable)
+                            if (bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[i].first - j] == 1)
+                                {
+                                    value += 1; // insert the bit
+                                }
+                        }
+                }
+        }
+    else  // we assume we are in a 32 bits system
+        {
+            // read the MSB and perform the sign extension
+            if (bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[0].first] == 1)
+                {
+                    value ^= 0xFFFFFFFF;
+                }
+            else
+                {
+                    value &= 0;
+                }
+
+            for (int i=0; i<num_of_slices; i++)
+                {
+                    for (int j=0; j<parameter[i].second; j++)
+                        {
+                            value <<= 1; //shift left
+                            value &= 0xFFFFFFFE; //reset the corresponding bit
+                            if (bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[i].first - j] == 1)
+                                {
+                                    value += 1; // insert the bit
+                                }
+                        }
+                }
+        }
+    return value;
+}
+
+bool Galileo_Fnav_Message::have_new_ephemeris() //Check if we have a new ephemeris stored in the galileo navigation class
+{
+    if ((flag_ephemeris_1 == true) and (flag_ephemeris_2 == true) and (flag_ephemeris_3 == true) and (flag_iono_and_GST == true))
+        {
+            //if all ephemeris pages have the same IOD, then they belong to the same block
+            if ((FNAV_IODnav_1 == FNAV_IODnav_2) and (FNAV_IODnav_3 == FNAV_IODnav_4) and (FNAV_IODnav_1 == FNAV_IODnav_3))
+                {
+                    std::cout << "Ephemeris (1, 2, 3) have been received and belong to the same batch" << std::endl;
+                    flag_ephemeris_1 = false;// clear the flag
+                    flag_ephemeris_2 = false;// clear the flag
+                    flag_ephemeris_3 = false;// clear the flag
+                    flag_all_ephemeris = true;
+                    IOD_ephemeris = FNAV_IODnav_1;
+                    std::cout << "Batch number: "<< IOD_ephemeris << std::endl;
+                    return true;
+                }
+            else
+                {
+                    return false;
+                }
+        }
+    else
+        return false;
+}
+bool Galileo_Fnav_Message::have_new_iono_and_GST() //Check if we have a new iono data set stored in the galileo navigation class
+{
+    if ((flag_iono_and_GST == true) and (flag_utc_model == true)) //the condition on flag_utc_model is added to have a time stamp for iono
+        {
+            flag_iono_and_GST = false; // clear the flag
+            return true;
+        }
+    else
+        return false;
+}
+bool Galileo_Fnav_Message::have_new_utc_model() // Check if we have a new utc data set stored in the galileo navigation class
+{
+    if (flag_utc_model == true)
+        {
+            flag_utc_model = false; // clear the flag
+            return true;
+        }
+    else
+        return false;
+}
+bool Galileo_Fnav_Message::have_new_almanac() //Check if we have a new almanac data set stored in the galileo navigation class
+{
+    if ((flag_almanac_1 == true) and (flag_almanac_2 == true))
+        {
+            //All almanac have been received
+            flag_almanac_1 = false;
+            flag_almanac_2 = false;
+            flag_all_almanac = true;
+            return true;
+        }
+    else
+        return false;
+}
+
+Galileo_Ephemeris Galileo_Fnav_Message::get_ephemeris()
+{
+    Galileo_Ephemeris ephemeris;
+    ephemeris.flag_all_ephemeris = flag_all_ephemeris;
+    ephemeris.IOD_ephemeris = IOD_ephemeris;
+    ephemeris.SV_ID_PRN_4 = FNAV_SV_ID_PRN_1;
+    ephemeris.i_satellite_PRN = FNAV_SV_ID_PRN_1;
+    ephemeris.M0_1 = FNAV_M0_2;          // Mean anomaly at reference time [semi-circles]
+    ephemeris.delta_n_3 = FNAV_deltan_3;// Mean motion difference from computed value  [semi-circles/sec]
+    ephemeris.e_1 = FNAV_e_2;            // Eccentricity
+    ephemeris.A_1 =  FNAV_a12_2;           // Square root of the semi-major axis [metres^1/2]
+    ephemeris.OMEGA_0_2 = FNAV_omega0_2;// Longitude of ascending node of orbital plane at weekly epoch [semi-circles]
+    ephemeris.i_0_2 = FNAV_i0_3;        // Inclination angle at reference time  [semi-circles]
+    ephemeris.omega_2 = FNAV_w_3;    // Argument of perigee [semi-circles]
+    ephemeris.OMEGA_dot_3 = FNAV_omegadot_2; // Rate of right ascension [semi-circles/sec]
+    ephemeris.iDot_2 = FNAV_idot_2;      // Rate of inclination angle [semi-circles/sec]
+    ephemeris.C_uc_3 = FNAV_Cuc_3;	    // Amplitude of the cosine harmonic correction term to the argument of latitude [radians]
+    ephemeris.C_us_3 = FNAV_Cus_3;	    // Amplitude of the sine harmonic correction term to the argument of latitude [radians]
+    ephemeris.C_rc_3 = FNAV_Crc_3;	    // Amplitude of the cosine harmonic correction term to the orbit radius [meters]
+    ephemeris.C_rs_3 = FNAV_Crs_3;	    // Amplitude of the sine harmonic correction term to the orbit radius [meters]
+    ephemeris.C_ic_4 = FNAV_Cic_4;      // Amplitude of the cosine harmonic correction 	term to the angle of inclination [radians]
+    ephemeris.C_is_4 = FNAV_Cis_4;      // Amplitude of the sine harmonic correction term to the angle of inclination [radians]
+    ephemeris.t0e_1 = FNAV_t0e_3;        // Ephemeris reference time [s]
+
+    /*Clock correction parameters*/
+    ephemeris.t0c_4 = FNAV_t0c_1;        // Clock correction data reference Time of Week [sec]
+    ephemeris.af0_4 = FNAV_af0_1;        // SV clock bias correction coefficient [s]
+    ephemeris.af1_4 = FNAV_af1_1;        // SV clock drift correction coefficient [s/s]
+    ephemeris.af2_4 = FNAV_af2_1;        // SV clock drift rate correction coefficient [s/s^2]
+
+    /*GST*/
+    ephemeris.WN_5 = FNAV_WN_3;          // Week number
+    ephemeris.TOW_5 = FNAV_TOW_3;        // Time of Week
+    return ephemeris;
+}
+
+Galileo_Iono Galileo_Fnav_Message::get_iono()
+{
+    Galileo_Iono iono;
+    /*Ionospheric correction*/
+    /*Az*/
+    iono.ai0_5 = FNAV_ai0_1;		// Effective Ionisation Level 1st order parameter [sfu]
+    iono.ai1_5 = FNAV_ai1_1;		// Effective Ionisation Level 2st order parameter [sfu/degree]
+    iono.ai2_5 = FNAV_ai2_1;		// Effective Ionisation Level 3st order parameter [sfu/degree]
+
+    /*Ionospheric disturbance flag*/
+    iono.Region1_flag_5 = FNAV_region1_1;	// Ionospheric Disturbance Flag for region 1
+    iono.Region2_flag_5 = FNAV_region2_1;	// Ionospheric Disturbance Flag for region 2
+    iono.Region3_flag_5 = FNAV_region3_1;	// Ionospheric Disturbance Flag for region 3
+    iono.Region4_flag_5 = FNAV_region4_1;	// Ionospheric Disturbance Flag for region 4
+    iono.Region5_flag_5 = FNAV_region5_1;	// Ionospheric Disturbance Flag for region 5
+
+    /*GST*/
+    iono.TOW_5 = FNAV_TOW_1;
+    iono.WN_5 = FNAV_WN_1;
+    return iono;
+}
+
+Galileo_Utc_Model Galileo_Fnav_Message::get_utc_model()
+{
+    Galileo_Utc_Model utc_model;
+    //Gal_utc_model.valid = flag_utc_model_valid;
+    /*Word type 6: GST-UTC conversion parameters*/
+    utc_model.A0_6 = FNAV_A0_4;
+    utc_model.A1_6 = FNAV_A1_4;
+    utc_model.Delta_tLS_6 = FNAV_deltatls_4;
+    utc_model.t0t_6 = FNAV_t0t_4;
+    utc_model.WNot_6 = FNAV_WNot_4;
+    utc_model.WN_LSF_6 = FNAV_WNlsf_4;
+    utc_model.DN_6 = FNAV_DN_4;
+    utc_model.Delta_tLSF_6 = FNAV_deltatlsf_4;
+    utc_model.flag_utc_model = flag_utc_model;
+    /*GST*/
+    //utc_model.WN_5 = WN_5; //Week number
+    //utc_model.TOW_5 = WN_5; //Time of Week
+    return utc_model;
+}
+
+Galileo_Almanac Galileo_Fnav_Message::get_almanac()
+{
+    Galileo_Almanac almanac;
+    /*FNAV equivalent of INAV Word type 7: Almanac for SVID1 (1/2), almanac reference time and almanac reference week number*/
+    almanac.IOD_a_7 = FNAV_IODa_5;
+    almanac.WN_a_7 = FNAV_WNa_5;
+    almanac.t0a_7 = FNAV_t0a_5;
+    almanac.SVID1_7 = FNAV_SVID1_5;
+    almanac.DELTA_A_7 = FNAV_Deltaa12_1_5;
+    almanac.e_7 = FNAV_e_1_5;
+    almanac.omega_7 = FNAV_w_1_5;
+    almanac.delta_i_7 = FNAV_deltai_1_5;
+    almanac.Omega0_7 = FNAV_Omega0_1_5;
+    almanac.Omega_dot_7 = FNAV_Omegadot_1_5;
+    almanac.M0_7 = FNAV_M0_1_5;
+
+    /*FNAV equivalent of INAV Word type 8: Almanac for SVID1 (2/2) and SVID2 (1/2)*/
+    almanac.IOD_a_8 = FNAV_IODa_5;
+    almanac.af0_8 = FNAV_af0_1_5;
+    almanac.af1_8 = FNAV_af1_1_5;
+    almanac.E5a_HS_8 = FNAV_E5ahs_1_5;
+    almanac.SVID2_8 = FNAV_SVID2_5;
+    almanac.DELTA_A_8 = FNAV_Deltaa12_2_5;
+    almanac.e_8 = FNAV_e_2_5;
+    almanac.omega_8 = FNAV_w_2_5;
+    almanac.delta_i_8 = FNAV_deltai_2_5;
+    almanac.Omega0_8 = FNAV_Omega0_2_6;
+    almanac.Omega_dot_8 = FNAV_Omegadot_2_6;
+
+    /*FNAV equivalent of INAV Word type 9: Almanac for SVID2 (2/2) and SVID3 (1/2)*/
+    almanac.IOD_a_9 = FNAV_IODa_6;
+    almanac.WN_a_9 = FNAV_WNa_5;
+    almanac.t0a_9 = FNAV_t0a_5;
+    almanac.M0_9 = FNAV_M0_2_6;
+    almanac.af0_9 = FNAV_af0_2_6;
+    almanac.af1_9 = FNAV_af1_2_6;
+    almanac.E5a_HS_9 = FNAV_E5ahs_2_6;
+    almanac.SVID3_9 = FNAV_SVID3_6;
+    almanac.DELTA_A_9 = FNAV_Deltaa12_3_6;
+    almanac.e_9 = FNAV_e_3_6;
+    almanac.omega_9 = FNAV_w_3_6;
+    almanac.delta_i_9 = FNAV_deltai_3_6;
+
+    /*FNAV equivalent of INAV Word type 10: Almanac for SVID3 (2/2)*/
+    almanac.IOD_a_10 = FNAV_IODa_6;
+    almanac.Omega0_10 = FNAV_Omega0_3_6;
+    almanac.Omega_dot_10 = FNAV_Omegadot_3_6;
+    almanac.M0_10 = FNAV_M0_3_6;
+    almanac.af0_10 = FNAV_af0_3_6;
+    almanac.af1_10 = FNAV_af1_3_6;
+    almanac.E5a_HS_10 = FNAV_E5ahs_3_6;
+    return almanac;
+}

src/core/system_parameters/galileo_fnav_message.h

@@ -0,0 +1,229 @@
+/*!
+ * \file galileo_fnav_message.h
+ * \brief  Implementation of a Galileo F/NAV Data message
+ *         as described in Galileo OS SIS ICD Issue 1.1 (Sept. 2010)
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ * \based on work from:
+ * 		<ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          </ul>
+ *
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_FNAV_MESSAGE_H_
+#define GNSS_SDR_GALILEO_FNAV_MESSAGE_H_
+
+#include <iostream>
+#include <map>
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <bitset>
+#include <boost/assign.hpp>
+#include <boost/cstdint.hpp>  // for boost::uint16_t
+#include <cmath>
+#include <utility>
+#include "galileo_ephemeris.h"
+#include "galileo_iono.h"
+#include "galileo_almanac.h"
+#include "galileo_utc_model.h"
+#include "Galileo_E5a.h"
+
+/*!
+ * \brief This class handles the Galileo F/NAV Data message, as described in the
+ * Galileo Open Service Signal in Space Interface Control Document (OS SIS ICD), Issue 1.1 (Sept 2010).
+ * See http://ec.europa.eu/enterprise/policies/satnav/galileo/files/galileo-os-sis-icd-issue1-revision1_en.pdf
+ */
+class Galileo_Fnav_Message
+{
+public:
+//    void Galileo_Fnav_Message::split_page(std::string page_string);
+//    void Galileo_Fnav_Message::reset();
+//    bool Galileo_Fnav_Message::have_new_ephemeris();
+//    bool Galileo_Fnav_Message::have_new_iono_and_GST();
+//    bool Galileo_Fnav_Message::have_new_utc_model();
+//    bool Galileo_Fnav_Message::have_new_almanac();
+//    Galileo_Ephemeris Galileo_Fnav_Message::get_ephemeris();
+//    Galileo_Iono Galileo_Fnav_Message::get_iono();
+//    Galileo_Utc_Model Galileo_Fnav_Message::get_utc_model();
+//    Galileo_Almanac Galileo_Fnav_Message::get_almanac();
+    //
+    void split_page(std::string page_string);
+    void reset();
+    bool have_new_ephemeris();
+    bool have_new_iono_and_GST();
+    bool have_new_utc_model();
+    bool have_new_almanac();
+    Galileo_Ephemeris get_ephemeris();
+    Galileo_Iono get_iono();
+    Galileo_Utc_Model get_utc_model();
+    Galileo_Almanac get_almanac();
+
+    Galileo_Fnav_Message();
+
+    bool flag_CRC_test;
+    bool flag_all_ephemeris;  //!< Flag indicating that all words containing ephemeris have been received
+    bool flag_ephemeris_1;    //!< Flag indicating that ephemeris 1/3 (word 2) have been received
+    bool flag_ephemeris_2;    //!< Flag indicating that ephemeris 2/3 (word 3) have been received
+    bool flag_ephemeris_3;    //!< Flag indicating that ephemeris 3/3 (word 4) have been received
+
+    bool flag_iono_and_GST;   //!< Flag indicating that ionospheric and GST parameters (word 1) have been received
+    bool flag_TOW_1;
+    bool flag_TOW_2;
+    bool flag_TOW_3;
+    bool flag_TOW_4;
+    bool flag_TOW_set; 	      //!< it is true when page 1,2,3 or 4 arrives
+    bool flag_utc_model;      //!< Flag indicating that utc model parameters (word 4) have been received
+
+    bool flag_all_almanac;    //!< Flag indicating that all almanac have been received
+    bool flag_almanac_1;      //!< Flag indicating that almanac 1/2 (word 5) have been received
+    bool flag_almanac_2;      //!< Flag indicating that almanac 2/2 (word 6) have been received
+
+    int IOD_ephemeris;
+
+    int page_type;
+    /* WORD 1 SVID, Clock correction, SISA, Ionospheric correction, BGD, GST, Signal
+     * health and Data validity status*/
+    int FNAV_SV_ID_PRN_1;
+    int FNAV_IODnav_1;
+    double FNAV_t0c_1;
+    double FNAV_af0_1;
+    double FNAV_af1_1;
+    double FNAV_af2_1;
+    double FNAV_SISA_1;
+    double FNAV_ai0_1;
+    double FNAV_ai1_1;
+    double FNAV_ai2_1;
+    bool FNAV_region1_1;
+    bool FNAV_region2_1;
+    bool FNAV_region3_1;
+    bool FNAV_region4_1;
+    bool FNAV_region5_1;
+    double FNAV_BGD_1;
+    double FNAV_E5ahs_1;
+    double FNAV_WN_1;
+    double FNAV_TOW_1;
+    double FNAV_E5advs_1;
+
+    // WORD 2 Ephemeris (1/3) and GST
+    int FNAV_IODnav_2;
+    double FNAV_M0_2;
+    double FNAV_omegadot_2;
+    double FNAV_e_2;
+    double FNAV_a12_2;
+    double FNAV_omega0_2;
+    double FNAV_idot_2;
+    double FNAV_WN_2;
+    double FNAV_TOW_2;
+
+    // WORD 3 Ephemeris (2/3) and GST
+    int FNAV_IODnav_3;
+    double FNAV_i0_3;
+    double FNAV_w_3;
+    double FNAV_deltan_3;
+    double FNAV_Cuc_3;
+    double FNAV_Cus_3;
+    double FNAV_Crc_3;
+    double FNAV_Crs_3;
+    double FNAV_t0e_3;
+    double FNAV_WN_3;
+    double FNAV_TOW_3;
+
+    /* WORD 4 Ephemeris (3/3), GST-UTC conversion, GST-GPS conversion and TOW.
+    Note that the clock is repeated in this page type*/
+    int FNAV_IODnav_4;
+    double FNAV_Cic_4;
+    double FNAV_Cis_4;
+    double FNAV_A0_4;
+    double FNAV_A1_4;
+    double FNAV_deltatls_4;
+    double FNAV_t0t_4;
+    double FNAV_WNot_4;
+    double FNAV_WNlsf_4;
+    double FNAV_DN_4;
+    double FNAV_deltatlsf_4;
+    double FNAV_t0g_4;
+    double FNAV_A0g_4;
+    double FNAV_A1g_4;
+    double FNAV_WN0g_4;
+    double FNAV_TOW_4;
+
+    // WORD 5 Almanac (SVID1 and SVID2(1/2)), Week Number and almanac reference time
+    int FNAV_IODa_5;
+    double FNAV_WNa_5;
+    double FNAV_t0a_5;
+    int FNAV_SVID1_5;
+    double FNAV_Deltaa12_1_5;
+    double FNAV_e_1_5;
+    double FNAV_w_1_5;
+    double FNAV_deltai_1_5;
+    double FNAV_Omega0_1_5;
+    double FNAV_Omegadot_1_5;
+    double FNAV_M0_1_5;
+    double FNAV_af0_1_5;
+    double FNAV_af1_1_5;
+    double FNAV_E5ahs_1_5;
+    int FNAV_SVID2_5;
+    double FNAV_Deltaa12_2_5;
+    double FNAV_e_2_5;
+    double FNAV_w_2_5;
+    double FNAV_deltai_2_5;
+
+    // WORD 6 Almanac (SVID2(2/2) and SVID3)
+    int FNAV_IODa_6;
+    double FNAV_Omega0_2_6;
+    double FNAV_Omegadot_2_6;
+    double FNAV_M0_2_6;
+    double FNAV_af0_2_6;
+    double FNAV_af1_2_6;
+    double FNAV_E5ahs_2_6;
+    int FNAV_SVID3_6;
+    double FNAV_Deltaa12_3_6;
+    double FNAV_e_3_6;
+    double FNAV_w_3_6;
+    double FNAV_deltai_3_6;
+    double FNAV_Omega0_3_6;
+    double FNAV_Omegadot_3_6;
+    double FNAV_M0_3_6;
+    double FNAV_af0_3_6;
+    double FNAV_af1_3_6;
+    double FNAV_E5ahs_3_6;
+
+
+
+private:
+    bool _CRC_test(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> bits,boost::uint32_t checksum);
+    void decode_page(std::string data);
+    unsigned long int read_navigation_unsigned(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> bits, const std::vector<std::pair<int,int>> parameter);
+    signed long int read_navigation_signed(std::bitset<GALILEO_FNAV_DATA_FRAME_BITS> bits, const std::vector<std::pair<int,int>> parameter);
+
+    std::string omega0_1;
+    //std::string omega0_2;
+    //bool omega_flag;
+};
+
+#endif /* GNSS_SDR_GALILEO_FNAV_MESSAGE_H_ */

src/tests/CMakeLists.txt

@@ -116,6 +116,9 @@ include_directories(
      ${CMAKE_SOURCE_DIR}/src/algorithms/tracking/libs
      ${CMAKE_SOURCE_DIR}/src/algorithms/tracking/adapters
      ${CMAKE_SOURCE_DIR}/src/algorithms/tracking/gnuradio_blocks
+     ${CMAKE_SOURCE_DIR}/src/algorithms/telemetry_decoder/adapters
+     ${CMAKE_SOURCE_DIR}/src/algorithms/telemetry_decoder/gnuradio_blocks
+     ${CMAKE_SOURCE_DIR}/src/algorithms/telemetry_decoder/libs
      ${CMAKE_SOURCE_DIR}/src/algorithms/signal_source/adapters
      ${CMAKE_SOURCE_DIR}/src/algorithms/signal_generator/adapters
      ${CMAKE_SOURCE_DIR}/src/algorithms/signal_generator/gnuradio_blocks

src/tests/gnss_block/galileo_e5a_pcps_acquisition_gsoc2014_gensource_test.cc

@@ -0,0 +1,994 @@
+/*!
+ * \file galileo_e5a_pcps_acquisition_gsoc2014_gensource_test.cc
+ * \brief  This class implements an acquisition test for
+ * GalileoE5a3msNoncoherentIQAcquisition class.
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2014  (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 <ctime>
+#include <iostream>
+#include <gnuradio/top_block.h>
+#include <gnuradio/blocks/file_source.h>
+#include <gnuradio/analog/sig_source_waveform.h>
+#include <gnuradio/analog/sig_source_c.h>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/blocks/null_sink.h>
+#include "gnss_block_factory.h"
+#include "gnss_block_interface.h"
+#include "in_memory_configuration.h"
+#include "configuration_interface.h"
+#include "gnss_synchro.h"
+#include "galileo_e5a_noncoherent_iq_acquisition_caf.h"
+#include "signal_generator.h"
+#include "signal_generator_c.h"
+#include "fir_filter.h"
+#include "gen_signal_source.h"
+#include "gnss_sdr_valve.h"
+#include "boost/shared_ptr.hpp"
+#include "pass_through.h"
+#include "file_output_filter.h"
+
+#include "gnss_block_factory.h"
+
+class GalileoE5aPcpsAcquisitionGSoC2014GensourceTest: public ::testing::Test
+{
+protected:
+    GalileoE5aPcpsAcquisitionGSoC2014GensourceTest()
+    {
+        queue = gr::msg_queue::make(0);
+        top_block = gr::make_top_block("Acquisition test");
+
+        item_size = sizeof(gr_complex);
+        stop = false;
+        message = 0;
+    }
+
+    ~GalileoE5aPcpsAcquisitionGSoC2014GensourceTest()
+    {
+    }
+
+    void init();
+    void config_1();
+    void config_2();
+    void config_3();
+    void start_queue();
+    void wait_message();
+    void process_message();
+    void stop_queue();
+
+    gr::msg_queue::sptr queue;
+    gr::top_block_sptr top_block;
+    //std::shared_ptr<GNSSBlockFactory> factory = std::make_shared<GNSSBlockFactory>();
+    GalileoE5aNoncoherentIQAcquisitionCaf *acquisition;
+
+    std::shared_ptr<InMemoryConfiguration> config;
+    Gnss_Synchro gnss_synchro;
+    size_t item_size;
+    concurrent_queue<int> channel_internal_queue;
+    bool stop;
+    int message;
+    boost::thread ch_thread;
+
+    unsigned int integration_time_ms;
+    unsigned int fs_in;
+
+    double expected_delay_chips;
+    double expected_delay_sec;
+    double expected_doppler_hz;
+    double expected_delay_chips1;
+    double expected_delay_sec1;
+    double expected_doppler_hz1;
+    double expected_delay_chips2;
+    double expected_delay_sec2;
+    double expected_doppler_hz2;
+    double expected_delay_chips3;
+    double expected_delay_sec3;
+    double expected_doppler_hz3;
+    float max_doppler_error_hz;
+    float max_delay_error_chips;
+    int CAF_window_hz;
+    int Zero_padding;
+
+    unsigned int num_of_realizations;
+    unsigned int realization_counter;
+    unsigned int detection_counter;
+    unsigned int correct_estimation_counter;
+    unsigned int acquired_samples;
+    unsigned int mean_acq_time_us;
+
+    double mse_doppler;
+    double mse_delay;
+
+    double Pd;
+    double Pfa_p;
+    double Pfa_a;
+
+    int sat;
+};
+
+void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::init()
+{
+    message = 0;
+    realization_counter = 0;
+    detection_counter = 0;
+    correct_estimation_counter = 0;
+    acquired_samples = 0;
+    mse_doppler = 0;
+    mse_delay = 0;
+    mean_acq_time_us = 0;
+    Pd = 0;
+    Pfa_p = 0;
+    Pfa_a = 0;
+}
+
+void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::config_1()
+{
+    gnss_synchro.Channel_ID = 0;
+    gnss_synchro.System = 'E';
+//    std::string signal = "5I";
+//    std::string signal = "5Q";
+    std::string signal = "5X";
+    signal.copy(gnss_synchro.Signal,2,0);
+
+
+    integration_time_ms = 3;
+    //fs_in = 11e6;
+    //fs_in = 18e6;
+    fs_in = 32e6;
+    //fs_in = 30.69e6;
+    //fs_in = 20.47e6;
+
+//    unsigned int delay_samples = (delay_chips_[sat] % codelen)
+//                	      * samples_per_code_[sat] / codelen;
+    expected_delay_chips = round(14000*((double)10230000/(double)fs_in));
+    expected_doppler_hz = 2800;
+    //expected_doppler_hz = 0;
+    expected_delay_sec = 94;
+//    CAF_window_hz = 3000;
+    CAF_window_hz = 0;
+    Zero_padding = 0;
+
+    //expected_delay_chips = 1000;
+    //expected_doppler_hz = 250;
+    max_doppler_error_hz = 2/(3*integration_time_ms*1e-3);
+    max_delay_error_chips = 0.50;
+
+    //max_doppler_error_hz = 1000;
+    //max_delay_error_chips = 1;
+
+    num_of_realizations = 1;
+
+    config = std::make_shared<InMemoryConfiguration>();
+
+
+    config->set_property("Channel.signal",signal);
+
+    config->set_property("GNSS-SDR.internal_fs_hz", std::to_string(fs_in));
+    int a = config->property("GNSS-SDR.internal_fs_hz",10);
+    std::cout << "fs "<< a <<std::endl;
+
+    config->set_property("SignalSource.fs_hz", std::to_string(fs_in));
+
+    config->set_property("SignalSource.item_type", "gr_complex");
+
+    config->set_property("SignalSource.num_satellites", "1");
+
+    config->set_property("SignalSource.system_0", "E");
+    config->set_property("SignalSource.signal_0", "5X");
+    config->set_property("SignalSource.PRN_0", "11");
+    config->set_property("SignalSource.CN0_dB_0", "50");
+    config->set_property("SignalSource.doppler_Hz_0", std::to_string(expected_doppler_hz));
+    config->set_property("SignalSource.delay_chips_0", std::to_string(expected_delay_chips));
+    config->set_property("SignalSource.delay_sec_0", std::to_string(expected_delay_sec));
+
+    config->set_property("SignalSource.noise_flag", "false");
+    config->set_property("SignalSource.data_flag", "false");
+    config->set_property("SignalSource.BW_BB", "0.97");
+
+    config->set_property("SignalSource.dump", "true");
+    config->set_property("SignalSource.dump_filename", "../data/signal_source.dat");
+
+    config->set_property("InputFilter.implementation", "Fir_Filter");
+    config->set_property("InputFilter.input_item_type", "gr_complex");
+    config->set_property("InputFilter.output_item_type", "gr_complex");
+    config->set_property("InputFilter.taps_item_type", "float");
+    config->set_property("InputFilter.number_of_taps", "11");
+    config->set_property("InputFilter.number_of_bands", "2");
+    config->set_property("InputFilter.band1_begin", "0.0");
+    config->set_property("InputFilter.band1_end", "0.97");
+    config->set_property("InputFilter.band2_begin", "0.98");
+    config->set_property("InputFilter.band2_end", "1.0");
+    config->set_property("InputFilter.ampl1_begin", "1.0");
+    config->set_property("InputFilter.ampl1_end", "1.0");
+    config->set_property("InputFilter.ampl2_begin", "0.0");
+    config->set_property("InputFilter.ampl2_end", "0.0");
+    config->set_property("InputFilter.band1_error", "1.0");
+    config->set_property("InputFilter.band2_error", "1.0");
+    config->set_property("InputFilter.filter_type", "bandpass");
+    config->set_property("InputFilter.grid_density", "16");
+
+    config->set_property("Acquisition.item_type", "gr_complex");
+    config->set_property("Acquisition.if", "0");
+    config->set_property("Acquisition.coherent_integration_time_ms",
+                         std::to_string(integration_time_ms));
+    config->set_property("Acquisition.max_dwells", "1");
+    config->set_property("Acquisition.CAF_window_hz",std::to_string(CAF_window_hz));
+    config->set_property("Acquisition.Zero_padding",std::to_string(Zero_padding));
+
+    config->set_property("Acquisition.implementation", "Galileo_E5a_Noncoherent_IQ_Acquisition_CAF");
+    config->set_property("Acquisition.pfa","0.003");
+//    config->set_property("Acquisition.threshold", "0.01");
+    config->set_property("Acquisition.doppler_max", "10000");
+    config->set_property("Acquisition.doppler_step", "250");
+//    config->set_property("Acquisition.doppler_step", "500");
+    config->set_property("Acquisition.bit_transition_flag", "false");
+    config->set_property("Acquisition.dump", "true");
+    config->set_property("SignalSource.dump_filename", "../data/acquisition.dat");
+}
+
+void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::config_2()
+{
+    gnss_synchro.Channel_ID = 0;
+    gnss_synchro.System = 'E';
+    std::string signal = "5Q";
+    //std::string signal = "5X";
+    signal.copy(gnss_synchro.Signal,2,0);
+
+    integration_time_ms = 3;
+    //fs_in = 10.24e6;
+    //fs_in = 12e6;
+    fs_in = 12e6;
+
+    //expected_delay_chips = 600;
+    //expected_doppler_hz = 750;
+
+    expected_delay_chips = 1000;
+    expected_doppler_hz = 250;
+    max_doppler_error_hz = 2/(3*integration_time_ms*1e-3);
+    max_delay_error_chips = 0.50;
+
+    //max_doppler_error_hz = 1000;
+    //max_delay_error_chips = 1;
+
+    num_of_realizations = 1;
+
+    config = std::make_shared<InMemoryConfiguration>();
+
+    config->set_property("GNSS-SDR.internal_fs_hz", std::to_string(fs_in));
+
+    config->set_property("Acquisition.item_type", "gr_complex");
+    config->set_property("Acquisition.if", "0");
+    config->set_property("Acquisition.coherent_integration_time_ms",
+                         std::to_string(integration_time_ms));
+    config->set_property("Acquisition.max_dwells", "1");
+    config->set_property("Acquisition.implementation", "Galileo_E5a_PCPS_Acquisition");
+    //config->set_property("Acquisition.implementation", "Galileo_E5a_Pilot_3ms_Acquisition");
+    //config->set_property("Acquisition.implementation", "Galileo_E5ax_2ms_Pcps_Acquisition");
+    config->set_property("Acquisition.threshold", "0.1");
+    config->set_property("Acquisition.doppler_max", "10000");
+    config->set_property("Acquisition.doppler_step", "250");
+    config->set_property("Acquisition.bit_transition_flag", "false");
+    config->set_property("Acquisition.dump", "true");
+    config->set_property("SignalSource.dump_filename", "../data/acquisition.dat");
+}
+
+void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::config_3()
+{
+    gnss_synchro.Channel_ID = 0;
+    gnss_synchro.System = 'E';
+    //std::string signal = "5Q";
+    std::string signal = "5X";
+    signal.copy(gnss_synchro.Signal,2,0);
+
+
+    integration_time_ms = 3;
+    //fs_in = 10.24e6;
+    //fs_in = 12e6;
+    fs_in = 12e6;
+
+    //expected_delay_chips = 600;
+    //expected_doppler_hz = 750;
+
+    expected_delay_chips = 0;
+    expected_delay_sec = 0;
+    expected_doppler_hz = 0;
+    expected_delay_chips1 = 6000;
+    expected_delay_sec1 = 10;
+    expected_doppler_hz1 = 700;
+    expected_delay_chips2 = 9000;
+    expected_delay_sec2 = 26;
+    expected_doppler_hz2 = -1500;
+    expected_delay_chips3 = 2000;
+    expected_delay_sec3 = 77;
+    expected_doppler_hz3 = 5000;
+
+
+
+    max_doppler_error_hz = 2/(3*integration_time_ms*1e-3);
+    max_delay_error_chips = 0.50;
+
+
+    //max_doppler_error_hz = 1000;
+    //max_delay_error_chips = 1;
+
+    num_of_realizations = 10;
+
+    config = std::make_shared<InMemoryConfiguration>();
+
+    config->set_property("GNSS-SDR.internal_fs_hz", std::to_string(fs_in));
+
+    config->set_property("SignalSource.fs_hz", std::to_string(fs_in));
+
+    config->set_property("SignalSource.item_type", "gr_complex");
+
+    config->set_property("SignalSource.num_satellites", "4");
+
+    config->set_property("SignalSource.system_0", "E");
+    config->set_property("SignalSource.signal_0", "5X");
+    config->set_property("SignalSource.PRN_0", "11");
+    config->set_property("SignalSource.CN0_dB_0", "46");
+    config->set_property("SignalSource.doppler_Hz_0", std::to_string(expected_doppler_hz));
+    config->set_property("SignalSource.delay_chips_0", std::to_string(expected_delay_chips));
+    config->set_property("SignalSource.delay_sec_0", std::to_string(expected_delay_sec));
+
+    config->set_property("SignalSource.system_1", "E");
+    config->set_property("SignalSource.signal_1", "5X");
+    config->set_property("SignalSource.PRN_1", "12");
+    config->set_property("SignalSource.CN0_dB_1", "46");
+    config->set_property("SignalSource.doppler_Hz_1", std::to_string(expected_doppler_hz1));
+    config->set_property("SignalSource.delay_chips_1", std::to_string(expected_delay_chips1));
+    config->set_property("SignalSource.delay_sec_1", std::to_string(expected_delay_sec1));
+
+    config->set_property("SignalSource.system_2", "E");
+    config->set_property("SignalSource.signal_2", "5X");
+    config->set_property("SignalSource.PRN_2", "19");
+    config->set_property("SignalSource.CN0_dB_2", "43");
+    config->set_property("SignalSource.doppler_Hz_2", std::to_string(expected_doppler_hz2));
+    config->set_property("SignalSource.delay_chips_2", std::to_string(expected_delay_chips2));
+    config->set_property("SignalSource.delay_sec_2", std::to_string(expected_delay_sec2));
+
+    config->set_property("SignalSource.system_3", "E");
+    config->set_property("SignalSource.signal_3", "5X");
+    config->set_property("SignalSource.PRN_3", "20");
+    config->set_property("SignalSource.CN0_dB_3", "39");
+    config->set_property("SignalSource.doppler_Hz_3", std::to_string(expected_doppler_hz3));
+    config->set_property("SignalSource.delay_chips_3", std::to_string(expected_delay_chips3));
+    config->set_property("SignalSource.delay_sec_3", std::to_string(expected_delay_sec3));
+
+    config->set_property("SignalSource.noise_flag", "true");
+    config->set_property("SignalSource.data_flag", "true");
+    config->set_property("SignalSource.BW_BB", "0.97");
+
+    config->set_property("SignalSource.dump", "true");
+    config->set_property("SignalSource.dump_filename", "../data/signal_source.dat");
+
+    config->set_property("InputFilter.implementation", "Fir_Filter");
+    config->set_property("InputFilter.input_item_type", "gr_complex");
+    config->set_property("InputFilter.output_item_type", "gr_complex");
+    config->set_property("InputFilter.taps_item_type", "float");
+    config->set_property("InputFilter.number_of_taps", "11");
+    config->set_property("InputFilter.number_of_bands", "2");
+    config->set_property("InputFilter.band1_begin", "0.0");
+    config->set_property("InputFilter.band1_end", "0.97");
+    config->set_property("InputFilter.band2_begin", "0.98");
+    config->set_property("InputFilter.band2_end", "1.0");
+    config->set_property("InputFilter.ampl1_begin", "1.0");
+    config->set_property("InputFilter.ampl1_end", "1.0");
+    config->set_property("InputFilter.ampl2_begin", "0.0");
+    config->set_property("InputFilter.ampl2_end", "0.0");
+    config->set_property("InputFilter.band1_error", "1.0");
+    config->set_property("InputFilter.band2_error", "1.0");
+    config->set_property("InputFilter.filter_type", "bandpass");
+    config->set_property("InputFilter.grid_density", "16");
+
+    config->set_property("Acquisition.item_type", "gr_complex");
+    config->set_property("Acquisition.if", "0");
+    config->set_property("Acquisition.coherent_integration_time_ms",
+                         std::to_string(integration_time_ms));
+    config->set_property("Acquisition.max_dwells", "1");
+    config->set_property("Acquisition.implementation", "Galileo_E5a_PCPS_Acquisition");
+    //config->set_property("Acquisition.implementation", "Galileo_E1_PCPS_Ambiguous_Acquisition");
+    //config->set_property("Acquisition.implementation", "Galileo_E5a_Pilot_3ms_Acquisition");
+
+    config->set_property("Acquisition.threshold", "0.5");
+    config->set_property("Acquisition.doppler_max", "10000");
+    config->set_property("Acquisition.doppler_step", "250");
+    config->set_property("Acquisition.bit_transition_flag", "false");
+    config->set_property("Acquisition.dump", "true");
+    config->set_property("SignalSource.dump_filename", "../data/acquisition.dat");
+}
+
+void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::start_queue()
+{
+    stop = false;
+    ch_thread = boost::thread(&GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::wait_message, this);
+}
+
+void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::wait_message()
+{
+    struct timeval tv;
+    long long int begin = 0;
+    long long int end = 0;
+
+    while (!stop)
+        {
+            acquisition->reset();
+
+            gettimeofday(&tv, NULL);
+            begin = tv.tv_sec *1e6 + tv.tv_usec;
+
+            channel_internal_queue.wait_and_pop(message);
+
+            gettimeofday(&tv, NULL);
+            end = tv.tv_sec *1e6 + tv.tv_usec;
+
+            mean_acq_time_us += (end-begin);
+
+            process_message();
+        }
+}
+
+void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::process_message()
+{
+    if (message == 1)
+        {
+	    double delay_error_chips;
+	    double doppler_error_hz;
+	    switch (sat)
+	    {
+		case 0:
+		    delay_error_chips = abs((double)expected_delay_chips - (double)(gnss_synchro.Acq_delay_samples-5)*10230.0/((double)fs_in*1e-3));
+		    doppler_error_hz = abs(expected_doppler_hz - gnss_synchro.Acq_doppler_hz);
+		    break;
+		case 1:
+		    delay_error_chips = abs((double)expected_delay_chips1 - (double)(gnss_synchro.Acq_delay_samples-5)*10230.0/((double)fs_in*1e-3));
+		    doppler_error_hz = abs(expected_doppler_hz1 - gnss_synchro.Acq_doppler_hz);
+		    break;
+		case 2:
+		    delay_error_chips = abs((double)expected_delay_chips2 - (double)(gnss_synchro.Acq_delay_samples-5)*10230.0/((double)fs_in*1e-3));
+		    doppler_error_hz = abs(expected_doppler_hz2 - gnss_synchro.Acq_doppler_hz);
+		    break;
+		case 3:
+		    delay_error_chips = abs((double)expected_delay_chips3 - (double)(gnss_synchro.Acq_delay_samples-5)*10230.0/((double)fs_in*1e-3));
+		    doppler_error_hz = abs(expected_doppler_hz3 - gnss_synchro.Acq_doppler_hz);
+		    break;
+		default: // case 3
+		    std::cout << "Error: message from unexpected acquisition channel" << std::endl;
+		    break;
+	    }
+            detection_counter++;
+
+            // The term -5 is here to correct the additional delay introduced by the FIR filter
+            /*
+            double delay_error_chips = abs((double)expected_delay_chips - (double)(gnss_synchro.Acq_delay_samples-5)*10230.0/((double)fs_in*1e-3));
+            double doppler_error_hz = abs(expected_doppler_hz - gnss_synchro.Acq_doppler_hz);
+            */
+            mse_delay += std::pow(delay_error_chips, 2);
+            mse_doppler += std::pow(doppler_error_hz, 2);
+
+            if ((delay_error_chips < max_delay_error_chips) && (doppler_error_hz < max_doppler_error_hz))
+                {
+                    correct_estimation_counter++;
+                }
+        }
+
+    realization_counter++;
+
+    std::cout << correct_estimation_counter << "correct estimation counter" << std::endl;
+    std::cout << "Progress: " << round((float)realization_counter/num_of_realizations*100) << "% \r" << std::flush;
+    std::cout << message << "message" <<std::endl;
+    if (realization_counter == num_of_realizations)
+        {
+            mse_delay /= num_of_realizations;
+            mse_doppler /= num_of_realizations;
+
+            Pd = (double)correct_estimation_counter / (double)num_of_realizations;
+            Pfa_a = (double)detection_counter / (double)num_of_realizations;
+            Pfa_p = (double)(detection_counter - correct_estimation_counter) / (double)num_of_realizations;
+
+            mean_acq_time_us /= num_of_realizations;
+
+            stop_queue();
+            top_block->stop();
+        }
+}
+
+void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::stop_queue()
+{
+    stop = true;
+}
+/*
+TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, Instantiate)
+{
+    config_1();
+//    acquisition = new GalileoE5aPilot_3msAcquisition(config.get(), "Acquisition", 1, 1, queue);
+    acquisition = new GalileoE5a3msNoncoherentIQAcquisition(config.get(), "Acquisition", 1, 1, queue);
+
+    delete acquisition;
+
+}
+*/
+/*
+TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, ConnectAndRun)
+{
+    config_1();
+    //int nsamples = floor(5*fs_in*integration_time_ms*1e-3);
+    int nsamples = 21000*3;
+    struct timeval tv;
+    long long int begin = 0;
+    long long int end = 0;
+    //acquisition = new GalileoE5aPcpsAcquisition(config.get(), "Acquisition", 1, 1, queue);
+    //acquisition = new GalileoE5aPilot_3msAcquisition(config.get(), "Acquisition", 1, 1, queue);
+    acquisition = new GalileoE5a3msNoncoherentIQAcquisition(config.get(), "Acquisition", 1, 1, queue);
+
+
+    ASSERT_NO_THROW( {
+        acquisition->connect(top_block);
+        boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0));
+        boost::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
+        top_block->connect(source, 0, valve, 0);
+        top_block->connect(valve, 0, acquisition->get_left_block(), 0);
+    }) << "Failure connecting the blocks of acquisition test."<< std::endl;
+
+    EXPECT_NO_THROW( {
+        gettimeofday(&tv, NULL);
+        begin = tv.tv_sec *1e6 + tv.tv_usec;
+        top_block->run(); // Start threads and wait
+        gettimeofday(&tv, NULL);
+        end = tv.tv_sec *1e6 + tv.tv_usec;
+    }) << "Failure running the top_block."<< std::endl;
+
+    std::cout <<  "Processed " << nsamples << " samples in " << (end - begin) << " microseconds" << std::endl;
+
+    delete acquisition;
+}
+*/
+/*
+TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, SOURCEValidation)
+{
+    config_1();
+    ASSERT_NO_THROW( {
+        boost::shared_ptr<GenSignalSource> signal_source;
+        SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
+        FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1, queue);
+        signal_source.reset(new GenSignalSource(config.get(), signal_generator, filter, "SignalSource", queue));
+        signal_source->connect(top_block);
+
+
+        //top_block->connect(signal_source->get_right_block(), 0, acquisition->get_left_block(), 0);
+
+    }) << "Failure generating signal" << std::endl;
+}
+*/
+/*
+TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, SOURCEValidationTOFILE)
+{
+    config_1();
+    ASSERT_NO_THROW( {
+	std::string filename_ = "../data/Tiered_sinknull.dat";
+	boost::shared_ptr<gr::blocks::file_sink> file_sink_;
+
+        boost::shared_ptr<GenSignalSource> signal_source;
+        SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
+        FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1, queue);
+        signal_source.reset(new GenSignalSource(config.get(), signal_generator, filter, "SignalSource", queue));
+        //signal_source->connect(top_block);
+        file_sink_=gr::blocks::file_sink::make(sizeof(gr_complex), filename_.c_str());
+
+        top_block->connect(signal_source->get_right_block(),0,file_sink_,0);
+
+        //top_block->connect(signal_source->get_right_block(), 0, acquisition->get_left_block(), 0);
+
+    }) << "Failure generating signal" << std::endl;
+}
+*/
+
+TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, ValidationOfSIM)
+{
+    config_1();
+
+    //int nsamples = floor(fs_in*integration_time_ms*1e-3);
+    acquisition = new GalileoE5aNoncoherentIQAcquisitionCaf(config.get(), "Acquisition", 1, 1, queue);
+    unsigned int skiphead_sps = 28000+32000; // 32 Msps
+//    unsigned int skiphead_sps = 0;
+//    unsigned int skiphead_sps = 84000;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_channel(1);
+    }) << "Failure setting channel."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_gnss_synchro(&gnss_synchro);
+    }) << "Failure setting gnss_synchro."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_channel_queue(&channel_internal_queue);
+    }) << "Failure setting channel_internal_queue."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_doppler_max(config->property("Acquisition.doppler_max", 10000));
+    }) << "Failure setting doppler_max."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_doppler_step(config->property("Acquisition.doppler_step", 500));
+    }) << "Failure setting doppler_step."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_threshold(config->property("Acquisition.threshold", 0.0));
+    }) << "Failure setting threshold."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->connect(top_block);
+    }) << "Failure connecting acquisition to the top_block."<< std::endl;
+
+    acquisition->init();
+    // USING SIGNAL GENERATOR
+/*
+    ASSERT_NO_THROW( {
+	//std::string filename_ = "../data/Tiered_sink.dat";
+	//boost::shared_ptr<gr::blocks::file_sink> file_sink_;
+
+        boost::shared_ptr<GenSignalSource> signal_source;
+        SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
+
+        FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1, queue);
+        signal_source.reset(new GenSignalSource(config.get(), signal_generator, filter, "SignalSource", queue));
+        signal_source->connect(top_block);
+        //
+        //signal_generator->connect(top_block);
+        //
+        //file_sink_=gr::blocks::file_sink::make(sizeof(gr_complex), filename_.c_str());
+
+        top_block->connect(signal_source->get_right_block(), 0, acquisition->get_left_block(), 0);
+        //top_block->connect(signal_source->get_right_block(), 0, file_sink_, 0);
+        //
+        //top_block->connect(signal_generator->get_right_block(), 0, acquisition->get_left_block(), 0);
+        //top_block->connect(signal_generator->get_right_block(), 0, file_sink_, 0);
+        //
+
+    }) << "Failure connecting the blocks of acquisition test." << std::endl;
+*/
+// USING SIGNAL FROM FILE SOURCE
+
+    ASSERT_NO_THROW( {
+	//noiseless sim
+	//std::string file =  "/home/marc/E5a_acquisitions/sim_32M_sec94_PRN11_long.dat";
+	// real
+	std::string file =  "/home/marc/E5a_acquisitions/32MS_complex.dat";
+
+	const char * file_name = file.c_str();
+	gr::blocks::file_source::sptr file_source = gr::blocks::file_source::make(sizeof(gr_complex), file_name, false);
+
+	gr::blocks::skiphead::sptr skip_head = gr::blocks::skiphead::make(sizeof(gr_complex), skiphead_sps);
+	top_block->connect(file_source, 0, skip_head, 0);
+	top_block->connect(skip_head, 0, acquisition->get_left_block(), 0);
+
+//	top_block->connect(file_source, 0, acquisition->get_left_block(), 0);
+    }) << "Failure connecting the blocks of acquisition test." << std::endl;
+
+    // i = 0 --> satellite in acquisition is visible
+    // i = 1 --> satellite in acquisition is not visible
+    for (unsigned int i = 0; i < 1; i++)
+        {
+            init();
+
+            switch (i)
+            {
+        	case 0:
+        	    {
+        		gnss_synchro.PRN = 19; //real
+        		//gnss_synchro.PRN = 11; //sim
+        		break;
+        	    }
+//        	case 1:
+//        	    {
+//        		gnss_synchro.PRN = 11;
+//        		break;
+//        	    }
+//        	case 2:
+//        	    {
+//        		gnss_synchro.PRN = 12;
+//        		break;
+//        	    }
+//        	case 3:
+//        	    {
+//        		gnss_synchro.PRN = 20;
+//        		break;
+//        	    }
+            }
+//            if (i == 0)
+//                {
+//                    gnss_synchro.PRN = 11;// This satellite is visible
+//                }
+//            else if (i == 1)
+//                {
+//                    gnss_synchro.PRN = 19; // This satellite is not visible
+//                }
+            acquisition->set_local_code();
+
+            start_queue();
+
+            EXPECT_NO_THROW( {
+                top_block->run(); // Start threads and wait
+            }) << "Failure running he top_block."<< std::endl;
+
+            std::cout << gnss_synchro.Acq_delay_samples << "acq delay" <<std::endl;
+            std::cout << gnss_synchro.Acq_doppler_hz << "acq doppler" <<std::endl;
+            std::cout << gnss_synchro.Acq_samplestamp_samples << "acq samples" <<std::endl;
+//            if (i == 0)
+//            {
+//                EXPECT_EQ(1, message) << "Acquisition failure. Expected message: 1=ACQ SUCCESS.";
+//                if (message == 1)
+//                    {
+//                	std::cout << gnss_synchro.Acq_delay_samples << "acq delay" <<std::endl;
+//                        EXPECT_EQ((unsigned int) 1, correct_estimation_counter) << "Acquisition failure. Incorrect parameters estimation.";
+//                    }
+//
+//            }
+//            else if (i == 1)
+//            {
+//                EXPECT_EQ(2, message) << "Acquisition failure. Expected message: 2=ACQ FAIL.";
+//            }
+        }
+
+//    free(acquisition);
+    delete acquisition;
+}
+
+/*
+TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, ValidationOfResults)
+{
+    config_1();
+
+    int nsamples = floor(fs_in*integration_time_ms*1e-3);
+    //acquisition = new GalileoE5aPcpsAcquisition(config.get(), "Acquisition", 1, 1, queue);
+    acquisition = new GalileoE5aPilot_3msAcquisition(config.get(), "Acquisition", 1, 1, queue);
+    //acquisition = new GalileoE5ax2msPcpsAcquisition(config.get(), "Acquisition", 1, 1, queue);
+    //unsigned int skiphead_sps = 12000000*4; // 12 Msps
+    unsigned int skiphead_sps = 37500000; // 12 Msps
+    //unsigned int skiphead_sps = 10; // 12 Msps
+
+    ASSERT_NO_THROW( {
+        acquisition->set_channel(0);
+    }) << "Failure setting channel."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_gnss_synchro(&gnss_synchro);
+    }) << "Failure setting gnss_synchro."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_channel_queue(&channel_internal_queue);
+    }) << "Failure setting channel_internal_queue."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_doppler_max(config->property("Acquisition.doppler_max", 10000));
+    }) << "Failure setting doppler_max."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_doppler_step(config->property("Acquisition.doppler_step", 500));
+    }) << "Failure setting doppler_step."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_threshold(config->property("Acquisition.threshold", 0.0));
+    }) << "Failure setting threshold."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->connect(top_block);
+    }) << "Failure connecting acquisition to the top_block."<< std::endl;
+
+    acquisition->init();
+
+    ASSERT_NO_THROW( {
+	//std::string path = std::string(TEST_PATH);
+	//std::string file =  "/home/marc/E5a_acquisitions/signal_source_5X_primary.dat";
+	//std::string file =  "/home/marc/E5a_acquisitions/Tiered_sink_4sat_stup4.dat";
+	//std::string file =  "/home/marc/E5a_acquisitions/Tiered_4sat_down_upsampled12M_stup2.dat";
+	//std::string file =  "/home/marc/E5a_acquisitions/Tiered_stup4_down-upsampl12.dat";
+	//std::string file =  "/home/marc/E5a_acquisitions/Tiered_sim_4sat_stup4_2s_up.dat";
+//	std::string file =  "/home/marc/E5a_acquisitions/Tiered_sink_4sat_setup5_down-upsampled12M.dat";
+	std::string file =  "/home/marc/E5a_acquisitions/32Ms_complex.dat";
+	//std::string file =  "/home/marc/E5a_acquisitions/galileo_E5_8M_r2_upsampled_12.dat";
+
+	const char * file_name = file.c_str();
+	gr::blocks::file_source::sptr file_source = gr::blocks::file_source::make(sizeof(gr_complex), file_name, false);
+	gr::blocks::skiphead::sptr skip_head = gr::blocks::skiphead::make(sizeof(gr_complex), skiphead_sps);
+
+	top_block->connect(file_source, 0, skip_head, 0);
+	top_block->connect(skip_head, 0, acquisition->get_left_block(), 0);
+    }) << "Failure connecting the blocks of acquisition test." << std::endl;
+
+    for (unsigned int i = 0; i < 5; i++)
+        {
+            init();
+
+            switch (i)
+            {
+            case 0:
+        	gnss_synchro.PRN = 10;
+        	break;
+            case 1:
+        	gnss_synchro.PRN = 19;
+        	break;
+            case 2:
+        	gnss_synchro.PRN = 12;
+        	break;
+            case 3:
+        	gnss_synchro.PRN = 20;
+        	break;
+            case 4:
+        	gnss_synchro.PRN = 11;
+        	break;
+            }
+
+            acquisition->set_local_code();
+
+            start_queue();
+
+            EXPECT_NO_THROW( {
+                top_block->run(); // Start threads and wait
+            }) << "Failure running he top_block."<< std::endl;
+
+        }
+
+    delete acquisition;
+}
+*/
+/*
+TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, FourSatsGen)
+{
+    config_3();
+
+    int nsamples = floor(fs_in*integration_time_ms*1e-3);
+//    acquisition = new GalileoE5aPcpsAcquisition(config.get(), "Acquisition", 1, 1, queue);
+    acquisition = new GalileoE5aPilot_3msAcquisition(config.get(), "Acquisition", 1, 1, queue);
+    ASSERT_NO_THROW( {
+        acquisition->set_channel(0);
+    }) << "Failure setting channel."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_gnss_synchro(&gnss_synchro);
+    }) << "Failure setting gnss_synchro."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_channel_queue(&channel_internal_queue);
+    }) << "Failure setting channel_internal_queue."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_doppler_max(config->property("Acquisition.doppler_max", 10000));
+    }) << "Failure setting doppler_max."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_doppler_step(config->property("Acquisition.doppler_step", 500));
+    }) << "Failure setting doppler_step."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->set_threshold(config->property("Acquisition.threshold", 0.0));
+    }) << "Failure setting threshold."<< std::endl;
+
+    ASSERT_NO_THROW( {
+        acquisition->connect(top_block);
+    }) << "Failure connecting acquisition to the top_block."<< std::endl;
+
+    acquisition->init();
+
+    ASSERT_NO_THROW( {
+	std::string filename_ = "../data/Tiered_sink_4sat.dat";
+	boost::shared_ptr<gr::blocks::file_sink> file_sink_;
+
+        boost::shared_ptr<GenSignalSource> signal_source;
+        SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
+
+        FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1, queue);
+        signal_source.reset(new GenSignalSource(config.get(), signal_generator, filter, "SignalSource", queue));
+        signal_source->connect(top_block);
+        //
+        file_sink_=gr::blocks::file_sink::make(sizeof(gr_complex), filename_.c_str());
+
+        top_block->connect(signal_source->get_right_block(), 0, acquisition->get_left_block(), 0);
+        top_block->connect(signal_source->get_right_block(), 0, file_sink_, 0);
+
+    }) << "Failure connecting the blocks of acquisition test." << std::endl;
+
+//    ASSERT_NO_THROW( {
+//	//std::string path = std::string(TEST_PATH);
+//	//std::string file =  "/home/marc/E5a_acquisitions/signal_source_5X_primary.dat";
+//	std::string file =  "/home/marc/E5a_acquisitions/Tiered_sink_test.dat";
+//	//std::string file =  "/home/marc/E5a_acquisitions/galileo_E5_8M_r2_upsampled_12.dat";
+//	const char * file_name = file.c_str();
+//	gr::blocks::file_source::sptr file_source = gr::blocks::file_source::make(sizeof(gr_complex), file_name, false);
+//	top_block->connect(file_source, 0, acquisition->get_left_block(), 0);
+//    }) << "Failure connecting the blocks of acquisition test." << std::endl;
+
+    // all satellite visibles but with different CN0
+    for (unsigned int i = 0; i < 4; i++)
+        {
+            init();
+            sat=i;
+
+            switch (i)
+            {
+            case 0:
+        	gnss_synchro.PRN = 11;
+        	break;
+            case 1:
+        	gnss_synchro.PRN = 12;
+        	break;
+            case 2:
+        	gnss_synchro.PRN = 19;
+        	break;
+            case 3:
+        	gnss_synchro.PRN = 20;
+        	break;
+            }
+
+            acquisition->set_local_code();
+
+            start_queue();
+
+            EXPECT_NO_THROW( {
+                top_block->run(); // Start threads and wait
+            }) << "Failure running he top_block."<< std::endl;
+
+            switch (i)
+            {
+            case 0:
+        	//EXPECT_EQ(1, message) << "Acquisition failure. Expected message: 1=ACQ SUCCESS.";
+                if (message == 1)
+                    {
+                	std::cout << gnss_synchro.Acq_delay_samples << "acq delay" <<std::endl;
+                	EXPECT_EQ((unsigned int) 1, correct_estimation_counter) << "Acquisition failure. Incorrect parameters estimation.";
+                    }
+        	break;
+            case 1:
+        	//EXPECT_EQ(1, message) << "Acquisition failure. Expected message: 1=ACQ SUCCESS.";
+                if (message == 1)
+                    {
+                	std::cout << gnss_synchro.Acq_delay_samples << "acq delay" <<std::endl;
+                	EXPECT_EQ((unsigned int) 1, correct_estimation_counter) << "Acquisition failure. Incorrect parameters estimation.";
+                    }
+        	break;
+            case 2:
+        	//EXPECT_EQ(1, message) << "Acquisition failure. Expected message: 1=ACQ SUCCESS.";
+                if (message == 1)
+                    {
+                	std::cout << gnss_synchro.Acq_delay_samples << "acq delay" <<std::endl;
+                	EXPECT_EQ((unsigned int) 1, correct_estimation_counter) << "Acquisition failure. Incorrect parameters estimation.";
+                    }
+        	break;
+            case 3:
+                if (message == 1)
+                    {
+                	std::cout << gnss_synchro.Acq_delay_samples << "acq delay" <<std::endl;
+                	EXPECT_EQ((unsigned int) 1, correct_estimation_counter) << "Acquisition failure. Incorrect parameters estimation.";
+                    }
+        	break;
+            }
+        }
+    delete acquisition;
+}
+*/
+

src/tests/gnss_block/galileo_e5a_tracking_test.cc

@@ -0,0 +1,253 @@
+/*!
+ * \file galileo_e1_dll_pll_veml_tracking_test.cc
+ * \brief  This class implements a tracking test for Galileo_E5a_DLL_PLL_Tracking
+ *  implementation based on some input parameters.
+ * \author Marc Sales, 2014. marcsales92(at)gmail.com
+ *
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2012-2014  (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 <ctime>
+#include <iostream>
+#include <gnuradio/top_block.h>
+#include <gnuradio/blocks/file_source.h>
+#include <gnuradio/analog/sig_source_waveform.h>
+#include <gnuradio/analog/sig_source_c.h>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/blocks/null_sink.h>
+#include <gnuradio/blocks/skiphead.h>
+#include "gnss_block_factory.h"
+#include "gnss_block_interface.h"
+#include "in_memory_configuration.h"
+#include "gnss_sdr_valve.h"
+#include "gnss_synchro.h"
+//#include "galileo_e1_dll_pll_veml_tracking.h"
+#include "galileo_e5a_dll_pll_tracking.h"
+
+
+class GalileoE5aTrackingTest: public ::testing::Test
+{
+protected:
+    GalileoE5aTrackingTest()
+    {
+        queue = gr::msg_queue::make(0);
+        top_block = gr::make_top_block("Tracking test");
+        std::shared_ptr<GNSSBlockFactory> factory = std::make_shared<GNSSBlockFactory>();
+        config = std::make_shared<InMemoryConfiguration>();
+        item_size = sizeof(gr_complex);
+        stop = false;
+        message = 0;
+    }
+
+    ~GalileoE5aTrackingTest()
+    {}
+
+    void init();
+
+    gr::msg_queue::sptr queue;
+    gr::top_block_sptr top_block;
+    std::shared_ptr<GNSSBlockFactory> factory;
+    std::shared_ptr<InMemoryConfiguration> config;
+    Gnss_Synchro gnss_synchro;
+    size_t item_size;
+    concurrent_queue<int> channel_internal_queue;
+    bool stop;
+    int message;
+};
+
+
+void GalileoE5aTrackingTest::init()
+{
+    gnss_synchro.Channel_ID = 0;
+    gnss_synchro.System = 'E';
+    std::string signal = "5Q";
+    signal.copy(gnss_synchro.Signal, 2, 0);
+
+
+    config->set_property("GNSS-SDR.internal_fs_hz", "32000000");
+    config->set_property("Tracking.item_type", "gr_complex");
+    config->set_property("Tracking.dump", "true");
+    config->set_property("Tracking.dump_filename", "../data/e5a_tracking_ch_");
+    config->set_property("Tracking.implementation", "Galileo_E5a_DLL_PLL_Tracking");
+    config->set_property("Tracking.early_late_space_chips", "0.5");
+
+    config->set_property("Tracking.pll_bw_hz_init","20.0");
+//    config->set_property("Tracking.pll_bw_hz_init","5.0");
+    config->set_property("Tracking.dll_bw_hz_init","2.0");
+
+    config->set_property("Tracking.pll_bw_hz", "5");
+    config->set_property("Tracking.dll_bw_hz", "2");
+    config->set_property("Tracking.ti_ms","1");
+
+//    config->set_property("Tracking.pll_bw_hz", "5");
+//    config->set_property("Tracking.dll_bw_hz", "2");
+//    config->set_property("Tracking.ti_ms","1");
+    //config->set_property("Tracking.fll_bw_hz", "10.0");
+}
+/*
+TEST_F(GalileoE5aTrackingTest, InstantiateTrack)
+{
+
+    init();
+    auto tracking = factory->GetBlock(config, "Tracking", "Galileo_E5a_DLL_PLL_Tracking", 1, 1, queue);
+    EXPECT_STREQ("Galileo_E5a_DLL_PLL_Tracking", tracking->implementation().c_str());
+//    auto tracking = factory->GetBlock(config, "Tracking", "Galileo_E1_DLL_PLL_VEML_Tracking", 1, 1, queue);
+//    EXPECT_STREQ("Galileo_E1_DLL_PLL_VEML_Tracking", tracking->implementation().c_str());
+
+}*/
+/*
+TEST_F(GalileoE5aTrackingTest, ConnectAndRun)
+{
+    int fs_in = 21000000;
+    int nsamples = 21000000;
+    struct timeval tv;
+    long long int begin;
+    long long int end;
+    init();
+
+    // Example using smart pointers and the block factory
+    std::shared_ptr<GNSSBlockInterface> trk_ = factory->GetBlock(config, "Tracking", "Galileo_E5a_DLL_PLL_Tracking", 1, 1, queue);
+    std::shared_ptr<GalileoE5aDllPllTracking> tracking = std::dynamic_pointer_cast<GalileoE5aDllPllTracking>(trk_);
+
+    ASSERT_NO_THROW( {
+        tracking->set_channel(gnss_synchro.Channel_ID);
+    }) << "Failure setting channel." << std::endl;
+
+    ASSERT_NO_THROW( {
+        tracking->set_gnss_synchro(&gnss_synchro);
+    }) << "Failure setting gnss_synchro." << std::endl;
+
+    ASSERT_NO_THROW( {
+        tracking->set_channel_queue(&channel_internal_queue);
+    }) << "Failure setting channel_internal_queue." << std::endl;
+
+
+    ASSERT_NO_THROW( {
+        tracking->connect(top_block);
+        gr::analog::sig_source_c::sptr source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0));
+        boost::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
+        gr::blocks::null_sink::sptr sink = gr::blocks::null_sink::make(sizeof(Gnss_Synchro));
+        top_block->connect(source, 0, valve, 0);
+        top_block->connect(valve, 0, tracking->get_left_block(), 0);
+        top_block->connect(tracking->get_right_block(), 0, sink, 0);
+
+    }) << "Failure connecting the blocks of tracking test." << std::endl;
+
+    tracking->start_tracking();
+
+    EXPECT_NO_THROW( {
+        gettimeofday(&tv, NULL);
+        begin = tv.tv_sec *1000000 + tv.tv_usec;
+        top_block->run();   //Start threads and wait
+        gettimeofday(&tv, NULL);
+        end = tv.tv_sec *1000000 + tv.tv_usec;
+    }) << "Failure running the top_block." << std::endl;
+
+    std::cout <<  "Processed " << nsamples << " samples in " << (end - begin) << " microseconds" << std::endl;
+}
+*/
+TEST_F(GalileoE5aTrackingTest, ValidationOfResults)
+{
+    struct timeval tv;
+    long long int begin = 0;
+    long long int end = 0;
+    int num_samples = 320000000*1.5; // 32 Msps
+    //unsigned int skiphead_sps = 98000; // 1 Msample
+    unsigned int skiphead_sps = 0; // 1 Msampl
+//    unsigned int skiphead_sps = 104191; // 1 Msampl
+    init();
+
+    // Example using smart pointers and the block factory
+    std::shared_ptr<GNSSBlockInterface> trk_ = factory->GetBlock(config, "Tracking", "Galileo_E5a_DLL_PLL_Tracking", 1, 1, queue);
+    std::shared_ptr<TrackingInterface> tracking = std::dynamic_pointer_cast<TrackingInterface>(trk_);
+
+//REAL
+    gnss_synchro.Acq_delay_samples = 15579+1; // 32 Msps
+//    gnss_synchro.Acq_doppler_hz = 3500; // 32 Msps
+    gnss_synchro.Acq_doppler_hz = 3750; // 500 Hz resolution
+//    gnss_synchro.Acq_samplestamp_samples = 98000;
+    gnss_synchro.Acq_samplestamp_samples = 0;
+//SIM
+//    gnss_synchro.Acq_delay_samples = 14001+1; // 32 Msps
+//    //gnss_synchro.Acq_doppler_hz = 2750; // 32 Msps (real 2800)
+////    gnss_synchro.Acq_doppler_hz = 2800; // 32 Msps (real 2800)
+//    gnss_synchro.Acq_doppler_hz = 0; // 32 Msps (real 2800)
+////    gnss_synchro.Acq_samplestamp_samples = 98000;
+//    gnss_synchro.Acq_samplestamp_samples = 0;
+
+//SIM2
+//    gnss_synchro.Acq_delay_samples = 5810; // 32 Msps
+//    gnss_synchro.Acq_doppler_hz = 2800;
+//    gnss_synchro.Acq_samplestamp_samples = 0;
+
+    ASSERT_NO_THROW( {
+        tracking->set_channel(gnss_synchro.Channel_ID);
+    }) << "Failure setting channel." << std::endl;
+
+    ASSERT_NO_THROW( {
+        tracking->set_gnss_synchro(&gnss_synchro);
+    }) << "Failure setting gnss_synchro." << std::endl;
+
+    ASSERT_NO_THROW( {
+        tracking->set_channel_queue(&channel_internal_queue);
+    }) << "Failure setting channel_internal_queue." << std::endl;
+
+    ASSERT_NO_THROW( {
+        tracking->connect(top_block);
+    }) << "Failure connecting tracking to the top_block." << std::endl;
+
+    ASSERT_NO_THROW( {
+        std::string file =  "/home/marc/E5a_acquisitions/32MS_complex.dat";
+        //std::string file =  "/home/marc/E5a_acquisitions/sim_32M_sec94_PRN11_long.dat";
+        //std::string file =  "/home/marc/E5a_acquisitions/sim_32M_sec94_PRN11_long_0dopp.dat";
+        gnss_synchro.PRN = 19;//real
+        //gnss_synchro.PRN = 11;//sim
+
+        const char * file_name = file.c_str();
+        gr::blocks::file_source::sptr file_source = gr::blocks::file_source::make(sizeof(gr_complex),file_name,false);
+        gr::blocks::skiphead::sptr skip_head = gr::blocks::skiphead::make(sizeof(gr_complex), skiphead_sps);
+        boost::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), num_samples, queue);
+        gr::blocks::null_sink::sptr sink = gr::blocks::null_sink::make(sizeof(Gnss_Synchro));
+        top_block->connect(file_source, 0, skip_head, 0);
+        top_block->connect(skip_head, 0, valve, 0);
+        top_block->connect(valve, 0, tracking->get_left_block(), 0);
+        top_block->connect(tracking->get_right_block(), 0, sink, 0);
+    }) << "Failure connecting the blocks of tracking test." << std::endl;
+
+    tracking->start_tracking();
+
+    EXPECT_NO_THROW( {
+        gettimeofday(&tv, NULL);
+        begin = tv.tv_sec *1000000 + tv.tv_usec;
+        top_block->run(); // Start threads and wait
+        gettimeofday(&tv, NULL);
+        end = tv.tv_sec *1000000 + tv.tv_usec;
+    }) << "Failure running the top_block." << std::endl;
+
+    std::cout <<  "Tracked " << num_samples << " samples in " << (end - begin) << " microseconds" << std::endl;
+}
+

src/tests/test_main.cc

@@ -1,33 +1,33 @@
 /*!
- * \file test_main.cc
- * \brief  This file implements all system tests.
- * \author Carles Fernandez-Prades, 2012. cfernandez(at)cttc.es
- *
- *
- * -------------------------------------------------------------------------
- *
- * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
- *
- * GNSS-SDR is a software defined Global Navigation
- *          Satellite Systems receiver
- *
- * This file is part of GNSS-SDR.
- *
- * GNSS-SDR is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * at your option) any later version.
- *
- * GNSS-SDR is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
- *
- * -------------------------------------------------------------------------
- */
+* \file test_main.cc
+* \brief This file implements all system tests.
+* \author Carles Fernandez-Prades, 2012. cfernandez(at)cttc.es
+*
+*
+* -------------------------------------------------------------------------
+*
+* Copyright (C) 2010-2012 (see AUTHORS file for a list of contributors)
+*
+* GNSS-SDR is a software defined Global Navigation
+* Satellite Systems receiver
+*
+* This file is part of GNSS-SDR.
+*
+* GNSS-SDR is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* at your option) any later version.
+*
+* GNSS-SDR is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+*
+* -------------------------------------------------------------------------
+*/
 
 
 
@@ -88,7 +88,7 @@ DECLARE_string(log_dir);
 #include "gnss_block/gps_l1_ca_pcps_acquisition_gsoc2013_test.cc"
 //#include "gnss_block/gps_l1_ca_pcps_multithread_acquisition_gsoc2013_test.cc"
 #if OPENCL_BLOCKS_TEST
-    #include "gnss_block/gps_l1_ca_pcps_opencl_acquisition_gsoc2013_test.cc"
+#include "gnss_block/gps_l1_ca_pcps_opencl_acquisition_gsoc2013_test.cc"
 #endif
 #include "gnss_block/gps_l1_ca_pcps_quicksync_acquisition_gsoc2014_test.cc"
 #include "gnss_block/gps_l1_ca_pcps_tong_acquisition_gsoc2013_test.cc"
@@ -104,6 +104,12 @@ DECLARE_string(log_dir);
 #include "gnuradio_block/direct_resampler_conditioner_cc_test.cc"
 #include "string_converter/string_converter_test.cc"
 
+//#include "gnss_block/galileo_e5a_pcps_acquisition_test.cc"
+//#include "gnss_block/galileo_e5a_pcps_acquisition_test_2.cc"
+#include "gnss_block/galileo_e5a_pcps_acquisition_gsoc2014_gensource_test.cc"
+#include "gnss_block/galileo_e5a_tracking_test.cc"
+
+
 
 concurrent_queue<Gps_Ephemeris> global_gps_ephemeris_queue;
 concurrent_queue<Gps_Iono> global_gps_iono_queue;

src/utils/matlab/galileo_e5a_dll_pll_plot_sample_64bits.m

@@ -0,0 +1,90 @@
+% /*!
+%  * \file galileo_e5a_dll_pll_plot_sample_64bits.m
+%  * \brief Read GNSS-SDR Tracking dump binary file using the provided
+%  function and plot some internal variables
+%  * \author Javier Arribas, Marc Sales 2014. jarribas(at)cttc.es
+%  marcsales92@gmail.com
+%  * -------------------------------------------------------------------------
+%  *
+%  * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+%  *
+%  * GNSS-SDR is a software defined Global Navigation
+%  *          Satellite Systems receiver
+%  *
+%  * This file is part of GNSS-SDR.
+%  *
+%  * GNSS-SDR is free software: you can redistribute it and/or modify
+%  * it under the terms of the GNU General Public License as published by
+%  * the Free Software Foundation, either version 3 of the License, or
+%  * at your option) any later version.
+%  *
+%  * GNSS-SDR is distributed in the hope that it will be useful,
+%  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+%  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%  * GNU General Public License for more details.
+%  *
+%  * You should have received a copy of the GNU General Public License
+%  * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+%  *
+%  * -------------------------------------------------------------------------
+%  */ 
+close all;
+clear all;
+samplingFreq       =  64e6/32;     %[Hz]
+channels=1;
+%path='/home/javier/workspace/gnss-sdr/trunk/install/';
+path='/home/marc/git/gnss-sdr/data/';
+clear PRN_absolute_sample_start;
+for N=1:1:channels
+    tracking_log_path=[path 'e5a_tracking_ch_' num2str(N-1) '.dat'];
+    GNSS_tracking(N)= gps_l1_ca_dll_pll_read_tracking_dump_64bits(tracking_log_path);   
+end
+
+% GNSS-SDR format conversion to MATLAB GPS receiver
+
+for N=1:1:channels
+        trackResults(N).status='T'; %fake track
+        trackResults(N).codeFreq=GNSS_tracking(N).code_freq_hz.';
+        trackResults(N).carrFreq=GNSS_tracking(N).carrier_doppler_hz.';
+        trackResults(N).dllDiscr       = GNSS_tracking(N).code_error.';
+        trackResults(N).dllDiscrFilt   = GNSS_tracking(N).code_nco.';
+        trackResults(N).pllDiscr       = GNSS_tracking(N).carr_error.';
+        trackResults(N).pllDiscrFilt   = GNSS_tracking(N).carr_nco.';
+
+        trackResults(N).I_PN=GNSS_tracking(N).prompt_I.';
+        trackResults(N).Q_PN=GNSS_tracking(N).prompt_Q.';
+        trackResults(N).Q_P=zeros(1,length(GNSS_tracking(N).P));
+        trackResults(N).I_P=GNSS_tracking(N).P.';
+
+        trackResults(N).I_E= GNSS_tracking(N).E.';
+        trackResults(N).I_L = GNSS_tracking(N).L.';
+        trackResults(N).Q_E = zeros(1,length(GNSS_tracking(N).E));
+        trackResults(N).Q_L =zeros(1,length(GNSS_tracking(N).E));
+        trackResults(N).PRN=N; %fake PRN
+        
+        % Use original MATLAB tracking plot function
+        settings.numberOfChannels=channels;
+        settings.msToProcess=length(GNSS_tracking(N).E);
+        plotTrackingE5a(N,trackResults,settings)
+end
+
+for N=1:1:channels
+%  figure;
+%  plot([GNSS_tracking(N).E,GNSS_tracking(N).P,GNSS_tracking(N).L],'-*');
+%  title(['Early, Prompt, and Late correlator absolute value output for channel ' num2str(N)']);
+%  figure;
+%  plot(GNSS_tracking(N).prompt_I,GNSS_tracking(N).prompt_Q,'+');
+%  title(['Navigation constellation plot for channel ' num2str(N)]);
+%  figure;
+%  
+%  plot(GNSS_tracking(N).prompt_Q,'r');
+%  hold on;
+%  plot(GNSS_tracking(N).prompt_I);
+%  title(['Navigation symbols I(red) Q(blue) for channel ' num2str(N)]);
+%  
+ figure;
+ t=0:length(GNSS_tracking(N).carrier_doppler_hz)-1;
+ t=t/1000;
+ plot(t,GNSS_tracking(N).carrier_doppler_hz/1000);
+ xlabel('Time(s)');ylabel('Doppler(KHz)');title(['Doppler frequency channel ' num2str(N)]);
+end

src/utils/matlab/plotTrackingE5a.m

@@ -0,0 +1,153 @@
+function plotTracking(channelList, trackResults, settings)
+%This function plots the tracking results for the given channel list.
+%
+%plotTracking(channelList, trackResults, settings)
+%
+%   Inputs:
+%       channelList     - list of channels to be plotted.
+%       trackResults    - tracking results from the tracking function.
+%       settings        - receiver settings.
+
+%--------------------------------------------------------------------------
+%                           SoftGNSS v3.0
+% 
+% Copyright (C) Darius Plausinaitis
+% Written by Darius Plausinaitis
+%--------------------------------------------------------------------------
+%This program 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 2
+%of the License, or (at your option) any later version.
+%
+%This program 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 this program; if not, write to the Free Software
+%Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
+%USA.
+%--------------------------------------------------------------------------
+
+%CVS record:
+%$Id: plotTracking.m,v 1.5.2.23 2006/08/14 14:45:14 dpl Exp $
+
+% Protection - if the list contains incorrect channel numbers
+channelList = intersect(channelList, 1:settings.numberOfChannels);
+
+%=== For all listed channels ==============================================
+for channelNr = channelList
+
+%% Select (or create) and clear the figure ================================
+    % The number 200 is added just for more convenient handling of the open
+    % figure windows, when many figures are closed and reopened.
+    % Figures drawn or opened by the user, will not be "overwritten" by
+    % this function.
+
+    figure(channelNr +200);
+    clf(channelNr +200);
+    set(channelNr +200, 'Name', ['Channel ', num2str(channelNr), ...
+                                 ' (PRN ', ...
+                                 num2str(trackResults(channelNr).PRN), ...
+                                 ') results']);
+
+%% Draw axes ==============================================================
+        % Row 1
+        handles(1, 1) = subplot(3, 3, 1);
+        handles(1, 2) = subplot(3, 3, [2 3]);
+        % Row 2
+        handles(2, 1) = subplot(3, 3, 4);
+        handles(2, 2) = subplot(3, 3, [5 6]);
+        % Row 3
+        handles(3, 1) = subplot(3, 3, 7);
+        handles(3, 2) = subplot(3, 3, 8);
+        handles(3, 3) = subplot(3, 3, 9);
+
+%% Plot all figures =======================================================
+
+        timeAxisInSeconds = (1:settings.msToProcess)/1000;
+
+        %----- Discrete-Time Scatter Plot ---------------------------------
+        plot(handles(1, 1), trackResults(channelNr).I_PN,...
+                            trackResults(channelNr).Q_PN, ...
+                            '.');
+
+        grid  (handles(1, 1));
+        axis  (handles(1, 1), 'equal');
+        title (handles(1, 1), 'Discrete-Time Scatter Plot');
+        xlabel(handles(1, 1), 'I prompt');
+        ylabel(handles(1, 1), 'Q prompt');
+
+        %----- Nav bits ---------------------------------------------------
+        plot  (handles(1, 2), timeAxisInSeconds, ...
+                              trackResults(channelNr).I_PN);
+
+        grid  (handles(1, 2));
+        title (handles(1, 2), 'Bits of the navigation message');
+        xlabel(handles(1, 2), 'Time (s)');
+        axis  (handles(1, 2), 'tight');
+
+        %----- PLL discriminator unfiltered--------------------------------
+        plot  (handles(2, 1), timeAxisInSeconds, ...
+                              trackResults(channelNr).pllDiscr, 'r');      
+
+        grid  (handles(2, 1));
+        axis  (handles(2, 1), 'tight');
+        xlabel(handles(2, 1), 'Time (s)');
+        ylabel(handles(2, 1), 'Amplitude');
+        title (handles(2, 1), 'Raw PLL discriminator');
+
+        %----- Correlation ------------------------------------------------
+        plot(handles(2, 2), timeAxisInSeconds, ...
+                            [sqrt(trackResults(channelNr).I_E.^2 + ...
+                                  trackResults(channelNr).Q_E.^2)', ...
+                             sqrt(trackResults(channelNr).I_P.^2 + ...
+                                  trackResults(channelNr).Q_P.^2)', ...
+                             sqrt(trackResults(channelNr).I_L.^2 + ...
+                                  trackResults(channelNr).Q_L.^2)'], ...
+                            '-*');
+
+        grid  (handles(2, 2));
+        title (handles(2, 2), 'Correlation results');
+        xlabel(handles(2, 2), 'Time (s)');
+        axis  (handles(2, 2), 'tight');
+        
+        hLegend = legend(handles(2, 2), '$\sqrt{I_{E}^2 + Q_{E}^2}$', ...
+                                        '$\sqrt{I_{P}^2 + Q_{P}^2}$', ...
+                                        '$\sqrt{I_{L}^2 + Q_{L}^2}$');
+                          
+        %set interpreter from tex to latex. This will draw \sqrt correctly
+        set(hLegend, 'Interpreter', 'Latex');
+
+        %----- PLL discriminator filtered----------------------------------
+        plot  (handles(3, 1), timeAxisInSeconds, ...
+                              trackResults(channelNr).pllDiscrFilt, 'b');      
+
+        grid  (handles(3, 1));
+        axis  (handles(3, 1), 'tight');
+        xlabel(handles(3, 1), 'Time (s)');
+        ylabel(handles(3, 1), 'Amplitude');
+        title (handles(3, 1), 'Filtered PLL discriminator');
+
+        %----- DLL discriminator unfiltered--------------------------------
+        plot  (handles(3, 2), timeAxisInSeconds, ...
+                              trackResults(channelNr).dllDiscr, 'r');      
+
+        grid  (handles(3, 2));
+        axis  (handles(3, 2), 'tight');
+        xlabel(handles(3, 2), 'Time (s)');
+        ylabel(handles(3, 2), 'Amplitude');
+        title (handles(3, 2), 'Raw DLL discriminator');
+
+        %----- DLL discriminator filtered----------------------------------
+        plot  (handles(3, 3), timeAxisInSeconds, ...
+                              trackResults(channelNr).dllDiscrFilt, 'b');      
+
+        grid  (handles(3, 3));
+        axis  (handles(3, 3), 'tight');
+        xlabel(handles(3, 3), 'Time (s)');
+        ylabel(handles(3, 3), 'Amplitude');
+        title (handles(3, 3), 'Filtered DLL discriminator');
+
+end % for channelNr = channelList

src/utils/matlab/plot_acq_grid_gsoc_e5.m

@@ -0,0 +1,137 @@
+% /*!
+%  * \file plot_acq_grid_gsoc_e5.m
+%  * \brief Read GNSS-SDR Acquisition dump binary file using the provided
+%  function and plot acquisition grid of acquisition statistic of PRN sat.
+%  CAF input must be 0 or 1 depending if the user desires to read the file
+%  that resolves doppler ambiguity or not.
+%
+%  This function analyzes a experiment performed by Marc Sales in the framework 
+%  of the Google Summer of Code (GSoC) 2014, with the collaboration of Luis Esteve, Javier Arribas
+%  and Carles Fernández, related to the extension of GNSS-SDR to Galileo.
+%
+%  * \author Marc Sales marcsales92(at)gmail.com, Luis Esteve, 2014. luis(at)epsilon-formacion.com
+%  * -------------------------------------------------------------------------
+%  *
+%  * Copyright (C) 2010-2014  (see AUTHORS file for a list of contributors)
+%  *
+%  * GNSS-SDR is a software defined Global Navigation
+%  *          Satellite Systems receiver
+%  *
+%  * This file is part of GNSS-SDR.
+%  *
+%  * GNSS-SDR is free software: you can redistribute it and/or modify
+%  * it under the terms of the GNU General Public License as published by
+%  * the Free Software Foundation, either version 3 of the License, or
+%  * at your option) any later version.
+%  *
+%  * GNSS-SDR is distributed in the hope that it will be useful,
+%  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+%  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+%  * GNU General Public License for more details.
+%  *
+%  * You should have received a copy of the GNU General Public License
+%  * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+%  *
+%  * -------------------------------------------------------------------------
+%  */ 
+
+function plot_acq_grid_gsoc_e5(sat,CAF)
+
+path='/home/marc/git/gnss-sdr/data/';
+file=[path 'test_statistics_E5a_sat_' num2str(sat) '_doppler_0.dat'];
+
+sampling_freq_Hz=32E6
+%Doppler_max_Hz = 14875
+%Doppler_min_Hz = -15000
+%Doppler_step_Hz = 125
+Doppler_max_Hz = 10000
+Doppler_min_Hz = -10000
+Doppler_step_Hz = 250
+
+
+
+% read files
+
+%x=read_complex_binary (file);
+%x=load_complex_data(file); % complex
+%l_y=length(x);
+myFile = java.io.File(file);
+flen = length(myFile);
+l_y=flen/4;% float
+
+
+Doppler_axes=Doppler_min_Hz:Doppler_step_Hz:Doppler_max_Hz;
+
+l_x=length(Doppler_axes);
+
+acq_grid = zeros(l_x,l_y);
+
+index=0;
+
+for k=Doppler_min_Hz:Doppler_step_Hz:Doppler_max_Hz
+    index=index+1;
+    filename=[path 'test_statistics_E5a_sat_' num2str(sat) '_doppler_' num2str(k) '.dat'];
+    fid=fopen(filename,'r');
+    xx=fread(fid,'float');%floats from squared correlation
+    %xx=load_complex_data (filename); %complex
+    acq_grid(index,:)=abs(xx);
+end
+
+[fila,col]=find(acq_grid==max(max(acq_grid)));
+
+if (CAF > 0)
+    filename=[path 'test_statistics_E5a_sat_' num2str(sat) '_CAF.dat'];
+    fid=fopen(filename,'r');
+    xx=fread(fid,'float');%floats from squared correlation
+    acq_grid(:,col(1))=abs(xx);
+    Doppler_error_Hz = Doppler_axes(xx==max(xx))
+    maximum_correlation_peak = max(xx)
+else
+    Doppler_error_Hz = Doppler_axes(fila)
+    maximum_correlation_peak = max(max(acq_grid))
+end
+
+delay_error_sps = col -1
+
+
+
+noise_grid=acq_grid;
+delay_span=floor(3*sampling_freq_Hz/(1.023e7));
+Doppler_span=floor(500/Doppler_step_Hz);
+noise_grid(fila-Doppler_span:fila+Doppler_span,col-delay_span:col+delay_span)=0;
+
+n=numel(noise_grid)-(2*delay_span+1)*(2*Doppler_span+1);
+
+noise_floor= sum(sum(noise_grid))/n
+
+Gain_dbs = 10*log10(maximum_correlation_peak/noise_floor)
+
+
+%% Plot 3D FULL RESOLUTION
+
+
+[X,Y] = meshgrid(Doppler_axes,1:1:l_y);
+figure;
+surf(X,Y,acq_grid');
+
+xlabel('Doppler(Hz)');ylabel('Code Delay(samples)');title(['GLRT statistic of Galileo Parallel Code Phase Search Acquisition. PRN ' num2str(sat)]);
+
+
+end
+
+function x=load_complex_data(file)
+fid = fopen(file,'r');
+%fid = fopen('signal_source.dat','r');
+
+myFile = java.io.File(file);
+flen = length(myFile);
+num_samples=flen/8; % 8 bytes (2 single floats) per complex sample
+
+for k=1:num_samples   
+    a(1:2) = fread(fid, 2, 'float');
+    x(k) = a(1) + a(2)*1i;
+    k=k+1;
+end
+
+end
+