Merge branch 'next' into new_fsm

conf/gnss-sdr_galileo_E1_extended_correlator_byte.conf

@@ -0,0 +1,269 @@
+; 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_sps: Internal signal sampling frequency after the signal conditioning stage [samples per second].
+GNSS-SDR.internal_fs_sps=20000000
+
+
+;######### SIGNAL_SOURCE CONFIG ############
+;#implementation: Use [File_Signal_Source] or [UHD_Signal_Source] or [GN3S_Signal_Source] (experimental)
+SignalSource.implementation=File_Signal_Source
+
+;#filename: path to file with the captured GNSS signal samples to be processed
+;SignalSource.filename=/home/javier/signals/L125_III1b_210s_L1_2msps.bin     ; <- PUT YOUR FILE HERE
+
+SignalSource.filename=/media/javier/SISTEMA/signals/fraunhofer/L125_III1b_210s_L1.bin
+
+;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
+SignalSource.item_type=byte
+
+;#sampling_frequency: Original Signal sampling frequency in [Hz]
+SignalSource.sampling_frequency=20000000
+
+;#freq: RF front-end center frequency in [Hz]
+SignalSource.freq=1575420000
+
+;#samples: Number of samples to be processed. Notice that 0 indicates the entire file.
+SignalSource.samples=0
+
+;#repeat: Repeat the processing file. Disable this option in this version
+SignalSource.repeat=false
+
+;#dump: Dump the Signal source data to a file. Disable this option in this version
+SignalSource.dump=false
+
+SignalSource.dump_filename=../data/signal_source.dat
+
+;#enable_throttle_control: Enabling this option tells the signal source to keep the delay between samples in post processing.
+; it helps to not overload the CPU, but the processing time will be longer.
+SignalSource.enable_throttle_control=false
+
+
+;######### SIGNAL_CONDITIONER CONFIG ############
+;## It holds blocks to change data type, filter and resample input data.
+
+;#implementation: Use [Pass_Through] or [Signal_Conditioner]
+;#[Pass_Through] disables this block and the [DataTypeAdapter], [InputFilter] and [Resampler] blocks
+;#[Signal_Conditioner] enables this block. Then you have to configure [DataTypeAdapter], [InputFilter] and [Resampler] blocks
+SignalConditioner.implementation=Signal_Conditioner
+
+;######### DATA_TYPE_ADAPTER CONFIG ############
+;## Changes the type of input data. Please disable it in this version.
+;#implementation: [Pass_Through] disables this block
+DataTypeAdapter.implementation=Ibyte_To_Complex
+
+;######### INPUT_FILTER CONFIG ############
+;## Filter the input data. Can be combined with frequency translation for IF signals
+
+InputFilter.implementation=Pass_Through
+
+
+;######### RESAMPLER CONFIG ############
+;## Resamples the input data.
+
+;#implementation: Use [Pass_Through] or [Direct_Resampler]
+;#[Pass_Through] disables this block
+;#[Direct_Resampler] enables a resampler that implements a nearest neigbourhood interpolation
+;Resampler.implementation=Direct_Resampler
+Resampler.implementation=Pass_Through
+
+
+;######### CHANNELS GLOBAL CONFIG ############
+;#count: Number of available GPS satellite channels.
+Channels_1C.count=0
+;#count: Number of available Galileo satellite channels.
+Channels_1B.count=1
+;#in_acquisition: Number of channels simultaneously acquiring for the whole receiver
+Channels.in_acquisition=1
+
+;#signal:
+;#if the option is disabled by default is assigned "1C" GPS L1 C/A
+Channel1.signal=1B
+Channel2.signal=1B
+Channel3.signal=1B
+Channel4.signal=1B
+Channel5.signal=1B
+Channel6.signal=1B
+Channel7.signal=1B
+Channel8.signal=1B
+Channel9.signal=1B
+Channel10.signal=1B
+Channel11.signal=1B
+Channel12.signal=1B
+Channel13.signal=1B
+Channel14.signal=1B
+Channel15.signal=1B
+
+
+;######### GPS ACQUISITION CONFIG ############
+
+;#dump: Enable or disable the acquisition internal data file logging [true] or [false]
+Acquisition_1C.dump=false
+;#filename: Log path and filename
+Acquisition_1C.dump_filename=./acq_dump.dat
+;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
+Acquisition_1C.item_type=gr_complex
+;#if: Signal intermediate frequency in [Hz]
+Acquisition_1C.if=0
+;#sampled_ms: Signal block duration for the acquisition signal detection [ms]
+Acquisition_1C.sampled_ms=1
+;#implementation: Acquisition algorithm selection for this channel: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
+Acquisition_1C.implementation=GPS_L1_CA_PCPS_Acquisition
+Acquisition_1C.use_CFAR_algorithm=false;
+;#threshold: Acquisition threshold
+Acquisition_1C.threshold=18
+;#doppler_max: Maximum expected Doppler shift [Hz]
+Acquisition_1C.doppler_max=5000
+;#doppler_max: Doppler step in the grid search [Hz]
+Acquisition_1C.doppler_step=500
+
+
+;######### GALILEO ACQUISITION CONFIG ############
+
+;#dump: Enable or disable the acquisition internal data file logging [true] or [false]
+Acquisition_1B.dump=false
+;#filename: Log path and filename
+Acquisition_1B.dump_filename=../data/acq_dump.dat
+;#item_type: Type and resolution for each of the signal samples. Use only gr_complex in this version.
+Acquisition_1B.item_type=gr_complex
+;#if: Signal intermediate frequency in [Hz]
+Acquisition_1B.if=0
+;#sampled_ms: Signal block duration for the acquisition signal detection [ms]
+Acquisition_1B.sampled_ms=4
+;#implementation: Acquisition algorithm selection for this channel: [GPS_L1_CA_PCPS_Acquisition] or [Galileo_E1_PCPS_Ambiguous_Acquisition]
+Acquisition_1B.implementation=Galileo_E1_PCPS_Ambiguous_Acquisition
+Acquisition_1B.acquire_pilot=true
+Acquisition_1B.use_CFAR_algorithm=false
+;#threshold: Acquisition threshold
+Acquisition_1B.threshold=21
+;#doppler_max: Maximum expected Doppler shift [Hz]
+Acquisition_1B.doppler_max=5000
+;#doppler_max: Doppler step in the grid search [Hz]
+Acquisition_1B.doppler_step=125
+Acquisition_1B.bit_transition_flag=true
+
+;######### TRACKING GPS CONFIG ############
+
+;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_PLL_C_Aid_Tracking] or [GPS_L1_CA_TCP_CONNECTOR_Tracking] or [Galileo_E1_DLL_PLL_VEML_Tracking]
+Tracking_1C.implementation=GPS_L1_CA_DLL_PLL_Tracking
+;#item_type: Type and resolution for each of the signal samples. Use only [gr_complex] in this version.
+Tracking_1C.item_type=gr_complex
+
+;#sampling_frequency: Signal Intermediate Frequency in [Hz]
+Tracking_1C.if=0
+
+;#dump: Enable or disable the Tracking internal binary data file logging [true] or [false]
+Tracking_1C.dump=false
+
+;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number.
+Tracking_1C.dump_filename=../data/epl_tracking_ch_
+
+;#pll_bw_hz: PLL loop filter bandwidth [Hz]
+Tracking_1C.pll_bw_hz=30.0;
+
+;#dll_bw_hz: DLL loop filter bandwidth [Hz]
+Tracking_1C.dll_bw_hz=2.0;
+
+;#order: PLL/DLL loop filter order [2] or [3]
+Tracking_1C.order=3;
+
+;######### TRACKING GALILEO CONFIG ############
+
+;#implementation: Selected tracking algorithm: [GPS_L1_CA_DLL_PLL_Tracking] or [GPS_L1_CA_DLL_PLL_C_Aid_Tracking] or [GPS_L1_CA_TCP_CONNECTOR_Tracking] or [Galileo_E1_DLL_PLL_VEML_Tracking]
+Tracking_1B.implementation=Galileo_E1_DLL_PLL_VEML_Tracking
+;#item_type: Type and resolution for each of the signal samples.
+Tracking_1B.item_type=gr_complex
+
+;#sampling_frequency: Signal Intermediate Frequency in [Hz]
+Tracking_1B.if=0
+
+;#dump: Enable or disable the Tracking internal binary data file logging [true] or [false]
+Tracking_1B.dump=true
+
+;#dump_filename: Log path and filename. Notice that the tracking channel will add "x.dat" where x is the channel number.
+Tracking_1B.dump_filename=../data/veml_tracking_ch_
+
+Tracking_1B.track_pilot=true
+
+;#pll_bw_hz: PLL loop filter bandwidth [Hz]
+Tracking_1B.pll_bw_hz=4.0;
+
+;#dll_bw_hz: DLL loop filter bandwidth [Hz]
+Tracking_1B.dll_bw_hz=0.5;
+
+;#pll_bw_hz: PLL loop filter bandwidth [Hz]
+Tracking_1B.pll_bw_narrow_hz=2.0;
+
+;#dll_bw_hz: DLL loop filter bandwidth [Hz]
+Tracking_1B.dll_bw_narrow_hz=0.25;
+
+Tracking_1B.extend_correlation_symbols=4;
+
+;#order: PLL/DLL loop filter order [2] or [3]
+Tracking_1B.order=3;
+
+;#early_late_space_chips: correlator early-late space [chips]. Use [0.5] for GPS and [0.15] for Galileo
+Tracking_1B.early_late_space_chips=0.15;
+
+;#very_early_late_space_chips: only for [Galileo_E1_DLL_PLL_VEML_Tracking], correlator very early-late space [chips]. Use [0.6]
+Tracking_1B.very_early_late_space_chips=0.6;
+
+;#early_late_space_chips: correlator early-late space [chips]. Use [0.5] for GPS and [0.15] for Galileo
+Tracking_1B.early_late_space_narrow_chips=0.06;
+
+;#very_early_late_space_chips: only for [Galileo_E1_DLL_PLL_VEML_Tracking], correlator very early-late space [chips]. Use [0.6]
+Tracking_1B.very_early_late_space_narrow_chips=0.25;
+
+
+
+;######### TELEMETRY DECODER GPS CONFIG ############
+;#implementation: Use [GPS_L1_CA_Telemetry_Decoder] for GPS L1 C/A
+TelemetryDecoder_1C.implementation=GPS_L1_CA_Telemetry_Decoder
+TelemetryDecoder_1C.dump=false
+;#decimation factor
+TelemetryDecoder_1C.decimation_factor=4;
+
+;######### TELEMETRY DECODER GALILEO CONFIG ############
+;#implementation: Use [Galileo_E1B_Telemetry_Decoder] for Galileo E1B
+TelemetryDecoder_1B.implementation=Galileo_E1B_Telemetry_Decoder
+TelemetryDecoder_1B.dump=false
+
+;######### OBSERVABLES CONFIG ############
+;#implementation:
+Observables.implementation=Hybrid_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:
+PVT.implementation=RTKLIB_PVT
+
+PVT.positioning_mode=PPP_Static  ; options: Single, Static, Kinematic, PPP_Static, PPP_Kinematic
+PVT.iono_model=Broadcast ; options: OFF, Broadcast, SBAS, Iono-Free-LC, Estimate_STEC, IONEX
+PVT.trop_model=Saastamoinen ; options: OFF, Saastamoinen, SBAS, Estimate_ZTD, Estimate_ZTD_Grad
+
+;#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;
+
+;#dump: Enable or disable the PVT internal binary data file logging [true] or [false]
+PVT.dump=false
+
+PVT.flag_rtcm_server=false
+PVT.flag_rtcm_tty_port=false
+PVT.rtcm_dump_devname=/dev/pts/1
+
+;#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

src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc

@@ -70,6 +70,7 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition(
 
     bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
     use_CFAR_algorithm_flag_ = configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions
+    acquire_pilot_= configuration_->property(role + ".acquire_pilot", false); //will be true in future versions
 
     max_dwells_ = configuration_->property(role + ".max_dwells", 1);
 
@@ -252,8 +253,18 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
 
     std::complex<float> * code = new std::complex<float>[code_length_];
 
-    galileo_e1_code_gen_complex_sampled(code, gnss_synchro_->Signal,
+    if (acquire_pilot_==true)
-                    cboc, gnss_synchro_->PRN, fs_in_, 0, false);
+    {
+        //set local signal generator to Galileo E1 pilot component (1C)
+        char pilot_signal[3]="1C";
+        galileo_e1_code_gen_complex_sampled(code, pilot_signal,
+                        cboc, gnss_synchro_->PRN, fs_in_, 0, false);
+    }else
+    {
+        galileo_e1_code_gen_complex_sampled(code, gnss_synchro_->Signal,
+                        cboc, gnss_synchro_->PRN, fs_in_, 0, false);
+    }
+
 
     for (unsigned int i = 0; i < sampled_ms_ / 4; i++)
         {

src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.h

@@ -146,6 +146,7 @@ private:
     unsigned int code_length_;
     bool bit_transition_flag_;
     bool use_CFAR_algorithm_flag_;
+    bool acquire_pilot_;
     unsigned int channel_;
     float threshold_;
     unsigned int doppler_max_;

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc

@@ -127,13 +127,9 @@ pcps_acquisition_cc::pcps_acquisition_cc(
     // For dumping samples into a file
     d_dump = dump;
     d_dump_filename = dump_filename;
-
     d_gnss_synchro = 0;
     d_grid_doppler_wipeoffs = 0;
-
-    d_done = false;
     d_blocking = blocking;
-    d_new_data_available = false;
     d_worker_active = false;
     d_data_buffer = static_cast<gr_complex*>(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
 }
@@ -160,19 +156,6 @@ pcps_acquisition_cc::~pcps_acquisition_cc()
         {
             d_dump_file.close();
         }
-
-    // Let the worker thread know that we are done and then wait to join
-    if( d_worker_thread.joinable() )
-        {
-            {
-                std::lock_guard<std::mutex> lk( d_mutex );
-                d_done = true;
-                d_cond.notify_one();
-            }
-
-            d_worker_thread.join();
-        }
-
     volk_gnsssdr_free( d_data_buffer );
 }
 
@@ -233,9 +216,6 @@ void pcps_acquisition_cc::init()
             int doppler = -static_cast<int>(d_doppler_max) + d_doppler_step * doppler_index;
             update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_freq + doppler);
         }
-
-    d_new_data_available = false;
-    d_done = false;
     d_worker_active = false;
 }
 
@@ -253,6 +233,7 @@ void pcps_acquisition_cc::set_state(int state)
             d_mag = 0.0;
             d_input_power = 0.0;
             d_test_statistics = 0.0;
+            d_active = true;
         }
     else if (d_state == 0)
         {}
@@ -299,7 +280,7 @@ void pcps_acquisition_cc::send_negative_acquisition()
 }
 
 
-int pcps_acquisition_cc::general_work(int noutput_items,
+int pcps_acquisition_cc::general_work(int noutput_items __attribute__((unused)),
         gr_vector_int &ninput_items, gr_vector_const_void_star &input_items,
         gr_vector_void_star &output_items __attribute__((unused)))
 {
@@ -314,192 +295,157 @@ int pcps_acquisition_cc::general_work(int noutput_items,
      * 6. Declare positive or negative acquisition using a message port
      */
 
-    switch (d_state)
+    gr::thread::scoped_lock lk(d_setlock);
+    if(!d_active || d_worker_active)
+        {
+            d_sample_counter += d_fft_size * ninput_items[0];
+            consume_each(ninput_items[0]);
+            return 0;
+        }
+
+    switch(d_state)
     {
     case 0:
         {
-            if (d_active)
+            //restart acquisition variables
-                {
+            d_gnss_synchro->Acq_delay_samples = 0.0;
-                    //restart acquisition variables
+            d_gnss_synchro->Acq_doppler_hz = 0.0;
-                    d_gnss_synchro->Acq_delay_samples = 0.0;
+            d_gnss_synchro->Acq_samplestamp_samples = 0;
-                    d_gnss_synchro->Acq_doppler_hz = 0.0;
+            d_well_count = 0;
-                    d_gnss_synchro->Acq_samplestamp_samples = 0;
+            d_mag = 0.0;
-                    d_well_count = 0;
+            d_input_power = 0.0;
-                    d_mag = 0.0;
+            d_test_statistics = 0.0;
-                    d_input_power = 0.0;
+            d_state = 1;
-                    d_test_statistics = 0.0;
-                    d_state = 1;
-                }
-
             d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
             consume_each(ninput_items[0]);
-
             break;
         }
 
     case 1:
         {
-            std::unique_lock<std::mutex> lk( d_mutex );
+            // Copy the data to the core and let it know that new data is available
-
+            memcpy(d_data_buffer, input_items[0], d_fft_size * sizeof(gr_complex));
-            int num_items_consumed = 1;
+            if(d_blocking)
-
-            if( d_worker_active )
                 {
-                    if( d_blocking )
+                    lk.unlock();
-                        {
+                    acquisition_core(d_sample_counter);
-                            // Should never get here:
-                            std::string msg = "pcps_acquisition_cc: Entered general work with worker active in blocking mode, should never happen";
-                            LOG(WARNING) << msg;
-                            std::cout << msg << std::endl;
-                            d_cond.wait( lk, [&]{ return !this->d_worker_active; } );
-                        }
-                    else
-                        {
-                            num_items_consumed = ninput_items[0];
-                            d_sample_counter += d_fft_size * num_items_consumed;
-                        }
                 }
             else
                 {
-                    // Copy the data to the core and let it know that new data is available
+                    gr::thread::thread d_worker(&pcps_acquisition_cc::acquisition_core, this, d_sample_counter);
-                    memcpy( d_data_buffer, input_items[0], d_fft_size * sizeof( gr_complex ) );
+                    d_worker_active = true;
-                    d_new_data_available = true;
-                    d_cond.notify_one();
-
-                    if( d_blocking )
-                        {
-                            d_cond.wait( lk, [&]{ return !this->d_new_data_available; } );
-                        }
                 }
-
+            d_sample_counter += d_fft_size;
-            consume_each(num_items_consumed);
+            consume_each(1);
-
             break;
-        } // case 1, switch d_state
+        }
-
+    }
-    } // switch d_state
+    return 0;
-
-    return noutput_items;
 }
 
 
-void pcps_acquisition_cc::acquisition_core( void )
+void pcps_acquisition_cc::acquisition_core( unsigned long int samp_count )
 {
-    d_worker_active = false;
+    gr::thread::scoped_lock lk(d_setlock);
-    while( 1 )
+
+    // initialize acquisition algorithm
+    int doppler;
+    uint32_t indext = 0;
+    float magt = 0.0;
+    const gr_complex *in = d_data_buffer; //Get the input samples pointer
+
+    int effective_fft_size = ( d_bit_transition_flag ? d_fft_size/2 : d_fft_size );
+
+    float fft_normalization_factor = static_cast<float>(d_fft_size) * static_cast<float>(d_fft_size);
+
+    d_input_power = 0.0;
+    d_mag = 0.0;
+    d_well_count++;
+
+    DLOG(INFO) << "Channel: " << d_channel
+            << " , doing acquisition of satellite: " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN
+            << " ,sample stamp: " << samp_count << ", threshold: "
+            << d_threshold << ", doppler_max: " << d_doppler_max
+            << ", doppler_step: " << d_doppler_step
+            << ", use_CFAR_algorithm_flag: " << ( d_use_CFAR_algorithm_flag ? "true" : "false" );
+
+    lk.unlock();
+    if (d_use_CFAR_algorithm_flag)
         {
-            std::unique_lock<std::mutex> lk( d_mutex );
+            // 1- (optional) Compute the input signal power estimation
-            d_cond.wait( lk, [&]{ return this->d_new_data_available or this->d_done; } );
+            volk_32fc_magnitude_squared_32f(d_magnitude, in, d_fft_size);
-            d_worker_active = !d_done;
+            volk_32f_accumulator_s32f(&d_input_power, d_magnitude, d_fft_size);
-            unsigned long int sample_counter = d_sample_counter; // sample counter
+            d_input_power /= static_cast<float>(d_fft_size);
-            lk.unlock();
+        }
+    // 2- Doppler frequency search loop
+    for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
+        {
+            // doppler search steps
+            doppler = -static_cast<int>(d_doppler_max) + d_doppler_step * doppler_index;
 
-            if( d_done )
+            volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index], d_fft_size);
+
+            // 3- Perform the FFT-based convolution  (parallel time search)
+            // Compute the FFT of the carrier wiped--off incoming signal
+            d_fft_if->execute();
+
+            // Multiply carrier wiped--off, Fourier transformed incoming signal
+            // with the local FFT'd code reference using SIMD operations with VOLK library
+            volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
+
+            // compute the inverse FFT
+            d_ifft->execute();
+
+            // Search maximum
+            size_t offset = ( d_bit_transition_flag ? effective_fft_size : 0 );
+            volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size);
+            volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size);
+            magt = d_magnitude[indext];
+
+            if (d_use_CFAR_algorithm_flag)
                 {
-                    break;
+                    // Normalize the maximum value to correct the scale factor introduced by FFTW
+                    magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor);
                 }
-
+            // 4- record the maximum peak and the associated synchronization parameters
-            // initialize acquisition algorithm
+            if (d_mag < magt)
-            int doppler;
-            uint32_t indext = 0;
-            float magt = 0.0;
-            const gr_complex *in = d_data_buffer; //Get the input samples pointer
-
-            int effective_fft_size = ( d_bit_transition_flag ? d_fft_size/2 : d_fft_size );
-
-            float fft_normalization_factor = static_cast<float>(d_fft_size) * static_cast<float>(d_fft_size);
-
-            d_input_power = 0.0;
-            d_mag = 0.0;
-            d_well_count++;
-
-            DLOG(INFO) << "Channel: " << d_channel
-                       << " , doing acquisition of satellite: " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN
-                       << " ,sample stamp: " << sample_counter << ", threshold: "
-                       << d_threshold << ", doppler_max: " << d_doppler_max
-                       << ", doppler_step: " << d_doppler_step
-                       << ", use_CFAR_algorithm_flag: " << ( d_use_CFAR_algorithm_flag ? "true" : "false" );
-
-            if (d_use_CFAR_algorithm_flag == true)
                 {
-                    // 1- (optional) Compute the input signal power estimation
+                    d_mag = magt;
-                    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<float>(d_fft_size);
-                }
-            // 2- Doppler frequency search loop
-            for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
-                {
-                    // doppler search steps
-                    doppler = -static_cast<int>(d_doppler_max) + d_doppler_step * doppler_index;
 
-                    volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in,
+                    if (!d_use_CFAR_algorithm_flag)
-                            d_grid_doppler_wipeoffs[doppler_index], d_fft_size);
-
-                    // 3- Perform the FFT-based convolution  (parallel time search)
-                    // Compute the FFT of the carrier wiped--off incoming signal
-                    d_fft_if->execute();
-
-                    // Multiply carrier wiped--off, Fourier transformed incoming signal
-                    // with the local FFT'd code reference using SIMD operations with VOLK library
-                    volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(),
-                            d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
-
-                    // compute the inverse FFT
-                    d_ifft->execute();
-
-                    // Search maximum
-                    size_t offset = ( d_bit_transition_flag ? effective_fft_size : 0 );
-                    volk_32fc_magnitude_squared_32f(d_magnitude, d_ifft->get_outbuf() + offset, effective_fft_size);
-                    volk_gnsssdr_32f_index_max_32u(&indext, d_magnitude, effective_fft_size);
-                    magt = d_magnitude[indext];
-
-                    if (d_use_CFAR_algorithm_flag == true)
                         {
-                            // Normalize the maximum value to correct the scale factor introduced by FFTW
+                            // Search grid noise floor approximation for this doppler line
-                            magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor);
+                            volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size);
-                        }
+                            d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1);
-                    // 4- record the maximum peak and the associated synchronization parameters
-                    if (d_mag < magt)
-                        {
-                            d_mag = magt;
-
-                            if (d_use_CFAR_algorithm_flag == false)
-                                {
-                                    // Search grid noise floor approximation for this doppler line
-                                    volk_32f_accumulator_s32f(&d_input_power, d_magnitude, effective_fft_size);
-                                    d_input_power = (d_input_power - d_mag) / (effective_fft_size - 1);
-                                }
-
-                            // In case that d_bit_transition_flag = true, we compare the potentially
-                            // new maximum test statistics (d_mag/d_input_power) with the value in
-                            // d_test_statistics. When the second dwell is being processed, the value
-                            // of d_mag/d_input_power could be lower than d_test_statistics (i.e,
-                            // the maximum test statistics in the previous dwell is greater than
-                            // current d_mag/d_input_power). Note that d_test_statistics is not
-                            // restarted between consecutive dwells in multidwell operation.
-
-                            if (d_test_statistics < (d_mag / d_input_power) || !d_bit_transition_flag)
-                                {
-                                    d_gnss_synchro->Acq_delay_samples = static_cast<double>(indext % d_samples_per_code);
-                                    d_gnss_synchro->Acq_doppler_hz = static_cast<double>(doppler);
-                                    d_gnss_synchro->Acq_samplestamp_samples = sample_counter;
-
-                                    // 5- Compute the test statistics and compare to the threshold
-                                    //d_test_statistics = 2 * d_fft_size * d_mag / d_input_power;
-                                    d_test_statistics = d_mag / d_input_power;
-                                }
                         }
 
-                    // Record results to file if required
+                    // In case that d_bit_transition_flag = true, we compare the potentially
-                    if (d_dump)
+                    // new maximum test statistics (d_mag/d_input_power) with the value in
-                        {
+                    // d_test_statistics. When the second dwell is being processed, the value
-                            std::stringstream filename;
+                    // of d_mag/d_input_power could be lower than d_test_statistics (i.e,
-                            std::streamsize n = 2 * sizeof(float) * (d_fft_size); // complex file write
+                    // the maximum test statistics in the previous dwell is greater than
-                            filename.str("");
+                    // current d_mag/d_input_power). Note that d_test_statistics is not
+                    // restarted between consecutive dwells in multidwell operation.
 
-                            boost::filesystem::path p = d_dump_filename;
+                    if (d_test_statistics < (d_mag / d_input_power) || !d_bit_transition_flag)
-                            filename << p.parent_path().string()
+                        {
+                            d_gnss_synchro->Acq_delay_samples = static_cast<double>(indext % d_samples_per_code);
+                            d_gnss_synchro->Acq_doppler_hz = static_cast<double>(doppler);
+                            d_gnss_synchro->Acq_samplestamp_samples = samp_count;
+
+                            // 5- Compute the test statistics and compare to the threshold
+                            //d_test_statistics = 2 * d_fft_size * d_mag / d_input_power;
+                            d_test_statistics = d_mag / d_input_power;
+                        }
+                }
+            // Record results to file if required
+            if (d_dump)
+                {
+                    std::stringstream filename;
+                    std::streamsize n = 2 * sizeof(float) * (d_fft_size); // complex file write
+                    filename.str("");
+                    boost::filesystem::path p = d_dump_filename;
+                    filename << p.parent_path().string()
                             << boost::filesystem::path::preferred_separator
                             << p.stem().string()
                             << "_" << d_gnss_synchro->System
@@ -508,15 +454,32 @@ void pcps_acquisition_cc::acquisition_core( void )
                             <<  doppler
                             << p.extension().string();
 
-                            DLOG(INFO) << "Writing ACQ out to " << filename.str();
+                    DLOG(INFO) << "Writing ACQ out to " << filename.str();
 
-                            d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
+                    d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
-                            d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
+                    d_dump_file.write(reinterpret_cast<char*>(d_ifft->get_outbuf()), n); //write directly |abs(x)|^2 in this Doppler bin?
-                            d_dump_file.close();
+                    d_dump_file.close();
-                        }
                 }
-
+        }
-            if (!d_bit_transition_flag)
+    lk.lock();
+    if (!d_bit_transition_flag)
+        {
+            if (d_test_statistics > d_threshold)
+                {
+                    d_state = 0; // Positive acquisition
+                    d_active = false;
+                    send_positive_acquisition();
+                }
+            else if (d_well_count == d_max_dwells)
+                {
+                    d_state = 0;
+                    d_active = false;
+                    send_negative_acquisition();
+                }
+        }
+    else
+        {
+            if (d_well_count == d_max_dwells) // d_max_dwells = 2
                 {
                     if (d_test_statistics > d_threshold)
                         {
@@ -524,66 +487,13 @@ void pcps_acquisition_cc::acquisition_core( void )
                             d_active = false;
                             send_positive_acquisition();
                         }
-                    else if (d_well_count == d_max_dwells)
+                    else
                         {
-                            d_state = 0;
+                            d_state = 0; // Negative acquisition
                             d_active = false;
                             send_negative_acquisition();
                         }
                 }
-            else
-                {
-                    if (d_well_count == d_max_dwells) // d_max_dwells = 2
-                        {
-                            if (d_test_statistics > d_threshold)
-                                {
-                                    d_state = 0; // Positive acquisition
-                                    d_active = false;
-                                    send_positive_acquisition();
-                                }
-                            else
-                                {
-                                    d_state = 0; // Negative acquisition
-                                    d_active = false;
-                                    send_negative_acquisition();
-                                }
-                        }
-                }
-
-            lk.lock();
-            d_worker_active = false;
-            d_new_data_available = false;
-            lk.unlock();
-            d_cond.notify_one();
         }
-}
-
-
-bool pcps_acquisition_cc::start( void )
-{
     d_worker_active = false;
-    d_done = false;
-
-    // Start the worker thread and wait for it to acknowledge:
-    d_worker_thread = std::move( std::thread( &pcps_acquisition_cc::acquisition_core, this ) );
-
-    return gr::block::start();
 }
-
-
-bool pcps_acquisition_cc::stop( void )
-{
-    // Let the worker thread know that we are done and then wait to join
-    if( d_worker_thread.joinable() )
-        {
-            {
-                std::lock_guard<std::mutex> lk( d_mutex );
-                d_done = true;
-                d_cond.notify_one();
-            }
-
-            d_worker_thread.join();
-        }
-    return gr::block::stop();
-}
-

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.h

@@ -21,6 +21,7 @@
  *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
  *          <li> Marc Molina, 2013. marc.molina.pena@gmail.com
  *          <li> Cillian O'Driscoll, 2017. cillian(at)ieee.org
+ *          <li> Antonio Ramos, 2017. antonio.ramos@cttc.es
  *          </ul>
  *
  * -------------------------------------------------------------------------
@@ -53,9 +54,6 @@
 
 #include <fstream>
 #include <string>
-#include <mutex>
-#include <thread>
-#include <condition_variable>
 #include <gnuradio/block.h>
 #include <gnuradio/gr_complex.h>
 #include <gnuradio/fft/fft.h>
@@ -100,7 +98,7 @@ private:
 
     void update_local_carrier(gr_complex* carrier_vector, int correlator_length_samples, float freq);
 
-    void acquisition_core( void );
+    void acquisition_core( unsigned long int samp_count );
 
     void send_negative_acquisition();
     void send_positive_acquisition();
@@ -110,7 +108,6 @@ private:
     int d_samples_per_code;
     //unsigned int d_doppler_resolution;
     float d_threshold;
-    std::string d_satellite_str;
     unsigned int d_doppler_max;
     unsigned int d_doppler_step;
     unsigned int d_sampled_ms;
@@ -138,16 +135,8 @@ private:
     bool d_dump;
     unsigned int d_channel;
     std::string d_dump_filename;
-
-    std::thread d_worker_thread;
-    std::mutex  d_mutex;
-
-    std::condition_variable d_cond;
-    bool d_done;
-    bool d_new_data_available;
     bool d_worker_active;
     bool d_blocking;
-
     gr_complex *d_data_buffer;
 
 public:
@@ -252,15 +241,6 @@ public:
              gr_vector_const_void_star &input_items,
              gr_vector_void_star &output_items);
 
-     /*!
-      * Called by the flowgraph when processing is about to start.
-      */
-     bool start( void );
-
-     /*!
-      * Called by the flowgraph when processing is done.
-      */
-     bool stop( void );
 };
 
 #endif /* GNSS_SDR_PCPS_ACQUISITION_CC_H_*/

src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc

@@ -57,19 +57,31 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
     std::string item_type;
     std::string default_item_type = "gr_complex";
     float pll_bw_hz;
+    float pll_bw_narrow_hz;
     float dll_bw_hz;
+    float dll_bw_narrow_hz;
     float early_late_space_chips;
     float very_early_late_space_chips;
+    float early_late_space_narrow_chips;
+    float very_early_late_space_narrow_chips;
 
     item_type = configuration->property(role + ".item_type", default_item_type);
     int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
     fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
     f_if = configuration->property(role + ".if", 0);
     dump = configuration->property(role + ".dump", false);
-    pll_bw_hz = configuration->property(role + ".pll_bw_hz", 50.0);
+    pll_bw_hz = configuration->property(role + ".pll_bw_hz", 5.0);
-    dll_bw_hz = configuration->property(role + ".dll_bw_hz", 2.0);
+    dll_bw_hz = configuration->property(role + ".dll_bw_hz", 0.5);
+    pll_bw_narrow_hz = configuration->property(role + ".pll_bw_narrow_hz", 2.0);
+    dll_bw_narrow_hz = configuration->property(role + ".dll_bw_narrow_hz", 0.25);
+    int extend_correlation_symbols;
+    extend_correlation_symbols = configuration->property(role + ".extend_correlation_symbols", 1);
     early_late_space_chips = configuration->property(role + ".early_late_space_chips", 0.15);
     very_early_late_space_chips = configuration->property(role + ".very_early_late_space_chips", 0.6);
+    early_late_space_narrow_chips = configuration->property(role + ".early_late_space_narrow_chips", 0.15);
+    very_early_late_space_narrow_chips = configuration->property(role + ".very_early_late_space_narrow_chips", 0.6);
+
+    bool track_pilot=configuration->property(role + ".track_pilot", false);
 
     std::string default_dump_filename = "./track_ch";
     dump_filename = configuration->property(role + ".dump_filename",
@@ -88,8 +100,24 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
                     dump_filename,
                     pll_bw_hz,
                     dll_bw_hz,
+                    pll_bw_narrow_hz,
+                    dll_bw_narrow_hz,
                     early_late_space_chips,
-                    very_early_late_space_chips);
+                    very_early_late_space_chips,
+                    early_late_space_narrow_chips,
+                    very_early_late_space_narrow_chips,
+                    extend_correlation_symbols,
+                    track_pilot);
+//            tracking_ = galileo_e1_dll_pll_veml_make_tracking_cc(
+//                    f_if,
+//                    fs_in,
+//                    vector_length,
+//                    dump,
+//                    dump_filename,
+//                    pll_bw_hz,
+//                    dll_bw_hz,
+//                    early_late_space_chips,
+//                    very_early_late_space_chips);
         }
     else
         {

src/algorithms/tracking/gnuradio_blocks/galileo_e1_dll_pll_veml_tracking_cc.h

@@ -53,8 +53,14 @@ galileo_e1_dll_pll_veml_make_tracking_cc(long if_freq,
                                    std::string dump_filename,
                                    float pll_bw_hz,
                                    float dll_bw_hz,
+                                   float pll_bw_narrow_hz,
+                                   float dll_bw_narrow_hz,
                                    float early_late_space_chips,
-                                   float very_early_late_space_chips);
+                                   float very_early_late_space_chips,
+                                   float early_late_space_narrow_chips,
+                                   float very_early_late_space_narrow_chips,
+                                   int extend_correlation_symbols,
+                                   bool track_pilot);
 
 /*!
  * \brief This class implements a code DLL + carrier PLL VEML (Very Early
@@ -88,8 +94,14 @@ private:
             std::string dump_filename,
             float pll_bw_hz,
             float dll_bw_hz,
+            float pll_bw_narrow_hz,
+            float dll_bw_narrow_hz,
             float early_late_space_chips,
-            float very_early_late_space_chips);
+            float very_early_late_space_chips,
+            float early_late_space_narrow_chips,
+            float very_early_late_space_narrow_chips,
+            int extend_correlation_symbols,
+            bool track_pilot);
 
     galileo_e1_dll_pll_veml_tracking_cc(long if_freq,
             long fs_in, unsigned
@@ -98,12 +110,25 @@ private:
             std::string dump_filename,
             float pll_bw_hz,
             float dll_bw_hz,
+            float pll_bw_narrow_hz,
+            float dll_bw_narrow_hz,
             float early_late_space_chips,
-            float very_early_late_space_chips);
+            float very_early_late_space_chips,
+            float early_late_space_narrow_chips,
+            float very_early_late_space_narrow_chips,
+            int extend_correlation_symbols,
+            bool track_pilot);
 
+    bool cn0_and_tracking_lock_status();
+    void do_correlation_step(const gr_complex* input_samples);
+    void run_dll_pll(bool disable_costas_loop);
     void update_local_code();
-
     void update_local_carrier();
+    bool acquire_secondary();
+
+    void clear_tracking_vars();
+
+    void log_data();
 
     // tracking configuration vars
     unsigned int d_vector_length;
@@ -114,16 +139,29 @@ private:
     long d_if_freq;
     long d_fs_in;
 
+    //tracking state machine
+    int d_state;
+
     //Integration period in samples
     int d_correlation_length_samples;
     int d_n_correlator_taps;
     double d_early_late_spc_chips;
     double d_very_early_late_spc_chips;
 
-    float* d_ca_code;
+    double d_early_late_spc_narrow_chips;
+    double d_very_early_late_spc_narrow_chips;
+
+    float* d_tracking_code;
+    float* d_data_code;
     float* d_local_code_shift_chips;
     gr_complex* d_correlator_outs;
     cpu_multicorrelator_real_codes multicorrelator_cpu;
+    //todo: currently the multicorrelator does not support adding extra correlator
+    //with different local code, thus we need extra multicorrelator instance.
+    //Implement this functionality inside multicorrelator class
+    //as an enhancement to increase the performance
+    float* d_local_code_data_shift_chips;
+    cpu_multicorrelator_real_codes correlator_data_cpu; //for data channel
 
     gr_complex *d_Very_Early;
     gr_complex *d_Early;
@@ -131,6 +169,22 @@ private:
     gr_complex *d_Late;
     gr_complex *d_Very_Late;
 
+    int d_extend_correlation_symbols;
+    int d_extend_correlation_symbols_count;
+    bool d_enable_extended_integration;
+    int d_current_symbol;
+
+    gr_complex d_VE_accu;
+    gr_complex d_E_accu;
+    gr_complex d_P_accu;
+    gr_complex d_L_accu;
+    gr_complex d_VL_accu;
+
+    bool d_track_pilot;
+    gr_complex *d_Prompt_Data;
+
+    double d_code_phase_step_chips;
+    double d_carrier_phase_step_rad;
     // remaining code phase and carrier phase between tracking loops
     double d_rem_code_phase_samples;
     double d_rem_carr_phase_rad;
@@ -143,11 +197,24 @@ private:
     double d_acq_code_phase_samples;
     double d_acq_carrier_doppler_hz;
 
+    // tracking parameters
+    float d_dll_bw_hz;
+    float d_pll_bw_hz;
+    float d_dll_bw_narrow_hz;
+    float d_pll_bw_narrow_hz;
     // tracking vars
+    double d_carr_error_hz;
+    double d_carr_error_filt_hz;
+    double d_code_error_chips;
+    double d_code_error_filt_chips;
+
+    double d_K_blk_samples;
+
     double d_code_freq_chips;
     double d_carrier_doppler_hz;
     double d_acc_carrier_phase_rad;
-    double d_acc_code_phase_secs;
+    double d_rem_code_phase_chips;
+    double d_code_phase_samples;
 
     //PRN period in samples
     int d_current_prn_length_samples;
@@ -158,16 +225,13 @@ private:
 
     // CN0 estimation and lock detector
     int d_cn0_estimation_counter;
+    std::deque<gr_complex> d_Prompt_buffer_deque;
     gr_complex* d_Prompt_buffer;
     double d_carrier_lock_test;
     double d_CN0_SNV_dB_Hz;
     double 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;

src/core/system_parameters/Galileo_E1.h

@@ -57,7 +57,7 @@ const double Galileo_E1_SUB_CARRIER_A_RATE_HZ = 1.023e6; //!< Galileo E1 sub-car
 const double Galileo_E1_SUB_CARRIER_B_RATE_HZ = 6.138e6; //!< Galileo E1 sub-carrier 'b' rate [Hz]
 const double Galileo_E1_B_CODE_LENGTH_CHIPS = 4092.0;    //!< Galileo E1-B code length [chips]
 const double Galileo_E1_B_SYMBOL_RATE_BPS = 250.0;       //!< Galileo E1-B symbol rate [bits/second]
-const double Galileo_E1_C_SECONDARY_CODE_LENGTH = 25.0;  //!< Galileo E1-C secondary code length [chips]
+const int Galileo_E1_C_SECONDARY_CODE_LENGTH = 25;  //!< Galileo E1-C secondary code length [chips]
 const int Galileo_E1_NUMBER_OF_CODES = 50;
 
 const double GALILEO_STARTOFFSET_ms = 68.802; //[ms] Initial sign. travel time (this cannot go here)