diff --git a/CMakeLists.txt b/CMakeLists.txt index f9d9a2d8b..f22c839f3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1027,11 +1027,11 @@ if(ENABLE_GPERFTOOLS) endif(ENABLE_GPERFTOOLS) if(ENABLE_GPROF) - if(CMAKE_COMPILER_IS_GNUCXX) + #if(CMAKE_COMPILER_IS_GNUCXX) set(MY_CXX_FLAGS "${MY_CXX_FLAGS} -pg") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pg") - endif(CMAKE_COMPILER_IS_GNUCXX) + #endif(CMAKE_COMPILER_IS_GNUCXX) endif(ENABLE_GPROF) diff --git a/conf/gnss-sdr.conf b/conf/gnss-sdr.conf index fefbb2730..8fb0a3790 100644 --- a/conf/gnss-sdr.conf +++ b/conf/gnss-sdr.conf @@ -33,8 +33,8 @@ SignalSource.implementation=File_Signal_Source 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 -SignalSource.item_type=byte +SignalSource.item_type=short +;SignalSource.item_type=byte ;#sampling_frequency: Original Signal sampling frequency in [Hz] SignalSource.sampling_frequency=4000000 @@ -77,10 +77,10 @@ SignalConditioner.implementation=Signal_Conditioner ;######### DATA_TYPE_ADAPTER CONFIG ############ ;## Changes the type of input data. Please disable it in this version. ;#implementation: [Pass_Through] disables this block -;DataTypeAdapter.implementation=Ishort_To_Complex +DataTypeAdapter.implementation=Ishort_To_Complex ;DataTypeAdapter.implementation=Ibyte_To_Cbyte -DataTypeAdapter.implementation=Pass_Through -DataTypeAdapter.item_type=byte +;DataTypeAdapter.implementation=Pass_Through +;DataTypeAdapter.item_type=byte ;######### INPUT_FILTER CONFIG ############ ;## Filter the input data. Can be combined with frequency translation for IF signals @@ -91,8 +91,8 @@ DataTypeAdapter.item_type=byte ;#[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 +;InputFilter.implementation=Freq_Xlating_Fir_Filter +InputFilter.implementation=Pass_Through ;#dump: Dump the filtered data to a file. InputFilter.dump=false @@ -105,7 +105,7 @@ InputFilter.dump_filename=../data/input_filter.dat ;#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=byte +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 diff --git a/conf/gnss-sdr_GPS_L1_gr_complex.conf b/conf/gnss-sdr_GPS_L1_gr_complex.conf index b921f1ce0..4b411a2ee 100644 --- a/conf/gnss-sdr_GPS_L1_gr_complex.conf +++ b/conf/gnss-sdr_GPS_L1_gr_complex.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=../data/agilent_cap2.dat +SignalSource.filename=/datalogger/signals/Agilent/New York/4msps.dat ;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version. SignalSource.item_type=gr_complex @@ -210,7 +210,7 @@ Acquisition_GPS.sampled_ms=1 ;#implementation: Acquisition algorithm selection for this channel: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition] Acquisition_GPS.implementation=GPS_L1_CA_PCPS_Acquisition ;#threshold: Acquisition threshold -Acquisition_GPS.threshold=0.008 +Acquisition_GPS.threshold=0.005 ;#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_GPS.pfa=0.01 ;#doppler_max: Maximum expected Doppler shift [Hz] @@ -289,7 +289,7 @@ PVT.dump_filename=./PVT 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; +PVT.flag_nmea_tty_port=false; ;#nmea_dump_devname: serial device descriptor for NMEA logging PVT.nmea_dump_devname=/dev/pts/4 diff --git a/conf/gnss-sdr_multichannel_GPS_L2_M_Flexiband_bin_file_III_1a.conf b/conf/gnss-sdr_multichannel_GPS_L2_M_Flexiband_bin_file_III_1a.conf new file mode 100644 index 000000000..b88f6b6a1 --- /dev/null +++ b/conf/gnss-sdr_multichannel_GPS_L2_M_Flexiband_bin_file_III_1a.conf @@ -0,0 +1,477 @@ +; 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=5000000 + +;######### 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=true +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=Flexiband_Signal_Source + +SignalSource.flag_read_file=true +;SignalSource.signal_file=/datalogger/captures/eclipse/eclipse_IIIa_2.bin +SignalSource.signal_file=/datalogger/signals/Fraunhofer/L125_III1b_210s.usb + +;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version. +SignalSource.item_type=gr_complex + +;# FPGA firmware file +SignalSource.firmware_file=flexiband_III-1b.bit + +;#RF_channels: Number of RF channels present in the frontend device, must agree the FPGA firmware file +SignalSource.RF_channels=2 + +;#frontend channels gain. Not usable yet! +SignalSource.gain1=0 +SignalSource.gain2=0 +SignalSource.gain3=0 + +;#frontend channels AGC +SignalSource.AGC=true + +;# USB 3.0 packet buffer size (number of SuperSpeed packets) +SignalSource.usb_packet_buffer=128 + +;###################################################### +;######### RF CHANNEL 0 SIGNAL CONDITIONER ############ +;###################################################### + +;######### SIGNAL_CONDITIONER 0 CONFIG ############ +;## It holds blocks to change data type, filter and resample input data. +SignalConditioner0.implementation=Signal_Conditioner + +;######### DATA_TYPE_ADAPTER 0 CONFIG ############ +DataTypeAdapter0.implementation=Pass_Through +DataTypeAdapter0.item_type=gr_complex + +;######### INPUT_FILTER 0 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. + +InputFilter0.implementation=Freq_Xlating_Fir_Filter + +;#dump: Dump the filtered data to a file. +InputFilter0.dump=true + +;#dump_filename: Log path and filename. +InputFilter0.dump_filename=../data/input_filter_ch0.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. +InputFilter0.input_item_type=gr_complex + +;#outut_item_type: Type and resolution for output filtered signal samples. Use only gr_complex in this version. +InputFilter0.output_item_type=gr_complex + +;#taps_item_type: Type and resolution for the taps of the filter. Use only float in this version. +InputFilter0.taps_item_type=float + +;#number_of_taps: Number of taps in the filter. Increasing this parameter increases the processing time +InputFilter0.number_of_taps=5 + +;#number_of _bands: Number of frequency bands in the filter. +InputFilter0.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 + +InputFilter0.band1_begin=0.0 +InputFilter0.band1_end=0.45 +InputFilter0.band2_begin=0.55 +InputFilter0.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 + +InputFilter0.ampl1_begin=1.0 +InputFilter0.ampl1_end=1.0 +InputFilter0.ampl2_begin=0.0 +InputFilter0.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 +InputFilter0.band1_error=1.0 +InputFilter0.band2_error=1.0 + +;#filter_type: one of "bandpass", "hilbert" or "differentiator" +InputFilter0.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. +InputFilter0.grid_density=16 + +;#The following options are used only in Freq_Xlating_Fir_Filter implementation. +;#InputFilter0.IF is the intermediate frequency (in Hz) shifted down to zero Hz +;FOR USE GNSS-SDR WITH RTLSDR DONGLES USER MUST SET THE CALIBRATED SAMPLE RATE HERE +; i.e. using front-end-cal as reported here:http://www.cttc.es/publication/turning-a-television-into-a-gnss-receiver/ +InputFilter0.sampling_frequency=20000000 +;# IF deviation due to front-end LO inaccuracies [HZ] +InputFilter0.IF=-205000 + +;# Decimation factor after the frequency tranaslating block +InputFilter0.decimation_factor=4 + +;######### RESAMPLER CONFIG 0 ############ +;## Resamples the input data. +Resampler0.implementation=Pass_Through + +;###################################################### +;######### RF CHANNEL 1 SIGNAL CONDITIONER ############ +;###################################################### + +;######### SIGNAL_CONDITIONER 1 CONFIG ############ +;## It holds blocks to change data type, filter and resample input data. +SignalConditioner1.implementation=Signal_Conditioner + +;######### DATA_TYPE_ADAPTER 1 CONFIG ############ +DataTypeAdapter1.implementation=Pass_Through +DataTypeAdapter1.item_type=gr_complex + +;######### INPUT_FILTER 0 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. + +InputFilter1.implementation=Freq_Xlating_Fir_Filter + +;#dump: Dump the filtered data to a file. +InputFilter1.dump=true + +;#dump_filename: Log path and filename. +InputFilter1.dump_filename=../data/input_filter_ch1.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. +InputFilter1.input_item_type=gr_complex + +;#outut_item_type: Type and resolution for output filtered signal samples. Use only gr_complex in this version. +InputFilter1.output_item_type=gr_complex + +;#taps_item_type: Type and resolution for the taps of the filter. Use only float in this version. +InputFilter1.taps_item_type=float + +;#number_of_taps: Number of taps in the filter. Increasing this parameter increases the processing time +InputFilter1.number_of_taps=5 + +;#number_of _bands: Number of frequency bands in the filter. +InputFilter1.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 + +InputFilter1.band1_begin=0.0 +InputFilter1.band1_end=0.45 +InputFilter1.band2_begin=0.55 +InputFilter1.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 + +InputFilter1.ampl1_begin=1.0 +InputFilter1.ampl1_end=1.0 +InputFilter1.ampl2_begin=0.0 +InputFilter1.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 +InputFilter1.band1_error=1.0 +InputFilter1.band2_error=1.0 + +;#filter_type: one of "bandpass", "hilbert" or "differentiator" +InputFilter1.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. +InputFilter1.grid_density=16 + +;#The following options are used only in Freq_Xlating_Fir_Filter implementation. +;#InputFilter0.IF is the intermediate frequency (in Hz) shifted down to zero Hz +;FOR USE GNSS-SDR WITH RTLSDR DONGLES USER MUST SET THE CALIBRATED SAMPLE RATE HERE +; i.e. using front-end-cal as reported here:http://www.cttc.es/publication/turning-a-television-into-a-gnss-receiver/ +InputFilter1.sampling_frequency=20000000 +;# IF deviation due to front-end LO inaccuracies [HZ] +InputFilter1.IF=-100000 + +;# Decimation factor after the frequency tranaslating block +InputFilter1.decimation_factor=4 + + +;######### RESAMPLER CONFIG 1 ############ +;## Resamples the input data. +Resampler1.implementation=Pass_Through + +;######### SIGNAL_CONDITIONER 2 CONFIG ############ +;## It holds blocks to change data type, filter and resample input data. +SignalConditioner2.implementation=Pass_Through + +;######### DATA_TYPE_ADAPTER 2 CONFIG ############ +DataTypeAdapter2.implementation=Pass_Through +DataTypeAdapter2.item_type=gr_complex + +;######### INPUT_FILTER 2 CONFIG ############ +InputFilter2.implementation=Pass_Through + +;#dump: Dump the filtered data to a file. +InputFilter2.dump=false + +;#dump_filename: Log path and filename. +InputFilter2.dump_filename=../data/input_filter.dat + +;#input_item_type: Type and resolution for input signal samples. Use only gr_complex in this version. +InputFilter2.input_item_type=gr_complex + +;#outut_item_type: Type and resolution for output filtered signal samples. Use only gr_complex in this version. +InputFilter2.output_item_type=gr_complex + +;######### RESAMPLER CONFIG 2 ############ +;## Resamples the input data. +Resampler2.implementation=Pass_Through + +;######### CHANNELS GLOBAL CONFIG ############ +;#count: Number of available GPS satellite channels. +Channels_GPS.count=2 +;#count: Number of available Galileo satellite channels. +Channels_Galileo.count=0 +;#in_acquisition: Number of channels simultaneously acquiring for the whole receiver +Channels.in_acquisition=1 +;#system: GPS, GLONASS, GALILEO, SBAS or COMPASS +;#if the option is disabled by default is assigned GPS +Channel.system=GPS, GPS L2C M + +;# CHANNEL CONNECTION +Channel0.RF_channel_ID=0 +Channel0.system=GPS +Channel0.signal=1C + +Channel1.RF_channel_ID=1 +Channel1.system=GPS L2C M +Channel1.signal=2S + +Channel2.RF_channel_ID=0 +Channel3.RF_channel_ID=0 +Channel4.RF_channel_ID=0 +Channel5.RF_channel_ID=0 +Channel6.RF_channel_ID=0 +Channel7.RF_channel_ID=0 + +;#signal: +;#if the option is disabled by default is assigned "1C" GPS L1 C/A +Channel.signal=1C + +;######### SPECIFIC CHANNELS CONFIG ###### +;#The following options are specific to each channel and overwrite the generic options + +;#dump: Enable or disable the acquisition internal data file logging [true] or [false] +Acquisition_GPS0.dump=false +;#filename: Log path and filename +Acquisition_GPS0.dump_filename=./acq_dump.dat +;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version. +Acquisition_GPS0.item_type=gr_complex +;#if: Signal intermediate frequency in [Hz] +Acquisition_GPS0.if=0 +;#sampled_ms: Signal block duration for the acquisition signal detection [ms] +Acquisition_GPS0.coherent_integration_time_ms=1 +;#implementation: Acquisition algorithm selection for this channel: +Acquisition_GPS0.implementation=GPS_L1_CA_PCPS_Acquisition +;#threshold: Acquisition threshold. It will be ignored if pfa is defined. +Acquisition_GPS0.threshold=0.002 +;#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_GPS0.pfa=0.0001 +;#doppler_max: Maximum expected Doppler shift [Hz] +Acquisition_GPS0.doppler_max=5000 +;#doppler_max: Doppler step in the grid search [Hz] +Acquisition_GPS0.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_GPS0.bit_transition_flag=false +;#max_dwells: Maximum number of consecutive dwells to be processed. It will be ignored if bit_transition_flag=true +Acquisition_GPS0.max_dwells=1 + +;#dump: Enable or disable the acquisition internal data file logging [true] or [false] +Acquisition_GPS1.dump=false +;#filename: Log path and filename +Acquisition_GPS1.dump_filename=./acq_dump.dat +;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version. +Acquisition_GPS1.item_type=gr_complex +;#if: Signal intermediate frequency in [Hz] +Acquisition_GPS1.if=0 +;#sampled_ms: Signal block duration for the acquisition signal detection [ms] +Acquisition_GPS1.coherent_integration_time_ms=1 +;#implementation: Acquisition algorithm selection for this channel: +Acquisition_GPS1.implementation=GPS_L2_M_PCPS_Acquisition +;#threshold: Acquisition threshold. It will be ignored if pfa is defined. +Acquisition_GPS1.threshold=0.0005 +;#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_GPS1.pfa=0.0001 +;#doppler_max: Maximum expected Doppler shift [Hz] +Acquisition_GPS1.doppler_max=5000 +;#doppler_max: Doppler step in the grid search [Hz] +Acquisition_GPS1.doppler_step=100 +;#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_GPS1.bit_transition_flag=false +;#max_dwells: Maximum number of consecutive dwells to be processed. It will be ignored if bit_transition_flag=true +Acquisition_GPS1.max_dwells=1 + + +;######### ACQUISITION GLOBAL CONFIG ############ + +;#dump: Enable or disable the acquisition internal data file logging [true] or [false] +Acquisition_GPS.dump=true +;#filename: Log path and filename +Acquisition_GPS.dump_filename=./acq_dump.dat +;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version. +Acquisition_GPS.item_type=gr_complex +;#if: Signal intermediate frequency in [Hz] +Acquisition_GPS.if=0 +;#sampled_ms: Signal block duration for the acquisition signal detection [ms] +Acquisition_GPS.coherent_integration_time_ms=1 +;#implementation: Acquisition algorithm selection for this channel: +Acquisition_GPS.implementation=GPS_L2_M_PCPS_Acquisition +;#threshold: Acquisition threshold. It will be ignored if pfa is defined. +Acquisition_GPS.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_GPS.pfa=0.0001 +;#doppler_max: Maximum expected Doppler shift [Hz] +Acquisition_GPS.doppler_max=5000 +;#doppler_max: Doppler step in the grid search [Hz] +Acquisition_GPS.doppler_step=100 +;#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_GPS.bit_transition_flag=false +;#max_dwells: Maximum number of consecutive dwells to be processed. It will be ignored if bit_transition_flag=true +Acquisition_GPS.max_dwells=1 + + +;######### ACQUISITION CHANNELS CONFIG ###### +;#The following options are specific to each channel and overwrite the generic options + + +;######### TRACKING GLOBAL CONFIG ############ + +;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking] +Tracking_GPS.implementation=GPS_L1_CA_DLL_PLL_Tracking +;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version. +Tracking_GPS.item_type=gr_complex + +;#sampling_frequency: Signal Intermediate Frequency in [Hz] +Tracking_GPS.if=0 + +;#dump: Enable or disable the Tracking internal binary data file logging [true] or [false] +Tracking_GPS.dump=false + +;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number. +Tracking_GPS.dump_filename=./tracking_ch_ + +;#pll_bw_hz: PLL loop filter bandwidth [Hz] +Tracking_GPS.pll_bw_hz=40.0; + +;#dll_bw_hz: DLL loop filter bandwidth [Hz] +Tracking_GPS.dll_bw_hz=3.0; + +;#fll_bw_hz: FLL loop filter bandwidth [Hz] +Tracking_GPS.fll_bw_hz=10.0; + +;#order: PLL/DLL loop filter order [2] or [3] +Tracking_GPS.order=3; + +;#early_late_space_chips: correlator early-late space [chips]. Use [0.5] +Tracking_GPS.early_late_space_chips=0.5; + +;######### TELEMETRY DECODER GPS CONFIG ############ +;#implementation: Use [GPS_L1_CA_Telemetry_Decoder] for GPS L1 C/A +TelemetryDecoder_GPS.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS.dump=false +;#decimation factor +TelemetryDecoder_GPS.decimation_factor=1; + +;######### OBSERVABLES CONFIG ############ +;#implementation: Use [GPS_L1_CA_Observables] for GPS L1 C/A. +Observables.implementation=GPS_L1_CA_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. +PVT.implementation=GPS_L1_CA_PVT + +;#averaging_depth: Number of PVT observations in the moving average algorithm +PVT.averaging_depth=10 + +;#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=false; + +;#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 diff --git a/conf/gnss-sdr_multichannel_GPS_L2_M_Flexiband_bin_file_III_1b.conf b/conf/gnss-sdr_multichannel_GPS_L2_M_Flexiband_bin_file_III_1b.conf new file mode 100644 index 000000000..b2aac0e3f --- /dev/null +++ b/conf/gnss-sdr_multichannel_GPS_L2_M_Flexiband_bin_file_III_1b.conf @@ -0,0 +1,915 @@ +; 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=5000000 + +;######### 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=true +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=Flexiband_Signal_Source + +SignalSource.flag_read_file=true +SignalSource.signal_file=/datalogger/signals/Fraunhofer/L125_III1b_210s.usb + +;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version. +SignalSource.item_type=gr_complex + +;# FPGA firmware file +SignalSource.firmware_file=flexiband_III-1b.bit + +;#RF_channels: Number of RF channels present in the frontend device, must agree the FPGA firmware file +SignalSource.RF_channels=2 + +;#frontend channels gain. Not usable yet! +SignalSource.gain1=0 +SignalSource.gain2=0 +SignalSource.gain3=0 + +;#frontend channels AGC +SignalSource.AGC=true + +;# USB 3.0 packet buffer size (number of SuperSpeed packets) +SignalSource.usb_packet_buffer=128 + +;###################################################### +;######### RF CHANNEL 0 SIGNAL CONDITIONER ############ +;###################################################### + +;######### SIGNAL_CONDITIONER 0 CONFIG ############ +;## It holds blocks to change data type, filter and resample input data. +SignalConditioner0.implementation=Signal_Conditioner + +;######### DATA_TYPE_ADAPTER 0 CONFIG ############ +DataTypeAdapter0.implementation=Pass_Through +DataTypeAdapter0.item_type=gr_complex + +;######### INPUT_FILTER 0 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. + +InputFilter0.implementation=Freq_Xlating_Fir_Filter + +;#dump: Dump the filtered data to a file. +InputFilter0.dump=false + +;#dump_filename: Log path and filename. +InputFilter0.dump_filename=../data/input_filter_ch0.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. +InputFilter0.input_item_type=gr_complex + +;#outut_item_type: Type and resolution for output filtered signal samples. Use only gr_complex in this version. +InputFilter0.output_item_type=gr_complex + +;#taps_item_type: Type and resolution for the taps of the filter. Use only float in this version. +InputFilter0.taps_item_type=float + +;#number_of_taps: Number of taps in the filter. Increasing this parameter increases the processing time +InputFilter0.number_of_taps=5 + +;#number_of _bands: Number of frequency bands in the filter. +InputFilter0.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 + +InputFilter0.band1_begin=0.0 +InputFilter0.band1_end=0.45 +InputFilter0.band2_begin=0.55 +InputFilter0.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 + +InputFilter0.ampl1_begin=1.0 +InputFilter0.ampl1_end=1.0 +InputFilter0.ampl2_begin=0.0 +InputFilter0.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 +InputFilter0.band1_error=1.0 +InputFilter0.band2_error=1.0 + +;#filter_type: one of "bandpass", "hilbert" or "differentiator" +InputFilter0.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. +InputFilter0.grid_density=16 + +;#The following options are used only in Freq_Xlating_Fir_Filter implementation. +;#InputFilter0.IF is the intermediate frequency (in Hz) shifted down to zero Hz +;FOR USE GNSS-SDR WITH RTLSDR DONGLES USER MUST SET THE CALIBRATED SAMPLE RATE HERE +; i.e. using front-end-cal as reported here:http://www.cttc.es/publication/turning-a-television-into-a-gnss-receiver/ +InputFilter0.sampling_frequency=20000000 +;# IF deviation due to front-end LO inaccuracies [HZ] +;# WARNING: Fraunhofer front-end hardwareconfigurations can difer. Signals available on http://www.iis.fraunhofer.de/de/ff/lok/leist/test/flexiband.html are centered on 0 Hz, ALL BANDS. +:#InputFilter0.IF=-205000 +InputFilter0.IF=0 + +;# Decimation factor after the frequency tranaslating block +InputFilter0.decimation_factor=4 + +;######### RESAMPLER CONFIG 0 ############ +;## Resamples the input data. +Resampler0.implementation=Pass_Through + +;###################################################### +;######### RF CHANNEL 1 SIGNAL CONDITIONER ############ +;###################################################### + +;######### SIGNAL_CONDITIONER 1 CONFIG ############ +;## It holds blocks to change data type, filter and resample input data. +SignalConditioner1.implementation=Signal_Conditioner + +;######### DATA_TYPE_ADAPTER 1 CONFIG ############ +DataTypeAdapter1.implementation=Pass_Through +DataTypeAdapter1.item_type=gr_complex + +;######### INPUT_FILTER 0 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. + +InputFilter1.implementation=Freq_Xlating_Fir_Filter + +;#dump: Dump the filtered data to a file. +InputFilter1.dump=false + +;#dump_filename: Log path and filename. +InputFilter1.dump_filename=../data/input_filter_ch1.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. +InputFilter1.input_item_type=gr_complex + +;#outut_item_type: Type and resolution for output filtered signal samples. Use only gr_complex in this version. +InputFilter1.output_item_type=gr_complex + +;#taps_item_type: Type and resolution for the taps of the filter. Use only float in this version. +InputFilter1.taps_item_type=float + +;#number_of_taps: Number of taps in the filter. Increasing this parameter increases the processing time +InputFilter1.number_of_taps=5 + +;#number_of _bands: Number of frequency bands in the filter. +InputFilter1.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 + +InputFilter1.band1_begin=0.0 +InputFilter1.band1_end=0.45 +InputFilter1.band2_begin=0.55 +InputFilter1.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 + +InputFilter1.ampl1_begin=1.0 +InputFilter1.ampl1_end=1.0 +InputFilter1.ampl2_begin=0.0 +InputFilter1.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 +InputFilter1.band1_error=1.0 +InputFilter1.band2_error=1.0 + +;#filter_type: one of "bandpass", "hilbert" or "differentiator" +InputFilter1.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. +InputFilter1.grid_density=16 + +;#The following options are used only in Freq_Xlating_Fir_Filter implementation. +;#InputFilter0.IF is the intermediate frequency (in Hz) shifted down to zero Hz +;FOR USE GNSS-SDR WITH RTLSDR DONGLES USER MUST SET THE CALIBRATED SAMPLE RATE HERE +; i.e. using front-end-cal as reported here:http://www.cttc.es/publication/turning-a-television-into-a-gnss-receiver/ +InputFilter1.sampling_frequency=20000000 +;# IF deviation due to front-end LO inaccuracies [HZ] +InputFilter1.IF=0 + +;# Decimation factor after the frequency tranaslating block +InputFilter1.decimation_factor=4 + + +;######### RESAMPLER CONFIG 1 ############ +;## Resamples the input data. +Resampler1.implementation=Pass_Through + +;######### SIGNAL_CONDITIONER 2 CONFIG ############ +;## It holds blocks to change data type, filter and resample input data. +SignalConditioner2.implementation=Pass_Through + +;######### DATA_TYPE_ADAPTER 2 CONFIG ############ +DataTypeAdapter2.implementation=Pass_Through +DataTypeAdapter2.item_type=gr_complex + +;######### INPUT_FILTER 2 CONFIG ############ +InputFilter2.implementation=Pass_Through + +;#dump: Dump the filtered data to a file. +InputFilter2.dump=false + +;#dump_filename: Log path and filename. +InputFilter2.dump_filename=../data/input_filter.dat + +;#input_item_type: Type and resolution for input signal samples. Use only gr_complex in this version. +InputFilter2.input_item_type=gr_complex + +;#outut_item_type: Type and resolution for output filtered signal samples. Use only gr_complex in this version. +InputFilter2.output_item_type=gr_complex + +;######### RESAMPLER CONFIG 2 ############ +;## Resamples the input data. +Resampler2.implementation=Pass_Through + +;######### CHANNELS GLOBAL CONFIG ############ +;#count: Number of available GPS satellite channels. +Channels_GPS.count=16 +;#count: Number of available Galileo satellite channels. +Channels_Galileo.count=0 +;#in_acquisition: Number of channels simultaneously acquiring for the whole receiver +Channels.in_acquisition=2 +;#system: GPS, GLONASS, GALILEO, SBAS or COMPASS +;#if the option is disabled by default is assigned GPS +Channel.system=GPS, GPS L2C M + +;# CHANNEL CONNECTION +Channel0.RF_channel_ID=0 +Channel0.system=GPS +Channel0.signal=1C + +Channel1.RF_channel_ID=0 +Channel1.system=GPS +Channel1.signal=1C + +Channel2.RF_channel_ID=0 +Channel2.system=GPS +Channel2.signal=1C + +Channel3.RF_channel_ID=0 +Channel3.system=GPS +Channel3.signal=1C + +Channel4.RF_channel_ID=0 +Channel4.system=GPS +Channel4.signal=1C + +Channel5.RF_channel_ID=0 +Channel5.system=GPS +Channel5.signal=1C + +Channel6.RF_channel_ID=0 +Channel6.system=GPS +Channel6.signal=1C + +Channel7.RF_channel_ID=0 +Channel7.system=GPS +Channel7.signal=1C + + +Channel8.RF_channel_ID=1 +Channel8.system=GPS L2C M +Channel8.signal=2S + +Channel9.RF_channel_ID=1 +Channel9.system=GPS L2C M +Channel9.signal=2S + +Channel10.RF_channel_ID=1 +Channel10.system=GPS L2C M +Channel10.signal=2S + +Channel11.RF_channel_ID=1 +Channel11.system=GPS L2C M +Channel11.signal=2S + +Channel12.RF_channel_ID=1 +Channel12.system=GPS L2C M +Channel12.signal=2S + +Channel13.RF_channel_ID=1 +Channel13.system=GPS L2C M +Channel13.signal=2S + +Channel14.RF_channel_ID=1 +Channel14.system=GPS L2C M +Channel14.signal=2S + +Channel15.RF_channel_ID=1 +Channel15.system=GPS L2C M +Channel15.signal=2S + +;#signal: +;#if the option is disabled by default is assigned "1C" GPS L1 C/A +Channel.signal=1C + +;######### SPECIFIC CHANNELS CONFIG ###### +;#The following options are specific to each channel and overwrite the generic options + +;# GPS L1 C/A +Acquisition_GPS0.dump=false +Acquisition_GPS0.dump_filename=./acq_dump.dat +Acquisition_GPS0.item_type=gr_complex +Acquisition_GPS0.if=0 +Acquisition_GPS0.sampled_ms=1 +Acquisition_GPS0.implementation=GPS_L1_CA_PCPS_Acquisition_Fine_Doppler +Acquisition_GPS0.threshold=0.015 +;Acquisition_GPS0.pfa=0.0001 +Acquisition_GPS0.doppler_max=5000 +Acquisition_GPS0.doppler_min=-5000 +Acquisition_GPS0.doppler_step=250 +Acquisition_GPS0.max_dwells=2 + +Acquisition_GPS1.dump=false +Acquisition_GPS1.dump_filename=./acq_dump.dat +Acquisition_GPS1.item_type=gr_complex +Acquisition_GPS1.if=0 +Acquisition_GPS1.sampled_ms=1 +Acquisition_GPS1.implementation=GPS_L1_CA_PCPS_Acquisition_Fine_Doppler +Acquisition_GPS1.threshold=0.015 +;Acquisition_GPS1.pfa=0.0001 +Acquisition_GPS1.doppler_max=5000 +Acquisition_GPS1.doppler_min=-5000 +Acquisition_GPS1.doppler_step=250 +Acquisition_GPS1.max_dwells=2 + +Acquisition_GPS2.dump=false +Acquisition_GPS2.dump_filename=./acq_dump.dat +Acquisition_GPS2.item_type=gr_complex +Acquisition_GPS2.if=0 +Acquisition_GPS2.sampled_ms=1 +Acquisition_GPS2.implementation=GPS_L1_CA_PCPS_Acquisition_Fine_Doppler +Acquisition_GPS2.threshold=0.015 +;Acquisition_GPS2.pfa=0.0001 +Acquisition_GPS2.doppler_max=5000 +Acquisition_GPS2.doppler_min=-5000 +Acquisition_GPS2.doppler_step=250 +Acquisition_GPS2.max_dwells=2 + +Acquisition_GPS3.dump=false +Acquisition_GPS3.dump_filename=./acq_dump.dat +Acquisition_GPS3.item_type=gr_complex +Acquisition_GPS3.if=0 +Acquisition_GPS3.sampled_ms=1 +Acquisition_GPS3.implementation=GPS_L1_CA_PCPS_Acquisition_Fine_Doppler +Acquisition_GPS3.threshold=0.015 +;Acquisition_GPS3.pfa=0.0001 +Acquisition_GPS3.doppler_max=5000 +Acquisition_GPS3.doppler_min=-5000 +Acquisition_GPS3.doppler_step=250 +Acquisition_GPS3.max_dwells=2 + +Acquisition_GPS4.dump=false +Acquisition_GPS4.dump_filename=./acq_dump.dat +Acquisition_GPS4.item_type=gr_complex +Acquisition_GPS4.if=0 +Acquisition_GPS4.sampled_ms=1 +Acquisition_GPS4.implementation=GPS_L1_CA_PCPS_Acquisition_Fine_Doppler +Acquisition_GPS4.threshold=0.015 +;Acquisition_GPS4.pfa=0.0001 +Acquisition_GPS4.doppler_max=5000 +Acquisition_GPS4.doppler_min=-5000 +Acquisition_GPS4.doppler_step=250 +Acquisition_GPS4.max_dwells=2 + +Acquisition_GPS5.dump=false +Acquisition_GPS5.dump_filename=./acq_dump.dat +Acquisition_GPS5.item_type=gr_complex +Acquisition_GPS5.if=0 +Acquisition_GPS5.sampled_ms=1 +Acquisition_GPS5.implementation=GPS_L1_CA_PCPS_Acquisition_Fine_Doppler +Acquisition_GPS5.threshold=0.015 +;Acquisition_GPS5.pfa=0.0001 +Acquisition_GPS5.doppler_max=5000 +Acquisition_GPS5.doppler_min=-5000 +Acquisition_GPS5.doppler_step=250 +Acquisition_GPS5.max_dwells=2 + +Acquisition_GPS6.dump=false +Acquisition_GPS6.dump_filename=./acq_dump.dat +Acquisition_GPS6.item_type=gr_complex +Acquisition_GPS6.if=0 +Acquisition_GPS6.sampled_ms=1 +Acquisition_GPS6.implementation=GPS_L1_CA_PCPS_Acquisition_Fine_Doppler +Acquisition_GPS6.threshold=0.015 +;Acquisition_GPS6.pfa=0.0001 +Acquisition_GPS6.doppler_max=5000 +Acquisition_GPS6.doppler_min=-5000 +Acquisition_GPS6.doppler_step=250 +Acquisition_GPS6.max_dwells=2 + +Acquisition_GPS7.dump=false +Acquisition_GPS7.dump_filename=./acq_dump.dat +Acquisition_GPS7.item_type=gr_complex +Acquisition_GPS7.if=0 +Acquisition_GPS7.sampled_ms=1 +Acquisition_GPS7.implementation=GPS_L1_CA_PCPS_Acquisition_Fine_Doppler +Acquisition_GPS7.threshold=0.015 +;Acquisition_GPS7.pfa=0.0001 +Acquisition_GPS7.doppler_max=5000 +Acquisition_GPS7.doppler_min=-5000 +Acquisition_GPS7.doppler_step=250 +Acquisition_GPS7.max_dwells=2 + + +;# GPS L2C M +Acquisition_GPS8.dump=false +Acquisition_GPS8.dump_filename=./acq_dump.dat +Acquisition_GPS8.item_type=gr_complex +Acquisition_GPS8.if=0 +Acquisition_GPS8.implementation=GPS_L2_M_PCPS_Acquisition +Acquisition_GPS8.threshold=0.0005 +;Acquisition_GPS8.pfa=0.001 +Acquisition_GPS8.doppler_max=5000 +Acquisition_GPS8.doppler_min=-5000 +Acquisition_GPS8.doppler_step=100 +Acquisition_GPS8.max_dwells=1 + +Acquisition_GPS9.dump=false +Acquisition_GPS9.dump_filename=./acq_dump.dat +Acquisition_GPS9.item_type=gr_complex +Acquisition_GPS9.if=0 +Acquisition_GPS9.implementation=GPS_L2_M_PCPS_Acquisition +Acquisition_GPS9.threshold=0.0005 +;Acquisition_GPS9.pfa=0.001 +Acquisition_GPS9.doppler_max=5000 +Acquisition_GPS9.doppler_min=-5000 +Acquisition_GPS9.doppler_step=100 +Acquisition_GPS9.max_dwells=1 + +Acquisition_GPS10.dump=false +Acquisition_GPS10.dump_filename=./acq_dump.dat +Acquisition_GPS10.item_type=gr_complex +Acquisition_GPS10.if=0 +Acquisition_GPS10.implementation=GPS_L2_M_PCPS_Acquisition +Acquisition_GPS10.threshold=0.0005 +;Acquisition_GPS10.pfa=0.001 +Acquisition_GPS10.doppler_max=5000 +Acquisition_GPS10.doppler_min=-5000 +Acquisition_GPS10.doppler_step=100 +Acquisition_GPS10.max_dwells=1 + +Acquisition_GPS11.dump=false +Acquisition_GPS11.dump_filename=./acq_dump.dat +Acquisition_GPS11.item_type=gr_complex +Acquisition_GPS11.if=0 +Acquisition_GPS11.implementation=GPS_L2_M_PCPS_Acquisition +Acquisition_GPS11.threshold=0.0005 +;Acquisition_GPS11.pfa=0.001 +Acquisition_GPS11.doppler_max=5000 +Acquisition_GPS11.doppler_min=-5000 +Acquisition_GPS11.doppler_step=100 +Acquisition_GPS11.max_dwells=1 + +Acquisition_GPS12.dump=false +Acquisition_GPS12.dump_filename=./acq_dump.dat +Acquisition_GPS12.item_type=gr_complex +Acquisition_GPS12.if=0 +Acquisition_GPS12.implementation=GPS_L2_M_PCPS_Acquisition +Acquisition_GPS12.threshold=0.0005 +;Acquisition_GPS12.pfa=0.001 +Acquisition_GPS12.doppler_max=5000 +Acquisition_GPS12.doppler_min=-5000 +Acquisition_GPS12.doppler_step=100 +Acquisition_GPS12.max_dwells=1 + +Acquisition_GPS13.dump=false +Acquisition_GPS13.dump_filename=./acq_dump.dat +Acquisition_GPS13.item_type=gr_complex +Acquisition_GPS13.if=0 +Acquisition_GPS13.implementation=GPS_L2_M_PCPS_Acquisition +Acquisition_GPS13.threshold=0.0005 +;Acquisition_GPS13.pfa=0.001 +Acquisition_GPS13.doppler_max=5000 +Acquisition_GPS13.doppler_min=-5000 +Acquisition_GPS13.doppler_step=100 +Acquisition_GPS13.max_dwells=1 + +Acquisition_GPS14.dump=false +Acquisition_GPS14.dump_filename=./acq_dump.dat +Acquisition_GPS14.item_type=gr_complex +Acquisition_GPS14.if=0 +Acquisition_GPS14.implementation=GPS_L2_M_PCPS_Acquisition +Acquisition_GPS14.threshold=0.0005 +;Acquisition_GPS14.pfa=0.001 +Acquisition_GPS14.doppler_max=5000 +Acquisition_GPS14.doppler_min=-5000 +Acquisition_GPS14.doppler_step=100 +Acquisition_GPS14.max_dwells=1 + +Acquisition_GPS15.dump=false +Acquisition_GPS15.dump_filename=./acq_dump.dat +Acquisition_GPS15.item_type=gr_complex +Acquisition_GPS15.if=0 +Acquisition_GPS15.implementation=GPS_L2_M_PCPS_Acquisition +Acquisition_GPS15.threshold=0.0005 +;Acquisition_GPS15.pfa=0.001 +Acquisition_GPS15.doppler_max=5000 +Acquisition_GPS15.doppler_min=-5000 +Acquisition_GPS15.doppler_step=100 +Acquisition_GPS15.max_dwells=1 + +;######### ACQUISITION GLOBAL CONFIG ############ + +;#dump: Enable or disable the acquisition internal data file logging [true] or [false] +Acquisition_GPS.dump=true +;#filename: Log path and filename +Acquisition_GPS.dump_filename=./acq_dump.dat +;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version. +Acquisition_GPS.item_type=gr_complex +;#if: Signal intermediate frequency in [Hz] +Acquisition_GPS.if=0 +;#sampled_ms: Signal block duration for the acquisition signal detection [ms] +Acquisition_GPS.coherent_integration_time_ms=1 +;#implementation: Acquisition algorithm selection for this channel: +Acquisition_GPS.implementation=GPS_L2_M_PCPS_Acquisition +;#threshold: Acquisition threshold. It will be ignored if pfa is defined. +Acquisition_GPS.threshold=0.003 +;#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_GPS.pfa=0.0001 +;#doppler_max: Maximum expected Doppler shift [Hz] +Acquisition_GPS.doppler_max=5000 +;#doppler_max: Doppler step in the grid search [Hz] +Acquisition_GPS.doppler_step=100 +;#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_GPS.bit_transition_flag=false +;#max_dwells: Maximum number of consecutive dwells to be processed. It will be ignored if bit_transition_flag=true +Acquisition_GPS.max_dwells=1 + + +;######### ACQUISITION CHANNELS CONFIG ###### +;#The following options are specific to each channel and overwrite the generic options + + +;######### TRACKING CHANNEL 0 CONFIG ############ +Tracking_GPS0.implementation=GPS_L1_CA_DLL_PLL_Tracking +Tracking_GPS0.item_type=gr_complex +Tracking_GPS0.if=0 +Tracking_GPS0.dump=false +Tracking_GPS0.dump_filename=./tracking_ch_ +Tracking_GPS0.pll_bw_hz=40.0; +Tracking_GPS0.dll_bw_hz=3.0; +Tracking_GPS0.fll_bw_hz=10.0; +Tracking_GPS0.order=3; +Tracking_GPS0.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 1 CONFIG ############ +Tracking_GPS1.implementation=GPS_L1_CA_DLL_PLL_Tracking +Tracking_GPS1.item_type=gr_complex +Tracking_GPS1.if=0 +Tracking_GPS1.dump=false +Tracking_GPS1.dump_filename=./tracking_ch_ +Tracking_GPS1.pll_bw_hz=40.0; +Tracking_GPS1.dll_bw_hz=3.0; +Tracking_GPS1.fll_bw_hz=10.0; +Tracking_GPS1.order=3; +Tracking_GPS1.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 2 CONFIG ############ +Tracking_GPS2.implementation=GPS_L1_CA_DLL_PLL_Tracking +Tracking_GPS2.item_type=gr_complex +Tracking_GPS2.if=0 +Tracking_GPS2.dump=false +Tracking_GPS2.dump_filename=./tracking_ch_ +Tracking_GPS2.pll_bw_hz=40.0; +Tracking_GPS2.dll_bw_hz=3.0; +Tracking_GPS2.fll_bw_hz=10.0; +Tracking_GPS2.order=3; +Tracking_GPS2.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 3 CONFIG ############ +Tracking_GPS3.implementation=GPS_L1_CA_DLL_PLL_Tracking +Tracking_GPS3.item_type=gr_complex +Tracking_GPS3.if=0 +Tracking_GPS3.dump=false +Tracking_GPS3.dump_filename=./tracking_ch_ +Tracking_GPS3.pll_bw_hz=40.0; +Tracking_GPS3.dll_bw_hz=3.0; +Tracking_GPS3.fll_bw_hz=10.0; +Tracking_GPS3.order=3; +Tracking_GPS3.early_late_space_chips=0.5; + +;######### TRACKING CHANNEL 4 CONFIG ############ +Tracking_GPS4.implementation=GPS_L1_CA_DLL_PLL_Tracking +Tracking_GPS4.item_type=gr_complex +Tracking_GPS4.if=0 +Tracking_GPS4.dump=false +Tracking_GPS4.dump_filename=./tracking_ch_ +Tracking_GPS4.pll_bw_hz=40.0; +Tracking_GPS4.dll_bw_hz=3.0; +Tracking_GPS4.fll_bw_hz=10.0; +Tracking_GPS4.order=3; +Tracking_GPS4.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 5 CONFIG ############ +Tracking_GPS5.implementation=GPS_L1_CA_DLL_PLL_Tracking +Tracking_GPS5.item_type=gr_complex +Tracking_GPS5.if=0 +Tracking_GPS5.dump=false +Tracking_GPS5.dump_filename=./tracking_ch_ +Tracking_GPS5.pll_bw_hz=40.0; +Tracking_GPS5.dll_bw_hz=3.0; +Tracking_GPS5.fll_bw_hz=10.0; +Tracking_GPS5.order=3; +Tracking_GPS5.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 6 CONFIG ############ +Tracking_GPS6.implementation=GPS_L1_CA_DLL_PLL_Tracking +Tracking_GPS6.item_type=gr_complex +Tracking_GPS6.if=0 +Tracking_GPS6.dump=false +Tracking_GPS6.dump_filename=./tracking_ch_ +Tracking_GPS6.pll_bw_hz=40.0; +Tracking_GPS6.dll_bw_hz=3.0; +Tracking_GPS6.fll_bw_hz=10.0; +Tracking_GPS6.order=3; +Tracking_GPS6.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 7 CONFIG ############ +Tracking_GPS7.implementation=GPS_L1_CA_DLL_PLL_Tracking +Tracking_GPS7.item_type=gr_complex +Tracking_GPS7.if=0 +Tracking_GPS7.dump=false +Tracking_GPS7.dump_filename=./tracking_ch_ +Tracking_GPS7.pll_bw_hz=40.0; +Tracking_GPS7.dll_bw_hz=3.0; +Tracking_GPS7.fll_bw_hz=10.0; +Tracking_GPS7.order=3; +Tracking_GPS7.early_late_space_chips=0.5; + +;######### TRACKING CHANNEL 8 CONFIG ############ +Tracking_GPS8.implementation=GPS_L2_M_DLL_PLL_Tracking +Tracking_GPS8.item_type=gr_complex +Tracking_GPS8.if=0 +Tracking_GPS8.dump=false +Tracking_GPS8.dump_filename=./tracking_ch_ +Tracking_GPS8.pll_bw_hz=2.0; +Tracking_GPS8.dll_bw_hz=0.5; +Tracking_GPS8.fll_bw_hz=2.0; +Tracking_GPS8.order=2; +Tracking_GPS8.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 9 CONFIG ############ +Tracking_GPS9.implementation=GPS_L2_M_DLL_PLL_Tracking +Tracking_GPS9.item_type=gr_complex +Tracking_GPS9.if=0 +Tracking_GPS9.dump=false +Tracking_GPS9.dump_filename=./tracking_ch_ +Tracking_GPS9.pll_bw_hz=2.0; +Tracking_GPS9.dll_bw_hz=0.5; +Tracking_GPS9.fll_bw_hz=2.0; +Tracking_GPS9.order=2; +Tracking_GPS9.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 10 CONFIG ############ +Tracking_GPS10.implementation=GPS_L2_M_DLL_PLL_Tracking +Tracking_GPS10.item_type=gr_complex +Tracking_GPS10.if=0 +Tracking_GPS10.dump=false +Tracking_GPS10.dump_filename=./tracking_ch_ +Tracking_GPS10.pll_bw_hz=2.0; +Tracking_GPS10.dll_bw_hz=0.5; +Tracking_GPS10.fll_bw_hz=2.0; +Tracking_GPS10.order=2; +Tracking_GPS10.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 11 CONFIG ############ +Tracking_GPS11.implementation=GPS_L2_M_DLL_PLL_Tracking +Tracking_GPS11.item_type=gr_complex +Tracking_GPS11.if=0 +Tracking_GPS11.dump=false +Tracking_GPS11.dump_filename=./tracking_ch_ +Tracking_GPS11.pll_bw_hz=2.0; +Tracking_GPS11.dll_bw_hz=0.5; +Tracking_GPS11.fll_bw_hz=2.0; +Tracking_GPS11.order=2; +Tracking_GPS11.early_late_space_chips=0.5; + +;######### TRACKING CHANNEL 12 CONFIG ############ +Tracking_GPS12.implementation=GPS_L2_M_DLL_PLL_Tracking +Tracking_GPS12.item_type=gr_complex +Tracking_GPS12.if=0 +Tracking_GPS12.dump=false +Tracking_GPS12.dump_filename=./tracking_ch_ +Tracking_GPS12.pll_bw_hz=2.0; +Tracking_GPS12.dll_bw_hz=0.5; +Tracking_GPS12.fll_bw_hz=2.0; +Tracking_GPS12.order=2; +Tracking_GPS12.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 13 CONFIG ############ +Tracking_GPS13.implementation=GPS_L2_M_DLL_PLL_Tracking +Tracking_GPS13.item_type=gr_complex +Tracking_GPS13.if=0 +Tracking_GPS13.dump=false +Tracking_GPS13.dump_filename=./tracking_ch_ +Tracking_GPS13.pll_bw_hz=2.0; +Tracking_GPS13.dll_bw_hz=0.5; +Tracking_GPS13.fll_bw_hz=2.0; +Tracking_GPS13.order=2; +Tracking_GPS13.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 14 CONFIG ############ +Tracking_GPS14.implementation=GPS_L2_M_DLL_PLL_Tracking +Tracking_GPS14.item_type=gr_complex +Tracking_GPS14.if=0 +Tracking_GPS14.dump=false +Tracking_GPS14.dump_filename=./tracking_ch_ +Tracking_GPS14.pll_bw_hz=2.0; +Tracking_GPS14.dll_bw_hz=0.5; +Tracking_GPS14.fll_bw_hz=2.0; +Tracking_GPS14.order=2; +Tracking_GPS14.early_late_space_chips=0.5; +;######### TRACKING CHANNEL 15 CONFIG ############ +Tracking_GPS15.implementation=GPS_L2_M_DLL_PLL_Tracking +Tracking_GPS15.item_type=gr_complex +Tracking_GPS15.if=0 +Tracking_GPS15.dump=false +Tracking_GPS15.dump_filename=./tracking_ch_ +Tracking_GPS15.pll_bw_hz=2.0; +Tracking_GPS15.dll_bw_hz=0.5; +Tracking_GPS15.fll_bw_hz=2.0; +Tracking_GPS15.order=2; +Tracking_GPS15.early_late_space_chips=0.5; + + +;######### TRACKING GLOBAL CONFIG ############ + +;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_FLL_PLL_Tracking] +Tracking_GPS.implementation=GPS_L1_CA_DLL_PLL_Tracking +;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version. +Tracking_GPS.item_type=gr_complex +;#sampling_frequency: Signal Intermediate Frequency in [Hz] +Tracking_GPS.if=0 +;#dump: Enable or disable the Tracking internal binary data file logging [true] or [false] +Tracking_GPS.dump=false +;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number. +Tracking_GPS.dump_filename=./tracking_ch_ +;#pll_bw_hz: PLL loop filter bandwidth [Hz] +Tracking_GPS.pll_bw_hz=40.0; +;#dll_bw_hz: DLL loop filter bandwidth [Hz] +Tracking_GPS.dll_bw_hz=3.0; +;#fll_bw_hz: FLL loop filter bandwidth [Hz] +Tracking_GPS.fll_bw_hz=10.0; +;#order: PLL/DLL loop filter order [2] or [3] +Tracking_GPS.order=3; +;#early_late_space_chips: correlator early-late space [chips]. Use [0.5] +Tracking_GPS.early_late_space_chips=0.5; + +;######### TELEMETRY DECODER GPS CONFIG ############ +;#implementation: Use [GPS_L1_CA_Telemetry_Decoder] for GPS L1 C/A +TelemetryDecoder_GPS.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS.dump=false +;#decimation factor +TelemetryDecoder_GPS.decimation_factor=1; + +TelemetryDecoder_GPS0.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS0.dump=false +TelemetryDecoder_GPS0.decimation_factor=20; + +TelemetryDecoder_GPS1.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS1.dump=false +TelemetryDecoder_GPS1.decimation_factor=20; + +TelemetryDecoder_GPS2.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS2.dump=false +TelemetryDecoder_GPS2.decimation_factor=20; + +TelemetryDecoder_GPS3.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS3.dump=false +TelemetryDecoder_GPS3.decimation_factor=20; + +TelemetryDecoder_GPS4.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS4.dump=false +TelemetryDecoder_GPS4.decimation_factor=20; + +TelemetryDecoder_GPS5.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS5.dump=false +TelemetryDecoder_GPS5.decimation_factor=20; + +TelemetryDecoder_GPS6.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS6.dump=false +TelemetryDecoder_GPS6.decimation_factor=20; + +TelemetryDecoder_GPS7.implementation=GPS_L1_CA_Telemetry_Decoder +TelemetryDecoder_GPS7.dump=false +TelemetryDecoder_GPS7.decimation_factor=20; + + +TelemetryDecoder_GPS8.implementation=GPS_L2_M_Telemetry_Decoder +TelemetryDecoder_GPS8.dump=false +TelemetryDecoder_GPS8.decimation_factor=1; + +TelemetryDecoder_GPS9.implementation=GPS_L2_M_Telemetry_Decoder +TelemetryDecoder_GPS9.dump=false +TelemetryDecoder_GPS9.decimation_factor=1; + +TelemetryDecoder_GPS10.implementation=GPS_L2_M_Telemetry_Decoder +TelemetryDecoder_GPS10.dump=false +TelemetryDecoder_GPS10.decimation_factor=1; + +TelemetryDecoder_GPS11.implementation=GPS_L2_M_Telemetry_Decoder +TelemetryDecoder_GPS11.dump=false +TelemetryDecoder_GPS11.decimation_factor=1; + +TelemetryDecoder_GPS12.implementation=GPS_L2_M_Telemetry_Decoder +TelemetryDecoder_GPS12.dump=false +TelemetryDecoder_GPS12.decimation_factor=1; + +TelemetryDecoder_GPS13.implementation=GPS_L2_M_Telemetry_Decoder +TelemetryDecoder_GPS13.dump=false +TelemetryDecoder_GPS13.decimation_factor=1; + +TelemetryDecoder_GPS14.implementation=GPS_L2_M_Telemetry_Decoder +TelemetryDecoder_GPS14.dump=false +TelemetryDecoder_GPS14.decimation_factor=1; + +TelemetryDecoder_GPS15.implementation=GPS_L2_M_Telemetry_Decoder +TelemetryDecoder_GPS15.dump=false +TelemetryDecoder_GPS15.decimation_factor=1; + + +;######### OBSERVABLES CONFIG ############ +;#implementation: Use [GPS_L1_CA_Observables] for GPS L1 C/A. +Observables.implementation=GPS_L1_CA_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. +PVT.implementation=GPS_L1_CA_PVT + +;#averaging_depth: Number of PVT observations in the moving average algorithm +PVT.averaging_depth=10 + +;#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=false; + +;#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 diff --git a/src/algorithms/acquisition/adapters/CMakeLists.txt b/src/algorithms/acquisition/adapters/CMakeLists.txt index 781ecd1a5..e72f05fe3 100644 --- a/src/algorithms/acquisition/adapters/CMakeLists.txt +++ b/src/algorithms/acquisition/adapters/CMakeLists.txt @@ -24,6 +24,7 @@ set(ACQ_ADAPTER_SOURCES gps_l1_ca_pcps_acquisition_fine_doppler.cc gps_l1_ca_pcps_tong_acquisition.cc gps_l1_ca_pcps_quicksync_acquisition.cc + gps_l2_m_pcps_acquisition.cc galileo_e1_pcps_ambiguous_acquisition.cc galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc galileo_e1_pcps_quicksync_ambiguous_acquisition.cc diff --git a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc index 4c3b25974..579b0a62e 100644 --- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc @@ -90,6 +90,11 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition( code_= new gr_complex[vector_length_]; + std::complex* code = new std::complex[code_length_]; + + gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0); + + // if (item_type_.compare("gr_complex") == 0 ) // { item_size_ = sizeof(gr_complex); @@ -145,10 +150,7 @@ void GpsL1CaPcpsAcquisition::set_threshold(float threshold) if(pfa == 0.0) { - pfa = configuration_->property(role_+".pfa", 0.0); - } - if(pfa == 0.0) - { + pfa = configuration_->property(role_ + ".pfa", 0.0); threshold_ = threshold; } else @@ -156,7 +158,7 @@ void GpsL1CaPcpsAcquisition::set_threshold(float threshold) threshold_ = calculate_threshold(pfa); } - DLOG(INFO) <<"Channel "< + *
  • Javier Arribas, 2011. jarribas(at)cttc.es + * + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + +#include "gps_l2_m_pcps_acquisition.h" +#include +#include +#include +#include +#include +#include +#include "gps_l2c_signal.h" +#include "GPS_L2C.h" +#include "configuration_interface.h" + + +using google::LogMessage; + +GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition( + ConfigurationInterface* configuration, std::string role, + unsigned int in_streams, unsigned int out_streams, + gr::msg_queue::sptr 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"; + + LOG(INFO) << "role " << role; + + item_type_ = configuration_->property(role + ".item_type", + default_item_type); + //float pfa = configuration_->property(role + ".pfa", 0.0); + + fs_in_ = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000); + if_ = configuration_->property(role + ".ifreq", 0); + dump_ = configuration_->property(role + ".dump", false); + shift_resolution_ = configuration_->property(role + ".doppler_max", 15); + + bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false); + + if (!bit_transition_flag_) + { + max_dwells_ = configuration_->property(role + ".max_dwells", 1); + } + else + { + max_dwells_ = 2; + } + + dump_filename_ = configuration_->property(role + ".dump_filename", + default_dump_filename); + + //--- Find number of samples per spreading code ------------------------- + code_length_ = round((double)fs_in_ + / (GPS_L2_M_CODE_RATE_HZ / (double)GPS_L2_M_CODE_LENGTH_CHIPS)); + + vector_length_ = code_length_; + + code_= new gr_complex[vector_length_]; + + // if (item_type_.compare("gr_complex") == 0 ) + // { + item_size_ = sizeof(gr_complex); + acquisition_cc_ = pcps_make_acquisition_cc(1, max_dwells_, + shift_resolution_, if_, fs_in_, code_length_, code_length_, + bit_transition_flag_, queue_, dump_, dump_filename_); + + stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_); + + DLOG(INFO) << "stream_to_vector(" << stream_to_vector_->unique_id() << ")"; + DLOG(INFO) << "acquisition(" << acquisition_cc_->unique_id() << ")"; + // } + + if (item_type_.compare("cshort") == 0) + { + cshort_to_float_x2_ = make_cshort_to_float_x2(); + float_to_complex_ = gr::blocks::float_to_complex::make(); + } + + if (item_type_.compare("cbyte") == 0) + { + cbyte_to_float_x2_ = make_complex_byte_to_float_x2(); + float_to_complex_ = gr::blocks::float_to_complex::make(); + } + //} + //else + // { + // LOG(WARNING) << item_type_ + // << " unknown acquisition item type"; + // } +} + + +GpsL2MPcpsAcquisition::~GpsL2MPcpsAcquisition() +{ + delete[] code_; +} + + +void GpsL2MPcpsAcquisition::set_channel(unsigned int channel) +{ + channel_ = channel; + //if (item_type_.compare("gr_complex") == 0) + //{ + acquisition_cc_->set_channel(channel_); + //} +} + + +void GpsL2MPcpsAcquisition::set_threshold(float threshold) +{ + float pfa = configuration_->property(role_ + boost::lexical_cast(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 "<set_threshold(threshold_); + // } +} + + +void GpsL2MPcpsAcquisition::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 GpsL2MPcpsAcquisition::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 GpsL2MPcpsAcquisition::set_channel_queue( + concurrent_queue *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 GpsL2MPcpsAcquisition::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 GpsL2MPcpsAcquisition::mag() +{ + // // if (item_type_.compare("gr_complex") == 0) + // { + return acquisition_cc_->mag(); + // } + // else + // { + // return 0; + // } +} + + +void GpsL2MPcpsAcquisition::init() +{ + acquisition_cc_->init(); + set_local_code(); +} + + +void GpsL2MPcpsAcquisition::set_local_code() +{ + // if (item_type_.compare("gr_complex") == 0) + // { + gps_l2c_m_code_gen_complex_sampled(code_, gnss_synchro_->PRN, fs_in_); + acquisition_cc_->set_local_code(code_); + +// //debug +// std::ofstream d_dump_file; +// std::stringstream filename; +// std::streamsize n = 2 * sizeof(float) * (code_length_); // complex file write +// filename.str(""); +// filename << "../data/local_prn_sampled.dat"; +// d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary); +// d_dump_file.write((char*)code_, n); +// d_dump_file.close(); + + // } +} + + +void GpsL2MPcpsAcquisition::reset() +{ + // if (item_type_.compare("gr_complex") == 0) + // { + acquisition_cc_->set_active(true); + // } +} + +void GpsL2MPcpsAcquisition::set_state(int state) +{ + // if (item_type_.compare("gr_complex") == 0) + // { + acquisition_cc_->set_state(state); + // } +} + + + +float GpsL2MPcpsAcquisition::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 / static_cast(ncells); + double val = pow(1.0 - pfa, exponent); + double lambda = double(vector_length_); + boost::math::exponential_distribution mydist (lambda); + float threshold = (float)quantile(mydist,val); + + return threshold; +} + + +void GpsL2MPcpsAcquisition::connect(gr::top_block_sptr top_block) +{ + if (item_type_.compare("gr_complex") == 0) + { + top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0); + } + else if (item_type_.compare("cshort") == 0) + { + top_block->connect(cshort_to_float_x2_, 0, float_to_complex_, 0); + top_block->connect(cshort_to_float_x2_, 1, float_to_complex_, 1); + top_block->connect(float_to_complex_, 0, stream_to_vector_, 0); + top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0); + } + else if (item_type_.compare("cbyte") == 0) + { + top_block->connect(cbyte_to_float_x2_, 0, float_to_complex_, 0); + top_block->connect(cbyte_to_float_x2_, 1, float_to_complex_, 1); + top_block->connect(float_to_complex_, 0, stream_to_vector_, 0); + top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0); + } + else + { + LOG(WARNING) << item_type_ << " unknown acquisition item type"; + } + +} + + +void GpsL2MPcpsAcquisition::disconnect(gr::top_block_sptr top_block) +{ + if (item_type_.compare("gr_complex") == 0) + { + top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0); + } + else if (item_type_.compare("cshort") == 0) + { + // Since a short-based acq implementation is not available, + // we just convert cshorts to gr_complex + top_block->disconnect(cshort_to_float_x2_, 0, float_to_complex_, 0); + top_block->disconnect(cshort_to_float_x2_, 1, float_to_complex_, 1); + top_block->disconnect(float_to_complex_, 0, stream_to_vector_, 0); + top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0); + } + else if (item_type_.compare("cbyte") == 0) + { + // Since a byte-based acq implementation is not available, + // we just convert cshorts to gr_complex + top_block->disconnect(cbyte_to_float_x2_, 0, float_to_complex_, 0); + top_block->disconnect(cbyte_to_float_x2_, 1, float_to_complex_, 1); + top_block->disconnect(float_to_complex_, 0, stream_to_vector_, 0); + top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0); + } + else + { + LOG(WARNING) << item_type_ << " unknown acquisition item type"; + } +} + + +gr::basic_block_sptr GpsL2MPcpsAcquisition::get_left_block() +{ + if (item_type_.compare("gr_complex") == 0) + { + return stream_to_vector_; + } + else if (item_type_.compare("cshort") == 0) + { + return cshort_to_float_x2_; + } + else if (item_type_.compare("cbyte") == 0) + { + return cbyte_to_float_x2_; + } + else + { + LOG(WARNING) << item_type_ << " unknown acquisition item type"; + return nullptr; + } +} + + +gr::basic_block_sptr GpsL2MPcpsAcquisition::get_right_block() +{ + return acquisition_cc_; +} + diff --git a/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.h b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.h new file mode 100644 index 000000000..c6553ad69 --- /dev/null +++ b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.h @@ -0,0 +1,176 @@ +/*! + * \file gps_l2_m_pcps_acquisition.h + * \brief Adapts a PCPS acquisition block to an AcquisitionInterface for + * GPS L2 M signals + * \authors
      + *
    • Javier Arribas, 2015. jarribas(at)cttc.es + *
    + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + +#ifndef GNSS_SDR_GPS_L2_M_PCPS_ACQUISITION_H_ +#define GNSS_SDR_GPS_L2_M_PCPS_ACQUISITION_H_ + +#include +#include +#include +#include +#include "gnss_synchro.h" +#include "acquisition_interface.h" +#include "pcps_acquisition_cc.h" +#include "cshort_to_float_x2.h" +#include "complex_byte_to_float_x2.h" + + + +class ConfigurationInterface; + +/*! + * \brief This class adapts a PCPS acquisition block to an AcquisitionInterface + * for GPS L2 M signals + */ +class GpsL2MPcpsAcquisition: public AcquisitionInterface +{ +public: + GpsL2MPcpsAcquisition(ConfigurationInterface* configuration, + std::string role, unsigned int in_streams, + unsigned int out_streams, boost::shared_ptr queue); + + virtual ~GpsL2MPcpsAcquisition(); + + std::string role() + { + return role_; + } + + /*! + * \brief Returns "GPS_L2_M_PCPS_Acquisition" + */ + std::string implementation() + { + return "GPS_L2_M_PCPS_Acquisition"; + } + 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 *channel_internal_queue); + + /*! + * \brief Initializes acquisition algorithm. + */ + void init(); + + /*! + * \brief Sets local code for GPS L2/M PCPS acquisition algorithm. + */ + void set_local_code(); + + /*! + * \brief Returns the maximum peak of grid search + */ + signed int mag(); + + /*! + * \brief Restart acquisition algorithm + */ + void reset(); + + /*! + * \brief If state = 1, it forces the block to start acquiring from the first sample + */ + void set_state(int state); + +private: + ConfigurationInterface* configuration_; + pcps_acquisition_cc_sptr acquisition_cc_; + gr::blocks::stream_to_vector::sptr stream_to_vector_; + gr::blocks::float_to_complex::sptr float_to_complex_; + cshort_to_float_x2_sptr cshort_to_float_x2_; + complex_byte_to_float_x2_sptr cbyte_to_float_x2_; + 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 max_dwells_; + long fs_in_; + long if_; + bool dump_; + std::string dump_filename_; + std::complex * code_; + Gnss_Synchro * gnss_synchro_; + std::string role_; + unsigned int in_streams_; + unsigned int out_streams_; + boost::shared_ptr queue_; + concurrent_queue *channel_internal_queue_; + + float calculate_threshold(float pfa); +}; + +#endif /* GNSS_SDR_GPS_L2_M_PCPS_ACQUISITION_H_ */ diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc index 1dedcbc24..ef3e6ce7b 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc @@ -138,14 +138,15 @@ void pcps_acquisition_cc::init() d_mag = 0.0; d_input_power = 0.0; + d_num_doppler_bins=ceil((static_cast(d_doppler_max)-static_cast(-d_doppler_max))/d_doppler_step); // Count the number of bins - d_num_doppler_bins = 0; - for (int doppler = static_cast(-d_doppler_max); - doppler <= static_cast(d_doppler_max); - doppler += d_doppler_step) - { - d_num_doppler_bins++; - } +// d_num_doppler_bins = 0; +// for (int doppler = static_cast(-d_doppler_max); +// doppler <= static_cast(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]; @@ -154,7 +155,7 @@ void pcps_acquisition_cc::init() { d_grid_doppler_wipeoffs[doppler_index] = static_cast(volk_malloc(d_fft_size * sizeof(gr_complex), volk_get_alignment())); int doppler = -static_cast(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); + complex_exp_gen(d_grid_doppler_wipeoffs[doppler_index], d_freq - doppler, d_fs_in, d_fft_size); } } @@ -247,7 +248,6 @@ int pcps_acquisition_cc::general_work(int noutput_items, volk_32fc_magnitude_squared_32f(d_magnitude, in, d_fft_size); volk_32f_accumulator_s32f(&d_input_power, d_magnitude, d_fft_size); d_input_power /= static_cast(d_fft_size); - // 2- Doppler frequency search loop for (unsigned int doppler_index=0; doppler_index < d_num_doppler_bins; doppler_index++) { diff --git a/src/algorithms/libs/CMakeLists.txt b/src/algorithms/libs/CMakeLists.txt index 45259111d..7a09d88aa 100644 --- a/src/algorithms/libs/CMakeLists.txt +++ b/src/algorithms/libs/CMakeLists.txt @@ -18,6 +18,7 @@ set(GNSS_SPLIBS_SOURCES + gps_l2c_signal.cc galileo_e1_signal_processing.cc gnss_sdr_valve.cc gnss_signal_processing.cc diff --git a/src/algorithms/libs/gps_l2c_signal.cc b/src/algorithms/libs/gps_l2c_signal.cc new file mode 100644 index 000000000..abddb56c6 --- /dev/null +++ b/src/algorithms/libs/gps_l2c_signal.cc @@ -0,0 +1,128 @@ +/*! + * \file gps_l2c_signal.cc + * \brief This class implements signal generators for the GPS L2C signals + * \author Javier Arribas, 2015. jarribas(at)cttc.es + * + * Detailed description of the file here if needed. + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + +#include "GPS_L2C.h" +#include +#include +#include + + +int32_t gps_l2c_m_shift(int32_t x) +{ + return (int32_t)((x>>1)^((x&1)*0445112474)); +} + +void gps_l2c_m_code(int32_t * _dest, unsigned int _prn) +{ + int32_t x; + x= GPS_L2C_M_INIT_REG[_prn-1]; + for (int n=0; n* _dest, unsigned int _prn) +{ + int32_t _code[GPS_L2_M_CODE_LENGTH_CHIPS]; + + if (_prn>0 and _prn<51) + { + gps_l2c_m_code(_code, _prn); + } + + for (signed int i=0; i(1.0-2.0*_code[i],0); + } +} + + +/* + * Generates complex GPS L2C M code for the desired SV ID and sampled to specific sampling frequency + */ +void gps_l2c_m_code_gen_complex_sampled(std::complex* _dest, unsigned int _prn, signed int _fs) +{ + int32_t _code[GPS_L2_M_CODE_LENGTH_CHIPS]; + + if (_prn>0 and _prn<51) + { + gps_l2c_m_code(_code, _prn); + } + + signed int _samplesPerCode, _codeValueIndex; + float _ts; + float _tc; + const signed int _codeFreqBasis = GPS_L2_M_CODE_RATE_HZ; //Hz + const signed int _codeLength = GPS_L2_M_CODE_LENGTH_CHIPS; + + //--- Find number of samples per spreading code ---------------------------- + _samplesPerCode = round(_fs / (_codeFreqBasis / _codeLength)); + + //--- Find time constants -------------------------------------------------- + _ts = 1/(float)_fs; // Sampling period in sec + _tc = 1/(float)_codeFreqBasis; // C/A chip period in sec + + for (signed int i=0; i<_samplesPerCode; i++) + { + //=== Digitizing ======================================================= + + //--- Make index array to read C/A code values ------------------------- + // The length of the index array depends on the sampling frequency - + // number of samples per millisecond (because one C/A code period is one + // millisecond). + //TODO: Check this formula! Seems to start with an extra sample + + _codeValueIndex = ceil((_ts * ((float)i + 1)) / _tc) - 1; + + //--- Make the digitized version of the C/A code ----------------------- + // The "upsampled" code is made by selecting values form the CA code + // chip array (caCode) for the time instances of each sample. + if (i == _samplesPerCode - 1) + { + //--- Correct the last index (due to number rounding issues) ----------- + _dest[i] = std::complex(1.0-2.0*_code[_codeLength - 1],0); + + } + else + { + _dest[i] = std::complex(1.0-2.0*_code[_codeValueIndex],0);; //repeat the chip -> upsample + } + } +} + + + + diff --git a/src/algorithms/libs/gps_l2c_signal.h b/src/algorithms/libs/gps_l2c_signal.h new file mode 100644 index 000000000..de5d72dfb --- /dev/null +++ b/src/algorithms/libs/gps_l2c_signal.h @@ -0,0 +1,48 @@ +/*! + * \file gps_l2c_signal.h + * \brief This class implements signal generators for the GPS L2C signals + * \author Javier Arribas, 2015. jarribas(at)cttc.es + * + * Detailed description of the file here if needed. + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + +#ifndef GNSS_GPS_L2C_SIGNAL_H_ +#define GNSS_GPS_L2C_SIGNAL_H_ + +#include +#include +#include "GPS_L2C.h" + + +//!Generates complex GPS L2C M code for the desired SV ID +void gps_l2c_m_code_gen_complex(std::complex* _dest, unsigned int _prn); + + +//! Generates complex GPS L2C M code for the desired SV ID, and sampled to specific sampling frequency +void gps_l2c_m_code_gen_complex_sampled(std::complex* _dest, unsigned int _prn, signed int _fs); + +#endif /* GNSS_GPS_L2C_SIGNAL_H_ */ diff --git a/src/algorithms/libs/gps_sdr_signal_processing.cc b/src/algorithms/libs/gps_sdr_signal_processing.cc index 714c2dce1..e4de19b49 100644 --- a/src/algorithms/libs/gps_sdr_signal_processing.cc +++ b/src/algorithms/libs/gps_sdr_signal_processing.cc @@ -60,6 +60,7 @@ void gps_l1_ca_code_gen_complex(std::complex* _dest, signed int _prn, uns if(120 <= _prn && _prn <= 138) { prn_idx = _prn - 88; // SBAS PRNs are at array indices 31 to 50 (offset: -120+33-1 =-88) + //prn_idx = _prn - 87; // SBAS PRNs are at array indices 31 to 50 (offset: -120+33 =-87) } else { diff --git a/src/algorithms/telemetry_decoder/adapters/CMakeLists.txt b/src/algorithms/telemetry_decoder/adapters/CMakeLists.txt index f29ea2c75..3eaacbf1d 100644 --- a/src/algorithms/telemetry_decoder/adapters/CMakeLists.txt +++ b/src/algorithms/telemetry_decoder/adapters/CMakeLists.txt @@ -18,6 +18,7 @@ set(TELEMETRY_DECODER_ADAPTER_SOURCES gps_l1_ca_telemetry_decoder.cc + gps_l2_m_telemetry_decoder.cc galileo_e1b_telemetry_decoder.cc sbas_l1_telemetry_decoder.cc galileo_e5a_telemetry_decoder.cc diff --git a/src/algorithms/telemetry_decoder/adapters/gps_l2_m_telemetry_decoder.cc b/src/algorithms/telemetry_decoder/adapters/gps_l2_m_telemetry_decoder.cc new file mode 100644 index 000000000..da02c2968 --- /dev/null +++ b/src/algorithms/telemetry_decoder/adapters/gps_l2_m_telemetry_decoder.cc @@ -0,0 +1,122 @@ +/*! + * \file gps_l2_m_telemetry_decoder.cc + * \brief Implementation of an adapter of a GPS L2C M NAV data decoder block + * to a TelemetryDecoderInterface + * \author Javier Arribas, 2015. jarribas(at)cttc.es + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + + +#include "gps_l2_m_telemetry_decoder.h" +#include +#include +#include "gps_ephemeris.h" +#include "gps_almanac.h" +#include "gps_iono.h" +#include "gps_utc_model.h" +#include "configuration_interface.h" + +extern concurrent_queue global_gps_ephemeris_queue; +extern concurrent_queue global_gps_iono_queue; +extern concurrent_queue global_gps_utc_model_queue; +extern concurrent_queue global_gps_almanac_queue; + + +using google::LogMessage; + +GpsL2MTelemetryDecoder::GpsL2MTelemetryDecoder(ConfigurationInterface* configuration, + std::string role, + unsigned int in_streams, + unsigned int out_streams, + boost::shared_ptr 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_ = gps_l2_m_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_gps_ephemeris_queue); + telemetry_decoder_->set_iono_queue(&global_gps_iono_queue); + telemetry_decoder_->set_almanac_queue(&global_gps_almanac_queue); + telemetry_decoder_->set_utc_model_queue(&global_gps_utc_model_queue); + + //decimation factor + int decimation_factor = configuration->property(role + ".decimation_factor", 1); + telemetry_decoder_->set_decimation(decimation_factor); + LOG(INFO) << "global navigation message queue assigned to telemetry_decoder ("<< telemetry_decoder_->unique_id() << ")"<<"role "<set_satellite(satellite_); + DLOG(INFO) << "TELEMETRY DECODER: satellite set to " << satellite_; +} + + +void GpsL2MTelemetryDecoder::connect(gr::top_block_sptr top_block) +{ + if(top_block) { /* top_block is not null */}; + // Nothing to connect internally + DLOG(INFO) << "nothing to connect internally"; +} + + +void GpsL2MTelemetryDecoder::disconnect(gr::top_block_sptr top_block) +{ + if(top_block) { /* top_block is not null */}; + // Nothing to disconnect +} + + +gr::basic_block_sptr GpsL2MTelemetryDecoder::get_left_block() +{ + return telemetry_decoder_; +} + + +gr::basic_block_sptr GpsL2MTelemetryDecoder::get_right_block() +{ + return telemetry_decoder_; +} + diff --git a/src/algorithms/telemetry_decoder/adapters/gps_l2_m_telemetry_decoder.h b/src/algorithms/telemetry_decoder/adapters/gps_l2_m_telemetry_decoder.h new file mode 100644 index 000000000..506fdc4b5 --- /dev/null +++ b/src/algorithms/telemetry_decoder/adapters/gps_l2_m_telemetry_decoder.h @@ -0,0 +1,96 @@ +/*! + * \file gps_l2_m_telemetry_decoder.h + * \brief Interface of an adapter of a GPS L1 C/A NAV data decoder block + * to a TelemetryDecoderInterface + * \author Javier Arribas, 2015. jarribas(at)cttc.es + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + + +#ifndef GNSS_SDR_GPS_L2_M_TELEMETRY_DECODER_H_ +#define GNSS_SDR_GPS_L2_M_TELEMETRY_DECODER_H_ + +#include +#include +#include "telemetry_decoder_interface.h" +#include "gps_l2_m_telemetry_decoder_cc.h" + + +class ConfigurationInterface; + +/*! + * \brief This class implements a NAV data decoder for GPS L2 M + */ +class GpsL2MTelemetryDecoder : public TelemetryDecoderInterface +{ +public: + GpsL2MTelemetryDecoder(ConfigurationInterface* configuration, + std::string role, + unsigned int in_streams, + unsigned int out_streams, + boost::shared_ptr queue); + + virtual ~GpsL2MTelemetryDecoder(); + std::string role() + { + return role_; + } + + //! Returns "gps_l2_m_telemetry_decoder" + std::string implementation() + { + return "gps_l2_m_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: + gps_l2_m_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 queue_; +}; + +#endif diff --git a/src/algorithms/telemetry_decoder/gnuradio_blocks/CMakeLists.txt b/src/algorithms/telemetry_decoder/gnuradio_blocks/CMakeLists.txt index b7c1e03d6..c4e90470f 100644 --- a/src/algorithms/telemetry_decoder/gnuradio_blocks/CMakeLists.txt +++ b/src/algorithms/telemetry_decoder/gnuradio_blocks/CMakeLists.txt @@ -18,6 +18,7 @@ set(TELEMETRY_DECODER_GR_BLOCKS_SOURCES gps_l1_ca_telemetry_decoder_cc.cc + gps_l2_m_telemetry_decoder_cc.cc galileo_e1b_telemetry_decoder_cc.cc sbas_l1_telemetry_decoder_cc.cc galileo_e5a_telemetry_decoder_cc.cc diff --git a/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc b/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc index f5e9864c6..13e6cbeaa 100644 --- a/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc +++ b/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc @@ -86,7 +86,6 @@ gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc( d_queue = queue; d_dump = dump; d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN()); - LOG(INFO) << "TELEMETRY PROCESSING: satellite " << d_satellite; d_vector_length = vector_length; d_samples_per_bit = ( GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS ) / GPS_CA_TELEMETRY_RATE_BITS_SECOND; d_fs_in = fs_in; @@ -357,7 +356,7 @@ int gps_l1_ca_telemetry_decoder_cc::general_work (int noutput_items, gr_vector_i d_average_count = 0; //3. Make the output (copy the object contents to the GNURadio reserved memory) *out[0] = current_synchro_data; - //std::cout<<"GPS TLM output on CH="<d_channel << " SAMPLE STAMP="< +#include +#include +#include +#include +#include "control_message_factory.h" +#include "gnss_synchro.h" + +#ifndef _rotl +#define _rotl(X,N) ((X << N) ^ (X >> (32-N))) // Used in the parity check algorithm +#endif + +using google::LogMessage; +/*! + * \todo name and move the magic numbers to GPS_L1_CA.h + */ +gps_l2_m_telemetry_decoder_cc_sptr +gps_l2_m_make_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, long fs_in, unsigned + int vector_length, boost::shared_ptr queue, bool dump) +{ + return gps_l2_m_telemetry_decoder_cc_sptr(new gps_l2_m_telemetry_decoder_cc(satellite, if_freq, + fs_in, vector_length, queue, dump)); +} + + + +void gps_l2_m_telemetry_decoder_cc::forecast (int noutput_items, gr_vector_int &ninput_items_required) +{ + for (unsigned i = 0; i < 3; i++) + { + ninput_items_required[i] = d_samples_per_bit * 8; //set the required sample history + } +} + + + +gps_l2_m_telemetry_decoder_cc::gps_l2_m_telemetry_decoder_cc( + Gnss_Satellite satellite, + long if_freq, + long fs_in, + unsigned + int vector_length, + boost::shared_ptr queue, + bool dump) : + gr::block("gps_navigation_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()); + d_vector_length = vector_length; + d_samples_per_bit = ( GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS ) / GPS_CA_TELEMETRY_RATE_BITS_SECOND; + d_fs_in = fs_in; + //d_preamble_duration_seconds = (1.0 / GPS_CA_TELEMETRY_RATE_BITS_SECOND) * GPS_CA_PREAMBLE_LENGTH_BITS; + //std::cout<<"d_preamble_duration_seconds="<d_preambles_bits, (unsigned short int*)preambles_bits, GPS_CA_PREAMBLE_LENGTH_BITS*sizeof(unsigned short int)); + + // preamble bits to sampled symbols + d_preambles_symbols = (signed int*)malloc(sizeof(signed int) * GPS_CA_PREAMBLE_LENGTH_BITS * d_samples_per_bit); + int n = 0; + for (int i = 0; i < GPS_CA_PREAMBLE_LENGTH_BITS; i++) + { + for (unsigned int j = 0; j < d_samples_per_bit; j++) + { + if (d_preambles_bits[i] == 1) + { + d_preambles_symbols[n] = 1; + } + else + { + d_preambles_symbols[n] = -1; + } + n++; + } + } + d_sample_counter = 0; + //d_preamble_code_phase_seconds = 0; + d_stat = 0; + d_preamble_index = 0; + d_symbol_accumulator = 0; + d_symbol_accumulator_counter = 0; + d_frame_bit_index = 0; + d_preamble_time_seconds = 0; + d_flag_frame_sync = false; + d_GPS_frame_4bytes = 0; + d_prev_GPS_frame_4bytes = 0; + d_flag_parity = false; + d_TOW_at_Preamble = 0; + d_TOW_at_current_symbol = 0; + flag_TOW_set = false; + d_average_count = 0; + //set_history(d_samples_per_bit*8); // At least a history of 8 bits are needed to correlate with the preamble +} + + +gps_l2_m_telemetry_decoder_cc::~gps_l2_m_telemetry_decoder_cc() +{ + delete d_preambles_symbols; + d_dump_file.close(); +} + + + +bool gps_l2_m_telemetry_decoder_cc::gps_word_parityCheck(unsigned int gpsword) +{ + unsigned int d1, d2, d3, d4, d5, d6, d7, t, parity; + /* XOR as many bits in parallel as possible. The magic constants pick + up bits which are to be XOR'ed together to implement the GPS parity + check algorithm described in IS-GPS-200E. This avoids lengthy shift- + and-xor loops. */ + d1 = gpsword & 0xFBFFBF00; + d2 = _rotl(gpsword,1) & 0x07FFBF01; + d3 = _rotl(gpsword,2) & 0xFC0F8100; + d4 = _rotl(gpsword,3) & 0xF81FFE02; + d5 = _rotl(gpsword,4) & 0xFC00000E; + d6 = _rotl(gpsword,5) & 0x07F00001; + d7 = _rotl(gpsword,6) & 0x00003000; + t = d1 ^ d2 ^ d3 ^ d4 ^ d5 ^ d6 ^ d7; + // Now XOR the 5 6-bit fields together to produce the 6-bit final result. + parity = t ^ _rotl(t,6) ^ _rotl(t,12) ^ _rotl(t,18) ^ _rotl(t,24); + parity = parity & 0x3F; + if (parity == (gpsword & 0x3F)) return(true); + else return(false); +} + + +int gps_l2_m_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) +{ + int corr_value = 0; + int preamble_diff = 0; + + Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; + d_sample_counter++; //count for the processed samples + + // ########### Output the tracking data to navigation and PVT ########## + const Gnss_Synchro **in = (const Gnss_Synchro **) &input_items[0]; //Get the input samples pointer + + // TODO Optimize me! + //******* preamble correlation ******** + for (unsigned int i = 0; i < d_samples_per_bit*8; i++) + { + if (in[0][i].Prompt_I < 0) // symbols clipping + { + corr_value -= d_preambles_symbols[i]; + } + else + { + corr_value += d_preambles_symbols[i]; + } + } + d_flag_preamble = false; + + //******* frame sync ****************** + if (abs(corr_value) >= 160) + { + //TODO: Rewrite with state machine + if (d_stat == 0) + { + d_GPS_FSM.Event_gps_word_preamble(); + d_preamble_index = d_sample_counter;//record the preamble sample stamp + LOG(INFO) << "Preamble detection for SAT " << this->d_satellite; + d_symbol_accumulator = 0; //sync the symbol to bits integrator + d_symbol_accumulator_counter = 0; + d_frame_bit_index = 8; + d_stat = 1; // enter into frame pre-detection status + } + else if (d_stat == 1) //check 6 seconds of preamble separation + { + preamble_diff = d_sample_counter - d_preamble_index; + if (abs(preamble_diff - 6000) < 1) + { + d_GPS_FSM.Event_gps_word_preamble(); + d_flag_preamble = true; + d_preamble_index = d_sample_counter; //record the preamble sample stamp (t_P) + d_preamble_time_seconds = in[0][0].Tracking_timestamp_secs;// - d_preamble_duration_seconds; //record the PRN start sample index associated to the preamble + + 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]"; + } + } + } + } + else + { + if (d_stat == 1) + { + preamble_diff = d_sample_counter - d_preamble_index; + if (preamble_diff > 6001) + { + LOG(INFO) << "Lost of frame sync SAT " << this->d_satellite << " preamble_diff= " << preamble_diff; + d_stat = 0; //lost of frame sync + d_flag_frame_sync = false; + flag_TOW_set = false; + } + } + } + + //******* SYMBOL TO BIT ******* + d_symbol_accumulator += in[0][d_samples_per_bit*8 - 1].Prompt_I; // accumulate the input value in d_symbol_accumulator + d_symbol_accumulator_counter++; + if (d_symbol_accumulator_counter == 20) + { + if (d_symbol_accumulator > 0) + { //symbol to bit + d_GPS_frame_4bytes += 1; //insert the telemetry bit in LSB + } + d_symbol_accumulator = 0; + d_symbol_accumulator_counter = 0; + //******* bits to words ****** + d_frame_bit_index++; + if (d_frame_bit_index == 30) + { + d_frame_bit_index = 0; + // parity check + // Each word in wordbuff is composed of: + // Bits 0 to 29 = the GPS data word + // Bits 30 to 31 = 2 LSBs of the GPS word ahead. + // prepare the extended frame [-2 -1 0 ... 30] + if (d_prev_GPS_frame_4bytes & 0x00000001) + { + d_GPS_frame_4bytes = d_GPS_frame_4bytes | 0x40000000; + } + if (d_prev_GPS_frame_4bytes & 0x00000002) + { + d_GPS_frame_4bytes = d_GPS_frame_4bytes | 0x80000000; + } + /* Check that the 2 most recently logged words pass parity. Have to first + invert the data bits according to bit 30 of the previous word. */ + if(d_GPS_frame_4bytes & 0x40000000) + { + d_GPS_frame_4bytes ^= 0x3FFFFFC0; // invert the data bits (using XOR) + } + if (gps_l2_m_telemetry_decoder_cc::gps_word_parityCheck(d_GPS_frame_4bytes)) + { + memcpy(&d_GPS_FSM.d_GPS_frame_4bytes, &d_GPS_frame_4bytes, sizeof(char)*4); + d_GPS_FSM.d_preamble_time_ms = d_preamble_time_seconds*1000.0; + d_GPS_FSM.Event_gps_word_valid(); + d_flag_parity = true; + } + else + { + d_GPS_FSM.Event_gps_word_invalid(); + d_flag_parity = false; + } + d_prev_GPS_frame_4bytes = d_GPS_frame_4bytes; // save the actual frame + d_GPS_frame_4bytes = d_GPS_frame_4bytes & 0; + } + else + { + d_GPS_frame_4bytes <<= 1; //shift 1 bit left the telemetry word + } + } + // output the frame + consume_each(1); //one by one + 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_GPS_FSM.d_nav.d_TOW > 0) + //update TOW at the preamble instant (todo: check for valid d_TOW) + // JAVI: 30/06/2014 + // TOW, in GPS, is referred to the START of the SUBFRAME, that is, THE FIRST SYMBOL OF THAT SUBFRAME, NOT THE PREAMBLE. + // thus, no correction should be done. d_TOW_at_Preamble should be renamed to d_TOW_at_subframe_start. + // Sice we detected the preable, then, we are in the last symbol of that preamble, or just at the start of the first subframe symbol. + { + d_TOW_at_Preamble = d_GPS_FSM.d_nav.d_TOW + GPS_SUBFRAME_SECONDS; //we decoded the current TOW when the last word of the subframe arrive, so, we have a lag of ONE SUBFRAME + d_TOW_at_current_symbol = d_TOW_at_Preamble;//GPS_L1_CA_CODE_PERIOD;// + (double)GPS_CA_PREAMBLE_LENGTH_BITS/(double)GPS_CA_TELEMETRY_RATE_BITS_SECOND; + Prn_timestamp_at_preamble_ms = in[0][0].Tracking_timestamp_secs * 1000.0; + if (flag_TOW_set == false) + { + flag_TOW_set = true; + } + } + else + { + d_TOW_at_current_symbol = d_TOW_at_current_symbol + GPS_L1_CA_CODE_PERIOD; + } + + 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.d_TOW_hybrid_at_current_symbol = current_synchro_data.d_TOW_at_current_symbol; // to be used in the hybrid configuration + current_synchro_data.Flag_valid_word = (d_flag_frame_sync == true and d_flag_parity == true and flag_TOW_set == true); + 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 (std::ifstream::failure e) + { + LOG(WARNING) << "Exception writing observables dump file " << e.what(); + } + } + + //todo: implement averaging + + d_average_count++; + if (d_average_count == d_decimation_output_factor) + { + d_average_count = 0; + //3. Make the output (copy the object contents to the GNURadio reserved memory) + *out[0] = current_synchro_data; + //std::cout<<"GPS L2 TLM output on CH="<d_channel << " SAMPLE STAMP="<(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 (std::ifstream::failure e) + { + LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what(); + } + } + } +} + diff --git a/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2_m_telemetry_decoder_cc.h b/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2_m_telemetry_decoder_cc.h new file mode 100644 index 000000000..cbb5a6897 --- /dev/null +++ b/src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2_m_telemetry_decoder_cc.h @@ -0,0 +1,152 @@ +/*! + * \file gps_l2_m_telemetry_decoder_cc.h + * \brief Interface of a NAV message demodulator block based on + * Kay Borre book MATLAB-based GPS receiver + * \author Javier Arribas, 2015. jarribas(at)cttc.es + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + +#ifndef GNSS_SDR_GPS_L2_M_TELEMETRY_DECODER_CC_H +#define GNSS_SDR_GPS_L2_M_TELEMETRY_DECODER_CC_H + +#include +#include +#include +#include +#include "GPS_L1_CA.h" +#include "gps_l1_ca_subframe_fsm.h" +#include "concurrent_queue.h" +#include "gnss_satellite.h" + + + +class gps_l2_m_telemetry_decoder_cc; + +typedef boost::shared_ptr gps_l2_m_telemetry_decoder_cc_sptr; + +gps_l2_m_telemetry_decoder_cc_sptr +gps_l2_m_make_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, long fs_in, unsigned + int vector_length, boost::shared_ptr queue, bool dump); + +/*! + * \brief This class implements a block that decodes the NAV data defined in IS-GPS-200E + * + */ +class gps_l2_m_telemetry_decoder_cc : public gr::block +{ +public: + ~gps_l2_m_telemetry_decoder_cc(); + void set_satellite(Gnss_Satellite satellite); //!< Set satellite PRN + void set_channel(int channel); //!< Set receiver's channel + + + /*! + * \brief Set decimation factor to average the GPS synchronization estimation output from the tracking module. + */ + void set_decimation(int decimation); + + /*! + * \brief Set the satellite data queue + */ + void set_ephemeris_queue(concurrent_queue *ephemeris_queue){d_GPS_FSM.d_ephemeris_queue = ephemeris_queue;} //!< Set the ephemeris data queue + void set_iono_queue(concurrent_queue *iono_queue){d_GPS_FSM.d_iono_queue = iono_queue;} //!< Set the iono data queue + void set_almanac_queue(concurrent_queue *almanac_queue){d_GPS_FSM.d_almanac_queue = almanac_queue;} //!< Set the almanac data queue + void set_utc_model_queue(concurrent_queue *utc_model_queue){d_GPS_FSM.d_utc_model_queue = utc_model_queue;} //!< Set the UTC model data 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 gps_l2_m_telemetry_decoder_cc_sptr + gps_l2_m_make_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, long fs_in,unsigned + int vector_length, boost::shared_ptr queue, bool dump); + + gps_l2_m_telemetry_decoder_cc(Gnss_Satellite satellite, long if_freq, long fs_in, unsigned + int vector_length, boost::shared_ptr queue, bool dump); + + bool gps_word_parityCheck(unsigned int gpsword); + + // constants + unsigned short int d_preambles_bits[GPS_CA_PREAMBLE_LENGTH_BITS]; + // class private vars + + signed int *d_preambles_symbols; + unsigned int d_samples_per_bit; + long unsigned int d_sample_counter; + long unsigned int d_preamble_index; + unsigned int d_stat; + bool d_flag_frame_sync; + + // symbols + double d_symbol_accumulator; + short int d_symbol_accumulator_counter; + + //bits and frame + unsigned short int d_frame_bit_index; + unsigned int d_GPS_frame_4bytes; + unsigned int d_prev_GPS_frame_4bytes; + bool d_flag_parity; + bool d_flag_preamble; + int d_word_number; + + // output averaging and decimation + int d_average_count; + int d_decimation_output_factor; + + long d_fs_in; + //double d_preamble_duration_seconds; + // navigation message vars + Gps_Navigation_Message d_nav; + GpsL1CaSubframeFsm d_GPS_FSM; + + boost::shared_ptr d_queue; + unsigned int d_vector_length; + bool d_dump; + Gnss_Satellite d_satellite; + int d_channel; + + //std::deque d_prn_start_sample_history; + + 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 diff --git a/src/algorithms/tracking/adapters/CMakeLists.txt b/src/algorithms/tracking/adapters/CMakeLists.txt index 9a30ce222..fda0724a7 100644 --- a/src/algorithms/tracking/adapters/CMakeLists.txt +++ b/src/algorithms/tracking/adapters/CMakeLists.txt @@ -26,6 +26,7 @@ set(TRACKING_ADAPTER_SOURCES gps_l1_ca_dll_pll_tracking.cc gps_l1_ca_tcp_connector_tracking.cc galileo_e5a_dll_pll_tracking.cc + gps_l2_m_dll_pll_tracking.cc ) include_directories( diff --git a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc new file mode 100644 index 000000000..25fef9f76 --- /dev/null +++ b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc @@ -0,0 +1,154 @@ +/*! + * \file gps_l2_m_dll_pll_tracking.cc + * \brief Implementation of an adapter of a DLL+PLL tracking loop block + * for GPS L1 C/A to a TrackingInterface + * \author Javier Arribas, 2015. jarribas(at)cttc.es + * + * Code DLL + carrier PLL according to the algorithms described in: + * K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen, + * A Software-Defined GPS and Galileo Receiver. A Single-Frequency + * Approach, Birkhauser, 2007 + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + + +#include "gps_l2_m_dll_pll_tracking.h" +#include +#include "GPS_L2C.h" +#include "configuration_interface.h" + + +using google::LogMessage; + +GpsL2MDllPllTracking::GpsL2MDllPllTracking( + ConfigurationInterface* configuration, std::string role, + unsigned int in_streams, unsigned int out_streams, + boost::shared_ptr queue) : + role_(role), in_streams_(in_streams), out_streams_(out_streams), + queue_(queue) +{ + LOG(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 early_late_space_chips; + item_type = configuration->property(role + ".item_type", default_item_type); + fs_in = configuration->property("GNSS-SDR.internal_fs_hz", 2048000); + f_if = configuration->property(role + ".if", 0); + dump = configuration->property(role + ".dump", false); + pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0); + dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0); + 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 / (GPS_L2_M_CODE_RATE_HZ / GPS_L2_M_CODE_LENGTH_CHIPS)); + + //################# MAKE TRACKING GNURadio object ################### + if (item_type.compare("gr_complex") == 0) + { + item_size_ = sizeof(gr_complex); + tracking_ = gps_l2_m_dll_pll_make_tracking_cc( + f_if, + fs_in, + vector_length, + queue_, + dump, + dump_filename, + pll_bw_hz, + dll_bw_hz, + early_late_space_chips); + } + else + { + LOG(WARNING) << item_type << " unknown tracking item type."; + } + DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")"; +} + + +GpsL2MDllPllTracking::~GpsL2MDllPllTracking() +{} + + +void GpsL2MDllPllTracking::start_tracking() +{ + tracking_->start_tracking(); +} + +/* + * Set tracking channel unique ID + */ +void GpsL2MDllPllTracking::set_channel(unsigned int channel) +{ + channel_ = channel; + tracking_->set_channel(channel); +} + +/* + * Set tracking channel internal queue + */ +void GpsL2MDllPllTracking::set_channel_queue( + concurrent_queue *channel_internal_queue) +{ + channel_internal_queue_ = channel_internal_queue; + tracking_->set_channel_queue(channel_internal_queue_); +} + +void GpsL2MDllPllTracking::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) +{ + tracking_->set_gnss_synchro(p_gnss_synchro); +} + +void GpsL2MDllPllTracking::connect(gr::top_block_sptr top_block) +{ + if(top_block) { /* top_block is not null */}; + //nothing to connect, now the tracking uses gr_sync_decimator +} + +void GpsL2MDllPllTracking::disconnect(gr::top_block_sptr top_block) +{ + if(top_block) { /* top_block is not null */}; + //nothing to disconnect, now the tracking uses gr_sync_decimator +} + +gr::basic_block_sptr GpsL2MDllPllTracking::get_left_block() +{ + return tracking_; +} + +gr::basic_block_sptr GpsL2MDllPllTracking::get_right_block() +{ + return tracking_; +} + diff --git a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h new file mode 100644 index 000000000..06e9112d5 --- /dev/null +++ b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.h @@ -0,0 +1,114 @@ +/*! + * \file gps_l2_m_dll_pll_tracking.h + * \brief Interface of an adapter of a DLL+PLL tracking loop block + * for GPS L1 C/A to a TrackingInterface + * \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com + * Javier Arribas, 2011. jarribas(at)cttc.es + * + * Code DLL + carrier PLL according to the algorithms described in: + * K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen, + * A Software-Defined GPS and Galileo Receiver. A Single-Frequency + * Approach, Birkha user, 2007 + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + +#ifndef GNSS_SDR_gps_l2_m_dll_pll_tracking_H_ +#define GNSS_SDR_gps_l2_m_dll_pll_tracking_H_ + +#include +#include +#include "tracking_interface.h" +#include "gps_l2_m_dll_pll_tracking_cc.h" + + +class ConfigurationInterface; + +/*! + * \brief This class implements a code DLL + carrier PLL tracking loop + */ +class GpsL2MDllPllTracking : public TrackingInterface +{ +public: + + GpsL2MDllPllTracking(ConfigurationInterface* configuration, + std::string role, + unsigned int in_streams, + unsigned int out_streams, + boost::shared_ptr queue); + + virtual ~GpsL2MDllPllTracking(); + + std::string role() + { + return role_; + } + + //! Returns "gps_l2_m_dll_pll_tracking" + std::string implementation() + { + return "gps_l2_m_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 *channel_internal_queue); + + void start_tracking(); + +private: + gps_l2_m_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 queue_; + concurrent_queue *channel_internal_queue_; +}; + +#endif // GNSS_SDR_gps_l2_m_dll_pll_tracking_H_ diff --git a/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt b/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt index eec2ce09e..268e1f9b5 100644 --- a/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt +++ b/src/algorithms/tracking/gnuradio_blocks/CMakeLists.txt @@ -25,6 +25,7 @@ set(TRACKING_GR_BLOCKS_SOURCES gps_l1_ca_dll_pll_tracking_cc.cc gps_l1_ca_tcp_connector_tracking_cc.cc galileo_e5a_dll_pll_tracking_cc.cc + gps_l2_m_dll_pll_tracking_cc.cc ) include_directories( @@ -51,4 +52,4 @@ source_group(Headers FILES ${TRACKING_GR_BLOCKS_HEADERS}) target_link_libraries(tracking_gr_blocks tracking_lib ${GNURADIO_RUNTIME_LIBRARIES} gnss_sp_libs ${Boost_LIBRARIES} ${VOLK_GNSSSDR_LIBRARIES} ${ORC_LIBRARIES} ) if(NOT VOLK_GNSSSDR_FOUND) add_dependencies(tracking_gr_blocks volk_gnsssdr_module) -endif(NOT VOLK_GNSSSDR_FOUND) \ No newline at end of file +endif(NOT VOLK_GNSSSDR_FOUND) diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc index ccea190d2..f93c4a44a 100644 --- a/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_cc.cc @@ -163,6 +163,11 @@ Gps_L1_Ca_Dll_Pll_Tracking_cc::Gps_L1_Ca_Dll_Pll_Tracking_cc( systemName["G"] = std::string("GPS"); systemName["S"] = std::string("SBAS"); + + + set_relative_rate(1.0/((double)d_vector_length*2)); + + //set_min_output_buffer((long int)300); } @@ -327,6 +332,14 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in float code_error_chips; float code_error_filt_chips; + // Block input data and block output stream pointers + const gr_complex* in = (gr_complex*) input_items[0]; //PRN start block alignment + Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; + + // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder + Gnss_Synchro current_synchro_data; + + if (d_enable_tracking == true) { // Receiver signal alignment @@ -343,19 +356,16 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples d_pull_in = false; //std::cout<<" samples_offset="<telemetry_decoder - Gnss_Synchro current_synchro_data; // Fill the acquisition data current_synchro_data = *d_acquisition_gnss_synchro; - // Block input data and block output stream pointers - const gr_complex* in = (gr_complex*) input_items[0]; //PRN start block alignment - Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; - // Generate local code and carrier replicas (using \hat{f}_d(k-1)) update_local_code(); update_local_carrier(); @@ -390,7 +400,6 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in current_synchro_data.Flag_valid_pseudorange = false; *out[0] = current_synchro_data; - return 1; } @@ -503,8 +512,8 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in { d_last_seg = floor(d_sample_counter / d_fs_in); std::cout << "Current input signal time = " << d_last_seg << " [s]" << std::endl; - LOG(INFO) << "Tracking CH " << d_channel << ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) - << ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]"; + DLOG(INFO) << "GPS L1 C/A Tracking CH " << d_channel << ": Satellite " << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) + << ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]" << std::endl; //if (d_last_seg==5) d_carrier_lock_fail_counter=500; //DEBUG: force unlock! } } @@ -540,10 +549,9 @@ int Gps_L1_Ca_Dll_Pll_Tracking_cc::general_work (int noutput_items, gr_vector_in *d_Early = gr_complex(0,0); *d_Prompt = gr_complex(0,0); *d_Late = gr_complex(0,0); - Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; //block output streams pointer - // GNSS_SYNCHRO OBJECT to interchange data between tracking->telemetry_decoder - d_acquisition_gnss_synchro->Flag_valid_pseudorange = false; - *out[0] = *d_acquisition_gnss_synchro; + + current_synchro_data.Flag_valid_pseudorange = false; + *out[0] = current_synchro_data; } if(d_dump) diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc b/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc new file mode 100644 index 000000000..3137325b0 --- /dev/null +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.cc @@ -0,0 +1,657 @@ +/*! + * \file gps_l2_m_dll_pll_tracking_cc.cc + * \brief Implementation of a code DLL + carrier PLL tracking block + * \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com + * Javier Arribas, 2011. jarribas(at)cttc.es + * + * Code DLL + carrier PLL according to the algorithms described in: + * [1] K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen, + * A Software-Defined GPS and Galileo Receiver. A Single-Frequency + * Approach, Birkhauser, 2007 + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + +#include "gps_l2_m_dll_pll_tracking_cc.h" +#include +#include +#include +#include +#include +#include +#include +#include "gnss_synchro.h" +#include "gps_l2c_signal.h" +#include "tracking_discriminators.h" +#include "lock_detectors.h" +#include "GPS_L2C.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; + +gps_l2_m_dll_pll_tracking_cc_sptr +gps_l2_m_dll_pll_make_tracking_cc( + long if_freq, + long fs_in, + unsigned int vector_length, + boost::shared_ptr queue, + bool dump, + std::string dump_filename, + float pll_bw_hz, + float dll_bw_hz, + float early_late_space_chips) +{ + return gps_l2_m_dll_pll_tracking_cc_sptr(new gps_l2_m_dll_pll_tracking_cc(if_freq, + fs_in, vector_length, queue, dump, dump_filename, pll_bw_hz, dll_bw_hz, early_late_space_chips)); +} + + + +void gps_l2_m_dll_pll_tracking_cc::forecast (int noutput_items, + gr_vector_int &ninput_items_required) +{ + ninput_items_required[0] = static_cast(d_vector_length) * 2; //set the required available samples in each call +} + + + +gps_l2_m_dll_pll_tracking_cc::gps_l2_m_dll_pll_tracking_cc( + long if_freq, + long fs_in, + unsigned int vector_length, + boost::shared_ptr queue, + bool dump, + std::string dump_filename, + float pll_bw_hz, + float dll_bw_hz, + float early_late_space_chips) : + gr::block("gps_l2_m_dll_pll_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)), + gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) +{ + // 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; + + // DLL/PLL filter initialization + d_carrier_loop_filter=Tracking_2nd_PLL_filter(GPS_L2_M_PERIOD); + d_code_loop_filter=Tracking_2nd_DLL_filter(GPS_L2_M_PERIOD); + + // Initialize tracking ========================================== + d_code_loop_filter.set_DLL_BW(dll_bw_hz); + d_carrier_loop_filter.set_PLL_BW(pll_bw_hz); + + //--- DLL variables -------------------------------------------------------- + d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips) + + // Initialization of local code replica + // Get space for a vector with the C/A code replica sampled 1x/chip + d_ca_code = static_cast(volk_malloc((GPS_L2_M_CODE_LENGTH_CHIPS + 2) * sizeof(gr_complex), volk_get_alignment())); + + // Get space for the resampled early / prompt / late local replicas + d_early_code = static_cast(volk_malloc(2 * d_vector_length * sizeof(gr_complex), volk_get_alignment())); + d_prompt_code = static_cast(volk_malloc(2 * d_vector_length * sizeof(gr_complex), volk_get_alignment())); + d_late_code = static_cast(volk_malloc(2 * d_vector_length * sizeof(gr_complex), volk_get_alignment())); + + // space for carrier wipeoff and signal baseband vectors + d_carr_sign = static_cast(volk_malloc(2 * d_vector_length * sizeof(gr_complex), volk_get_alignment())); + + // correlator outputs (scalar) + d_Early = static_cast(volk_malloc(sizeof(gr_complex), volk_get_alignment())); + d_Prompt = static_cast(volk_malloc(sizeof(gr_complex), volk_get_alignment())); + d_Late = static_cast(volk_malloc(sizeof(gr_complex), volk_get_alignment())); + + + //--- Perform initializations ------------------------------ + // define initial code frequency basis of NCO + d_code_freq_chips = GPS_L2_M_CODE_RATE_HZ; + // define residual code phase (in chips) + d_rem_code_phase_samples = 0.0; + // define residual carrier phase + d_rem_carr_phase_rad = 0.0; + + // sample synchronization + d_sample_counter = 0; + //d_sample_counter_seconds = 0; + d_acq_sample_stamp = 0; + + d_enable_tracking = false; + d_pull_in = false; + d_last_seg = 0; + + d_current_prn_length_samples = static_cast(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"); + + set_relative_rate(1.0/((double)d_vector_length*2)); + //set_min_output_buffer((long int)300); + + LOG(INFO)<<"d_vector_length"<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 = static_cast(d_sample_counter) - static_cast(d_acq_sample_stamp);//-d_vector_length; + LOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples; + acq_trk_diff_seconds = static_cast(acq_trk_diff_samples) / static_cast(d_fs_in); + //doppler effect + // Fd=(C/(C+Vr))*F + float radial_velocity = (GPS_L2_FREQ_HZ + d_acq_carrier_doppler_hz) / GPS_L2_FREQ_HZ; + // new chip and prn sequence periods based on acq Doppler + float T_chip_mod_seconds; + float T_prn_mod_seconds; + float T_prn_mod_samples; + d_code_freq_chips = radial_velocity * GPS_L2_M_CODE_RATE_HZ; + T_chip_mod_seconds = 1/d_code_freq_chips; + T_prn_mod_seconds = T_chip_mod_seconds * GPS_L2_M_CODE_LENGTH_CHIPS; + T_prn_mod_samples = T_prn_mod_seconds * static_cast(d_fs_in); + + d_current_prn_length_samples = round(T_prn_mod_samples); + + float T_prn_true_seconds = GPS_L2_M_CODE_LENGTH_CHIPS / GPS_L2_M_CODE_RATE_HZ; + float T_prn_true_samples = T_prn_true_seconds * static_cast(d_fs_in); + float T_prn_diff_seconds= T_prn_true_seconds - T_prn_mod_seconds; + float 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 * static_cast(d_fs_in)), T_prn_true_samples); + if (corrected_acq_phase_samples < 0) + { + corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples; + } + delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples; + + d_acq_code_phase_samples = corrected_acq_phase_samples; + + d_carrier_doppler_hz = d_acq_carrier_doppler_hz; + + // DLL/PLL filter initialization + d_carrier_loop_filter.initialize(); // initialize the carrier filter + d_code_loop_filter.initialize(); // initialize the code filter + + // generate local reference ALWAYS starting at chip 1 (1 sample per chip) + gps_l2c_m_code_gen_complex(&d_ca_code[1], d_acquisition_gnss_synchro->PRN); + d_ca_code[0] = d_ca_code[static_cast(GPS_L2_M_CODE_LENGTH_CHIPS)]; + d_ca_code[static_cast(GPS_L2_M_CODE_LENGTH_CHIPS) + 1] = d_ca_code[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_pull_in = true; + d_enable_tracking = true; + + LOG(INFO) << "PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz + << " Code Phase correction [samples]=" << delay_correction_samples + << " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples; +} + + + + + +void gps_l2_m_dll_pll_tracking_cc::update_local_code() +{ + double tcode_chips; + double rem_code_phase_chips; + int associated_chip_index; + int code_length_chips = static_cast(GPS_L2_M_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 = static_cast(d_code_freq_chips) / static_cast(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)); + d_early_code[i] = d_ca_code[associated_chip_index]; + 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 gps_l2_m_dll_pll_tracking_cc::update_local_carrier() +{ + float phase_rad, phase_step_rad; + + phase_step_rad = static_cast(GPS_TWO_PI) * d_carrier_doppler_hz / static_cast(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; + } + //d_rem_carr_phase_rad = fmod(phase_rad, GPS_TWO_PI); + //d_acc_carrier_phase_rad = d_acc_carrier_phase_rad + d_rem_carr_phase_rad; +} + + + + +gps_l2_m_dll_pll_tracking_cc::~gps_l2_m_dll_pll_tracking_cc() +{ + d_dump_file.close(); + + volk_free(d_prompt_code); + volk_free(d_late_code); + volk_free(d_early_code); + volk_free(d_carr_sign); + volk_free(d_Early); + volk_free(d_Prompt); + volk_free(d_Late); + volk_free(d_ca_code); + + delete[] d_Prompt_buffer; +} + + + +int gps_l2_m_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 current_synchro_data; + + // Block input data and block output stream pointers + const gr_complex* in = (gr_complex*) input_items[0]; //PRN start block alignment + Gnss_Synchro **out = (Gnss_Synchro **) &output_items[0]; + + if (d_enable_tracking == true) + { + // Receiver signal alignment + if (d_pull_in == true) + { + 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(static_cast(acq_to_trk_delay_samples), static_cast(d_current_prn_length_samples)); + samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples); + // /todo: Check if the sample counter sent to the next block as a time reference should be incremented AFTER sended or BEFORE + //d_sample_counter_seconds = d_sample_counter_seconds + (((double)samples_offset) / static_cast(d_fs_in)); + d_sample_counter = d_sample_counter + samples_offset; //count for the processed samples + d_pull_in = false; + //std::cout<<" samples_offset="<(d_sample_counter) / static_cast(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; + current_synchro_data.Flag_valid_pseudorange = false; + + *out[0] = current_synchro_data; + + return 1; + } + + // ################## PLL ########################################################## + // PLL discriminator + carr_error_hz = pll_cloop_two_quadrant_atan(*d_Prompt) / static_cast(GPS_TWO_PI); + // Carrier discriminator filter + carr_error_filt_hz = d_carrier_loop_filter.get_carrier_nco(carr_error_hz); + // New carrier Doppler frequency estimation + d_carrier_doppler_hz = d_acq_carrier_doppler_hz + carr_error_filt_hz; + // New code Doppler frequency estimation + d_code_freq_chips = GPS_L2_M_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L2_M_CODE_RATE_HZ) / GPS_L2_FREQ_HZ); + //carrier phase accumulator for (K) doppler estimation + d_acc_carrier_phase_rad = d_acc_carrier_phase_rad + GPS_TWO_PI * d_carrier_doppler_hz * GPS_L2_M_PERIOD; + //remanent carrier phase to prevent overflow in the code NCO + d_rem_carr_phase_rad = d_rem_carr_phase_rad + GPS_TWO_PI * d_carrier_doppler_hz * GPS_L2_M_PERIOD; + d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, GPS_TWO_PI); + + // ################## DLL ########################################################## + // DLL discriminator + code_error_chips = dll_nc_e_minus_l_normalized(*d_Early, *d_Late); //[chips/Ti] + // Code discriminator filter + code_error_filt_chips = d_code_loop_filter.get_code_nco(code_error_chips); //[chips/second] + //Code phase accumulator + float code_error_filt_secs; + code_error_filt_secs = (GPS_L2_M_PERIOD * code_error_filt_chips) / GPS_L2_M_CODE_RATE_HZ; //[seconds] + d_acc_code_phase_secs = d_acc_code_phase_secs + code_error_filt_secs; + + // ################## CARRIER AND CODE NCO BUFFER ALIGNEMENT ####################### + // keep alignment parameters for the next input buffer + double T_chip_seconds; + double T_prn_seconds; + double T_prn_samples; + double K_blk_samples; + // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation + T_chip_seconds = 1 / static_cast(d_code_freq_chips); + T_prn_seconds = T_chip_seconds * GPS_L2_M_CODE_LENGTH_CHIPS; + T_prn_samples = T_prn_seconds * static_cast(d_fs_in); + K_blk_samples = T_prn_samples + d_rem_code_phase_samples + code_error_filt_secs * static_cast(d_fs_in); + d_current_prn_length_samples = round(K_blk_samples); //round to a discrete samples + //d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample + + // ####### CN0 ESTIMATION AND LOCK DETECTORS ###### + if (d_cn0_estimation_counter < CN0_ESTIMATION_SAMPLES) + { + // fill buffer with prompt correlator output values + d_Prompt_buffer[d_cn0_estimation_counter] = *d_Prompt; + d_cn0_estimation_counter++; + } + else + { + d_cn0_estimation_counter = 0; + // Code lock indicator + d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES, d_fs_in, GPS_L2_M_CODE_LENGTH_CHIPS); + // Carrier lock indicator + d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES); + // Loss of lock detection + if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < MINIMUM_VALID_CN0) + { + d_carrier_lock_fail_counter++; + } + else + { + if (d_carrier_lock_fail_counter > 0) d_carrier_lock_fail_counter--; + } + if (d_carrier_lock_fail_counter > MAXIMUM_LOCK_FAIL_COUNTER) + { + std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl; + LOG(INFO) << "Loss of lock in channel " << d_channel << "!"; + std::unique_ptr cmf(new ControlMessageFactory()); + if (d_queue != gr::msg_queue::sptr()) + { + d_queue->handle(cmf->GetQueueMessage(d_channel, 2)); + } + d_carrier_lock_fail_counter = 0; + d_enable_tracking = false; // TODO: check if disabling tracking is consistent with the channel state machine + } + } + // ########### Output the tracking data to navigation and PVT ########## + current_synchro_data.Prompt_I = static_cast((*d_Prompt).real()); + current_synchro_data.Prompt_Q = static_cast((*d_Prompt).imag()); + + // Tracking_timestamp_secs is aligned with the NEXT PRN start sample (Hybridization problem!) + //compute remnant code phase samples BEFORE the Tracking timestamp + //d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample + //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter + (double)d_current_prn_length_samples + (double)d_rem_code_phase_samples)/static_cast(d_fs_in); + + // Tracking_timestamp_secs is aligned with the CURRENT PRN start sample (Hybridization OK!, but some glitches??) + current_synchro_data.Tracking_timestamp_secs = (static_cast(d_sample_counter) + static_cast(d_rem_code_phase_samples)) / static_cast(d_fs_in); + //compute remnant code phase samples AFTER the Tracking timestamp + d_rem_code_phase_samples = K_blk_samples - d_current_prn_length_samples; //rounding error < 1 sample + + //current_synchro_data.Tracking_timestamp_secs = ((double)d_sample_counter)/static_cast(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 = static_cast(d_acc_carrier_phase_rad); + current_synchro_data.Carrier_Doppler_hz = static_cast(d_carrier_doppler_hz); + current_synchro_data.CN0_dB_hz = static_cast(d_CN0_SNV_dB_Hz); + current_synchro_data.Flag_valid_pseudorange = false; + *out[0] = current_synchro_data; + + // ########## DEBUG OUTPUT + /*! + * \todo The stop timer has to be moved to the signal source! + */ + // debug: Second counter in channel 0 + if (d_channel == 0) + { + if (floor(d_sample_counter / d_fs_in) != d_last_seg) + { + d_last_seg = floor(d_sample_counter / d_fs_in); + std::cout << "Current input signal time = " << d_last_seg << " [s]" << std::endl; + std::cout << "GPS L2C M Tracking CH " << d_channel << ": Satellite " + << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) << ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]"<< std::endl; + //if (d_last_seg==5) d_carrier_lock_fail_counter=500; //DEBUG: force unlock! + } + } + else + { + if (floor(d_sample_counter / d_fs_in) != d_last_seg) + { + d_last_seg = floor(d_sample_counter / d_fs_in); + std::cout << "GPS L2C M Tracking CH " << d_channel << ": Satellite " + << Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN) + << ", CN0 = " << d_CN0_SNV_dB_Hz << " [dB-Hz]"<(*d_Early); + tmp_P = std::abs(*d_Prompt); + tmp_L = std::abs(*d_Late); + try + { + // EPR + d_dump_file.write(reinterpret_cast(&tmp_E), sizeof(float)); + d_dump_file.write(reinterpret_cast(&tmp_P), sizeof(float)); + d_dump_file.write(reinterpret_cast(&tmp_L), sizeof(float)); + // PROMPT I and Q (to analyze navigation symbols) + d_dump_file.write(reinterpret_cast(&prompt_I), sizeof(float)); + d_dump_file.write(reinterpret_cast(&prompt_Q), sizeof(float)); + // PRN start sample stamp + //tmp_float=(float)d_sample_counter; + d_dump_file.write(reinterpret_cast(&d_sample_counter), sizeof(unsigned long int)); + // accumulated carrier phase + d_dump_file.write(reinterpret_cast(&d_acc_carrier_phase_rad), sizeof(float)); + + // carrier and code frequency + d_dump_file.write(reinterpret_cast(&d_carrier_doppler_hz), sizeof(float)); + d_dump_file.write(reinterpret_cast(&d_code_freq_chips), sizeof(float)); + + //PLL commands + d_dump_file.write(reinterpret_cast(&carr_error_hz), sizeof(float)); + d_dump_file.write(reinterpret_cast(&carr_error_filt_hz), sizeof(float)); + + //DLL commands + d_dump_file.write(reinterpret_cast(&code_error_chips), sizeof(float)); + d_dump_file.write(reinterpret_cast(&code_error_filt_chips), sizeof(float)); + + // CN0 and carrier lock test + d_dump_file.write(reinterpret_cast(&d_CN0_SNV_dB_Hz), sizeof(float)); + d_dump_file.write(reinterpret_cast(&d_carrier_lock_test), sizeof(float)); + + // AUX vars (for debug purposes) + tmp_float = d_rem_code_phase_samples; + d_dump_file.write(reinterpret_cast(&tmp_float), sizeof(float)); + tmp_double = static_cast(d_sample_counter + d_current_prn_length_samples); + d_dump_file.write(reinterpret_cast(&tmp_double), sizeof(double)); + } + catch (std::ifstream::failure e) + { + LOG(WARNING) << "Exception writing trk dump file " << e.what(); + } + } + consume_each(d_current_prn_length_samples); // this is necessary in gr::block derivates + d_sample_counter += d_current_prn_length_samples; //count for the processed samples + //LOG(INFO)<<"GPS L2 tracking output end on CH="<d_channel << " SAMPLE STAMP="<(d_channel)); + d_dump_filename.append(".dat"); + d_dump_file.exceptions (std::ifstream::failbit | std::ifstream::badbit); + d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary); + LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << d_dump_filename.c_str() << std::endl; + } + catch (std::ifstream::failure e) + { + LOG(WARNING) << "channel " << d_channel << " Exception opening trk dump file " << e.what() << std::endl; + } + } + } +} + + + +void gps_l2_m_dll_pll_tracking_cc::set_channel_queue(concurrent_queue *channel_internal_queue) +{ + d_channel_internal_queue = channel_internal_queue; +} + + +void gps_l2_m_dll_pll_tracking_cc::set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) +{ + d_acquisition_gnss_synchro = p_gnss_synchro; +} diff --git a/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.h b/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.h new file mode 100644 index 000000000..8432685b9 --- /dev/null +++ b/src/algorithms/tracking/gnuradio_blocks/gps_l2_m_dll_pll_tracking_cc.h @@ -0,0 +1,187 @@ +/*! + * \file gps_l2_m_dll_pll_tracking_cc.h + * \brief Interface of a code DLL + carrier PLL tracking block + * \author Javier Arribas, 2015. jarribas(at)cttc.es + * + * Code DLL + carrier PLL according to the algorithms described in: + * K.Borre, D.M.Akos, N.Bertelsen, P.Rinder, and S.H.Jensen, + * A Software-Defined GPS and Galileo Receiver. A Single-Frequency Approach, + * Birkhauser, 2007 + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + +#ifndef GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H +#define GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H + +#include +#include +#include +#include +#include +#include +#include +#include +#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 gps_l2_m_dll_pll_tracking_cc; + +typedef boost::shared_ptr + gps_l2_m_dll_pll_tracking_cc_sptr; + +gps_l2_m_dll_pll_tracking_cc_sptr +gps_l2_m_dll_pll_make_tracking_cc(long if_freq, + long fs_in, unsigned + int vector_length, + boost::shared_ptr queue, + bool dump, + std::string dump_filename, + float pll_bw_hz, + float dll_bw_hz, + float early_late_space_chips); + + + +/*! + * \brief This class implements a DLL + PLL tracking loop block + */ +class gps_l2_m_dll_pll_tracking_cc: public gr::block +{ +public: + ~gps_l2_m_dll_pll_tracking_cc(); + + void set_channel(unsigned int channel); + void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro); + void start_tracking(); + void set_channel_queue(concurrent_queue *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 gps_l2_m_dll_pll_tracking_cc_sptr + gps_l2_m_dll_pll_make_tracking_cc(long if_freq, + long fs_in, unsigned + int vector_length, + boost::shared_ptr queue, + bool dump, + std::string dump_filename, + float pll_bw_hz, + float dll_bw_hz, + float early_late_space_chips); + + gps_l2_m_dll_pll_tracking_cc(long if_freq, + long fs_in, unsigned + int vector_length, + boost::shared_ptr queue, + bool dump, + std::string dump_filename, + float pll_bw_hz, + float dll_bw_hz, + float early_late_space_chips); + void update_local_code(); + void update_local_carrier(); + + // tracking configuration vars + boost::shared_ptr d_queue; + concurrent_queue *d_channel_internal_queue; + unsigned int d_vector_length; + 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; + + gr_complex* d_ca_code; + + gr_complex* d_early_code; + gr_complex* d_late_code; + gr_complex* d_prompt_code; + gr_complex* d_carr_sign; + + gr_complex *d_Early; + gr_complex *d_Prompt; + gr_complex *d_Late; + + // remaining code phase and carrier phase between tracking loops + double 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 + double 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; + + //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 + bool d_enable_tracking; + bool d_pull_in; + + // file dump + std::string d_dump_filename; + std::ofstream d_dump_file; + + std::map systemName; + std::string sys; +}; + +#endif //GNSS_SDR_GPS_L2_M_DLL_PLL_TRACKING_CC_H diff --git a/src/core/receiver/gnss_block_factory.cc b/src/core/receiver/gnss_block_factory.cc index e31d4c227..973665092 100644 --- a/src/core/receiver/gnss_block_factory.cc +++ b/src/core/receiver/gnss_block_factory.cc @@ -62,6 +62,7 @@ #include "freq_xlating_fir_filter.h" #include "beamformer_filter.h" #include "gps_l1_ca_pcps_acquisition.h" +#include "gps_l2_m_pcps_acquisition.h" #include "gps_l1_ca_pcps_multithread_acquisition.h" #include "gps_l1_ca_pcps_tong_acquisition.h" #include "gps_l1_ca_pcps_assisted_acquisition.h" @@ -81,7 +82,9 @@ #include "galileo_volk_e1_dll_pll_veml_tracking.h" #include "galileo_e1_tcp_connector_tracking.h" #include "galileo_e5a_dll_pll_tracking.h" +#include "gps_l2_m_dll_pll_tracking.h" #include "gps_l1_ca_telemetry_decoder.h" +#include "gps_l2_m_telemetry_decoder.h" #include "galileo_e1b_telemetry_decoder.h" #include "galileo_e5a_telemetry_decoder.h" #include "sbas_l1_telemetry_decoder.h" @@ -254,16 +257,15 @@ std::unique_ptr GNSSBlockFactory::GetChannel_GPS( std::string acq, std::string trk, std::string tlm, int channel, boost::shared_ptr queue) { - std::stringstream stream; - stream << channel; - std::string id = stream.str(); - LOG(INFO) << "Instantiating Channel " << id << " with Acquisition Implementation: " + + LOG(INFO) << "Instantiating Channel " << channel << " with Acquisition Implementation: " << acq << ", Tracking Implementation: " << trk << ", Telemetry Decoder implementation: " << tlm; std::unique_ptr pass_through_ = GetBlock(configuration, "Channel", "Pass_Through", 1, 1, queue); std::unique_ptr acq_ = GetAcqBlock(configuration, "Acquisition_GPS", acq, 1, 1, queue); - std::unique_ptr trk_ = GetTrkBlock(configuration, "Tracking_GPS", trk, 1, 1, queue); - std::unique_ptr tlm_ = GetTlmBlock(configuration, "TelemetryDecoder_GPS", tlm, 1, 1, queue); + std::unique_ptr trk_ = GetTrkBlock(configuration, "Tracking_GPS" +boost::lexical_cast(channel), trk, 1, 1, queue); + + std::unique_ptr tlm_ = GetTlmBlock(configuration, "TelemetryDecoder_GPS"+boost::lexical_cast(channel) , tlm, 1, 1, queue); std::unique_ptr channel_(new Channel(configuration.get(), channel, pass_through_.release(), acq_.release(), @@ -276,7 +278,7 @@ std::unique_ptr GNSSBlockFactory::GetChannel_GPS( -//********* GPS CHANNEL ***************** +//********* GPS L1 C/A CHANNEL ***************** std::unique_ptr GNSSBlockFactory::GetChannel_1C( std::shared_ptr configuration, std::string acq, std::string trk, std::string tlm, int channel, @@ -362,7 +364,7 @@ std::unique_ptr>> GNSSBlockFacto { std::string default_implementation = "Pass_Through"; unsigned int channel_count; - std::string tracking; + std::string tracking_implementation; std::string telemetry_decoder; std::string acquisition_implementation; @@ -379,7 +381,7 @@ std::unique_ptr>> GNSSBlockFacto LOG(INFO) << "Getting " << channel_count << " GPS L1 C/A channels"; - tracking = configuration->property("Tracking_GPS.implementation", default_implementation); + tracking_implementation = configuration->property("Tracking_GPS.implementation", default_implementation); if (default_implementation.compare(tracking) == 0) { tracking = configuration->property("Tracking_1C.implementation", default_implementation); @@ -399,6 +401,8 @@ std::unique_ptr>> GNSSBlockFacto for (unsigned int i = 0; i < channel_count; i++) { + // Search for specific implementation of that particular channel in config file + //(i.e. Acquisition_GPS0.implementation=xxxx) std::string acquisition_implementation_specific = configuration->property( "Acquisition_GPS" + boost::lexical_cast(i) + ".implementation", default_implementation); @@ -407,6 +411,22 @@ std::unique_ptr>> GNSSBlockFacto acquisition_implementation = acquisition_implementation_specific; } + std::string tracking_implementation_specific = configuration->property( + "Tracking_GPS" + boost::lexical_cast(i) + ".implementation", + default_implementation); + if(tracking_implementation_specific.compare(default_implementation) != 0) + { + tracking_implementation = tracking_implementation_specific; + } + + std::string telemetry_decoder_implementation_specific = configuration->property( + "TelemetryDecoder_GPS" + boost::lexical_cast(i) + ".implementation", + default_implementation); + if(telemetry_decoder_implementation_specific.compare(default_implementation) != 0) + { + telemetry_decoder = telemetry_decoder_implementation_specific; + } + acquisition_implementation_specific = configuration->property( "Acquisition_1C" + boost::lexical_cast(i) + ".implementation", default_implementation); @@ -416,7 +436,7 @@ std::unique_ptr>> GNSSBlockFacto } channels->push_back(std::move(GetChannel_1C(configuration, - acquisition_implementation, tracking, telemetry_decoder, channel_absolute_id, queue))); + acquisition_implementation, tracking_implementation, telemetry_decoder, channel_absolute_id, queue))); channel_absolute_id++; } @@ -429,7 +449,7 @@ std::unique_ptr>> GNSSBlockFacto LOG(INFO) << "Getting " << channel_count << " Galileo E1B channels"; - tracking = configuration->property("Tracking_Galileo.implementation", default_implementation); + tracking_implementation = configuration->property("Tracking_Galileo.implementation", default_implementation); if (default_implementation.compare(tracking) == 0) { tracking = configuration->property("Tracking_1B.implementation", default_implementation); @@ -449,6 +469,8 @@ std::unique_ptr>> GNSSBlockFacto for (unsigned int i = 0; i < channel_count; i++) { + // Search for specific implementation of that particular channel in config file + //(i.e. Acquisition_Galileo0.implementation=xxxx) std::string acquisition_implementation_specific = configuration->property( "Acquisition_Galileo" + boost::lexical_cast(i) + ".implementation", default_implementation); @@ -457,6 +479,16 @@ std::unique_ptr>> GNSSBlockFacto acquisition_implementation = acquisition_implementation_specific; } + std::string tracking_implementation_specific = configuration->property( + "Tracking_Galileo" + boost::lexical_cast(i) + ".implementation", + default_implementation); + if(tracking_implementation_specific.compare(default_implementation) != 0) + { + tracking_implementation = tracking_implementation_specific; + } + + + acquisition_implementation_specific = configuration->property( "Acquisition_1B" + boost::lexical_cast(i) + ".implementation", default_implementation); @@ -465,7 +497,7 @@ std::unique_ptr>> GNSSBlockFacto acquisition_implementation = acquisition_implementation_specific; } channels->push_back(std::move(GetChannel_1B(configuration, - acquisition_implementation, tracking, telemetry_decoder, channel_absolute_id, queue))); + acquisition_implementation, tracking_implementation, telemetry_decoder, channel_absolute_id, queue))); channel_absolute_id++; } return channels; @@ -934,6 +966,12 @@ std::unique_ptr GNSSBlockFactory::GetAcqBlock( out_streams, queue)); block = std::move(block_); } + else if (implementation.compare("GPS_L2_M_PCPS_Acquisition") == 0) + { + std::unique_ptr block_(new GpsL2MPcpsAcquisition(configuration.get(), role, in_streams, + out_streams, queue)); + block = std::move(block_); + } else if (implementation.compare("Galileo_E1_PCPS_Ambiguous_Acquisition") == 0) { std::unique_ptr block_(new GalileoE1PcpsAmbiguousAcquisition(configuration.get(), role, in_streams, @@ -1043,7 +1081,12 @@ std::unique_ptr GNSSBlockFactory::GetTrkBlock( out_streams, queue)); block = std::move(block_); } - + else if (implementation.compare("GPS_L2_M_DLL_PLL_Tracking") == 0) + { + std::unique_ptr block_(new GpsL2MDllPllTracking(configuration.get(), role, in_streams, + out_streams, queue)); + block = std::move(block_); + } else { // Log fatal. This causes execution to stop. @@ -1061,6 +1104,7 @@ std::unique_ptr GNSSBlockFactory::GetTlmBlock( { std::unique_ptr block; + std::cout<<"implementation tlm="< GNSSBlockFactory::GetTlmBlock( out_streams, queue)); block = std::move(block_); } + else if (implementation.compare("GPS_L2_M_Telemetry_Decoder") == 0) + { + std::unique_ptr block_(new GpsL2MTelemetryDecoder(configuration.get(), role, in_streams, + out_streams, queue)); + block = std::move(block_); + } else { // Log fatal. This causes execution to stop. diff --git a/src/core/receiver/gnss_block_factory.h b/src/core/receiver/gnss_block_factory.h index 608067b84..f4b4afcd9 100644 --- a/src/core/receiver/gnss_block_factory.h +++ b/src/core/receiver/gnss_block_factory.h @@ -80,6 +80,10 @@ public: std::string acq, std::string trk, std::string tlm, int channel, boost::shared_ptr queue); + std::unique_ptr GetChannel_2S(std::shared_ptr configuration, + std::string acq, std::string trk, std::string tlm, int channel, + boost::shared_ptr queue); + //DEPRECATED std::unique_ptr GetChannel_Galileo(std::shared_ptr configuration, std::string acq, std::string trk, std::string tlm, int channel, diff --git a/src/core/receiver/gnss_flowgraph.cc b/src/core/receiver/gnss_flowgraph.cc index 704479b1e..f6e177160 100644 --- a/src/core/receiver/gnss_flowgraph.cc +++ b/src/core/receiver/gnss_flowgraph.cc @@ -227,25 +227,30 @@ void GNSSFlowgraph::connect() for (int j = 0; j < RF_Channels; j++) { //Connect the multichannel signal source to multiple signal conditioners - // check number of signal source output ports todo! - if (sig_source_.at(i)->get_right_block()->input_signature()->max_streams() > 1) + // GNURADIO max_streams=-1 means infinite ports! + LOG(WARNING)<<"sig_source_.at(i)->get_right_block()->output_signature()->max_streams()="<get_right_block()->output_signature()->max_streams(); + LOG(WARNING)<<"sig_conditioner_.at(signal_conditioner_ID)->get_left_block()->input_signature()="<get_left_block()->input_signature()->max_streams(); + + if (sig_source_.at(i)->get_right_block()->output_signature()->max_streams() > 1) { + + LOG(WARNING)<<"connecting sig_source_ "<connect(sig_source_.at(i)->get_right_block(), j, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0); - //std::cout<<"connect sig_source_ "<connect(sig_source_.at(i)->get_right_block(), 0, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0); - //std::cout<<"connect sig_source_ "<connect(sig_source_.at(i)->get_right_block(j), 0, sig_conditioner_.at(signal_conditioner_ID)->get_left_block(), 0); - //std::cout<<"connect sig_source_ "<property("Channel.system", std::string("GPS")); + std::string default_signal = configuration_->property("Channel.signal", std::string("1C")); + std::string gnss_system = (configuration_->property("Channel" + + boost::lexical_cast(i) + ".system", + default_system)); + std::string gnss_signal = (configuration_->property("Channel" + + boost::lexical_cast(i) + ".signal", + default_signal)); //TODO: add a specific string member to the channel template, and not re-use the implementation field! - while (channels_.at(i)->implementation() != available_GNSS_signals_.front().get_satellite().get_system()) + while (channels_.at(i)->implementation() != available_GNSS_signals_.front().get_satellite().get_system() + or gnss_signal != available_GNSS_signals_.front().get_signal() ) { available_GNSS_signals_.push_back(available_GNSS_signals_.front()); available_GNSS_signals_.pop_front(); @@ -388,10 +402,12 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what) switch (what) { case 0: - LOG(INFO) << "Channel " << who << " ACQ FAILED satellite " << channels_.at(who)->get_signal().get_satellite(); + LOG(INFO) << "Channel " << who << " ACQ FAILED satellite " << channels_.at(who)->get_signal().get_satellite()<<", Signal " << channels_.at(who)->get_signal().get_signal(); available_GNSS_signals_.push_back(channels_.at(who)->get_signal()); - while (channels_.at(who)->get_signal().get_satellite().get_system() != available_GNSS_signals_.front().get_satellite().get_system()) + //TODO: Optimize the channel and signal matching! + while (channels_.at(who)->get_signal().get_satellite().get_system() != available_GNSS_signals_.front().get_satellite().get_system() + or channels_.at(who)->get_signal().get_signal() != available_GNSS_signals_.front().get_signal() ) { available_GNSS_signals_.push_back(available_GNSS_signals_.front()); available_GNSS_signals_.pop_front(); @@ -587,6 +603,24 @@ void GNSSFlowgraph::set_signals_list() } } + if (default_system.find(std::string("GPS L2C M")) != std::string::npos ) + { + /* + * Loop to create GPS L2C M signals + */ + std::set available_gps_prn = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, + 29, 30, 31, 32 }; + + for (available_gnss_prn_iter = available_gps_prn.begin(); + available_gnss_prn_iter != available_gps_prn.end(); + available_gnss_prn_iter++) + { + available_GNSS_signals_.push_back(Gnss_Signal(Gnss_Satellite(std::string("GPS"), + *available_gnss_prn_iter), std::string("2S"))); + } + } + if (default_system.find(std::string("SBAS")) != std::string::npos) { @@ -657,19 +691,20 @@ void GNSSFlowgraph::set_signals_list() available_GNSS_signals_.remove(signal_value); available_GNSS_signals_.insert(gnss_it, signal_value); } + } // **** FOR DEBUGGING THE LIST OF GNSS SIGNALS **** - // std::cout<<"default_system="<. + * + * ------------------------------------------------------------------------- + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "gnss_block_factory.h" +#include "gnss_block_interface.h" +#include "tracking_interface.h" +#include "in_memory_configuration.h" +#include "gnss_sdr_valve.h" +#include "gnss_synchro.h" +#include "gps_l2_m_dll_pll_tracking.h" + + +class GpsL2MDllPllTrackingTest: public ::testing::Test +{ +protected: + GpsL2MDllPllTrackingTest() + { + factory = std::make_shared(); + config = std::make_shared(); + item_size = sizeof(gr_complex); + stop = false; + message = 0; + } + + ~GpsL2MDllPllTrackingTest() + {} + + void init(); + + gr::msg_queue::sptr queue; + gr::top_block_sptr top_block; + std::shared_ptr factory; + std::shared_ptr config; + Gnss_Synchro gnss_synchro; + size_t item_size; + concurrent_queue channel_internal_queue; + bool stop; + int message; +}; + + +void GpsL2MDllPllTrackingTest::init() +{ + gnss_synchro.Channel_ID = 0; + gnss_synchro.System = 'G'; + std::string signal = "2S"; + signal.copy(gnss_synchro.Signal, 2, 0); + gnss_synchro.PRN = 7; + + config->set_property("GNSS-SDR.internal_fs_hz", "5000000"); + config->set_property("Tracking_GPS.item_type", "gr_complex"); + config->set_property("Tracking_GPS.dump", "true"); + config->set_property("Tracking_GPS.dump_filename", "../data/L2m_tracking_ch_"); + config->set_property("Tracking_GPS.implementation", "GPS_L2_M_DLL_PLL_Tracking"); + config->set_property("Tracking_GPS.early_late_space_chips", "0.5"); + config->set_property("Tracking_GPS.order", "2"); + config->set_property("Tracking_GPS.pll_bw_hz", "2"); + config->set_property("Tracking_GPS.dll_bw_hz", "0.5"); +} + +TEST_F(GpsL2MDllPllTrackingTest, ValidationOfResults) +{ + struct timeval tv; + long long int begin = 0; + long long int end = 0; + int fs_in = 5000000; + int nsamples = fs_in*9; + init(); + queue = gr::msg_queue::make(0); + top_block = gr::make_top_block("Tracking test"); + + std::shared_ptr tracking = std::make_shared(config.get(), "Tracking_GPS", 1, 1, queue); + + //REAL + gnss_synchro.Acq_delay_samples = 1; + gnss_synchro.Acq_doppler_hz = 1200;//1200; + 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( { + //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)); + + + std::string path = std::string(TEST_PATH); + //std::string file = path + "signal_samples/GSoC_CTTC_capture_2012_07_26_4Msps_4ms.dat"; + //std::string file = "/datalogger/signals/Fraunhofer/L125_III1b_210s_L2_resampled.bin"; + std::string file = path + "/data/gps_l2c_m_prn7_5msps.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); + + + boost::shared_ptr 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(file_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 << "Tracked " << nsamples << " samples in " << (end - begin) << " microseconds" << std::endl; +} + diff --git a/src/tests/gnss_block/gps_l2_m_pcps_acquisition_test.cc b/src/tests/gnss_block/gps_l2_m_pcps_acquisition_test.cc new file mode 100644 index 000000000..56e4e7e3d --- /dev/null +++ b/src/tests/gnss_block/gps_l2_m_pcps_acquisition_test.cc @@ -0,0 +1,275 @@ +/*! + * \file gps_l1_ca_pcps_acquisition_test.cc + * \brief This class implements an acquisition test for + * GpsL1CaPcpsAcquisition class based on some input parameters. + * \author Javier Arribas, 2015 (jarribas@cttc.es) + * + * + * ------------------------------------------------------------------------- + * + * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) + * + * GNSS-SDR is a software defined Global Navigation + * Satellite Systems receiver + * + * This file is part of GNSS-SDR. + * + * GNSS-SDR is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GNSS-SDR is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNSS-SDR. If not, see . + * + * ------------------------------------------------------------------------- + */ + + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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 "gps_l2_m_pcps_acquisition.h" +#include "GPS_L2C.h" + + +class GpsL2MPcpsAcquisitionTest: public ::testing::Test +{ +protected: + GpsL2MPcpsAcquisitionTest() + { + //queue = gr::msg_queue::make(0); + factory = std::make_shared(); + config = std::make_shared(); + item_size = sizeof(gr_complex); + stop = false; + message = 0; + sampling_freqeuncy_hz = 0; + nsamples=0; + } + + ~GpsL2MPcpsAcquisitionTest() + {} + + void init(); + void start_queue(); + void wait_message(); + void stop_queue(); + + gr::msg_queue::sptr queue; + gr::top_block_sptr top_block; + std::shared_ptr factory; + std::shared_ptr config; + Gnss_Synchro gnss_synchro; + size_t item_size; + concurrent_queue channel_internal_queue; + bool stop; + int message; + boost::thread ch_thread; + + int sampling_freqeuncy_hz; + int nsamples; +}; + + +void GpsL2MPcpsAcquisitionTest::init() +{ + gnss_synchro.Channel_ID = 0; + gnss_synchro.System = 'G'; + std::string signal = "2S"; + strcpy(gnss_synchro.Signal,signal.c_str()); + gnss_synchro.PRN = 7; + + sampling_freqeuncy_hz = 5000000; + nsamples=round((double)sampling_freqeuncy_hz*GPS_L2_M_PERIOD)*2; + config->set_property("GNSS-SDR.internal_fs_hz", std::to_string(sampling_freqeuncy_hz)); + config->set_property("Acquisition.item_type", "gr_complex"); + config->set_property("Acquisition.if", "0"); + config->set_property("Acquisition.dump", "true"); + config->set_property("Acquisition.implementation", "GPS_L2_M_PCPS_Acquisition"); + config->set_property("Acquisition.threshold", "0.001"); + config->set_property("Acquisition.doppler_max", "5000"); + config->set_property("Acquisition.doppler_step", "10"); + config->set_property("Acquisition.repeat_satellite", "false"); + config->set_property("Acquisition.pfa", "0.0"); +} + + +void GpsL2MPcpsAcquisitionTest::start_queue() +{ + ch_thread = boost::thread(&GpsL2MPcpsAcquisitionTest::wait_message, this); +} + + +void GpsL2MPcpsAcquisitionTest::wait_message() +{ + while (!stop) + { + channel_internal_queue.wait_and_pop(message); + stop_queue(); + } +} + + + +void GpsL2MPcpsAcquisitionTest::stop_queue() +{ + stop = true; +} + + + +TEST_F(GpsL2MPcpsAcquisitionTest, Instantiate) +{ + init(); + queue = gr::msg_queue::make(0); + std::shared_ptr acquisition = std::make_shared(config.get(), "Acquisition", 1, 1, queue); +} + +TEST_F(GpsL2MPcpsAcquisitionTest, ConnectAndRun) +{ + struct timeval tv; + long long int begin = 0; + long long int end = 0; + top_block = gr::make_top_block("Acquisition test"); + queue = gr::msg_queue::make(0); + + init(); + std::shared_ptr acquisition = std::make_shared(config.get(), "Acquisition", 1, 1, queue); + + ASSERT_NO_THROW( { + acquisition->connect(top_block); + boost::shared_ptr source = gr::analog::sig_source_c::make(sampling_freqeuncy_hz, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); + boost::shared_ptr 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 * 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(GpsL2MPcpsAcquisitionTest, ValidationOfResults) +{ + struct timeval tv; + long long int begin = 0; + long long int end = 0; + top_block = gr::make_top_block("Acquisition test"); + queue = gr::msg_queue::make(0); + + + double expected_delay_samples = 1;//2004; + double expected_doppler_hz = 1200;//3000; + init(); + start_queue(); + std::shared_ptr acquisition = std::make_shared(config.get(), "Acquisition", 1, 1, queue); + + + 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_threshold(0.001); + }) << "Failure setting threshold." << std::endl; + + ASSERT_NO_THROW( { + acquisition->set_doppler_max(5000); + }) << "Failure setting doppler_max." << std::endl; + + ASSERT_NO_THROW( { + acquisition->set_doppler_step(10); + }) << "Failure setting doppler_step." << std::endl; + + ASSERT_NO_THROW( { + acquisition->connect(top_block); + }) << "Failure connecting acquisition to the top_block." << std::endl; + + ASSERT_NO_THROW( { + std::string path = std::string(TEST_PATH); + //std::string file = path + "signal_samples/GSoC_CTTC_capture_2012_07_26_4Msps_4ms.dat"; + std::string file = path + "/data/gps_l2c_m_prn7_5msps.dat"; + //std::string file = "/datalogger/signals/Fraunhofer/L125_III1b_210s_L2_resampled.bin"; + 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::interleaved_short_to_complex::sptr gr_interleaved_short_to_complex_ = gr::blocks::interleaved_short_to_complex::make(); + //gr::blocks::char_to_short::sptr gr_char_to_short_ = gr::blocks::char_to_short::make(); + boost::shared_ptr valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue); + + //top_block->connect(file_source, 0, gr_char_to_short_, 0); + //top_block->connect(gr_char_to_short_, 0, gr_interleaved_short_to_complex_ , 0); + top_block->connect(file_source, 0, valve , 0); + top_block->connect(valve, 0, acquisition->get_left_block(), 0); + + }) << "Failure connecting the blocks of acquisition test." << std::endl; + + + ASSERT_NO_THROW( { + acquisition->set_state(1); // Ensure that acquisition starts at the first sample + acquisition->init(); + }) << "Failure set_state and init acquisition test" << std::endl; + + 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; + + stop_queue(); + + unsigned long int Acq_samplestamp_samples = gnss_synchro.Acq_samplestamp_samples; + std::cout << "Acquisition process runtime duration: " << (end - begin) << " microseconds" << std::endl; + + std::cout << "gnss_synchro.Acq_doppler_hz = " << gnss_synchro.Acq_doppler_hz << " Hz" << std::endl; + std::cout << "gnss_synchro.Acq_delay_samples = " << gnss_synchro.Acq_delay_samples << " Samples" << std::endl; + + + ASSERT_EQ(1, message) << "Acquisition failure. Expected message: 1=ACQ SUCCESS."; + + double delay_error_samples = std::abs(expected_delay_samples - gnss_synchro.Acq_delay_samples); + float delay_error_chips = (float)(delay_error_samples * 1023 / 4000); + double doppler_error_hz = std::abs(expected_doppler_hz - gnss_synchro.Acq_doppler_hz); + + EXPECT_LE(doppler_error_hz, 200) << "Doppler error exceeds the expected value: 666 Hz = 2/(3*integration period)"; + EXPECT_LT(delay_error_chips, 0.5) << "Delay error exceeds the expected value: 0.5 chips"; + + ch_thread.join(); +} diff --git a/src/tests/test_main.cc b/src/tests/test_main.cc index 7e523d89f..538e90349 100644 --- a/src/tests/test_main.cc +++ b/src/tests/test_main.cc @@ -83,6 +83,7 @@ DECLARE_string(log_dir); #include "gnss_block/file_signal_source_test.cc" #include "gnss_block/fir_filter_test.cc" #include "gnss_block/gps_l1_ca_pcps_acquisition_test.cc" +#include "gnss_block/gps_l2_m_pcps_acquisition_test.cc" #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 @@ -106,6 +107,7 @@ DECLARE_string(log_dir); //#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" +#include "gnss_block/gps_l2_m_dll_pll_tracking_test.cc"