Adding new algorithms of adquisition:

gps_l1_ca_pcps_multithread_acquisition
     gps_l1_ca_pcps_tong_acquisition
     galileo_e1_pcps_cccwsr_ambiguous_acquisition
     galileo_e1_pcps_tong_ambiguous_acquisition
     galileo_e1_pcps_8ms_ambiguous_acquisition

and test for all the algorithms.


git-svn-id: https://svn.code.sf.net/p/gnss-sdr/code/trunk@411 64b25241-fba3-4117-9849-534c7e92360d

src/algorithms/acquisition/adapters/CMakeLists.txt

@@ -17,10 +17,15 @@
 #
 
 set(ACQ_ADAPTER_SOURCES 
-     galileo_e1_pcps_ambiguous_acquisition.cc
-     gps_l1_ca_pcps_acquisition.cc 
+     gps_l1_ca_pcps_acquisition.cc
+     gps_l1_ca_pcps_multithread_acquisition.cc
      gps_l1_ca_pcps_assisted_acquisition.cc
      gps_l1_ca_pcps_acquisition_fine_doppler.cc
+     gps_l1_ca_pcps_tong_acquisition.cc
+     galileo_e1_pcps_ambiguous_acquisition.cc
+     galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc
+     galileo_e1_pcps_tong_ambiguous_acquisition.cc
+     galileo_e1_pcps_8ms_ambiguous_acquisition.cc
 )
 
 include_directories(

src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc

@@ -0,0 +1,312 @@
+/*!
+ * \file galileo_e1_pcps_8ms_ambiguous_acquisition.cc
+ * \brief Adapts a Galileo PCPS 8ms acquisition block to an
+ * AcquisitionInterface for Galileo E1 Signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e1_pcps_8ms_ambiguous_acquisition.h"
+#include "galileo_e1_signal_processing.h"
+#include "Galileo_E1.h"
+#include "configuration_interface.h"
+#include <iostream>
+#include <string>
+#include <boost/lexical_cast.hpp>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <boost/math/distributions/exponential.hpp>
+
+using google::LogMessage;
+
+GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition(
+        ConfigurationInterface* configuration, std::string role,
+        unsigned int in_streams, unsigned int out_streams,
+        boost::shared_ptr<gr::msg_queue> queue) :
+        role_(role), in_streams_(in_streams), out_streams_(out_streams), queue_(queue)
+{
+    configuration_ = configuration;
+    std::string default_item_type = "gr_complex";
+    std::string default_dump_filename = "../data/acquisition.dat";
+
+    DLOG(INFO) << "role " << role;
+
+    item_type_ = configuration_->property(role + ".item_type",
+            default_item_type);
+
+    fs_in_ = configuration_->property("GNSS-SDR.internal_fs_hz", 4000000);
+    if_ = configuration_->property(role + ".ifreq", 0);
+    dump_ = configuration_->property(role + ".dump", false);
+    shift_resolution_ = configuration_->property(role + ".doppler_max", 15);
+    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 4);
+
+    if (sampled_ms_ % 4 != 0)
+        {
+            sampled_ms_ = (int)(sampled_ms_/4) * 4;
+            LOG_AT_LEVEL(WARNING) << "coherent_integration_time should be multiple of "
+                                     << "Galileo code length (4 ms). coherent_integration_time = "
+                                     << sampled_ms_ << " ms will be used.";
+
+        }
+
+    max_dwells_ = configuration_->property(role + ".max_dwells", 1);
+
+    dump_filename_ = configuration_->property(role + ".dump_filename",
+            default_dump_filename);
+
+    //--- Find number of samples per spreading code (4 ms)  -----------------
+
+    code_length_ = round(
+            fs_in_
+            / (Galileo_E1_CODE_CHIP_RATE_HZ
+                    / Galileo_E1_B_CODE_LENGTH_CHIPS));
+
+    vector_length_ = code_length_ * (int)(sampled_ms_/4);
+
+    int samples_per_ms = code_length_ / 4;
+
+    code_ = new gr_complex[vector_length_];
+
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            item_size_ = sizeof(gr_complex);
+            acquisition_cc_ = galileo_pcps_8ms_make_acquisition_cc(sampled_ms_, max_dwells_,
+                    shift_resolution_, if_, fs_in_, samples_per_ms, code_length_,
+                    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()
+                    << ")";
+        }
+    else
+        {
+            LOG_AT_LEVEL(WARNING) << item_type_
+                    << " unknown acquisition item type";
+        }
+}
+
+
+GalileoE1Pcps8msAmbiguousAcquisition::~GalileoE1Pcps8msAmbiguousAcquisition()
+{
+    delete[] code_;
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::set_channel(unsigned int channel)
+{
+    channel_ = channel;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel(channel_);
+        }
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::set_threshold(float threshold)
+{
+
+	float pfa = configuration_->property(role_+ boost::lexical_cast<std::string>(channel_) + ".pfa", 0.0);
+
+	if(pfa==0.0) pfa = configuration_->property(role_+".pfa", 0.0);
+
+	if(pfa==0.0)
+        {
+            threshold_ = threshold;
+        }
+	else
+        {
+            threshold_ = calculate_threshold(pfa);
+        }
+
+	DLOG(INFO) <<"Channel "<<channel_<<" Threshold = " << threshold_;
+
+	if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_threshold(threshold_);
+        }
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::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
+GalileoE1Pcps8msAmbiguousAcquisition::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
+GalileoE1Pcps8msAmbiguousAcquisition::set_channel_queue(
+        concurrent_queue<int> *channel_internal_queue)
+{
+    channel_internal_queue_ = channel_internal_queue;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel_queue(channel_internal_queue_);
+        }
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::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
+GalileoE1Pcps8msAmbiguousAcquisition::mag()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            return acquisition_cc_->mag();
+        }
+    else
+        {
+            return 0;
+        }
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::init()
+{
+    acquisition_cc_->init();
+    set_local_code();
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::set_local_code()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            bool cboc = configuration_->property(
+                    "Acquisition" + boost::lexical_cast<std::string>(channel_)
+                            + ".cboc", false);
+
+            std::complex<float> * code = new std::complex<float>[code_length_];
+
+            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++)
+                {
+                    memcpy(&(code_[i*code_length_]), code,
+                           sizeof(gr_complex)*code_length_);
+                }
+
+            acquisition_cc_->set_local_code(code_);
+
+            delete[] code;
+        }
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::reset()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_active(true);
+        }
+}
+
+float GalileoE1Pcps8msAmbiguousAcquisition::calculate_threshold(float pfa)
+{
+	unsigned int frequency_bins = 0;
+	for (int doppler = (int)(-doppler_max_); doppler <= (int)doppler_max_; doppler += doppler_step_)
+	{
+	 	frequency_bins++;
+	}
+
+	DLOG(INFO) <<"Channel "<<channel_<<"  Pfa = "<< pfa;
+
+    unsigned int ncells = vector_length_*frequency_bins;
+	double exponent = 1/(double)ncells;
+	double val = pow(1.0-pfa,exponent);
+    double lambda = double(vector_length_);
+	boost::math::exponential_distribution<double> mydist (lambda);
+	float threshold = (float)quantile(mydist,val);
+
+    return threshold;
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::connect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+}
+
+
+void
+GalileoE1Pcps8msAmbiguousAcquisition::disconnect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+}
+
+
+gr::basic_block_sptr GalileoE1Pcps8msAmbiguousAcquisition::get_left_block()
+{
+    return stream_to_vector_;
+}
+
+
+gr::basic_block_sptr GalileoE1Pcps8msAmbiguousAcquisition::get_right_block()
+{
+    return acquisition_cc_;
+}
+

src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.h

@@ -0,0 +1,159 @@
+/*!
+ * \file galileo_e1_pcps_8ms_ambiguous_acquisition.h
+ * \brief Adapts a PCPS 8ms acquisition block to an
+ * AcquisitionInterface for Galileo E1 Signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_E1_PCPS_8MS_AMBIGUOUS_ACQUISITION_H_
+#define GNSS_SDR_GALILEO_E1_PCPS_8MS_AMBIGUOUS_ACQUISITION_H_
+
+#include "gnss_synchro.h"
+#include "acquisition_interface.h"
+#include "galileo_pcps_8ms_acquisition_cc.h"
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/blocks/stream_to_vector.h>
+
+class ConfigurationInterface;
+
+/*!
+ * \brief Adapts a PCPS 8ms acquisition block to an
+ * AcquisitionInterface for Galileo E1 Signals
+ */
+class GalileoE1Pcps8msAmbiguousAcquisition: public AcquisitionInterface
+{
+public:
+    GalileoE1Pcps8msAmbiguousAcquisition(ConfigurationInterface* configuration,
+            std::string role, unsigned int in_streams,
+            unsigned int out_streams, boost::shared_ptr<gr::msg_queue> queue);
+
+    virtual ~GalileoE1Pcps8msAmbiguousAcquisition();
+
+    std::string role()
+    {
+        return role_;
+    }
+
+    /*!
+     * \brief Returns "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition"
+     */
+    std::string implementation()
+    {
+        return "Galileo_E1_PCPS_8ms_Ambiguous_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<int> *channel_internal_queue);
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    /*!
+     * \brief Sets local code for Galileo E1 PCPS acquisition algorithm.
+     */
+    void set_local_code();
+
+    /*!
+     * \brief Returns the maximum peak of grid search
+     */
+    signed int mag();
+
+    /*!
+     * \brief Restart acquisition algorithm
+     */
+    void reset();
+
+private:
+    ConfigurationInterface* configuration_;
+    galileo_pcps_8ms_acquisition_cc_sptr acquisition_cc_;
+    gr::blocks::stream_to_vector::sptr stream_to_vector_;
+    size_t item_size_;
+    std::string item_type_;
+    unsigned int vector_length_;
+    unsigned int code_length_;
+    unsigned int channel_;
+    float threshold_;
+    unsigned int doppler_max_;
+    unsigned int doppler_step_;
+    unsigned int shift_resolution_;
+    unsigned int sampled_ms_;
+    unsigned int max_dwells_;
+    long fs_in_;
+    long if_;
+    bool dump_;
+    std::string dump_filename_;
+    std::complex<float> * code_;
+    Gnss_Synchro * gnss_synchro_;
+    std::string role_;
+    unsigned int in_streams_;
+    unsigned int out_streams_;
+    boost::shared_ptr<gr::msg_queue> queue_;
+    concurrent_queue<int> *channel_internal_queue_;
+    float calculate_threshold(float pfa);
+};
+
+#endif /* GNSS_SDR_GALILEO_E1_PCPS_8MS_AMBIGUOUS_ACQUISITION_H_ */

src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc

@@ -6,7 +6,7 @@
  *
  * -------------------------------------------------------------------------
  *
- * Copyright (C) 2010-2011  (see AUTHORS file for a list of contributors)
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
  *
  * GNSS-SDR is a software defined Global Navigation
  *          Satellite Systems receiver
@@ -61,30 +61,51 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition(
     if_ = configuration_->property(role + ".ifreq", 0);
     dump_ = configuration_->property(role + ".dump", false);
     shift_resolution_ = configuration_->property(role + ".doppler_max", 15);
-    sampled_ms_ = configuration_->property(role + ".sampled_ms", 4);
+    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 4);
+
+    if (sampled_ms_ % 4 != 0)
+        {
+            sampled_ms_ = (int)(sampled_ms_/4) * 4;
+            LOG_AT_LEVEL(WARNING) << "coherent_integration_time should be multiple of "
+                                     << "Galileo code length (4 ms). coherent_integration_time = "
+                                     << sampled_ms_ << " ms will be used.";
+
+        }
+
+    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 (4 ms)  -----------------
 
-    vector_length_ = round(
+    code_length_ = round(
             fs_in_
             / (Galileo_E1_CODE_CHIP_RATE_HZ
                     / Galileo_E1_B_CODE_LENGTH_CHIPS));
 
-    int samples_per_ms = vector_length_ / 4;
+    vector_length_ = code_length_ * (int)(sampled_ms_/4);
 
-    vector_length_ = samples_per_ms * 4;
+    int samples_per_ms = code_length_ / 4;
 
-    code_ = new gr_complex[samples_per_ms*sampled_ms_];
+    code_ = new gr_complex[vector_length_];
 
     if (item_type_.compare("gr_complex") == 0)
         {
             item_size_ = sizeof(gr_complex);
-            acquisition_cc_ = pcps_make_acquisition_cc(sampled_ms_,
-                    shift_resolution_, if_, fs_in_, samples_per_ms, vector_length_,
-                    queue_, dump_, dump_filename_);
-            stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, samples_per_ms * sampled_ms_);
+            acquisition_cc_ = pcps_make_acquisition_cc(sampled_ms_, max_dwells_,
+                    shift_resolution_, if_, fs_in_, samples_per_ms, 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()
@@ -124,13 +145,13 @@ GalileoE1PcpsAmbiguousAcquisition::set_threshold(float threshold)
 	if(pfa==0.0) pfa = configuration_->property(role_+".pfa", 0.0);
 
 	if(pfa==0.0)
-	{
-		threshold_ = threshold;
-	}
+        {
+            threshold_ = threshold;
+        }
 	else
-    {
-		threshold_ = calculate_threshold(pfa);
-	}
+        {
+            threshold_ = calculate_threshold(pfa);
+        }
 
 	DLOG(INFO) <<"Channel "<<channel_<<" Threshold = " << threshold_;
 
@@ -150,7 +171,6 @@ GalileoE1PcpsAmbiguousAcquisition::set_doppler_max(unsigned int doppler_max)
         {
             acquisition_cc_->set_doppler_max(doppler_max_);
         }
-
 }
 
 
@@ -162,7 +182,6 @@ GalileoE1PcpsAmbiguousAcquisition::set_doppler_step(unsigned int doppler_step)
         {
             acquisition_cc_->set_doppler_step(doppler_step_);
         }
-
 }
 
 
@@ -211,6 +230,7 @@ GalileoE1PcpsAmbiguousAcquisition::init()
     set_local_code();
 }
 
+
 void
 GalileoE1PcpsAmbiguousAcquisition::set_local_code()
 {
@@ -220,18 +240,20 @@ GalileoE1PcpsAmbiguousAcquisition::set_local_code()
                     "Acquisition" + boost::lexical_cast<std::string>(channel_)
                             + ".cboc", false);
 
-            std::complex<float> * code = new std::complex<float>[vector_length_];
+            std::complex<float> * code = new std::complex<float>[code_length_];
 
             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++)
                 {
-                    memcpy(&(code_[i*vector_length_]), code,
-                           sizeof(gr_complex)*vector_length_);
+                    memcpy(&(code_[i*code_length_]), code,
+                           sizeof(gr_complex)*code_length_);
                 }
 
             acquisition_cc_->set_local_code(code_);
+
+            delete[] code;
         }
 }
 
@@ -255,14 +277,14 @@ float GalileoE1PcpsAmbiguousAcquisition::calculate_threshold(float pfa)
 
 	DLOG(INFO) <<"Channel "<<channel_<<"  Pfa = "<< pfa;
 
-	unsigned int ncells = vector_length_*frequency_bins;
+    unsigned int ncells = vector_length_*frequency_bins;
 	double exponent = 1/(double)ncells;
 	double val = pow(1.0-pfa,exponent);
-	double lambda = double(vector_length_);
+    double lambda = double(vector_length_);
 	boost::math::exponential_distribution<double> mydist (lambda);
 	float threshold = (float)quantile(mydist,val);
 
-	return threshold;
+    return threshold;
 }
 
 
@@ -273,11 +295,9 @@ GalileoE1PcpsAmbiguousAcquisition::connect(gr::top_block_sptr top_block)
         {
             top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0);
         }
-
 }
 
 
-
 void
 GalileoE1PcpsAmbiguousAcquisition::disconnect(gr::top_block_sptr top_block)
 {
@@ -288,14 +308,12 @@ GalileoE1PcpsAmbiguousAcquisition::disconnect(gr::top_block_sptr top_block)
 }
 
 
-
 gr::basic_block_sptr GalileoE1PcpsAmbiguousAcquisition::get_left_block()
 {
     return stream_to_vector_;
 }
 
 
-
 gr::basic_block_sptr GalileoE1PcpsAmbiguousAcquisition::get_right_block()
 {
     return acquisition_cc_;

src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.h

@@ -4,7 +4,6 @@
  *  Galileo E1 Signals
  * \author Luis Esteve, 2012. luis(at)epsilon-formacion.com
  *
- *
  * -------------------------------------------------------------------------
  *
  * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
@@ -42,8 +41,8 @@
 class ConfigurationInterface;
 
 /*!
- * \brief This class adapts a PCPS acquisition block to an AcquisitionInterface
- *  for Galileo E1 Signals
+ * \brief This class adapts a PCPS acquisition block to an
+ *  AcquisitionInterface for Galileo E1 Signals
  */
 class GalileoE1PcpsAmbiguousAcquisition: public AcquisitionInterface
 {
@@ -116,7 +115,6 @@ public:
     /*!
      * \brief Sets local code for Galileo E1 PCPS acquisition algorithm.
      */
-
     void set_local_code();
 
     /*!
@@ -136,13 +134,15 @@ private:
     size_t item_size_;
     std::string item_type_;
     unsigned int vector_length_;
-    //unsigned int satellite_;
+    unsigned int code_length_;
+    bool bit_transition_flag_;
     unsigned int channel_;
     float threshold_;
     unsigned int doppler_max_;
     unsigned int doppler_step_;
     unsigned int shift_resolution_;
     unsigned int sampled_ms_;
+    unsigned int max_dwells_;
     long fs_in_;
     long if_;
     bool dump_;

src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc

@@ -0,0 +1,303 @@
+/*!
+ * \file galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc
+ * \brief Adapts a PCPS CCCWSR acquisition block to an AcquisitionInterface for
+ *  Galileo E1 Signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2011  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e1_pcps_cccwsr_ambiguous_acquisition.h"
+#include "galileo_e1_signal_processing.h"
+#include "Galileo_E1.h"
+#include "configuration_interface.h"
+#include <iostream>
+#include <string>
+#include <boost/lexical_cast.hpp>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <boost/math/distributions/exponential.hpp>
+#include <volk/volk.h>
+
+
+using google::LogMessage;
+
+GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition(
+        ConfigurationInterface* configuration, std::string role,
+        unsigned int in_streams, unsigned int out_streams,
+        boost::shared_ptr<gr::msg_queue> queue) :
+        role_(role), in_streams_(in_streams), out_streams_(out_streams), queue_(queue)
+{
+    configuration_ = configuration;
+    std::string default_item_type = "gr_complex";
+    std::string default_dump_filename = "../data/acquisition.dat";
+
+    DLOG(INFO) << "role " << role;
+
+    item_type_ = configuration_->property(role + ".item_type",
+            default_item_type);
+
+    fs_in_ = configuration_->property("GNSS-SDR.internal_fs_hz", 4000000);
+    if_ = configuration_->property(role + ".ifreq", 0);
+    dump_ = configuration_->property(role + ".dump", false);
+    shift_resolution_ = configuration_->property(role + ".doppler_max", 15);
+    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 4);
+
+    if (sampled_ms_ % 4 != 0)
+        {
+            sampled_ms_ = (int)(sampled_ms_/4) * 4;
+            LOG_AT_LEVEL(WARNING) << "coherent_integration_time should be multiple of "
+                                  << "Galileo code length (4 ms). coherent_integration_time = "
+                                  << sampled_ms_ << " ms will be used.";
+        }
+
+    max_dwells_ = configuration_->property(role + ".max_dwells", 1);
+
+    dump_filename_ = configuration_->property(role + ".dump_filename",
+            default_dump_filename);
+
+    //--- Find number of samples per spreading code (4 ms)  -----------------
+
+    code_length_ = round(
+            fs_in_
+            / (Galileo_E1_CODE_CHIP_RATE_HZ
+                    / Galileo_E1_B_CODE_LENGTH_CHIPS));
+
+    vector_length_ = code_length_ * (int)(sampled_ms_/4);
+
+    int samples_per_ms = code_length_ / 4;
+
+    code_data_  = new gr_complex[vector_length_];
+    code_pilot_ = new gr_complex[vector_length_];
+
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            item_size_ = sizeof(gr_complex);
+            acquisition_cc_ = pcps_cccwsr_make_acquisition_cc(sampled_ms_, max_dwells_,
+                    shift_resolution_, if_, fs_in_, samples_per_ms, code_length_,
+                    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()
+                    << ")";
+        }
+    else
+        {
+            LOG_AT_LEVEL(WARNING) << item_type_
+                    << " unknown acquisition item type";
+        }
+}
+
+
+GalileoE1PcpsCccwsrAmbiguousAcquisition::~GalileoE1PcpsCccwsrAmbiguousAcquisition()
+{
+    delete[] code_data_;
+    delete[] code_pilot_;
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::set_channel(unsigned int channel)
+{
+    channel_ = channel;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel(channel_);
+        }
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::set_threshold(float threshold)
+{
+
+//    float pfa = configuration_->property(role_+ boost::lexical_cast<std::string>(channel_) + ".pfa", 0.0);
+
+//    if(pfa==0.0) pfa = configuration_->property(role_+".pfa", 0.0);
+
+//    if(pfa==0.0)
+//        {
+//            threshold_ = threshold;
+//        }
+//    else
+//        {
+//            threshold_ = calculate_threshold(pfa);
+//        }
+
+    threshold_ = threshold;
+
+	DLOG(INFO) <<"Channel "<<channel_<<" Threshold = " << threshold_;
+
+	if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_threshold(threshold_);
+        }
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::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
+GalileoE1PcpsCccwsrAmbiguousAcquisition::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
+GalileoE1PcpsCccwsrAmbiguousAcquisition::set_channel_queue(
+        concurrent_queue<int> *channel_internal_queue)
+{
+    channel_internal_queue_ = channel_internal_queue;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel_queue(channel_internal_queue_);
+        }
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::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
+GalileoE1PcpsCccwsrAmbiguousAcquisition::mag()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            return acquisition_cc_->mag();
+        }
+    else
+        {
+            return 0;
+        }
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::init()
+{
+    acquisition_cc_->init();
+    set_local_code();
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::set_local_code()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            bool cboc = configuration_->property(
+                    "Acquisition" + boost::lexical_cast<std::string>(channel_)
+                            + ".cboc", false);
+
+            char signal[3];
+
+            strcpy(signal, "1B");
+
+            galileo_e1_code_gen_complex_sampled(code_data_, signal,
+                    cboc, gnss_synchro_->PRN, fs_in_, 0, false);
+
+            strcpy(signal, "1C");
+
+            galileo_e1_code_gen_complex_sampled(code_pilot_, signal,
+                    cboc, gnss_synchro_->PRN, fs_in_, 0, false);
+
+            acquisition_cc_->set_local_code(code_data_, code_pilot_);
+        }
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::reset()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_active(true);
+        }
+}
+
+
+float GalileoE1PcpsCccwsrAmbiguousAcquisition::calculate_threshold(float pfa)
+{
+    return 0.0;
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::connect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+
+}
+
+
+void
+GalileoE1PcpsCccwsrAmbiguousAcquisition::disconnect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+}
+
+
+gr::basic_block_sptr GalileoE1PcpsCccwsrAmbiguousAcquisition::get_left_block()
+{
+    return stream_to_vector_;
+}
+
+
+gr::basic_block_sptr GalileoE1PcpsCccwsrAmbiguousAcquisition::get_right_block()
+{
+    return acquisition_cc_;
+}
+

src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.h

@@ -0,0 +1,158 @@
+/*!
+ * \file galileo_e1_pcps_cccwsr_ambiguous_acquisition.h
+ * \brief Adapts a PCPS CCCWSR acquisition block to an AcquisitionInterface for
+ *  Galileo E1 Signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_E1_PCPS_CCCWSR_AMBIGUOUS_ACQUISITION_H_
+#define GNSS_SDR_GALILEO_E1_PCPS_CCCWSR_AMBIGUOUS_ACQUISITION_H_
+
+#include "gnss_synchro.h"
+#include "acquisition_interface.h"
+#include "pcps_cccwsr_acquisition_cc.h"
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/blocks/stream_to_vector.h>
+
+class ConfigurationInterface;
+
+/*!
+ * \brief Adapts a PCPS CCCWSR acquisition block to an AcquisitionInterface
+ *  for Galileo E1 Signals
+ */
+class GalileoE1PcpsCccwsrAmbiguousAcquisition: public AcquisitionInterface
+{
+public:
+    GalileoE1PcpsCccwsrAmbiguousAcquisition(ConfigurationInterface* configuration,
+            std::string role, unsigned int in_streams,
+            unsigned int out_streams, boost::shared_ptr<gr::msg_queue> queue);
+
+    virtual ~GalileoE1PcpsCccwsrAmbiguousAcquisition();
+
+    std::string role()
+    {
+        return role_;
+    }
+
+    /*!
+     * \brief Returns "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition"
+     */
+    std::string implementation()
+    {
+        return "Galileo_E1_PCPS_CCCWSR_Ambiguous_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 CCCWSR algorithm
+     */
+    void set_threshold(float threshold);
+
+    /*!
+     * \brief Set maximum Doppler off grid search
+     */
+    void set_doppler_max(unsigned int doppler_max);
+
+    /*!
+     * \brief Set Doppler steps for the grid search
+     */
+    void set_doppler_step(unsigned int doppler_step);
+
+    /*!
+     * \brief Set tracking channel internal queue
+     */
+    void set_channel_queue(concurrent_queue<int> *channel_internal_queue);
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    void set_local_code();
+
+    /*!
+     * \brief Returns the maximum peak of grid search
+     */
+    signed int mag();
+
+    /*!
+     * \brief Restart acquisition algorithm
+     */
+    void reset();
+
+private:
+    ConfigurationInterface* configuration_;
+    pcps_cccwsr_acquisition_cc_sptr acquisition_cc_;
+    gr::blocks::stream_to_vector::sptr stream_to_vector_;
+    size_t item_size_;
+    std::string item_type_;
+    unsigned int vector_length_;
+    unsigned int code_length_;
+    //unsigned int satellite_;
+    unsigned int channel_;
+    float threshold_;
+    unsigned int doppler_max_;
+    unsigned int doppler_step_;
+    unsigned int shift_resolution_;
+    unsigned int sampled_ms_;
+    unsigned int max_dwells_;
+    long fs_in_;
+    long if_;
+    bool dump_;
+    std::string dump_filename_;
+    std::complex<float> * code_data_;
+    std::complex<float> * code_pilot_;
+    Gnss_Synchro * gnss_synchro_;
+    std::string role_;
+    unsigned int in_streams_;
+    unsigned int out_streams_;
+    boost::shared_ptr<gr::msg_queue> queue_;
+    concurrent_queue<int> *channel_internal_queue_;
+    float calculate_threshold(float pfa);
+};
+
+#endif /* GNSS_SDR_GALILEO_E1_PCPS_CCCWSR_AMBIGUOUS_ACQUISITION_H_ */

src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc

@@ -0,0 +1,316 @@
+/*!
+ * \file galileo_e1_pcps_tong_ambiguous_acquisition.cc
+ * \brief Adapts a PCPS Tong acquisition block to an Acq1uisitionInterface for
+ *  Galileo E1 Signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2011  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_e1_pcps_tong_ambiguous_acquisition.h"
+#include "galileo_e1_signal_processing.h"
+#include "Galileo_E1.h"
+#include "configuration_interface.h"
+#include <iostream>
+#include <string>
+#include <boost/lexical_cast.hpp>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <boost/math/distributions/exponential.hpp>
+
+using google::LogMessage;
+
+GalileoE1PcpsTongAmbiguousAcquisition::GalileoE1PcpsTongAmbiguousAcquisition(
+        ConfigurationInterface* configuration, std::string role,
+        unsigned int in_streams, unsigned int out_streams,
+        boost::shared_ptr<gr::msg_queue> queue) :
+        role_(role), in_streams_(in_streams), out_streams_(out_streams), queue_(queue)
+{
+    configuration_ = configuration;
+    std::string default_item_type = "gr_complex";
+    std::string default_dump_filename = "../data/acquisition.dat";
+
+    DLOG(INFO) << "role " << role;
+
+    item_type_ = configuration_->property(role + ".item_type",
+            default_item_type);
+
+    fs_in_ = configuration_->property("GNSS-SDR.internal_fs_hz", 4000000);
+    if_ = configuration_->property(role + ".ifreq", 0);
+    dump_ = configuration_->property(role + ".dump", false);
+    shift_resolution_ = configuration_->property(role + ".doppler_max", 15);
+    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 4);
+
+    if (sampled_ms_ % 4 != 0)
+        {
+            sampled_ms_ = (int)(sampled_ms_/4) * 4;
+            LOG_AT_LEVEL(WARNING) << "coherent_integration_time should be multiple of "
+                                     << "Galileo code length (4 ms). coherent_integration_time = "
+                                     << sampled_ms_ << " ms will be used.";
+
+        }
+
+    tong_init_val_ = configuration->property(role + ".tong_init_val", 1);
+    tong_max_val_ = configuration->property(role + ".tong_max_val", 2);
+
+    dump_filename_ = configuration_->property(role + ".dump_filename",
+            default_dump_filename);
+
+    //--- Find number of samples per spreading code (4 ms)  -----------------
+
+    code_length_ = round(
+            fs_in_
+            / (Galileo_E1_CODE_CHIP_RATE_HZ
+                    / Galileo_E1_B_CODE_LENGTH_CHIPS));
+
+    vector_length_ = code_length_ * (int)(sampled_ms_/4);
+
+    int samples_per_ms = code_length_ / 4;
+
+    code_ = new gr_complex[vector_length_];
+
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            item_size_ = sizeof(gr_complex);
+            acquisition_cc_ = pcps_tong_make_acquisition_cc(sampled_ms_, shift_resolution_,
+                    if_, fs_in_, samples_per_ms, code_length_, tong_init_val_,
+                    tong_max_val_, 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()
+                    << ")";
+        }
+    else
+        {
+            LOG_AT_LEVEL(WARNING) << item_type_
+                    << " unknown acquisition item type";
+        }
+}
+
+
+GalileoE1PcpsTongAmbiguousAcquisition::~GalileoE1PcpsTongAmbiguousAcquisition()
+{
+    delete[] code_;
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::set_channel(unsigned int channel)
+{
+    channel_ = channel;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel(channel_);
+        }
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::set_threshold(float threshold)
+{
+
+	float pfa = configuration_->property(role_+ boost::lexical_cast<std::string>(channel_) + ".pfa", 0.0);
+
+	if(pfa==0.0) pfa = configuration_->property(role_+".pfa", 0.0);
+
+	if(pfa==0.0)
+        {
+            threshold_ = threshold;
+        }
+	else
+        {
+            threshold_ = calculate_threshold(pfa);
+        }
+
+	DLOG(INFO) <<"Channel "<<channel_<<" Threshold = " << threshold_;
+
+	if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_threshold(threshold_);
+        }
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::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
+GalileoE1PcpsTongAmbiguousAcquisition::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
+GalileoE1PcpsTongAmbiguousAcquisition::set_channel_queue(
+        concurrent_queue<int> *channel_internal_queue)
+{
+    channel_internal_queue_ = channel_internal_queue;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel_queue(channel_internal_queue_);
+        }
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::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
+GalileoE1PcpsTongAmbiguousAcquisition::mag()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            return acquisition_cc_->mag();
+        }
+    else
+        {
+            return 0;
+        }
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::init()
+{
+    acquisition_cc_->init();
+    set_local_code();
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::set_local_code()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            bool cboc = configuration_->property(
+                    "Acquisition" + boost::lexical_cast<std::string>(channel_)
+                            + ".cboc", false);
+
+            std::complex<float> * code = new std::complex<float>[code_length_];
+
+            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++)
+                {
+                    memcpy(&(code_[i*code_length_]), code,
+                           sizeof(gr_complex)*code_length_);
+                }
+
+            acquisition_cc_->set_local_code(code_);
+
+            delete[] code;
+        }
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::reset()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_active(true);
+        }
+}
+
+
+float GalileoE1PcpsTongAmbiguousAcquisition::calculate_threshold(float pfa)
+{
+	unsigned int frequency_bins = 0;
+	for (int doppler = (int)(-doppler_max_); doppler <= (int)doppler_max_; doppler += doppler_step_)
+	{
+	 	frequency_bins++;
+	}
+
+	DLOG(INFO) <<"Channel "<<channel_<<"  Pfa = "<< pfa;
+
+	unsigned int ncells = vector_length_*frequency_bins;
+	double exponent = 1/(double)ncells;
+	double val = pow(1.0-pfa,exponent);
+	double lambda = double(vector_length_);
+	boost::math::exponential_distribution<double> mydist (lambda);
+	float threshold = (float)quantile(mydist,val);
+
+	return threshold;
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::connect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+}
+
+
+void
+GalileoE1PcpsTongAmbiguousAcquisition::disconnect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+}
+
+
+gr::basic_block_sptr GalileoE1PcpsTongAmbiguousAcquisition::get_left_block()
+{
+    return stream_to_vector_;
+}
+
+
+gr::basic_block_sptr GalileoE1PcpsTongAmbiguousAcquisition::get_right_block()
+{
+    return acquisition_cc_;
+}
+

src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.h

@@ -0,0 +1,161 @@
+/*!
+ * \file galileo_e1_pcps_tong_ambiguous_acquisition.h
+ * \brief Adapts a PCPS Tong acquisition block to an AcquisitionInterface for
+ *  Galileo E1 Signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GALILEO_E1_PCPS_TONG_AMBIGUOUS_ACQUISITION_H_
+#define GNSS_SDR_GALILEO_E1_PCPS_TONG_AMBIGUOUS_ACQUISITION_H_
+
+#include "gnss_synchro.h"
+#include "acquisition_interface.h"
+#include "pcps_tong_acquisition_cc.h"
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/blocks/stream_to_vector.h>
+
+class ConfigurationInterface;
+
+/*!
+ * \brief Adapts a PCPS Tong acquisition block to an AcquisitionInterface
+ *  for Galileo E1 Signals
+ */
+class GalileoE1PcpsTongAmbiguousAcquisition: public AcquisitionInterface
+{
+public:
+    GalileoE1PcpsTongAmbiguousAcquisition(ConfigurationInterface* configuration,
+            std::string role, unsigned int in_streams,
+            unsigned int out_streams, boost::shared_ptr<gr::msg_queue> queue);
+
+    virtual ~GalileoE1PcpsTongAmbiguousAcquisition();
+
+    std::string role()
+    {
+        return role_;
+    }
+
+    /*!
+     * \brief Returns "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition"
+     */
+    std::string implementation()
+    {
+        return "Galileo_E1_PCPS_Tong_Ambiguous_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 TONG algorithm
+     */
+    void set_threshold(float threshold);
+
+    /*!
+     * \brief Set maximum Doppler off grid search
+     */
+    void set_doppler_max(unsigned int doppler_max);
+
+    /*!
+     * \brief Set Doppler steps for the grid search
+     */
+    void set_doppler_step(unsigned int doppler_step);
+
+    /*!
+     * \brief Set tracking channel internal queue
+     */
+    void set_channel_queue(concurrent_queue<int> *channel_internal_queue);
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    /*!
+     * \brief Sets local code for Galileo E1 TONG acquisition algorithm.
+     */
+    void set_local_code();
+
+    /*!
+     * \brief Returns the maximum peak of grid search
+     */
+    signed int mag();
+
+    /*!
+     * \brief Restart acquisition algorithm
+     */
+    void reset();
+
+private:
+    ConfigurationInterface* configuration_;
+    pcps_tong_acquisition_cc_sptr acquisition_cc_;
+    gr::blocks::stream_to_vector::sptr stream_to_vector_;
+    size_t item_size_;
+    std::string item_type_;
+    unsigned int vector_length_;
+    unsigned int code_length_;
+    bool bit_transition_flag_;
+    unsigned int channel_;
+    float threshold_;
+    unsigned int doppler_max_;
+    unsigned int doppler_step_;
+    unsigned int shift_resolution_;
+    unsigned int sampled_ms_;
+    unsigned int tong_init_val_;
+    unsigned int tong_max_val_;
+    long fs_in_;
+    long if_;
+    bool dump_;
+    std::string dump_filename_;
+    std::complex<float> * code_;
+    Gnss_Synchro * gnss_synchro_;
+    std::string role_;
+    unsigned int in_streams_;
+    unsigned int out_streams_;
+    boost::shared_ptr<gr::msg_queue> queue_;
+    concurrent_queue<int> *channel_internal_queue_;
+    float calculate_threshold(float pfa);
+};
+
+#endif /* GNSS_SDR_GALILEO_E1_PCPS_TONG_AMBIGUOUS_ACQUISITION_H_ */

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc

@@ -1,10 +1,11 @@
 /*!
  * \file gps_l1_ca_pcps_acquisition.cc
  * \brief Adapts a PCPS acquisition block to an AcquisitionInterface for
- *  GPS L1 C/A Signals
+ *  GPS L1 C/A signals
  * \authors <ul>
  *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
  *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          <li> Marc Molina, 2013. marc.molina.pena(at)gmail.com
  *          </ul>
  *
  * -------------------------------------------------------------------------
@@ -57,33 +58,45 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition(
 
     DLOG(INFO) << "role " << role;
 
-//    std::cout << "role " << role_ << std::endl;
-
     item_type_ = configuration_->property(role + ".item_type",
             default_item_type);
 
     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", 10000);
-    sampled_ms_ = configuration_->property(role + ".sampled_ms", 1);
+    shift_resolution_ = configuration_->property(role + ".doppler_max", 15);
+    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1);
+
+    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 -------------------------
-    vector_length_ = round(fs_in_
+    code_length_ = round(fs_in_
             / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS));
 
-    code_= new gr_complex[vector_length_ * sampled_ms_];
+    vector_length_ = code_length_ * sampled_ms_;
+
+    code_= new gr_complex[vector_length_];
 
     if (item_type_.compare("gr_complex") == 0)
     {
         item_size_ = sizeof(gr_complex);
-        acquisition_cc_ = pcps_make_acquisition_cc(sampled_ms_,
-                shift_resolution_, if_, fs_in_, vector_length_, vector_length_, queue_,
-                dump_, dump_filename_);
+        acquisition_cc_ = pcps_make_acquisition_cc(sampled_ms_, 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_*sampled_ms_);
+        stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);
 
         DLOG(INFO) << "stream_to_vector(" << stream_to_vector_->unique_id()
                 << ")";
@@ -154,9 +167,9 @@ void GpsL1CaPcpsAcquisition::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_);
-    }
+        {
+            acquisition_cc_->set_doppler_step(doppler_step_);
+        }
 
 }
 
@@ -185,13 +198,13 @@ void GpsL1CaPcpsAcquisition::set_gnss_synchro(Gnss_Synchro* gnss_synchro)
 signed int GpsL1CaPcpsAcquisition::mag()
 {
     if (item_type_.compare("gr_complex") == 0)
-    {
-        return acquisition_cc_->mag();
-    }
+        {
+            return acquisition_cc_->mag();
+        }
     else
-    {
-        return 0;
-    }
+        {
+            return 0;
+        }
 }
 
 
@@ -201,24 +214,28 @@ void GpsL1CaPcpsAcquisition::init()
     set_local_code();
 }
 
+
 void GpsL1CaPcpsAcquisition::set_local_code()
 {
     if (item_type_.compare("gr_complex") == 0)
     {
-        std::complex<float>* code = new std::complex<float>[vector_length_];
+        std::complex<float>* code = new std::complex<float>[code_length_];
 
         gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
 
         for (unsigned int i = 0; i < sampled_ms_; i++)
             {
-                memcpy(&(code_[i*vector_length_]), code,
-                       sizeof(gr_complex)*vector_length_);
+                memcpy(&(code_[i*code_length_]), code,
+                       sizeof(gr_complex)*code_length_);
             }
 
         acquisition_cc_->set_local_code(code_);
+
+        delete[] code;
     }
 }
 
+
 void GpsL1CaPcpsAcquisition::reset()
 {
     if (item_type_.compare("gr_complex") == 0)
@@ -227,6 +244,7 @@ void GpsL1CaPcpsAcquisition::reset()
     }
 }
 
+
 float GpsL1CaPcpsAcquisition::calculate_threshold(float pfa)
 {
 	//Calculate the threshold
@@ -243,12 +261,13 @@ float GpsL1CaPcpsAcquisition::calculate_threshold(float pfa)
 	double exponent = 1/(double)ncells;
 	double val = pow(1.0-pfa,exponent);
 	double lambda = double(vector_length_);
-	boost::math::exponential_distribution<double> mydist (lambda);
+    boost::math::exponential_distribution<double> mydist (lambda);
 	float threshold = (float)quantile(mydist,val);
 
 	return threshold;
 }
 
+
 void GpsL1CaPcpsAcquisition::connect(gr::top_block_sptr top_block)
 {
     if (item_type_.compare("gr_complex") == 0)

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.h

@@ -5,6 +5,7 @@
  * \authors <ul>
  *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
  *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          <li> Marc Molina, 2013. marc.molina.pena(at)gmail.com
  *          </ul>
  *
  * -------------------------------------------------------------------------
@@ -119,7 +120,6 @@ public:
     /*!
      * \brief Sets local code for GPS L1/CA PCPS acquisition algorithm.
      */
-
     void set_local_code();
 
     /*!
@@ -139,13 +139,15 @@ private:
     size_t item_size_;
     std::string item_type_;
     unsigned int vector_length_;
-    //unsigned int satellite_;
+    unsigned int code_length_;
+    bool bit_transition_flag_;
     unsigned int channel_;
     float threshold_;
     unsigned int doppler_max_;
     unsigned int doppler_step_;
     unsigned int shift_resolution_;
     unsigned int sampled_ms_;
+    unsigned int max_dwells_;
     long fs_in_;
     long if_;
     bool dump_;

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.cc

@@ -64,7 +64,7 @@ GpsL1CaPcpsAcquisitionFineDoppler::GpsL1CaPcpsAcquisitionFineDoppler(
     dump_ = configuration->property(role + ".dump", false);
     doppler_max_ = configuration->property(role + ".doppler_max", 5000);
     doppler_min_ = configuration->property(role + ".doppler_min", -5000);
-    sampled_ms_ = configuration->property(role + ".sampled_ms", 1);
+    sampled_ms_ = configuration->property(role + ".coherent_integration_time_ms", 1);
     max_dwells_= configuration->property(role + ".max_dwells", 1);
     dump_filename_ = configuration->property(role + ".dump_filename",
             default_dump_filename);

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.h

@@ -132,7 +132,6 @@ private:
     size_t item_size_;
     std::string item_type_;
     unsigned int vector_length_;
-    //unsigned int satellite_;
     unsigned int channel_;
     float threshold_;
     int doppler_max_;

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_assisted_acquisition.cc

@@ -63,7 +63,7 @@ GpsL1CaPcpsAssistedAcquisition::GpsL1CaPcpsAssistedAcquisition(
     dump_ = configuration->property(role + ".dump", false);
     doppler_max_ = configuration->property(role + ".doppler_max", 5000);
     doppler_min_ = configuration->property(role + ".doppler_min", -5000);
-    sampled_ms_ = configuration->property(role + ".sampled_ms", 1);
+    sampled_ms_ = configuration->property(role + ".coherent_integration_time_ms", 1);
     max_dwells_= configuration->property(role + ".max_dwells", 1);
     dump_filename_ = configuration->property(role + ".dump_filename",
                                              default_dump_filename);

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_multithread_acquisition.cc

@@ -0,0 +1,296 @@
+/*!
+ * \file gps_l1_ca_pcps_multithread_acquisition.cc
+ * \brief Adapts a multithread PCPS acquisition block to an
+ *  AcquisitionInterface for GPS L1 C/A signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "gps_l1_ca_pcps_multithread_acquisition.h"
+#include "gps_sdr_signal_processing.h"
+#include "GPS_L1_CA.h"
+#include "configuration_interface.h"
+#include <iostream>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <stdexcept>
+#include <boost/math/distributions/exponential.hpp>
+#include <gnuradio/msg_queue.h>
+
+using google::LogMessage;
+
+GpsL1CaPcpsMultithreadAcquisition::GpsL1CaPcpsMultithreadAcquisition(
+        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";
+
+    DLOG(INFO) << "role " << role;
+
+    item_type_ = configuration_->property(role + ".item_type",
+            default_item_type);
+
+    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);
+    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1);
+
+    bit_transition_flag_ = configuration_->property("Acquisition.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(fs_in_
+            / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS));
+
+    vector_length_ = code_length_ * sampled_ms_;
+
+    code_= new gr_complex[vector_length_];
+
+    if (item_type_.compare("gr_complex") == 0)
+    {
+        item_size_ = sizeof(gr_complex);
+        acquisition_cc_ = pcps_make_multithread_acquisition_cc(sampled_ms_, 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()
+                << ")";
+    }
+    else
+    {
+        LOG_AT_LEVEL(WARNING) << item_type_
+                << " unknown acquisition item type";
+    }
+}
+
+
+GpsL1CaPcpsMultithreadAcquisition::~GpsL1CaPcpsMultithreadAcquisition()
+{
+	delete[] code_;
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::set_channel(unsigned int channel)
+{
+    channel_ = channel;
+    if (item_type_.compare("gr_complex") == 0)
+    {
+        acquisition_cc_->set_channel(channel_);
+    }
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::set_threshold(float threshold)
+{
+	float pfa = configuration_->property(role_ + boost::lexical_cast<std::string>(channel_) + ".pfa", 0.0);
+
+	if(pfa==0.0)
+        {
+                 pfa = configuration_->property(role_+".pfa", 0.0);
+        }
+	if(pfa==0.0)
+		{
+			threshold_ = threshold;
+		}
+	else
+		{
+			threshold_ = calculate_threshold(pfa);
+		}
+
+	DLOG(INFO) <<"Channel "<<channel_<<" Threshold = " << threshold_;
+
+    if (item_type_.compare("gr_complex") == 0)
+    {
+        acquisition_cc_->set_threshold(threshold_);
+    }
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::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 GpsL1CaPcpsMultithreadAcquisition::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 GpsL1CaPcpsMultithreadAcquisition::set_channel_queue(
+        concurrent_queue<int> *channel_internal_queue)
+{
+    channel_internal_queue_ = channel_internal_queue;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel_queue(channel_internal_queue_);
+        }
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::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 GpsL1CaPcpsMultithreadAcquisition::mag()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            return acquisition_cc_->mag();
+        }
+    else
+        {
+            return 0;
+        }
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::init()
+{
+    acquisition_cc_->init();
+    set_local_code();
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::set_local_code()
+{
+    if (item_type_.compare("gr_complex") == 0)
+    {
+        std::complex<float>* code = new std::complex<float>[code_length_];
+
+        gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
+
+        for (unsigned int i = 0; i < sampled_ms_; i++)
+            {
+                memcpy(&(code_[i*code_length_]), code,
+                       sizeof(gr_complex)*code_length_);
+            }
+
+        acquisition_cc_->set_local_code(code_);
+
+        delete[] code;
+    }
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::reset()
+{
+    if (item_type_.compare("gr_complex") == 0)
+    {
+        acquisition_cc_->set_active(true);
+    }
+}
+
+
+float GpsL1CaPcpsMultithreadAcquisition::calculate_threshold(float pfa)
+{
+	//Calculate the threshold
+
+	unsigned int frequency_bins = 0;
+	for (int doppler = (int)(-doppler_max_); doppler <= (int)doppler_max_; doppler += doppler_step_)
+	{
+	 	frequency_bins++;
+	}
+
+	DLOG(INFO) <<"Channel "<<channel_<<"  Pfa = "<< pfa;
+
+	unsigned int ncells = vector_length_*frequency_bins;
+	double exponent = 1/(double)ncells;
+	double val = pow(1.0-pfa,exponent);
+	double lambda = double(vector_length_);
+	boost::math::exponential_distribution<double> mydist (lambda);
+	float threshold = (float)quantile(mydist,val);
+
+	return threshold;
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::connect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+
+}
+
+
+void GpsL1CaPcpsMultithreadAcquisition::disconnect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+    {
+        top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0);
+    }
+}
+
+
+gr::basic_block_sptr GpsL1CaPcpsMultithreadAcquisition::get_left_block()
+{
+    return stream_to_vector_;
+}
+
+
+gr::basic_block_sptr GpsL1CaPcpsMultithreadAcquisition::get_right_block()
+{
+    return acquisition_cc_;
+}
+

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_multithread_acquisition.h

@@ -0,0 +1,162 @@
+/*!
+ * \file gps_l1_ca_pcps_multithread_acquisition.h
+ * \brief Adapts a multithread PCPS acquisition block to an
+ *  AcquisitionInterface for GPS L1 C/A signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GPS_L1_CA_PCPS_MULTITHREAD_CQUISITION_H_
+#define GNSS_SDR_GPS_L1_CA_PCPS_MULTITHREAD_CQUISITION_H_
+
+#include "gnss_synchro.h"
+#include "acquisition_interface.h"
+#include "pcps_multithread_acquisition_cc.h"
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/blocks/stream_to_vector.h>
+
+
+class ConfigurationInterface;
+
+/*!
+ * \brief This class adapts a multithread PCPS acquisition block to an
+ *  AcquisitionInterface for GPS L1 C/A signals
+ */
+class GpsL1CaPcpsMultithreadAcquisition: public AcquisitionInterface
+{
+public:
+    GpsL1CaPcpsMultithreadAcquisition(ConfigurationInterface* configuration,
+            std::string role, unsigned int in_streams,
+            unsigned int out_streams, boost::shared_ptr<gr::msg_queue> queue);
+
+    virtual ~GpsL1CaPcpsMultithreadAcquisition();
+
+    std::string role()
+    {
+        return role_;
+    }
+
+    /*!
+     * \brief Returns "GPS_L1_CA_PCPS_Multithread_Acquisition"
+     */
+    std::string implementation()
+    {
+        return "GPS_L1_CA_PCPS_Multithread_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<int> *channel_internal_queue);
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    /*!
+     * \brief Sets local code for GPS L1/CA PCPS acquisition algorithm.
+     */
+    void set_local_code();
+
+    /*!
+     * \brief Returns the maximum peak of grid search
+     */
+    signed int mag();
+
+    /*!
+     * \brief Restart acquisition algorithm
+     */
+    void reset();
+
+private:
+    ConfigurationInterface* configuration_;
+    pcps_multithread_acquisition_cc_sptr acquisition_cc_;
+    gr::blocks::stream_to_vector::sptr stream_to_vector_;
+    size_t item_size_;
+    std::string item_type_;
+    unsigned int vector_length_;
+    unsigned int code_length_;
+    bool bit_transition_flag_;
+    unsigned int channel_;
+    float threshold_;
+    unsigned int doppler_max_;
+    unsigned int doppler_step_;
+    unsigned int shift_resolution_;
+    unsigned int sampled_ms_;
+    unsigned int max_dwells_;
+    long fs_in_;
+    long if_;
+    bool dump_;
+    std::string dump_filename_;
+    std::complex<float> * code_;
+    Gnss_Synchro * gnss_synchro_;
+    std::string role_;
+    unsigned int in_streams_;
+    unsigned int out_streams_;
+    boost::shared_ptr<gr::msg_queue> queue_;
+    concurrent_queue<int> *channel_internal_queue_;
+
+    float calculate_threshold(float pfa);
+};
+
+#endif /* GNSS_SDR_GPS_L1_CA_PCPS_MULTITHREAD_CQUISITION_H_ */

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc

@@ -0,0 +1,284 @@
+/*!
+ * \file gps_l1_ca_pcps_tong_acquisition.cc
+ * \brief Adapts a PCPS Tong acquisition block to an AcquisitionInterface for
+ *  GPS L1 C/A signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "gps_l1_ca_pcps_tong_acquisition.h"
+#include "gps_sdr_signal_processing.h"
+#include "GPS_L1_CA.h"
+#include "configuration_interface.h"
+#include <iostream>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <stdexcept>
+#include <boost/math/distributions/exponential.hpp>
+#include <gnuradio/msg_queue.h>
+
+using google::LogMessage;
+
+GpsL1CaPcpsTongAcquisition::GpsL1CaPcpsTongAcquisition(
+        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";
+
+    DLOG(INFO) << "role " << role;
+
+    item_type_ = configuration_->property(role + ".item_type",
+            default_item_type);
+
+    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);
+    sampled_ms_ = configuration_->property(role + ".coherent_integration_time_ms", 1);
+
+    tong_init_val_ = configuration->property(role + ".tong_init_val", 1);
+    tong_max_val_ = configuration->property(role + ".tong_max_val", 2);
+
+    dump_filename_ = configuration_->property(role + ".dump_filename",
+            default_dump_filename);
+
+    //--- Find number of samples per spreading code -------------------------
+    code_length_ = round(fs_in_
+            / (GPS_L1_CA_CODE_RATE_HZ / GPS_L1_CA_CODE_LENGTH_CHIPS));
+
+    vector_length_ = code_length_ * sampled_ms_;
+
+    code_= new gr_complex[vector_length_];
+
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            item_size_ = sizeof(gr_complex);
+            acquisition_cc_ = pcps_tong_make_acquisition_cc(sampled_ms_, shift_resolution_, if_, fs_in_,
+                                    code_length_, code_length_, tong_init_val_, tong_max_val_,
+                                    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()
+                    << ")";
+        }
+    else
+        {
+            LOG_AT_LEVEL(WARNING) << item_type_
+                    << " unknown acquisition item type";
+        }
+}
+
+
+GpsL1CaPcpsTongAcquisition::~GpsL1CaPcpsTongAcquisition()
+{
+	delete[] code_;
+}
+
+
+void GpsL1CaPcpsTongAcquisition::set_channel(unsigned int channel)
+{
+    channel_ = channel;
+    if (item_type_.compare("gr_complex") == 0)
+    {
+        acquisition_cc_->set_channel(channel_);
+    }
+}
+
+
+void GpsL1CaPcpsTongAcquisition::set_threshold(float threshold)
+{
+	float pfa = configuration_->property(role_ + boost::lexical_cast<std::string>(channel_) + ".pfa", 0.0);
+
+	if(pfa==0.0)
+        {
+                 pfa = configuration_->property(role_+".pfa", 0.0);
+        }
+	if(pfa==0.0)
+		{
+			threshold_ = threshold;
+		}
+	else
+		{
+			threshold_ = calculate_threshold(pfa);
+		}
+
+	DLOG(INFO) <<"Channel "<<channel_<<" Threshold = " << threshold_;
+
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_threshold(threshold_);
+        }
+}
+
+
+void GpsL1CaPcpsTongAcquisition::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 GpsL1CaPcpsTongAcquisition::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 GpsL1CaPcpsTongAcquisition::set_channel_queue(
+        concurrent_queue<int> *channel_internal_queue)
+{
+    channel_internal_queue_ = channel_internal_queue;
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_channel_queue(channel_internal_queue_);
+        }
+}
+
+
+void GpsL1CaPcpsTongAcquisition::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 GpsL1CaPcpsTongAcquisition::mag()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            return acquisition_cc_->mag();
+        }
+    else
+        {
+            return 0;
+        }
+}
+
+
+void GpsL1CaPcpsTongAcquisition::init()
+{
+    acquisition_cc_->init();
+    set_local_code();
+}
+
+void GpsL1CaPcpsTongAcquisition::set_local_code()
+{
+    if (item_type_.compare("gr_complex") == 0)
+    {
+        std::complex<float>* code = new std::complex<float>[code_length_];
+
+        gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
+
+        for (unsigned int i = 0; i < sampled_ms_; i++)
+            {
+                memcpy(&(code_[i*code_length_]), code,
+                       sizeof(gr_complex)*code_length_);
+            }
+
+        acquisition_cc_->set_local_code(code_);
+
+        delete[] code;
+    }
+}
+
+void GpsL1CaPcpsTongAcquisition::reset()
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            acquisition_cc_->set_active(true);
+        }
+}
+
+float GpsL1CaPcpsTongAcquisition::calculate_threshold(float pfa)
+{
+	//Calculate the threshold
+
+	unsigned int frequency_bins = 0;
+	for (int doppler = (int)(-doppler_max_); doppler <= (int)doppler_max_; doppler += doppler_step_)
+        {
+            frequency_bins++;
+        }
+
+	DLOG(INFO) <<"Channel "<<channel_<<"  Pfa = "<< pfa;
+
+	unsigned int ncells = vector_length_*frequency_bins;
+	double exponent = 1/(double)ncells;
+	double val = pow(1.0-pfa,exponent);
+	double lambda = double(vector_length_);
+	boost::math::exponential_distribution<double> mydist (lambda);
+	float threshold = (float)quantile(mydist,val);
+
+	return threshold;
+}
+
+void GpsL1CaPcpsTongAcquisition::connect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+
+}
+
+
+void GpsL1CaPcpsTongAcquisition::disconnect(gr::top_block_sptr top_block)
+{
+    if (item_type_.compare("gr_complex") == 0)
+        {
+            top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0);
+        }
+}
+
+
+gr::basic_block_sptr GpsL1CaPcpsTongAcquisition::get_left_block()
+{
+    return stream_to_vector_;
+}
+
+
+gr::basic_block_sptr GpsL1CaPcpsTongAcquisition::get_right_block()
+{
+    return acquisition_cc_;
+}
+

src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.h

@@ -0,0 +1,165 @@
+/*!
+ * \file gps_l1_ca_pcps_tong_acquisition.h
+ * \brief Adapts a PCPS Tong acquisition block to an AcquisitionInterface for
+ *  GPS L1 C/A signals
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_GPS_L1_CA_TONG_ACQUISITION_H_
+#define GNSS_SDR_GPS_L1_CA_TONG_ACQUISITION_H_
+
+#include "gnss_synchro.h"
+#include "acquisition_interface.h"
+#include "pcps_tong_acquisition_cc.h"
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/blocks/stream_to_vector.h>
+
+
+class ConfigurationInterface;
+
+/*!
+ * \brief This class adapts a PCPS Tong acquisition block to an
+ *  AcquisitionInterface for GPS L1 C/A signals
+ */
+class GpsL1CaPcpsTongAcquisition: public AcquisitionInterface
+{
+public:
+    GpsL1CaPcpsTongAcquisition(ConfigurationInterface* configuration,
+            std::string role, unsigned int in_streams,
+            unsigned int out_streams, boost::shared_ptr<gr::msg_queue> queue);
+
+    virtual ~GpsL1CaPcpsTongAcquisition();
+
+    std::string role()
+    {
+        return role_;
+    }
+
+    /*!
+     * \brief Returns "GPS_L1_CA_PCPS_Tong_Acquisition"
+     */
+    std::string implementation()
+    {
+        return "GPS_L1_CA_PCPS_Tong_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 TONG algorithm
+     */
+    void set_threshold(float threshold);
+
+    /*!    bit_transition_flag_ = configuration_->property("Acquisition.bit_transition_flag", false);
+
+     * \brief Set maximum Doppler off grid search
+     */
+    void set_doppler_max(unsigned int doppler_max);
+
+    /*!
+     * \brief Set Doppler steps for the grid search
+     */
+    void set_doppler_step(unsigned int doppler_step);
+
+    /*!
+     * \brief Set tracking channel internal queue
+     */
+    void set_channel_queue(concurrent_queue<int> *channel_internal_queue);
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    /*!
+     * \brief Sets local code for GPS L1/CA TONG acquisition algorithm.
+     */
+    void set_local_code();
+
+    /*!
+     * \brief Returns the maximum peak of grid search
+     */
+    signed int mag();
+
+    /*!
+     * \brief Restart acquisition algorithm
+     *///    std::cout << "role " << role_ << std::endl;
+
+    void reset();
+
+private:
+    ConfigurationInterface* configuration_;
+    pcps_tong_acquisition_cc_sptr acquisition_cc_;
+    gr::blocks::stream_to_vector::sptr stream_to_vector_;
+    size_t item_size_;
+    std::string item_type_;
+    unsigned int vector_length_;
+    unsigned int code_length_;
+    bool bit_transition_flag_;
+    unsigned int channel_;
+    float threshold_;
+    unsigned int doppler_max_;
+    unsigned int doppler_step_;
+    unsigned int shift_resolution_;
+    unsigned int sampled_ms_;
+    unsigned int tong_init_val_;
+    unsigned int tong_max_val_;
+    long fs_in_;
+    long if_;
+    bool dump_;
+    std::string dump_filename_;
+    std::complex<float> * code_;
+    Gnss_Synchro * gnss_synchro_;
+    std::string role_;
+    unsigned int in_streams_;
+    unsigned int out_streams_;
+    boost::shared_ptr<gr::msg_queue> queue_;
+    concurrent_queue<int> *channel_internal_queue_;
+
+    float calculate_threshold(float pfa);
+};
+
+#endif /* GNSS_SDR_GPS_L1_CA_TONG_ACQUISITION_H_ */

src/algorithms/acquisition/gnuradio_blocks/CMakeLists.txt

@@ -17,9 +17,13 @@
 #
 
 set(ACQ_GR_BLOCKS_SOURCES 
-	pcps_acquisition_cc.cc 
+        pcps_acquisition_cc.cc
+        pcps_multithread_acquisition_cc.cc
 	pcps_assisted_acquisition_cc.cc
 	pcps_acquisition_fine_doppler_cc.cc
+        pcps_tong_acquisition_cc.cc
+        pcps_cccwsr_acquisition_cc.cc
+        galileo_pcps_8ms_acquisition_cc.cc
 )
 
 include_directories(

src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.cc

@@ -0,0 +1,404 @@
+/*!
+ * \file galileo_pcps_8ms_acquisition_cc.cc
+ * \brief This class implements a Parallel Code Phase Search Acquisition for
+ * Galileo E1 signals with coherent integration time = 8 ms (two codes)
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "galileo_pcps_8ms_acquisition_cc.h"
+#include "gnss_signal_processing.h"
+#include "control_message_factory.h"
+#include <gnuradio/io_signature.h>
+#include <sstream>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <volk/volk.h>
+
+using google::LogMessage;
+
+galileo_pcps_8ms_acquisition_cc_sptr galileo_pcps_8ms_make_acquisition_cc(
+                                 unsigned int sampled_ms, unsigned int max_dwells,
+                                 unsigned int doppler_max, long freq, long fs_in,
+                                 int samples_per_ms, int samples_per_code,
+                                 gr::msg_queue::sptr queue, bool dump,
+                                 std::string dump_filename)
+{
+
+    return galileo_pcps_8ms_acquisition_cc_sptr(
+            new galileo_pcps_8ms_acquisition_cc(sampled_ms, max_dwells, doppler_max, freq, fs_in, samples_per_ms,
+                                     samples_per_code, queue, dump, dump_filename));
+}
+
+
+galileo_pcps_8ms_acquisition_cc::galileo_pcps_8ms_acquisition_cc(
+                         unsigned int sampled_ms, unsigned int max_dwells,
+                         unsigned int doppler_max, long freq, long fs_in,
+                         int samples_per_ms, int samples_per_code,
+                         gr::msg_queue::sptr queue, bool dump,
+                         std::string dump_filename) :
+    gr::block("galileo_pcps_8ms_acquisition_cc",
+    gr::io_signature::make(1, 1, sizeof(gr_complex) * sampled_ms * samples_per_ms),
+    gr::io_signature::make(0, 0, sizeof(gr_complex) * sampled_ms * samples_per_ms))
+{
+    d_sample_counter = 0;    // SAMPLE COUNTER
+    d_active = false;
+    d_state = 0;
+    d_queue = queue;
+    d_freq = freq;
+    d_fs_in = fs_in;
+    d_samples_per_ms = samples_per_ms;
+    d_samples_per_code = samples_per_code;
+    d_sampled_ms = sampled_ms;
+    d_max_dwells = max_dwells;
+    d_well_count = 0;
+    d_doppler_max = doppler_max;
+    d_fft_size = d_sampled_ms * d_samples_per_ms;
+    d_mag = 0;
+    d_input_power = 0.0;
+    d_num_doppler_bins = 0;
+
+    //todo: do something if posix_memalign fails
+    if (posix_memalign((void**)&d_fft_code_A, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_fft_code_B, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_magnitude, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+
+    // Direct FFT
+    d_fft_if = new gr::fft::fft_complex(d_fft_size, true);
+
+    // Inverse FFT
+    d_ifft = new gr::fft::fft_complex(d_fft_size, false);
+
+    // For dumping samples into a file
+    d_dump = dump;
+    d_dump_filename = dump_filename;
+}
+
+
+galileo_pcps_8ms_acquisition_cc::~galileo_pcps_8ms_acquisition_cc()
+{
+
+    for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
+        {
+            free(d_grid_doppler_wipeoffs[doppler_index]);
+        }
+
+
+    if (d_num_doppler_bins > 0)
+        {
+            delete[] d_grid_doppler_wipeoffs;
+        }
+
+    free(d_fft_code_A);
+    free(d_fft_code_B);
+    free(d_magnitude);
+
+    delete d_ifft;
+    delete d_fft_if;
+
+    if (d_dump)
+        {
+            d_dump_file.close();
+        }
+}
+
+
+void galileo_pcps_8ms_acquisition_cc::set_local_code(std::complex<float> * code)
+{
+    memcpy(d_fft_if->get_inbuf(), code, sizeof(gr_complex)*d_fft_size);
+
+    d_fft_if->execute(); // We need the FFT of local code
+
+    //Conjugate the local code
+    if (is_unaligned())
+        {
+            volk_32fc_conjugate_32fc_u(d_fft_code_A,d_fft_if->get_outbuf(),d_fft_size);
+        }
+    else
+        {
+            volk_32fc_conjugate_32fc_a(d_fft_code_A,d_fft_if->get_outbuf(),d_fft_size);
+        }
+
+
+    volk_32fc_s32fc_multiply_32fc_a(&(d_fft_if->get_inbuf())[d_samples_per_code],
+                                    &code[d_samples_per_code], gr_complex(-1,0),
+                                    d_samples_per_code);
+
+    d_fft_if->execute(); // We need the FFT of local code
+
+    //Conjugate the local code
+    if (is_unaligned())
+        {
+            volk_32fc_conjugate_32fc_u(d_fft_code_B,d_fft_if->get_outbuf(),d_fft_size);
+        }
+    else
+        {
+            volk_32fc_conjugate_32fc_a(d_fft_code_B,d_fft_if->get_outbuf(),d_fft_size);
+        }
+}
+
+
+void galileo_pcps_8ms_acquisition_cc::init()
+{
+    d_gnss_synchro->Acq_delay_samples = 0.0;
+    d_gnss_synchro->Acq_doppler_hz = 0.0;
+    d_gnss_synchro->Acq_samplestamp_samples = 0;
+    d_mag = 0.0;
+    d_input_power = 0.0;
+
+    // Create the carrier Doppler wipeoff signals
+    d_num_doppler_bins = 0;//floor(2*std::abs((int)d_doppler_max)/d_doppler_step);
+    for (int doppler = (int)(-d_doppler_max); doppler <= (int)d_doppler_max; doppler += d_doppler_step)
+    {
+        d_num_doppler_bins++;
+    }
+    d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins];
+    for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+        {
+            if (posix_memalign((void**)&(d_grid_doppler_wipeoffs[doppler_index]), 16,
+                               d_fft_size * sizeof(gr_complex)) == 0){};
+
+            int doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+            complex_exp_gen_conj(d_grid_doppler_wipeoffs[doppler_index],
+                                 d_freq + doppler, d_fs_in, d_fft_size);
+        }
+}
+
+
+int galileo_pcps_8ms_acquisition_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 acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
+
+    switch (d_state)
+    {
+    case 0:
+        {
+            if (d_active)
+                {
+                    //restart acquisition variables
+                    d_gnss_synchro->Acq_delay_samples = 0.0;
+                    d_gnss_synchro->Acq_doppler_hz = 0.0;
+                    d_gnss_synchro->Acq_samplestamp_samples = 0;
+                    d_well_count = 0;
+                    d_mag = 0.0;
+                    d_input_power = 0.0;
+                    d_test_statistics = 0.0;
+
+                    d_state = 1;
+                }
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            break;
+        }
+
+    case 1:
+        {
+            // initialize acquisition algorithm
+            int doppler;
+            unsigned int indext = 0;
+            unsigned int indext_A = 0;
+            unsigned int indext_B = 0;
+            float magt = 0.0;
+            float magt_A = 0.0;
+            float magt_B = 0.0;
+            const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
+            float fft_normalization_factor = (float)d_fft_size * (float)d_fft_size;
+            d_input_power = 0.0;
+            d_mag = 0.0;
+
+            d_sample_counter += d_fft_size; // sample counter
+
+            d_well_count++;
+
+            DLOG(INFO) << "Channel: " << d_channel
+                    << " , doing acquisition of satellite: " << d_gnss_synchro->System << " "<< d_gnss_synchro->PRN
+                    << " ,sample stamp: " << d_sample_counter << ", threshold: "
+                    << d_threshold << ", doppler_max: " << d_doppler_max
+                    << ", doppler_step: " << d_doppler_step;
+
+            // 1- Compute the input signal power estimation
+            volk_32fc_magnitude_squared_32f_a(d_magnitude, in, d_fft_size);
+            volk_32f_accumulator_s32f_a(&d_input_power, d_magnitude, d_fft_size);
+            d_input_power /= (float)d_fft_size;
+
+            // 2- Doppler frequency search loop
+            for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+                {
+                    // doppler search steps
+
+                    doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+
+                    volk_32fc_x2_multiply_32fc_a(d_fft_if->get_inbuf(), 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_a(d_ifft->get_inbuf(),
+                                d_fft_if->get_outbuf(), d_fft_code_A, d_fft_size);
+
+                    // compute the inverse FFT
+                    d_ifft->execute();
+
+                    // Search maximum
+                    volk_32fc_magnitude_squared_32f_a(d_magnitude, d_ifft->get_outbuf(), d_fft_size);
+                    volk_32f_index_max_16u_a(&indext_A, d_magnitude, d_fft_size);
+
+                    // Normalize the maximum value to correct the scale factor introduced by FFTW
+                    magt_A = d_magnitude[indext_A] / (fft_normalization_factor * fft_normalization_factor);
+
+                    // Multiply carrier wiped--off, Fourier transformed incoming signal
+                    // with the local FFT'd code reference using SIMD operations with VOLK library
+                    volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
+                                d_fft_if->get_outbuf(), d_fft_code_B, d_fft_size);
+
+                    // compute the inverse FFT
+                    d_ifft->execute();
+
+                    // Search maximum
+                    volk_32fc_magnitude_squared_32f_a(d_magnitude, d_ifft->get_outbuf(), d_fft_size);
+                    volk_32f_index_max_16u_a(&indext_B, d_magnitude, d_fft_size);
+
+                    // Normalize the maximum value to correct the scale factor introduced by FFTW
+                    magt_B = d_magnitude[indext_B] / (fft_normalization_factor * fft_normalization_factor);
+
+                    if (magt_A >= magt_B)
+                    {
+                        magt = magt_A;
+                        indext = indext_A;
+                    }
+                    else
+                    {
+                        magt = magt_B;
+                        indext = indext_B;
+                    }
+
+                    // 4- record the maximum peak and the associated synchronization parameters
+                    if (d_mag < magt)
+                        {
+                            d_mag = magt;
+                            d_gnss_synchro->Acq_delay_samples = (double)(indext % d_samples_per_code);
+                            d_gnss_synchro->Acq_doppler_hz = (double)doppler;
+                            d_gnss_synchro->Acq_samplestamp_samples = d_sample_counter;
+                        }
+
+                    // 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("");
+                            filename << "../data/test_statistics_" << d_gnss_synchro->System
+                                     <<"_" << d_gnss_synchro->Signal << "_sat_"
+                                     << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
+                            d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
+                            d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.close();
+                        }
+                }
+
+            // 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;
+
+            if (d_test_statistics > d_threshold)
+                {
+                    d_state = 2; // Positive acquisition
+                }
+            else
+                {
+                    if (d_well_count == d_max_dwells)
+                        {
+                            d_state = 3; // Negative acquisition
+                        }
+                }
+
+            consume_each(1);
+
+            break;
+        }
+
+    case 2:
+        {
+            // 6.1- Declare positive acquisition using a message queue
+            DLOG(INFO) << "positive acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 1;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+
+    case 3:
+        {
+            // 6.2- Declare negative acquisition using a message queue
+            DLOG(INFO) << "negative acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 2;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+    }
+
+    return 0;
+}

src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.h

@@ -0,0 +1,218 @@
+/*!
+ * \file galileo_pcps_8ms_acquisition_cc.h
+ * \brief This class implements a Parallel Code Phase Search Acquisition for
+ * Galileo E1 signals with coherent integration time = 8 ms (two codes)
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_PCPS_8MS_ACQUISITION_CC_H_
+#define GNSS_SDR_PCPS_8MS_ACQUISITION_CC_H_
+
+#include <fstream>
+#include <gnuradio/block.h>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/gr_complex.h>
+#include <gnuradio/fft/fft.h>
+#include <queue>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include "concurrent_queue.h"
+#include "gnss_synchro.h"
+
+class galileo_pcps_8ms_acquisition_cc;
+
+typedef boost::shared_ptr<galileo_pcps_8ms_acquisition_cc> galileo_pcps_8ms_acquisition_cc_sptr;
+
+galileo_pcps_8ms_acquisition_cc_sptr
+galileo_pcps_8ms_make_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                             unsigned int doppler_max, long freq, long fs_in,
+                             int samples_per_ms, int samples_per_code,
+                             gr::msg_queue::sptr queue, bool dump,
+                             std::string dump_filename);
+
+/*!
+ * \brief This class implements a Parallel Code Phase Search Acquisition for
+ * Galileo E1 signals with coherent integration time = 8 ms (two codes)
+ */
+class galileo_pcps_8ms_acquisition_cc: public gr::block
+{
+private:
+    friend galileo_pcps_8ms_acquisition_cc_sptr
+    galileo_pcps_8ms_make_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                                 unsigned int doppler_max, long freq, long fs_in,
+                                 int samples_per_ms, int samples_per_code,
+                                 gr::msg_queue::sptr queue, bool dump,
+                                 std::string dump_filename);
+
+
+    galileo_pcps_8ms_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                            unsigned int doppler_max, long freq, long fs_in,
+                            int samples_per_ms, int samples_per_code,
+                            gr::msg_queue::sptr queue, bool dump,
+                            std::string dump_filename);
+
+    void calculate_magnitudes(gr_complex* fft_begin, int doppler_shift,
+            int doppler_offset);
+
+
+	long d_fs_in;
+	long d_freq;
+	int d_samples_per_ms;
+    int d_samples_per_code;
+	unsigned int d_doppler_resolution;
+	float d_threshold;
+    std::string d_satellite_str;
+	unsigned int d_doppler_max;
+	unsigned int d_doppler_step;
+	unsigned int d_sampled_ms;
+    unsigned int d_max_dwells;
+    unsigned int d_well_count;
+	unsigned int d_fft_size;
+	unsigned long int d_sample_counter;
+    gr_complex** d_grid_doppler_wipeoffs;
+    unsigned int d_num_doppler_bins;
+    gr_complex* d_fft_code_A;
+    gr_complex* d_fft_code_B;
+	gr::fft::fft_complex* d_fft_if;
+	gr::fft::fft_complex* d_ifft;
+    Gnss_Synchro *d_gnss_synchro;
+	unsigned int d_code_phase;
+	float d_doppler_freq;
+	float d_mag;
+    float* d_magnitude;
+	float d_input_power;
+	float d_test_statistics;
+    gr::msg_queue::sptr d_queue;
+	concurrent_queue<int> *d_channel_internal_queue;
+	std::ofstream d_dump_file;
+	bool d_active;
+    int d_state;
+	bool d_dump;
+	unsigned int d_channel;
+	std::string d_dump_filename;
+
+public:
+    /*!
+     * \brief Default destructor.
+     */
+    ~galileo_pcps_8ms_acquisition_cc();
+
+    /*!
+     * \brief Set acquisition/tracking common Gnss_Synchro object pointer
+     * to exchange synchronization data between acquisition and tracking blocks.
+     * \param p_gnss_synchro Satellite information shared by the processing blocks.
+     */
+    void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
+    {
+        d_gnss_synchro = p_gnss_synchro;
+    }
+
+    /*!
+     * \brief Returns the maximum peak of grid search.
+     */
+    unsigned int mag()
+    {
+        return d_mag;
+    }
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    /*!
+     * \brief Sets local code for PCPS acquisition algorithm.
+     * \param code - Pointer to the PRN code.
+     */
+    void set_local_code(std::complex<float> * code);
+
+    /*!
+     * \brief Starts acquisition algorithm, turning from standby mode to
+     * active mode
+     * \param active - bool that activates/deactivates the block.
+     */
+    void set_active(bool active)
+    {
+        d_active = active;
+    }
+
+    /*!
+     * \brief Set acquisition channel unique ID
+     * \param channel - receiver channel.
+     */
+    void set_channel(unsigned int channel)
+    {
+        d_channel = channel;
+    }
+
+    /*!
+     * \brief Set statistics threshold of PCPS algorithm.
+     * \param threshold - Threshold for signal detection (check \ref Navitec2012,
+     * Algorithm 1, for a definition of this threshold).
+     */
+    void set_threshold(float threshold)
+    {
+        d_threshold = threshold;
+    }
+
+    /*!
+     * \brief Set maximum Doppler grid search
+     * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz].
+     */
+    void set_doppler_max(unsigned int doppler_max)
+    {
+        d_doppler_max = doppler_max;
+    }
+
+    /*!
+     * \brief Set Doppler steps for the grid search
+     * \param doppler_step - Frequency bin of the search grid [Hz].
+     */
+    void set_doppler_step(unsigned int doppler_step)
+    {
+        d_doppler_step = doppler_step;
+    }
+
+
+    /*!
+     * \brief Set tracking channel internal queue.
+     * \param channel_internal_queue - Channel's internal blocks information queue.
+     */
+    void set_channel_queue(concurrent_queue<int> *channel_internal_queue)
+    {
+        d_channel_internal_queue = channel_internal_queue;
+    }
+
+    /*!
+     * \brief Parallel Code Phase Search Acquisition signal processing.
+     */
+    int general_work(int noutput_items, gr_vector_int &ninput_items,
+            gr_vector_const_void_star &input_items,
+            gr_vector_void_star &output_items);
+};
+
+#endif /* GNSS_SDR_PCPS_8MS_ACQUISITION_CC_H_*/

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc

@@ -44,39 +44,48 @@
 using google::LogMessage;
 
 pcps_acquisition_cc_sptr pcps_make_acquisition_cc(
-        unsigned int sampled_ms, unsigned int doppler_max,
-        long freq, long fs_in, int samples_per_ms, int samples_per_code,
-        gr::msg_queue::sptr queue, bool dump, std::string dump_filename)
+                                 unsigned int sampled_ms, unsigned int max_dwells,
+                                 unsigned int doppler_max, long freq, long fs_in,
+                                 int samples_per_ms, int samples_per_code,
+                                 bool bit_transition_flag,
+                                 gr::msg_queue::sptr queue, bool dump,
+                                 std::string dump_filename)
 {
 
     return pcps_acquisition_cc_sptr(
-            new pcps_acquisition_cc(sampled_ms, doppler_max, freq, fs_in,
-                    samples_per_ms, samples_per_code, queue, dump, dump_filename));
+            new pcps_acquisition_cc(sampled_ms, max_dwells, doppler_max, freq, fs_in, samples_per_ms,
+                                     samples_per_code, bit_transition_flag, queue, dump, dump_filename));
 }
 
 
-
 pcps_acquisition_cc::pcps_acquisition_cc(
-        unsigned int sampled_ms, unsigned int doppler_max,
-        long freq, long fs_in, int samples_per_ms, int samples_per_code,
-        gr::msg_queue::sptr queue, bool dump, std::string dump_filename) :
+                         unsigned int sampled_ms, unsigned int max_dwells,
+                         unsigned int doppler_max, long freq, long fs_in,
+                         int samples_per_ms, int samples_per_code,
+                         bool bit_transition_flag,
+                         gr::msg_queue::sptr queue, bool dump,
+                         std::string dump_filename) :
     gr::block("pcps_acquisition_cc",
     gr::io_signature::make(1, 1, sizeof(gr_complex) * sampled_ms * samples_per_ms),
     gr::io_signature::make(0, 0, sizeof(gr_complex) * sampled_ms * samples_per_ms))
 {
     d_sample_counter = 0;    // SAMPLE COUNTER
     d_active = false;
+    d_state = 0;
     d_queue = queue;
     d_freq = freq;
     d_fs_in = fs_in;
     d_samples_per_ms = samples_per_ms;
     d_samples_per_code = samples_per_code;
     d_sampled_ms = sampled_ms;
+    d_max_dwells = max_dwells;
+    d_well_count = 0;
     d_doppler_max = doppler_max;
     d_fft_size = d_sampled_ms * d_samples_per_ms;
     d_mag = 0;
     d_input_power = 0.0;
     d_num_doppler_bins = 0;
+    d_bit_transition_flag = bit_transition_flag;
 
     //todo: do something if posix_memalign fails
     if (posix_memalign((void**)&d_fft_codes, 16, d_fft_size * sizeof(gr_complex)) == 0){};
@@ -94,11 +103,9 @@ pcps_acquisition_cc::pcps_acquisition_cc(
 }
 
 
-
 pcps_acquisition_cc::~pcps_acquisition_cc()
 {
 
-
     for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
         {
             free(d_grid_doppler_wipeoffs[doppler_index]);
@@ -115,6 +122,7 @@ pcps_acquisition_cc::~pcps_acquisition_cc()
 
     delete d_ifft;
     delete d_fft_if;
+
     if (d_dump)
         {
             d_dump_file.close();
@@ -122,7 +130,6 @@ pcps_acquisition_cc::~pcps_acquisition_cc()
 }
 
 
-
 void pcps_acquisition_cc::set_local_code(std::complex<float> * code)
 {
     memcpy(d_fft_if->get_inbuf(), code, sizeof(gr_complex)*d_fft_size);
@@ -141,7 +148,6 @@ void pcps_acquisition_cc::set_local_code(std::complex<float> * code)
 }
 
 
-
 void pcps_acquisition_cc::init()
 {
     d_gnss_synchro->Acq_delay_samples = 0.0;
@@ -151,7 +157,11 @@ void pcps_acquisition_cc::init()
     d_input_power = 0.0;
 
     // Create the carrier Doppler wipeoff signals
-    d_num_doppler_bins=floor(2*std::abs((int)d_doppler_max)/d_doppler_step);
+    d_num_doppler_bins = 0;//floor(2*std::abs((int)d_doppler_max)/d_doppler_step);
+    for (int doppler = (int)(-d_doppler_max); doppler <= (int)d_doppler_max; doppler += d_doppler_step)
+    {
+        d_num_doppler_bins++;
+    }
     d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins];
     for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
         {
@@ -165,7 +175,6 @@ void pcps_acquisition_cc::init()
 }
 
 
-
 int pcps_acquisition_cc::general_work(int noutput_items,
         gr_vector_int &ninput_items, gr_vector_const_void_star &input_items,
         gr_vector_void_star &output_items)
@@ -181,31 +190,46 @@ int pcps_acquisition_cc::general_work(int noutput_items,
      * 6. Declare positive or negative acquisition using a message queue
      */
 
-    if (!d_active)
+    int acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
+
+    switch (d_state)
+    {
+    case 0:
         {
-            d_sample_counter += d_fft_size * noutput_items; // sample counter
-            consume_each(noutput_items);
+            if (d_active)
+                {
+                    //restart acquisition variables
+                    d_gnss_synchro->Acq_delay_samples = 0.0;
+                    d_gnss_synchro->Acq_doppler_hz = 0.0;
+                    d_gnss_synchro->Acq_samplestamp_samples = 0;
+                    d_well_count = 0;
+                    d_mag = 0.0;
+                    d_input_power = 0.0;
+                    d_test_statistics = 0.0;
+
+                    d_state = 1;
+                }
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            break;
         }
-    else
+
+    case 1:
         {
             // initialize acquisition algorithm
             int doppler;
             unsigned int indext = 0;
             float magt = 0.0;
             const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
-            bool positive_acquisition = false;
-            int acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
-            //aux vars
-            unsigned int i;
-            float fft_normalization_factor;
+            float fft_normalization_factor = (float)d_fft_size * (float)d_fft_size;
+            d_input_power = 0.0;
+            d_mag = 0.0;
 
             d_sample_counter += d_fft_size; // sample counter
 
-            //restart acquisition variables
-            d_gnss_synchro->Acq_delay_samples = 0.0;
-            d_gnss_synchro->Acq_doppler_hz = 0.0;
-            d_mag = 0.0;
-            d_input_power = 0.0;
+            d_well_count++;
 
             DLOG(INFO) << "Channel: " << d_channel
                     << " , doing acquisition of satellite: " << d_gnss_synchro->System << " "<< d_gnss_synchro->PRN
@@ -214,19 +238,22 @@ int pcps_acquisition_cc::general_work(int noutput_items,
                     << ", doppler_step: " << d_doppler_step;
 
             // 1- Compute the input signal power estimation
-            if (is_unaligned())
-                {
-                    volk_32fc_magnitude_squared_32f_u(d_magnitude, in, d_fft_size);
-                    for (i = 0; i < d_fft_size; i++)
-                        d_input_power += d_magnitude[i];
-                }
-            else
-                {
-                    volk_32fc_magnitude_squared_32f_a(d_magnitude, in, d_fft_size);
-                    volk_32f_accumulator_s32f_a(&d_input_power, d_magnitude, d_fft_size);
-                }
+            volk_32fc_magnitude_squared_32f_a(d_magnitude, in, d_fft_size);
+
+//            for(int i =0; i < 10 ;i++){
+//                DLOG(INFO) << "d_magnitude["<< i <<"] " << d_magnitude[i];
+//            }
+
+            volk_32f_accumulator_s32f_a(&d_input_power, d_magnitude, d_fft_size);
+
+//            DLOG(INFO) << "d_input_power before " << d_input_power;
+
             d_input_power /= (float)d_fft_size;
 
+//            DLOG(INFO) << "d_fft_size " << d_fft_size;
+//            DLOG(INFO) << "d_input_power " << d_input_power;
+
+
             // 2- Doppler frequency search loop
             for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
                 {
@@ -234,16 +261,8 @@ int pcps_acquisition_cc::general_work(int noutput_items,
 
                     doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
 
-                    if (is_unaligned())
-                        {
-                            volk_32fc_x2_multiply_32fc_u(d_fft_if->get_inbuf(), in,
-                                        d_grid_doppler_wipeoffs[doppler_index], d_fft_size);
-                        }
-                    else
-                        {
-                            volk_32fc_x2_multiply_32fc_a(d_fft_if->get_inbuf(), in,
-                                        d_grid_doppler_wipeoffs[doppler_index], d_fft_size);
-                        }
+                    volk_32fc_x2_multiply_32fc_a(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
@@ -251,43 +270,15 @@ int pcps_acquisition_cc::general_work(int noutput_items,
 
                     // Multiply carrier wiped--off, Fourier transformed incoming signal
                     // with the local FFT'd code reference using SIMD operations with VOLK library
-                    if (is_unaligned())
-                        {
-                            volk_32fc_x2_multiply_32fc_u(d_ifft->get_inbuf(),
-                                        d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
-                        }
-                    else
-                        {
-                            volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
-                                        d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
-                        }
+                    volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
+                                d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
 
                     // compute the inverse FFT
                     d_ifft->execute();
 
                     // Search maximum
-                    indext = 0;
-                    magt = 0.0;
-
-                    fft_normalization_factor = (float)d_fft_size * (float)d_fft_size;
-
-                    if (is_unaligned())
-                        {
-                            volk_32fc_magnitude_squared_32f_u(d_magnitude, d_ifft->get_outbuf(), d_fft_size);
-                            for (i = 0; i < d_fft_size; i++)
-                                {
-                                    if(d_magnitude[i] > magt)
-                                        {
-                                            magt = d_magnitude[i];
-                                            indext = i;
-                                        }
-                                }
-                        }
-                    else
-                        {
-                            volk_32fc_magnitude_squared_32f_a(d_magnitude, d_ifft->get_outbuf(), d_fft_size);
-                            volk_32f_index_max_16u_a(&indext, d_magnitude, d_fft_size);
-                        }
+                    volk_32fc_magnitude_squared_32f_a(d_magnitude, d_ifft->get_outbuf(), d_fft_size);
+                    volk_32f_index_max_16u_a(&indext, d_magnitude, d_fft_size);
 
                     // Normalize the maximum value to correct the scale factor introduced by FFTW
                     magt = d_magnitude[indext] / (fft_normalization_factor * fft_normalization_factor);
@@ -296,8 +287,17 @@ int pcps_acquisition_cc::general_work(int noutput_items,
                     if (d_mag < magt)
                         {
                             d_mag = magt;
-                            d_gnss_synchro->Acq_delay_samples = (double)(indext % d_samples_per_code);
-                            d_gnss_synchro->Acq_doppler_hz = (double)doppler;
+
+                            if (d_test_statistics < (magt / d_input_power) || !d_bit_transition_flag)
+                            {
+                                d_gnss_synchro->Acq_delay_samples = (double)(indext % d_samples_per_code);
+                                d_gnss_synchro->Acq_doppler_hz = (double)doppler;
+                                d_gnss_synchro->Acq_samplestamp_samples = d_sample_counter;
+
+                                // 5- Compute the test statistics and compare to the threshold
+                                //d_test_statistics = 2 * d_fft_size * d_mag / d_input_power;
+                                d_test_statistics = d_mag / d_input_power;
+                            }
                         }
 
                     // Record results to file if required
@@ -315,51 +315,90 @@ int pcps_acquisition_cc::general_work(int noutput_items,
                         }
                 }
 
-            // 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;
-
-            // 6- Declare positive or negative acquisition using a message queue
-            if (d_test_statistics > d_threshold)
+            if (!d_bit_transition_flag)
                 {
-                    positive_acquisition = true;
-                    d_gnss_synchro->Acq_samplestamp_samples = d_sample_counter;
-                    DLOG(INFO) << "positive acquisition";
-                    DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
-                    DLOG(INFO) << "sample_stamp " << d_sample_counter;
-                    DLOG(INFO) << "test statistics value " << d_test_statistics;
-                    DLOG(INFO) << "test statistics threshold " << d_threshold;
-                    DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
-                    DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
-                    DLOG(INFO) << "magnitude " << d_mag;
-                    DLOG(INFO) << "input signal power " << d_input_power;
+                    if (d_test_statistics > d_threshold)
+                        {
+                            d_state = 2; // Positive acquisition
+                        }
+                    else
+                        {
+                            if (d_well_count == d_max_dwells)
+                                {
+                                    d_state = 3; // Negative acquisition
+                                }
+                        }
                 }
             else
                 {
-                    DLOG(INFO) << "negative acquisition";
-                    DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
-                    DLOG(INFO) << "sample_stamp " << d_sample_counter;
-                    DLOG(INFO) << "test statistics value " << d_test_statistics;
-                    DLOG(INFO) << "test statistics threshold " << d_threshold;
-                    DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
-                    DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
-                    DLOG(INFO) << "magnitude " << d_mag;
-                    DLOG(INFO) << "input signal power " << d_input_power;
+                    if (d_well_count == d_max_dwells)
+                        {
+                            if (d_test_statistics > d_threshold)
+                                {
+                                    d_state = 2; // Positive acquisition
+                                }
+                            else
+                                {
+                                    d_state = 3; // Negative acquisition
+                                }
+                        }
                 }
 
+            consume_each(1);
+
+            break;
+        }
+
+    case 2:
+        {
+            // 6.1- Declare positive acquisition using a message queue
+            DLOG(INFO) << "positive acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
             d_active = false;
+            d_state = 0;
 
-            if (positive_acquisition)
-                {
-                    acquisition_message = 1;
-                }
-            else
-                {
-                    acquisition_message = 2;
-                }
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
 
+            acquisition_message = 1;
             d_channel_internal_queue->push(acquisition_message);
-            consume_each(1);
+
+            break;
         }
+
+    case 3:
+        {
+            // 6.2- Declare negative acquisition using a message queue
+            DLOG(INFO) << "negative acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 2;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+    }
+
     return 0;
 }

src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.h

@@ -66,9 +66,12 @@ class pcps_acquisition_cc;
 typedef boost::shared_ptr<pcps_acquisition_cc> pcps_acquisition_cc_sptr;
 
 pcps_acquisition_cc_sptr
-pcps_make_acquisition_cc(unsigned int sampled_ms, unsigned int doppler_max,
-        long freq, long fs_in, int samples_per_ms, int samples_per_code,
-        gr::msg_queue::sptr queue, bool dump, std::string dump_filename);
+pcps_make_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                         unsigned int doppler_max, long freq, long fs_in,
+                         int samples_per_ms, int samples_per_code,
+                         bool bit_transition_flag,
+                         gr::msg_queue::sptr queue, bool dump,
+                         std::string dump_filename);
 
 /*!
  * \brief This class implements a Parallel Code Phase Search Acquisition.
@@ -80,13 +83,20 @@ class pcps_acquisition_cc: public gr::block
 {
 private:
     friend pcps_acquisition_cc_sptr
-    pcps_make_acquisition_cc(unsigned int sampled_ms, unsigned int doppler_max,
-            long freq, long fs_in, int samples_per_ms, int samples_per_code,
-            gr::msg_queue::sptr queue, bool dump, std::string dump_filename);
+    pcps_make_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                             unsigned int doppler_max, long freq, long fs_in,
+                             int samples_per_ms, int samples_per_code,
+                             bool bit_transition_flag,
+                             gr::msg_queue::sptr queue, bool dump,
+                             std::string dump_filename);
 
-    pcps_acquisition_cc(unsigned int sampled_ms, unsigned int doppler_max,
-            long freq, long fs_in, int samples_per_ms, int samples_per_code,
-            gr::msg_queue::sptr queue, bool dump, std::string dump_filename);
+
+    pcps_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                        unsigned int doppler_max, long freq, long fs_in,
+                        int samples_per_ms, int samples_per_code,
+                        bool bit_transition_flag,
+                        gr::msg_queue::sptr queue, bool dump,
+                        std::string dump_filename);
 
     void calculate_magnitudes(gr_complex* fft_begin, int doppler_shift,
             int doppler_offset);
@@ -98,10 +108,12 @@ private:
     int d_samples_per_code;
 	unsigned int d_doppler_resolution;
 	float d_threshold;
-	std::string d_satellite_str;
+    std::string d_satellite_str;
 	unsigned int d_doppler_max;
 	unsigned int d_doppler_step;
 	unsigned int d_sampled_ms;
+    unsigned int d_max_dwells;
+    unsigned int d_well_count;
 	unsigned int d_fft_size;
 	unsigned long int d_sample_counter;
     gr_complex** d_grid_doppler_wipeoffs;
@@ -109,17 +121,19 @@ private:
 	gr_complex* d_fft_codes;
 	gr::fft::fft_complex* d_fft_if;
 	gr::fft::fft_complex* d_ifft;
-	Gnss_Synchro *d_gnss_synchro;
+    Gnss_Synchro *d_gnss_synchro;
 	unsigned int d_code_phase;
 	float d_doppler_freq;
 	float d_mag;
     float* d_magnitude;
 	float d_input_power;
 	float d_test_statistics;
+    bool d_bit_transition_flag;
     gr::msg_queue::sptr d_queue;
 	concurrent_queue<int> *d_channel_internal_queue;
 	std::ofstream d_dump_file;
 	bool d_active;
+    int d_state;
 	bool d_dump;
 	unsigned int d_channel;
 	std::string d_dump_filename;

src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.cc

@@ -0,0 +1,420 @@
+/*!
+ * \file pcps_cccwsr_acquisition_cc.cc
+ * \brief This class implements a Parallel Code Phase Search acquisition
+ *  with Coherent Channel Combining With Sign Recovery scheme.
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * D.Borio, C.O'Driscoll, G.Lachapelle, "Coherent, Noncoherent and
+ * Differentially Coherent Combining Techniques for Acquisition of
+ * New Composite GNSS Signals", IEEE Transactions On Aerospace and
+ * Electronic Systems vol. 45 no. 3, July 2009, section IV
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "pcps_cccwsr_acquisition_cc.h"
+#include "gnss_signal_processing.h"
+#include "control_message_factory.h"
+#include <gnuradio/io_signature.h>
+#include <sstream>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <volk/volk.h>
+#include <gperftools/profiler.h>
+
+using google::LogMessage;
+
+pcps_cccwsr_acquisition_cc_sptr pcps_cccwsr_make_acquisition_cc(
+                                unsigned int sampled_ms, unsigned int max_dwells,
+                                unsigned int doppler_max, long freq, long fs_in,
+                                int samples_per_ms, int samples_per_code,
+                                gr::msg_queue::sptr queue, bool dump,
+                                std::string dump_filename)
+
+{
+
+    return pcps_cccwsr_acquisition_cc_sptr(
+            new pcps_cccwsr_acquisition_cc(sampled_ms, max_dwells, doppler_max, freq, fs_in,
+                    samples_per_ms, samples_per_code, queue, dump, dump_filename));
+}
+
+
+pcps_cccwsr_acquisition_cc::pcps_cccwsr_acquisition_cc(
+                    unsigned int sampled_ms, unsigned int max_dwells,
+                    unsigned int doppler_max, long freq, long fs_in,
+                    int samples_per_ms, int samples_per_code,
+                    gr::msg_queue::sptr queue, bool dump,
+                    std::string dump_filename) :
+    gr::block("pcps_cccwsr_acquisition_cc",
+    gr::io_signature::make(1, 1, sizeof(gr_complex) * sampled_ms * samples_per_ms),
+    gr::io_signature::make(0, 0, sizeof(gr_complex) * sampled_ms * samples_per_ms))
+{
+    d_sample_counter = 0;    // SAMPLE COUNTER
+    d_active = false;
+    d_state = 0;
+    d_queue = queue;
+    d_freq = freq;
+    d_fs_in = fs_in;
+    d_samples_per_ms = samples_per_ms;
+    d_samples_per_code = samples_per_code;
+    d_sampled_ms = sampled_ms;
+    d_max_dwells = max_dwells;
+    d_well_count = 0;
+    d_doppler_max = doppler_max;
+    d_fft_size = d_sampled_ms * d_samples_per_ms;
+    d_mag = 0;
+    d_input_power = 0.0;
+    d_num_doppler_bins = 0;
+
+    //todo: do something if posix_memalign fails
+    if (posix_memalign((void**)&d_fft_code_data, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_fft_code_pilot, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_data_correlation, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_pilot_correlation, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_correlation_plus, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_correlation_minus, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_magnitude, 16, d_fft_size * sizeof(float)) == 0){};
+
+    // Direct FFT
+    d_fft_if = new gr::fft::fft_complex(d_fft_size, true);
+
+    // Inverse FFT
+    d_ifft = new gr::fft::fft_complex(d_fft_size, false);
+
+    // For dumping samples into a file
+    d_dump = dump;
+    d_dump_filename = dump_filename;
+}
+
+
+pcps_cccwsr_acquisition_cc::~pcps_cccwsr_acquisition_cc()
+{
+
+    for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
+        {
+            free(d_grid_doppler_wipeoffs[doppler_index]);
+        }
+
+
+    if (d_num_doppler_bins > 0)
+        {
+            delete[] d_grid_doppler_wipeoffs;
+        }
+
+    free(d_fft_code_data);
+    free(d_fft_code_pilot);
+    free(d_data_correlation);
+    free(d_pilot_correlation);
+    free(d_correlation_plus);
+    free(d_correlation_minus);
+    free(d_magnitude);
+
+    delete d_ifft;
+    delete d_fft_if;
+
+    if (d_dump)
+        {
+            d_dump_file.close();
+        }
+}
+
+
+void pcps_cccwsr_acquisition_cc::set_local_code(std::complex<float> * code_data,
+                                           std::complex<float> * code_pilot)
+{
+    memcpy(d_fft_if->get_inbuf(), code_data, sizeof(gr_complex)*d_fft_size);
+
+    d_fft_if->execute(); // We need the FFT of local code
+
+    //Conjugate the local code
+    if (is_unaligned())
+        {
+            volk_32fc_conjugate_32fc_u(d_fft_code_data,d_fft_if->get_outbuf(),d_fft_size);
+        }
+    else
+        {
+            volk_32fc_conjugate_32fc_a(d_fft_code_data,d_fft_if->get_outbuf(),d_fft_size);
+        }
+
+    memcpy(d_fft_if->get_inbuf(), code_pilot, sizeof(gr_complex)*d_fft_size);
+
+    d_fft_if->execute(); // We need the FFT of local code
+
+    //Conjugate the local code,
+    if (is_unaligned())
+        {
+            volk_32fc_conjugate_32fc_u(d_fft_code_pilot,d_fft_if->get_outbuf(),d_fft_size);
+        }
+    else
+        {
+            volk_32fc_conjugate_32fc_a(d_fft_code_pilot,d_fft_if->get_outbuf(),d_fft_size);
+        }
+}
+
+
+void pcps_cccwsr_acquisition_cc::init()
+{
+    d_gnss_synchro->Acq_delay_samples = 0.0;
+    d_gnss_synchro->Acq_doppler_hz = 0.0;
+    d_gnss_synchro->Acq_samplestamp_samples = 0;
+    d_mag = 0.0;
+    d_input_power = 0.0;
+
+    // Create the carrier Doppler wipeoff signals
+    d_num_doppler_bins = 0;//floor(2*std::abs((int)d_doppler_max)/d_doppler_step);
+    for (int doppler = (int)(-d_doppler_max); doppler <= (int)d_doppler_max; doppler += d_doppler_step)
+    {
+        d_num_doppler_bins++;
+    }
+    d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins];
+    for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+        {
+            if (posix_memalign((void**)&(d_grid_doppler_wipeoffs[doppler_index]), 16,
+                               d_fft_size * sizeof(gr_complex)) == 0){};
+
+            int doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+            complex_exp_gen_conj(d_grid_doppler_wipeoffs[doppler_index],
+                                 d_freq + doppler, d_fs_in, d_fft_size);
+        }
+}
+
+
+int pcps_cccwsr_acquisition_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 acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
+
+    switch (d_state)
+    {
+    case 0:
+        {
+            if (d_active)
+                {
+                    //restart acquisition variables
+                    d_gnss_synchro->Acq_delay_samples = 0.0;
+                    d_gnss_synchro->Acq_doppler_hz = 0.0;
+                    d_gnss_synchro->Acq_samplestamp_samples = 0;
+                    d_well_count = 0;
+                    d_mag = 0.0;
+                    d_input_power = 0.0;
+                    d_test_statistics = 0.0;
+
+                    d_state = 1;
+                }
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            break;
+        }
+    case 1:
+        {
+            // initialize acquisition algorithm
+            int doppler;
+            unsigned int indext = 0;
+            unsigned int indext_plus = 0;
+            unsigned int indext_minus = 0;
+            float magt = 0.0;
+            float magt_plus = 0.0;
+            float magt_minus = 0.0;
+            const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
+            float fft_normalization_factor = (float)d_fft_size * (float)d_fft_size;
+
+            d_sample_counter += d_fft_size; // sample counter
+
+            d_well_count++;
+
+            DLOG(INFO) << "Channel: " << d_channel
+                    << " , doing acquisition of satellite: " << d_gnss_synchro->System << " "<< d_gnss_synchro->PRN
+                    << " ,sample stamp: " << d_sample_counter << ", threshold: "
+                    << d_threshold << ", doppler_max: " << d_doppler_max
+                    << ", doppler_step: " << d_doppler_step;
+
+            // 1- Compute the input signal power estimation
+            volk_32fc_magnitude_squared_32f_a(d_magnitude, in, d_fft_size);
+            volk_32f_accumulator_s32f_a(&d_input_power, d_magnitude, d_fft_size);
+            d_input_power /= (float)d_fft_size;
+
+            // 2- Doppler frequency search loop
+            for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+                {
+                    // doppler search steps
+
+                    doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+
+                    volk_32fc_x2_multiply_32fc_a(d_fft_if->get_inbuf(), 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 {data+j*pilot} using SIMD operations with VOLK library
+                    volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
+                                d_fft_if->get_outbuf(), d_fft_code_data, d_fft_size);
+
+                    // compute the inverse FFT
+                    d_ifft->execute();
+
+                    memcpy(d_data_correlation, d_ifft->get_outbuf(), sizeof(gr_complex)*d_fft_size);
+
+
+                    volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(),
+                                d_fft_if->get_outbuf(), d_fft_code_pilot, d_fft_size);
+
+                    d_ifft->execute();
+
+                    memcpy(d_pilot_correlation, d_ifft->get_outbuf(), sizeof(gr_complex)*d_fft_size);
+
+                    for (unsigned int i = 0; i < d_fft_size; i++)
+                        {
+                            d_correlation_plus[i] = std::complex<float>(
+                                                    d_data_correlation[i].real() - d_pilot_correlation[i].imag(),
+                                                    d_data_correlation[i].imag() + d_pilot_correlation[i].real());
+
+                            d_correlation_minus[i] = std::complex<float>(
+                                                     d_data_correlation[i].real() + d_pilot_correlation[i].imag(),
+                                                     d_data_correlation[i].imag() - d_pilot_correlation[i].real());
+                        }
+
+                    volk_32fc_magnitude_squared_32f_a(d_magnitude, d_correlation_plus, d_fft_size);
+                    volk_32f_index_max_16u_a(&indext_plus, d_magnitude, d_fft_size);
+                    magt_plus = d_magnitude[indext_plus] / (fft_normalization_factor * fft_normalization_factor);
+
+                    volk_32fc_magnitude_squared_32f_a(d_magnitude, d_correlation_minus, d_fft_size);
+                    volk_32f_index_max_16u_a(&indext_minus, d_magnitude, d_fft_size);
+                    magt_minus = d_magnitude[indext_minus] / (fft_normalization_factor * fft_normalization_factor);
+
+                    if (magt_plus >= magt_minus)
+                    {
+                        magt = magt_plus;
+                        indext = indext_plus;
+                    }
+                    else
+                    {
+                        magt = magt_minus;
+                        indext = indext_minus;
+                    }
+
+                    // 4- record the maximum peak and the associated synchronization parameters
+                    if (d_mag < magt)
+                        {
+                            d_mag = magt;
+                            d_gnss_synchro->Acq_delay_samples = (double)(indext % d_samples_per_code);
+                            d_gnss_synchro->Acq_doppler_hz = (double)doppler;
+                            d_gnss_synchro->Acq_samplestamp_samples = d_sample_counter;
+                        }
+
+                    // 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("");
+                            filename << "../data/test_statistics_" << d_gnss_synchro->System
+                                     <<"_" << d_gnss_synchro->Signal << "_sat_"
+                                     << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
+                            d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
+                            d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.close();
+                        }
+                }
+
+            // 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;
+
+            // 6- Declare positive or negative acquisition using a message queue
+            if (d_test_statistics > d_threshold)
+                {
+                    d_state = 2; // Positive acquisition
+                }
+            else
+                {
+                    if (d_well_count == d_max_dwells)
+                        {
+                            d_state = 3; // Negative acquisition
+                        }
+                }
+
+            break;
+        }
+
+    case 2:
+        {
+            // 6.1- Declare positive acquisition using a message queue
+            DLOG(INFO) << "positive acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 1;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+
+    case 3:
+        {
+            // 6.2- Declare negative acquisition using a message queue
+            DLOG(INFO) << "negative acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 2;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+    }
+
+    return 0;
+}

src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.h

@@ -0,0 +1,230 @@
+/*!
+ * \file pcps_cccwsr_acquisition_cc.h
+ * \brief This class implements a Parallel Code Phase Search acquisition
+ *  with Coherent Channel Combining With Sign Recovery scheme.
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ * D.Borio, C.O'Driscoll, G.Lachapelle, "Coherent, Noncoherent and
+ * Differentially Coherent Combining Techniques for Acquisition of
+ * New Composite GNSS Signals", IEEE Transactions On Aerospace and
+ * Electronic Systems vol. 45 no. 3, July 2009, section IV
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_PCPS_CCCWSR_ACQUISITION_CC_H_
+#define GNSS_SDR_PCPS_CCCWSR_ACQUISITION_CC_H_
+
+#include <fstream>
+#include <gnuradio/block.h>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/gr_complex.h>
+#include <gnuradio/fft/fft.h>
+#include <queue>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include "concurrent_queue.h"
+#include "gnss_synchro.h"
+#include <boost/shared_array.hpp>
+
+class pcps_cccwsr_acquisition_cc;
+
+typedef boost::shared_ptr<pcps_cccwsr_acquisition_cc> pcps_cccwsr_acquisition_cc_sptr;
+
+pcps_cccwsr_acquisition_cc_sptr
+pcps_cccwsr_make_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                         unsigned int doppler_max, long freq, long fs_in,
+                         int samples_per_ms, int samples_per_code,
+                         gr::msg_queue::sptr queue, bool dump,
+                         std::string dump_filename);
+
+/*!
+ * \brief This class implements a Parallel Code Phase Search Acquisition with
+ * Coherent Channel Combining With Sign Recovery scheme.
+ */
+class pcps_cccwsr_acquisition_cc: public gr::block
+{
+private:
+    friend pcps_cccwsr_acquisition_cc_sptr
+    pcps_cccwsr_make_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                                    unsigned int doppler_max, long freq, long fs_in,
+                                    int samples_per_ms, int samples_per_code,
+                                    gr::msg_queue::sptr queue, bool dump,
+                                    std::string dump_filename);
+
+
+    pcps_cccwsr_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                               unsigned int doppler_max, long freq, long fs_in,
+                               int samples_per_ms, int samples_per_code,
+                               gr::msg_queue::sptr queue, bool dump,
+                               std::string dump_filename);
+
+    void calculate_magnitudes(gr_complex* fft_begin, int doppler_shift,
+            int doppler_offset);
+
+
+	long d_fs_in;
+	long d_freq;
+	int d_samples_per_ms;
+    int d_samples_per_code;
+	unsigned int d_doppler_resolution;
+	float d_threshold;
+    std::string d_satellite_str;
+	unsigned int d_doppler_max;
+	unsigned int d_doppler_step;
+	unsigned int d_sampled_ms;
+    unsigned int d_max_dwells;
+    unsigned int d_well_count;
+	unsigned int d_fft_size;
+	unsigned long int d_sample_counter;
+    gr_complex** d_grid_doppler_wipeoffs;
+    unsigned int d_num_doppler_bins;
+    gr_complex* d_fft_code_data;
+    gr_complex* d_fft_code_pilot;
+	gr::fft::fft_complex* d_fft_if;
+	gr::fft::fft_complex* d_ifft;
+    Gnss_Synchro *d_gnss_synchro;
+	unsigned int d_code_phase;
+	float d_doppler_freq;
+	float d_mag;
+    float* d_magnitude;
+    gr_complex* d_data_correlation;
+    gr_complex* d_pilot_correlation;
+    gr_complex* d_correlation_plus;
+    gr_complex* d_correlation_minus;
+    float d_input_power;
+	float d_test_statistics;
+    gr::msg_queue::sptr d_queue;
+	concurrent_queue<int> *d_channel_internal_queue;
+	std::ofstream d_dump_file;
+	bool d_active;
+    int d_state;
+	bool d_dump;
+	unsigned int d_channel;
+	std::string d_dump_filename;
+
+public:
+    /*!
+     * \brief Default destructor.
+     */
+    ~pcps_cccwsr_acquisition_cc();
+
+    /*!
+     * \brief Set acquisition/tracking common Gnss_Synchro object pointer
+     * to exchange synchronization data between acquisition and tracking blocks.
+     * \param p_gnss_synchro Satellite information shared by the processing blocks.
+     */
+    void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
+    {
+        d_gnss_synchro = p_gnss_synchro;
+    }
+
+    /*!
+     * \brief Returns the maximum peak of grid search.
+     */
+    unsigned int mag()
+    {
+        return d_mag;
+    }
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    /*!
+     * \brief Sets local code for CCCWSR acquisition algorithm.
+     * \param data_code - Pointer to the data PRN code.
+     * \param pilot_code - Pointer to the pilot PRN code.
+     */
+    void set_local_code(std::complex<float> * code_data, std::complex<float> * code_pilot);
+
+    /*!
+     * \brief Starts acquisition algorithm, turning from standby mode to
+     * active mode
+     * \param active - bool that activates/deactivates the block.
+     */
+    void set_active(bool active)
+    {
+        d_active = active;
+    }
+
+    /*!
+     * \brief Set acquisition channel unique ID
+     * \param channel - receiver channel.
+     */
+    void set_channel(unsigned int channel)
+    {
+        d_channel = channel;
+    }
+
+    /*!
+     * \brief Set statistics threshold of CCCWSR algorithm.
+     * \param threshold - Threshold for signal detection (check \ref Navitec2012,
+     * Algorithm 1, for a definition of this threshold).
+     */
+    void set_threshold(float threshold)
+    {
+        d_threshold = threshold;
+    }
+
+    /*!
+     * \brief Set maximum Doppler grid search
+     * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz].
+     */
+    void set_doppler_max(unsigned int doppler_max)
+    {
+        d_doppler_max = doppler_max;
+    }
+
+    /*!
+     * \brief Set Doppler steps for the grid search
+     * \param doppler_step - Frequency bin of the search grid [Hz].
+     */
+    void set_doppler_step(unsigned int doppler_step)
+    {
+        d_doppler_step = doppler_step;
+    }
+
+
+    /*!
+     * \brief Set tracking channel internal queue.
+     * \param channel_internal_queue - Channel's internal blocks information queue.
+     */
+    void set_channel_queue(concurrent_queue<int> *channel_internal_queue)
+    {
+        d_channel_internal_queue = channel_internal_queue;
+    }
+
+    /*!
+     * \brief Coherent Channel Combining With Sign Recovery Acquisition signal processing.
+     */
+    int general_work(int noutput_items, gr_vector_int &ninput_items,
+            gr_vector_const_void_star &input_items,
+            gr_vector_void_star &output_items);
+
+};
+
+#endif /* GNSS_SDR_PCPS_CCCWSR_ACQUISITION_CC_H_*/

src/algorithms/acquisition/gnuradio_blocks/pcps_multithread_acquisition_cc.cc

@@ -0,0 +1,401 @@
+/*!
+ * \file pcps_multithread_acquisition_cc.cc
+ * \brief This class implements a Parallel Code Phase Search Acquisition
+ * \authors <ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          <li> Marc Molina, 2013. marc.molina.pena@gmail.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "pcps_multithread_acquisition_cc.h"
+#include "gnss_signal_processing.h"
+#include "control_message_factory.h"
+#include <gnuradio/io_signature.h>
+#include <sstream>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <volk/volk.h>
+
+using google::LogMessage;
+
+pcps_multithread_acquisition_cc_sptr pcps_make_multithread_acquisition_cc(
+                                 unsigned int sampled_ms, unsigned int max_dwells,
+                                 unsigned int doppler_max, long freq, long fs_in,
+                                 int samples_per_ms, int samples_per_code,
+                                 bool bit_transition_flag,
+                                 gr::msg_queue::sptr queue, bool dump,
+                                 std::string dump_filename)
+{
+
+    return pcps_multithread_acquisition_cc_sptr(
+            new pcps_multithread_acquisition_cc(sampled_ms, max_dwells, doppler_max, freq, fs_in, samples_per_ms,
+                                     samples_per_code, bit_transition_flag, queue, dump, dump_filename));
+}
+
+
+pcps_multithread_acquisition_cc::pcps_multithread_acquisition_cc(
+                         unsigned int sampled_ms, unsigned int max_dwells,
+                         unsigned int doppler_max, long freq, long fs_in,
+                         int samples_per_ms, int samples_per_code,
+                         bool bit_transition_flag,
+                         gr::msg_queue::sptr queue, bool dump,
+                         std::string dump_filename) :
+    gr::block("pcps_multithread_acquisition_cc",
+    gr::io_signature::make(1, 1, sizeof(gr_complex) * sampled_ms * samples_per_ms),
+    gr::io_signature::make(0, 0, sizeof(gr_complex) * sampled_ms * samples_per_ms))
+{
+    d_sample_counter = 0;    // SAMPLE COUNTER
+    d_active = false;
+    d_state = 0;
+    d_queue = queue;
+    d_freq = freq;
+    d_fs_in = fs_in;
+    d_samples_per_ms = samples_per_ms;
+    d_samples_per_code = samples_per_code;
+    d_sampled_ms = sampled_ms;
+    d_max_dwells = max_dwells;
+    d_well_count = 0;
+    d_doppler_max = doppler_max;
+    d_fft_size = d_sampled_ms * d_samples_per_ms;
+    d_mag = 0;
+    d_input_power = 0.0;
+    d_num_doppler_bins = 0;
+    d_bit_transition_flag = bit_transition_flag;
+
+    //todo: do something if posix_memalign fails
+    if (posix_memalign((void**)&d_fft_codes, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_magnitude, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+
+    // Direct FFT
+    d_fft_if = new gr::fft::fft_complex(d_fft_size, true);
+
+    // Inverse FFT
+    d_ifft = new gr::fft::fft_complex(d_fft_size, false);
+
+    // For dumping samples into a file
+    d_dump = dump;
+    d_dump_filename = dump_filename;
+}
+
+
+pcps_multithread_acquisition_cc::~pcps_multithread_acquisition_cc()
+{
+
+    for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
+        {
+            free(d_grid_doppler_wipeoffs[doppler_index]);
+        }
+
+
+    if (d_num_doppler_bins > 0)
+        {
+            delete[] d_grid_doppler_wipeoffs;
+        }
+
+    free(d_fft_codes);
+    free(d_magnitude);
+
+    delete d_ifft;
+    delete d_fft_if;
+
+    if (d_dump)
+        {
+            d_dump_file.close();
+        }
+}
+
+
+void pcps_multithread_acquisition_cc::set_local_code(std::complex<float> * code)
+{
+    memcpy(d_fft_if->get_inbuf(), code, sizeof(gr_complex)*d_fft_size);
+
+    d_fft_if->execute(); // We need the FFT of local code
+
+    //Conjugate the local code
+    if (is_unaligned())
+        {
+            volk_32fc_conjugate_32fc_u(d_fft_codes,d_fft_if->get_outbuf(),d_fft_size);
+        }
+    else
+        {
+            volk_32fc_conjugate_32fc_a(d_fft_codes,d_fft_if->get_outbuf(),d_fft_size);
+        }
+}
+
+void pcps_multithread_acquisition_cc::perform_acquisition(const gr_complex* in, unsigned int samplestamp)
+{
+    // initialize acquisition algorithm
+    int doppler;
+    unsigned int indext = 0;
+    float magt = 0.0;
+    float fft_normalization_factor = (float)d_fft_size * (float)d_fft_size;
+    d_input_power = 0.0;
+    d_mag = 0.0;
+
+    d_well_count++;
+
+    DLOG(INFO) << "Channel: " << d_channel
+            << " , doing acquisition of satellite: " << d_gnss_synchro->System << " "<< d_gnss_synchro->PRN
+            << " ,sample stamp: " << d_sample_counter << ", threshold: "
+            << d_threshold << ", doppler_max: " << d_doppler_max
+            << ", doppler_step: " << d_doppler_step;
+
+    // 1- Compute the input signal power estimation
+    volk_32fc_magnitude_squared_32f_a(d_magnitude, in, d_fft_size);
+    volk_32f_accumulator_s32f_a(&d_input_power, d_magnitude, d_fft_size);
+    d_input_power /= (float)d_fft_size;
+
+    // 2- Doppler frequency search loop
+    for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+        {
+            // doppler search steps
+
+            doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+
+            volk_32fc_x2_multiply_32fc_a(d_fft_if->get_inbuf(), 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_a(d_ifft->get_inbuf(),
+                        d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
+
+            // compute the inverse FFT
+            d_ifft->execute();
+
+            // Search maximum
+            volk_32fc_magnitude_squared_32f_a(d_magnitude, d_ifft->get_outbuf(), d_fft_size);
+            volk_32f_index_max_16u_a(&indext, d_magnitude, d_fft_size);
+
+            // 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
+            if (d_mag < magt)
+                {
+                    d_mag = magt;
+
+                    if (d_test_statistics < (magt / d_input_power) || !d_bit_transition_flag)
+                    {
+                        d_gnss_synchro->Acq_delay_samples = (double)(indext % d_samples_per_code);
+                        d_gnss_synchro->Acq_doppler_hz = (double)doppler;
+                        d_gnss_synchro->Acq_samplestamp_samples = samplestamp;
+
+                        // 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("");
+                    filename << "../data/test_statistics_" << d_gnss_synchro->System
+                             <<"_" << d_gnss_synchro->Signal << "_sat_"
+                             << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
+                    d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
+                    d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                    d_dump_file.close();
+                }
+        }
+
+    if (!d_bit_transition_flag)
+        {
+            if (d_test_statistics > d_threshold)
+                {
+                    d_state = 3; // Positive acquisition
+                }
+            else
+                {
+                    if (d_well_count == d_max_dwells)
+                        {
+                            d_state = 4; // Negative acquisition
+                        }
+                    else
+                        {
+                            d_state = 1; // Process next block
+                        }
+                }
+        }
+    else
+        {
+            if (d_well_count == d_max_dwells)
+                {
+                    if (d_test_statistics > d_threshold)
+                        {
+                            d_state = 3; // Positive acquisition
+                        }
+                    else
+                        {
+                            d_state = 4; // Negative acquisition
+                        }
+                }
+            else
+                {
+                    d_state = 1; // Process next block
+                }
+        }
+}
+
+
+void pcps_multithread_acquisition_cc::init()
+{
+    d_gnss_synchro->Acq_delay_samples = 0.0;
+    d_gnss_synchro->Acq_doppler_hz = 0.0;
+    d_gnss_synchro->Acq_samplestamp_samples = 0;
+    d_mag = 0.0;
+    d_input_power = 0.0;
+
+    // Create the carrier Doppler wipeoff signals
+    d_num_doppler_bins = 0;//floor(2*std::abs((int)d_doppler_max)/d_doppler_step);
+    for (int doppler = (int)(-d_doppler_max); doppler <= (int)d_doppler_max; doppler += d_doppler_step)
+    {
+        d_num_doppler_bins++;
+    }
+    d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins];
+    for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+        {
+            if (posix_memalign((void**)&(d_grid_doppler_wipeoffs[doppler_index]), 16,
+                               d_fft_size * sizeof(gr_complex)) == 0){};
+
+            int doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+            complex_exp_gen_conj(d_grid_doppler_wipeoffs[doppler_index],
+                                 d_freq + doppler, d_fs_in, d_fft_size);
+        }
+}
+
+
+int pcps_multithread_acquisition_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 acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
+
+    switch (d_state)
+    {
+    case 0:
+        {
+            if (d_active)
+                {
+                    //restart acquisition variables
+                    d_gnss_synchro->Acq_delay_samples = 0.0;
+                    d_gnss_synchro->Acq_doppler_hz = 0.0;
+                    d_gnss_synchro->Acq_samplestamp_samples = 0;
+                    d_well_count = 0;
+                    d_mag = 0.0;
+                    d_input_power = 0.0;
+                    d_test_statistics = 0.0;
+
+                    d_state = 1;
+                }
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            break;
+        }
+
+    case 1:
+        {
+            const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
+            d_sample_counter += d_fft_size; // sample counter
+            boost::thread(&pcps_multithread_acquisition_cc::perform_acquisition, this, in, d_sample_counter);
+            d_state = 2;
+            consume_each(1);
+
+            break;
+        }
+
+    case 2:
+        {
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+            break;
+        }
+    case 3:
+        {
+
+            // Declare positive acquisition using a message queue
+            DLOG(INFO) << "positive acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 1;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+
+    case 4:
+        {
+            // Declare negative acquisition using a message queue
+            DLOG(INFO) << "negative acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 2;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+    }
+
+    return 0;
+}

src/algorithms/acquisition/gnuradio_blocks/pcps_multithread_acquisition_cc.h

@@ -0,0 +1,243 @@
+/*!
+ * \file pcps_multithread_acquisition_cc.h
+ * \brief This class implements a Parallel Code Phase Search Acquisition
+ *
+ *  Acquisition strategy (Kay Borre book + CFAR threshold).
+ *  <ol>
+ *  <li> Compute the input signal power estimation
+ *  <li> Doppler serial search loop
+ *  <li> Perform the FFT-based circular convolution (parallel time search)
+ *  <li> Record the maximum peak and the associated synchronization parameters
+ *  <li> Compute the test statistics and compare to the threshold
+ *  <li> Declare positive or negative acquisition using a message queue
+ *  </ol>
+ *
+ * Kay Borre book: 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. pp 81-84
+ *
+ * \authors <ul>
+ *          <li> Javier Arribas, 2011. jarribas(at)cttc.es
+ *          <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
+ *          <li> Marc Molina, 2013. marc.molina.pena@gmail.com
+ *          </ul>
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_PCPS_MULTITHREAD_ACQUISITION_CC_H_
+#define GNSS_SDR_PCPS_MULTITHREAD_ACQUISITION_CC_H_
+
+#include <fstream>
+#include <gnuradio/block.h>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/gr_complex.h>
+#include <gnuradio/fft/fft.h>
+#include <queue>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include "concurrent_queue.h"
+#include "gnss_synchro.h"
+
+class pcps_multithread_acquisition_cc;
+
+typedef boost::shared_ptr<pcps_multithread_acquisition_cc> pcps_multithread_acquisition_cc_sptr;
+
+pcps_multithread_acquisition_cc_sptr
+pcps_make_multithread_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                         unsigned int doppler_max, long freq, long fs_in,
+                         int samples_per_ms, int samples_per_code,
+                         bool bit_transition_flag,
+                         gr::msg_queue::sptr queue, bool dump,
+                         std::string dump_filename);
+
+/*!
+ * \brief This class implements a Parallel Code Phase Search Acquisition.
+ *
+ * Check \ref Navitec2012 "An Open Source Galileo E1 Software Receiver",
+ * Algorithm 1, for a pseudocode description of this implementation.
+ */
+class pcps_multithread_acquisition_cc: public gr::block
+{
+private:
+    friend pcps_multithread_acquisition_cc_sptr
+    pcps_make_multithread_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                             unsigned int doppler_max, long freq, long fs_in,
+                             int samples_per_ms, int samples_per_code,
+                             bool bit_transition_flag,
+                             gr::msg_queue::sptr queue, bool dump,
+                             std::string dump_filename);
+
+
+    pcps_multithread_acquisition_cc(unsigned int sampled_ms, unsigned int max_dwells,
+                        unsigned int doppler_max, long freq, long fs_in,
+                        int samples_per_ms, int samples_per_code,
+                        bool bit_transition_flag,
+                        gr::msg_queue::sptr queue, bool dump,
+                        std::string dump_filename);
+
+    void calculate_magnitudes(gr_complex* fft_begin, int doppler_shift,
+            int doppler_offset);
+
+
+	long d_fs_in;
+	long d_freq;
+	int d_samples_per_ms;
+    int d_samples_per_code;
+	unsigned int d_doppler_resolution;
+	float d_threshold;
+    std::string d_satellite_str;
+	unsigned int d_doppler_max;
+	unsigned int d_doppler_step;
+	unsigned int d_sampled_ms;
+    unsigned int d_max_dwells;
+    unsigned int d_well_count;
+	unsigned int d_fft_size;
+	unsigned long int d_sample_counter;
+    gr_complex** d_grid_doppler_wipeoffs;
+    unsigned int d_num_doppler_bins;
+	gr_complex* d_fft_codes;
+	gr::fft::fft_complex* d_fft_if;
+	gr::fft::fft_complex* d_ifft;
+    Gnss_Synchro *d_gnss_synchro;
+	unsigned int d_code_phase;
+	float d_doppler_freq;
+	float d_mag;
+    float* d_magnitude;
+	float d_input_power;
+	float d_test_statistics;
+    bool d_bit_transition_flag;
+    gr::msg_queue::sptr d_queue;
+	concurrent_queue<int> *d_channel_internal_queue;
+	std::ofstream d_dump_file;
+	bool d_active;
+    int d_state;
+	bool d_dump;
+	unsigned int d_channel;
+	std::string d_dump_filename;
+
+public:
+    /*!
+     * \brief Default destructor.
+     */
+    ~pcps_multithread_acquisition_cc();
+
+    /*!
+     * \brief Set acquisition/tracking common Gnss_Synchro object pointer
+     * to exchange synchronization data between acquisition and tracking blocks.
+     * \param p_gnss_synchro Satellite information shared by the processing blocks.
+     */
+    void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
+    {
+        d_gnss_synchro = p_gnss_synchro;
+    }
+
+    /*!
+     * \brief Returns the maximum peak of grid search.
+     */
+    unsigned int mag()
+    {
+        return d_mag;
+    }
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    /*!
+     * \brief Sets local code for PCPS acquisition algorithm.
+     * \param code - Pointer to the PRN code.
+     */
+    void set_local_code(std::complex<float> * code);
+
+    /*!
+     * \brief Starts acquisition algorithm, turning from standby mode to
+     * active mode
+     * \param active - bool that activates/deactivates the block.
+     */
+    void set_active(bool active)
+    {
+        d_active = active;
+    }
+
+    /*!
+     * \brief Set acquisition channel unique ID
+     * \param channel - receiver channel.
+     */
+    void set_channel(unsigned int channel)
+    {
+        d_channel = channel;
+    }
+
+    /*!
+     * \brief Set statistics threshold of PCPS algorithm.
+     * \param threshold - Threshold for signal detection (check \ref Navitec2012,
+     * Algorithm 1, for a definition of this threshold).
+     */
+    void set_threshold(float threshold)
+    {
+        d_threshold = threshold;
+    }
+
+    /*!
+     * \brief Set maximum Doppler grid search
+     * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz].
+     */
+    void set_doppler_max(unsigned int doppler_max)
+    {
+        d_doppler_max = doppler_max;
+    }
+
+    /*!
+     * \brief Set Doppler steps for the grid search
+     * \param doppler_step - Frequency bin of the search grid [Hz].
+     */
+    void set_doppler_step(unsigned int doppler_step)
+    {
+        d_doppler_step = doppler_step;
+    }
+
+
+    /*!
+     * \brief Set tracking channel internal queue.
+     * \param channel_internal_queue - Channel's internal blocks information queue.
+     */
+    void set_channel_queue(concurrent_queue<int> *channel_internal_queue)
+    {
+        d_channel_internal_queue = channel_internal_queue;
+    }
+
+    /*!
+     * \brief Parallel Code Phase Search Acquisition signal processing.
+     */
+    int general_work(int noutput_items, gr_vector_int &ninput_items,
+            gr_vector_const_void_star &input_items,
+            gr_vector_void_star &output_items);
+
+    void perform_acquisition(const gr_complex* in, const unsigned int samplestamp);
+};
+
+#endif /* GNSS_SDR_PCPS_MULTITHREAD_ACQUISITION_CC_H_*/

src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.cc

@@ -0,0 +1,408 @@
+/*!
+ * \file pcps_tong_acquisition_cc.h
+ * \brief This class implements a Parallel Code Phase Search Acquisition with
+ * Tong algorithm.
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ *  Acquisition strategy (Kaplan book + CFAR threshold).
+ *  <ol>
+ *  <li> Compute the input signal power estimation.
+ *  <li> Doppler serial search loop.
+ *  <li> Perform the FFT-based circular convolution (parallel time search).
+ *  <li> Compute the tests statistics for all the cells.
+ *  <li> Accumulate the grid of tests statistics with the previous grids.
+ *  <li> Record the maximum peak and the associated synchronization parameters.
+ *  <li> Compare the maximum averaged test statistics with a threshold.
+ *  <li> If the test statistics exceeds the threshold, increment the Tong counter.
+ *  <li>   Otherwise, decrement the Tong counter.
+ *  <li> If the Tong counter is equal to a given maximum value, declare positive
+ *  <li>   acquisition. If the Tong counter is equa to zero, declare negative
+ *  <li>   acquisition. Otherwise, process the next block.
+ *  </ol>
+ *
+ * Kaplan book: D.Kaplan, J.Hegarty, "Understanding GPS. Principles
+ * and Applications", Artech House, 2006, pp 223-227
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#include "pcps_tong_acquisition_cc.h"
+#include "gnss_signal_processing.h"
+#include "control_message_factory.h"
+#include <gnuradio/io_signature.h>
+#include <sstream>
+#include <glog/log_severity.h>
+#include <glog/logging.h>
+#include <volk/volk.h>
+
+using google::LogMessage;
+
+pcps_tong_acquisition_cc_sptr pcps_tong_make_acquisition_cc(
+                              unsigned int sampled_ms, unsigned int doppler_max,
+                              long freq, long fs_in, int samples_per_ms,
+                              int samples_per_code, unsigned int tong_init_val,
+                              unsigned int tong_max_val, gr::msg_queue::sptr queue,
+                              bool dump, std::string dump_filename)
+{
+    return pcps_tong_acquisition_cc_sptr(
+            new pcps_tong_acquisition_cc(sampled_ms, doppler_max, freq, fs_in, samples_per_ms, samples_per_code,
+                                    tong_init_val, tong_max_val, queue, dump, dump_filename));
+}
+
+
+pcps_tong_acquisition_cc::pcps_tong_acquisition_cc(
+                         unsigned int sampled_ms, unsigned int doppler_max,
+                         long freq, long fs_in, int samples_per_ms,
+                         int samples_per_code, unsigned int tong_init_val,
+                         unsigned int tong_max_val, gr::msg_queue::sptr queue,
+                         bool dump, std::string dump_filename) :
+    gr::block("pcps_tong_acquisition_cc",
+    gr::io_signature::make(1, 1, sizeof(gr_complex) * sampled_ms * samples_per_ms),
+    gr::io_signature::make(0, 0, sizeof(gr_complex) * sampled_ms * samples_per_ms))
+{
+    d_sample_counter = 0;    // SAMPLE COUNTER
+    d_active = false;
+    d_state = 0;
+    d_queue = queue;
+    d_freq = freq;
+    d_fs_in = fs_in;
+    d_samples_per_ms = samples_per_ms;
+    d_samples_per_code = samples_per_code;
+    d_sampled_ms = sampled_ms;
+    d_well_count = 0;
+    d_tong_max_val = tong_max_val;
+    d_tong_init_val = tong_init_val;
+    d_tong_count = d_tong_init_val;
+    d_doppler_max = doppler_max;
+    d_fft_size = d_sampled_ms * d_samples_per_ms;
+    d_mag = 0;
+    d_input_power = 0.0;
+    d_num_doppler_bins = 0;
+
+    //todo: do something if posix_memalign fails
+    if (posix_memalign((void**)&d_fft_codes, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+    if (posix_memalign((void**)&d_magnitude, 16, d_fft_size * sizeof(gr_complex)) == 0){};
+
+    // Direct FFT
+    d_fft_if = new gr::fft::fft_complex(d_fft_size, true);
+
+    // Inverse FFT
+    d_ifft = new gr::fft::fft_complex(d_fft_size, false);
+
+    // For dumping samples into a file
+    d_dump = dump;
+    d_dump_filename = dump_filename;
+}
+
+
+pcps_tong_acquisition_cc::~pcps_tong_acquisition_cc()
+{
+
+    for (unsigned int doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++)
+        {
+            free(d_grid_doppler_wipeoffs[doppler_index]);
+            free(d_grid_data[doppler_index]);
+        }
+
+
+    if (d_num_doppler_bins > 0)
+        {
+            delete[] d_grid_doppler_wipeoffs;
+            delete[] d_grid_data;
+        }
+
+    free(d_fft_codes);
+    free(d_magnitude);
+
+    delete d_ifft;
+    delete d_fft_if;
+
+    if (d_dump)
+        {
+            d_dump_file.close();
+        }
+}
+
+
+void pcps_tong_acquisition_cc::set_local_code(std::complex<float> * code)
+{
+    memcpy(d_fft_if->get_inbuf(), code, sizeof(gr_complex)*d_fft_size);
+
+    d_fft_if->execute(); // We need the FFT of local code
+
+    //Conjugate the local code
+    if (is_unaligned())
+        {
+            volk_32fc_conjugate_32fc_u(d_fft_codes,d_fft_if->get_outbuf(),d_fft_size);
+        }
+    else
+        {
+            volk_32fc_conjugate_32fc_a(d_fft_codes,d_fft_if->get_outbuf(),d_fft_size);
+        }
+}
+
+
+void pcps_tong_acquisition_cc::init()
+{
+    d_gnss_synchro->Acq_delay_samples = 0.0;
+    d_gnss_synchro->Acq_doppler_hz = 0.0;
+    d_gnss_synchro->Acq_samplestamp_samples = 0;
+    d_mag = 0.0;
+    d_input_power = 0.0;
+
+    // Create the carrier Doppler wipeoff signals
+    d_num_doppler_bins = 0;//floor(2*std::abs((int)d_doppler_max)/d_doppler_step);
+    for (int doppler = (int)(-d_doppler_max); doppler <= (int)d_doppler_max; doppler += d_doppler_step)
+    {
+        d_num_doppler_bins++;
+    }
+    d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins];
+    d_grid_data = new float*[d_num_doppler_bins];
+    for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+        {
+            if (posix_memalign((void**)&(d_grid_doppler_wipeoffs[doppler_index]), 16,
+                               d_fft_size * sizeof(gr_complex)) == 0){};
+
+            int doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+
+            complex_exp_gen_conj(d_grid_doppler_wipeoffs[doppler_index],
+                                 d_freq + doppler, d_fs_in, d_fft_size);
+
+            if (posix_memalign((void**)&(d_grid_data[doppler_index]), 16,
+                               d_fft_size * sizeof(float)) == 0){};
+
+            for (unsigned int i = 0; i < d_fft_size; i++)
+                {
+                    d_grid_data[doppler_index][i] = 0;
+                }
+        }
+}
+
+
+int pcps_tong_acquisition_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 acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
+
+    switch (d_state)
+    {
+    case 0:
+        {
+            if (d_active)
+                {
+                    //restart acquisition variables
+                    d_gnss_synchro->Acq_delay_samples = 0.0;
+                    d_gnss_synchro->Acq_doppler_hz = 0.0;
+                    d_gnss_synchro->Acq_samplestamp_samples = 0;
+                    d_well_count = 0;
+                    d_tong_count = d_tong_init_val;
+                    d_mag = 0.0;
+                    d_input_power = 0.0;
+                    d_test_statistics = 0.0;
+
+                    for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+                        {
+                            for (unsigned int i = 0; i < d_fft_size; i++)
+                                {
+                                    d_grid_data[doppler_index][i] = 0;
+                                }
+                        }
+
+                    d_state = 1;
+                }
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            break;
+        }
+
+    case 1:
+        {
+            // initialize acquisition algorithm
+            int doppler;
+            unsigned int indext = 0;
+            float magt = 0.0;
+            const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
+            float fft_normalization_factor = (float)d_fft_size * (float)d_fft_size;
+            d_input_power = 0.0;
+            d_mag = 0.0;
+
+            d_sample_counter += d_fft_size; // sample counter
+
+            d_well_count++;
+
+            DLOG(INFO) << "Channel: " << d_channel
+                    << " , doing acquisition of satellite: " << d_gnss_synchro->System << " "<< d_gnss_synchro->PRN
+                    << " ,sample stamp: " << d_sample_counter << ", threshold: "
+                    << d_threshold << ", doppler_max: " << d_doppler_max
+                    << ", doppler_step: " << d_doppler_step;
+
+            // 1- Compute the input signal power estimation
+            volk_32fc_magnitude_squared_32f_a(d_magnitude, in, d_fft_size);
+            volk_32f_accumulator_s32f_a(&d_input_power, d_magnitude, d_fft_size);
+            d_input_power /= (float)d_fft_size;
+
+            // 2- Doppler frequency search loop
+            for (unsigned int doppler_index=0;doppler_index<d_num_doppler_bins;doppler_index++)
+                {
+                    // doppler search steps
+
+                    doppler=-(int)d_doppler_max+d_doppler_step*doppler_index;
+
+                    volk_32fc_x2_multiply_32fc_a(d_fft_if->get_inbuf(), 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_a(d_ifft->get_inbuf(),
+                                d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
+
+                    // compute the inverse FFT
+                    d_ifft->execute();
+
+                    // Search maximum
+                    volk_32fc_magnitude_squared_32f_a(d_magnitude, d_ifft->get_outbuf(), d_fft_size);
+
+                    volk_32f_s32f_multiply_32f_a(d_magnitude, d_magnitude,
+                                                1/(fft_normalization_factor*fft_normalization_factor*d_input_power),
+                                                d_fft_size);
+
+                    volk_32f_x2_add_32f_a(d_grid_data[doppler_index], d_magnitude, d_grid_data[doppler_index], d_fft_size);
+
+                    volk_32f_index_max_16u_a(&indext, d_grid_data[doppler_index], d_fft_size);
+
+                    // Normalize the maximum value to correct the scale factor introduced by FFTW
+                    magt = d_grid_data[doppler_index][indext];
+
+                    // 4- record the maximum peak and the associated synchronization parameters
+                    if (d_mag < magt)
+                        {
+                            d_mag = magt;
+                            d_gnss_synchro->Acq_delay_samples = (double)(indext % d_samples_per_code);
+                            d_gnss_synchro->Acq_doppler_hz = (double)doppler;
+                            d_gnss_synchro->Acq_samplestamp_samples = d_sample_counter;
+                        }
+
+                    // 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("");
+                            filename << "../data/test_statistics_" << d_gnss_synchro->System
+                                     <<"_" << d_gnss_synchro->Signal << "_sat_"
+                                     << d_gnss_synchro->PRN << "_doppler_" <<  doppler << ".dat";
+                            d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
+                            d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
+                            d_dump_file.close();
+                        }
+                }
+
+            // 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;
+
+            if (d_test_statistics > d_threshold*d_well_count)
+                {
+                    d_tong_count++;
+                    if (d_tong_count == d_tong_max_val)
+                        {
+                            d_state = 2; // Positive acquisition
+                        }
+                }
+            else
+                {
+                    d_tong_count--;
+                    if (d_tong_count == 0)
+                        {
+                            d_state = 3; // Negative acquisition
+                        }
+                }
+
+            consume_each(1);
+
+            break;
+        }
+
+    case 2:
+        {
+            // 6.1- Declare positive acquisition using a message queue
+            DLOG(INFO) << "positive acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 1;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+
+    case 3:
+        {
+            // 6.2- Declare negative acquisition using a message queue
+            DLOG(INFO) << "negative acquisition";
+            DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
+            DLOG(INFO) << "sample_stamp " << d_sample_counter;
+            DLOG(INFO) << "test statistics value " << d_test_statistics;
+            DLOG(INFO) << "test statistics threshold " << d_threshold;
+            DLOG(INFO) << "code phase " << d_gnss_synchro->Acq_delay_samples;
+            DLOG(INFO) << "doppler " << d_gnss_synchro->Acq_doppler_hz;
+            DLOG(INFO) << "magnitude " << d_mag;
+            DLOG(INFO) << "input signal power " << d_input_power;
+
+            d_active = false;
+            d_state = 0;
+
+            d_sample_counter += d_fft_size * ninput_items[0]; // sample counter
+            consume_each(ninput_items[0]);
+
+            acquisition_message = 2;
+            d_channel_internal_queue->push(acquisition_message);
+
+            break;
+        }
+    }
+
+    return 0;
+}

src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h

@@ -0,0 +1,239 @@
+/*!
+ * \file pcps_tong_acquisition_cc.h
+ * \brief This class implements a Parallel Code Phase Search Acquisition with
+ * Tong algorithm.
+ * \author Marc Molina, 2013. marc.molina.pena(at)gmail.com
+ *
+ *  Acquisition strategy (Kaplan book + CFAR threshold).
+ *  <ol>
+ *  <li> Compute the input signal power estimation.
+ *  <li> Doppler serial search loop.
+ *  <li> Perform the FFT-based circular convolution (parallel time search).
+ *  <li> Compute the tests statistics for all the cells.
+ *  <li> Accumulate the grid of tests statistics with the previous grids.
+ *  <li> Record the maximum peak and the associated synchronization parameters.
+ *  <li> Compare the maximum averaged test statistics with a threshold.
+ *  <li> If the test statistics exceeds the threshold, increment the Tong counter.
+ *  <li>   Otherwise, decrement the Tong counter.
+ *  <li> If the Tong counter is equal to a given maximum value, declare positive
+ *  <li>   acquisition. If the Tong counter is equa to zero, declare negative
+ *  <li>   acquisition. Otherwise, process the next block.
+ *  </ol>
+ *
+ * Kaplan book: D.Kaplan, J.Hegarty, "Understanding GPS. Principles
+ * and Applications", Artech House, 2006, pp 223-227
+ *
+ * -------------------------------------------------------------------------
+ *
+ * Copyright (C) 2010-2012  (see AUTHORS file for a list of contributors)
+ *
+ * GNSS-SDR is a software defined Global Navigation
+ *          Satellite Systems receiver
+ *
+ * This file is part of GNSS-SDR.
+ *
+ * GNSS-SDR is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ *
+ * GNSS-SDR is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_PCPS_TONG_acquisition_cc_H_
+#define GNSS_SDR_PCPS_TONG_acquisition_cc_H_
+
+#include <fstream>
+#include <gnuradio/block.h>
+#include <gnuradio/msg_queue.h>
+#include <gnuradio/gr_complex.h>
+#include <gnuradio/fft/fft.h>
+#include <queue>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/thread.hpp>
+#include "concurrent_queue.h"
+#include "gnss_synchro.h"
+
+class pcps_tong_acquisition_cc;
+
+typedef boost::shared_ptr<pcps_tong_acquisition_cc> pcps_tong_acquisition_cc_sptr;
+
+pcps_tong_acquisition_cc_sptr
+pcps_tong_make_acquisition_cc(unsigned int sampled_ms, unsigned int doppler_max,
+                              long freq, long fs_in, int samples_per_ms,
+                              int samples_per_code, unsigned int tong_init_val,
+                              unsigned int tong_max_val, gr::msg_queue::sptr queue,
+                              bool dump, std::string dump_filename);
+
+/*!
+ * \brief This class implements a Parallel Code Phase Search Acquisition with
+ * Tong algorithm.
+ */
+class pcps_tong_acquisition_cc: public gr::block
+{
+private:
+    friend pcps_tong_acquisition_cc_sptr
+    pcps_tong_make_acquisition_cc(unsigned int sampled_ms, unsigned int doppler_max,
+                                  long freq, long fs_in, int samples_per_ms,
+                                  int samples_per_code, unsigned int tong_init_val,
+                                  unsigned int tong_max_val, gr::msg_queue::sptr queue,
+                                  bool dump, std::string dump_filename);
+
+
+    pcps_tong_acquisition_cc(unsigned int sampled_ms, unsigned int doppler_max,
+                        long freq, long fs_in, int samples_per_ms,
+                        int samples_per_code, unsigned int tong_init_val,
+                        unsigned int tong_max_val, gr::msg_queue::sptr queue,
+                        bool dump, std::string dump_filename);
+
+    void calculate_magnitudes(gr_complex* fft_begin, int doppler_shift,
+            int doppler_offset);
+
+
+	long d_fs_in;
+	long d_freq;
+	int d_samples_per_ms;
+    int d_samples_per_code;
+	unsigned int d_doppler_resolution;
+	float d_threshold;
+    std::string d_satellite_str;
+	unsigned int d_doppler_max;
+	unsigned int d_doppler_step;
+	unsigned int d_sampled_ms;
+    unsigned int d_well_count;
+    unsigned int d_tong_count;
+    unsigned int d_tong_init_val;
+    unsigned int d_tong_max_val;
+	unsigned int d_fft_size;
+	unsigned long int d_sample_counter;
+    gr_complex** d_grid_doppler_wipeoffs;
+    unsigned int d_num_doppler_bins;
+    gr_complex* d_fft_codes;
+    float** d_grid_data;
+	gr::fft::fft_complex* d_fft_if;
+	gr::fft::fft_complex* d_ifft;
+    Gnss_Synchro *d_gnss_synchro;
+	unsigned int d_code_phase;
+	float d_doppler_freq;
+	float d_mag;
+    float* d_magnitude;
+	float d_input_power;
+	float d_test_statistics;
+    gr::msg_queue::sptr d_queue;
+	concurrent_queue<int> *d_channel_internal_queue;
+	std::ofstream d_dump_file;
+	bool d_active;
+    int d_state;
+	bool d_dump;
+	unsigned int d_channel;
+	std::string d_dump_filename;
+
+public:
+    /*!
+     * \brief Default destructor.
+     */
+    ~pcps_tong_acquisition_cc();
+
+    /*!
+     * \brief Set acquisition/tracking common Gnss_Synchro object pointer
+     * to exchange synchronization data between acquisition and tracking blocks.
+     * \param p_gnss_synchro Satellite information shared by the processing blocks.
+     */
+    void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
+    {
+        d_gnss_synchro = p_gnss_synchro;
+    }
+
+    /*!
+     * \brief Returns the maximum peak of grid search.
+     */
+    unsigned int mag()
+    {
+        return d_mag;
+    }
+
+    /*!
+     * \brief Initializes acquisition algorithm.
+     */
+    void init();
+
+    /*!
+     * \brief Sets local code for TONG acquisition algorithm.
+     * \param code - Pointer to the PRN code.
+     */
+    void set_local_code(std::complex<float> * code);
+
+    /*!
+     * \brief Starts acquisition algorithm, turning from standby mode to
+     * active mode
+     * \param active - bool that activates/deactivates the block.
+     */
+    void set_active(bool active)
+    {
+        d_active = active;
+    }
+
+    /*!
+     * \brief Set acquisition channel unique ID
+     * \param channel - receiver channel.
+     */
+    void set_channel(unsigned int channel)
+    {
+        d_channel = channel;
+    }
+
+    /*!
+     * \brief Set statistics threshold of TONG algorithm.
+     * \param threshold - Threshold for signal detection (check \ref Navitec2012,
+     * Algorithm 1, for a definition of this threshold).
+     */
+    void set_threshold(float threshold)
+    {
+        d_threshold = threshold;
+    }
+
+    /*!
+     * \brief Set maximum Doppler grid search
+     * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz].
+     */
+    void set_doppler_max(unsigned int doppler_max)
+    {
+        d_doppler_max = doppler_max;
+    }
+
+    /*!
+     * \brief Set Doppler steps for the grid search
+     * \param doppler_step - Frequency bin of the search grid [Hz].
+     */
+    void set_doppler_step(unsigned int doppler_step)
+    {
+        d_doppler_step = doppler_step;
+    }
+
+
+    /*!
+     * \brief Set tracking channel internal queue.
+     * \param channel_internal_queue - Channel's internal blocks information queue.
+     */
+    void set_channel_queue(concurrent_queue<int> *channel_internal_queue)
+    {
+        d_channel_internal_queue = channel_internal_queue;
+    }
+
+    /*!
+     * \brief Parallel Code Phase Search Acquisition signal processing.
+     */
+    int general_work(int noutput_items, gr_vector_int &ninput_items,
+            gr_vector_const_void_star &input_items,
+            gr_vector_void_star &output_items);
+};
+
+#endif /* GNSS_SDR_PCPS_TONG_acquisition_cc_H_ */

src/algorithms/libs/gps_sdr_signal_processing.h

@@ -40,6 +40,9 @@
 //!Generates complex GPS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
 void gps_l1_ca_code_gen_complex(std::complex<float>* _dest, signed int _prn, unsigned int _chip_shift);
 
+//! Generates N complex GPS L1 C/A codes for the desired SV ID and code shift
+void gps_l1_ca_code_gen_complex_sampled(std::complex<float>* _dest, unsigned int _prn, signed int _fs, unsigned int _chip_shift, unsigned int _ncodes);
+
 //! Generates complex GPS L1 C/A code for the desired SV ID and code shift
 void gps_l1_ca_code_gen_complex_sampled(std::complex<float>* _dest, unsigned int _prn, signed int _fs, unsigned int _chip_shift);
 

src/algorithms/signal_generator/adapters/signal_generator.cc

@@ -1,6 +1,6 @@
 /*!
  * \file signal_generator.cc
- * \brief Signal generator.
+ * \brief Adapter of a class that generates synthesized GNSS signal.
  * \author Marc Molina, 2013. marc.molina.pena@gmail.com
  *
  *

src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc

@@ -1,5 +1,5 @@
 /*!
- * \file signal_generator_c.h
+ * \file signal_generator_c.cc
  * \brief GNU Radio source block that generates synthesized GNSS signal.
  * \author Marc Molina, 2013. marc.molina.pena@gmail.com
  *
@@ -27,9 +27,9 @@
  *
  * -------------------------------------------------------------------------
  */
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+//#ifdef HAVE_CONFIG_H
+//#include "config.h"
+//#endif
 
 #include "signal_generator_c.h"
 #include <gnuradio/io_signature.h>
@@ -73,7 +73,7 @@ signal_generator_c::signal_generator_c (std::vector<std::string> system, const s
   fs_in_(fs_in),
   num_sats_(PRN.size()),
   vector_length_(vector_length),
-  BW_BB_(BW_BB*(float)fs_in/2)
+  BW_BB_(BW_BB*(float)fs_in/2.0)
 {
     init();
     generate_codes();
@@ -122,14 +122,14 @@ void signal_generator_c::init()
 //    for (unsigned int i = 0; i < num_sats_; i++)
 //    {
 //        std::cout << "Sat " << i << ": " << std::endl;
-//        std::cout << "System " << system_[i] << ": " << std::endl;
+//        std::cout << "  System " << system_[i] << ": " << std::endl;
 //        std::cout << "  PRN: " << PRN_[i] << std::endl;
 //        std::cout << "  CN0: " << CN0_dB_[i] << std::endl;
 //        std::cout << "  Doppler: " << doppler_Hz_[i] << std::endl;
 //        std::cout << "  Delay: " << delay_chips_[i] << std::endl;
-//        std::cout << "Samples per code = " << samples_per_code_[i] << std::endl;
-//        std::cout << "codes per vector = " << num_of_codes_per_vector_[i] << std::endl;
-//        std::cout << "data_bit_duration = " << data_bit_duration_ms_[i] << std::endl;
+//        std::cout << "  Samples per code = " << samples_per_code_[i] << std::endl;
+//        std::cout << "  codes per vector = " << num_of_codes_per_vector_[i] << std::endl;
+//        std::cout << "  data_bit_duration = " << data_bit_duration_ms_[i] << std::endl;
 //    }
 }
 
@@ -152,9 +152,12 @@ void signal_generator_c::generate_codes()
                                     (int)GPS_L1_CA_CODE_LENGTH_CHIPS-delay_chips_[sat]);
 
                     // Obtain the desired CN0 assuming that Pn = 1.
-                    for (unsigned int i = 0; i < samples_per_code_[sat]; i++)
+                    if (noise_flag_)
                         {
-                            code[i] *= sqrt(pow(10,CN0_dB_[sat]/10)/BW_BB_);
+                            for (unsigned int i = 0; i < samples_per_code_[sat]; i++)
+                                {
+                                    code[i] *= sqrt(pow(10,CN0_dB_[sat]/10)/BW_BB_);
+                                }
                         }
 
                     // Concatenate "num_of_codes_per_vector_" codes
@@ -175,9 +178,12 @@ void signal_generator_c::generate_codes()
                                     (int)Galileo_E1_B_CODE_LENGTH_CHIPS-delay_chips_[sat]);
 
                     // Obtain the desired CN0 assuming that Pn = 1.
-                    for (unsigned int i = 0; i < samples_per_code_[sat]; i++)
+                    if (noise_flag_)
                         {
-                            code[i] *= sqrt(pow(10,CN0_dB_[sat]/10)/BW_BB_/2);
+                            for (unsigned int i = 0; i < samples_per_code_[sat]; i++)
+                                {
+                                    code[i] *= sqrt(pow(10,CN0_dB_[sat]/10)/BW_BB_/2);
+                                }
                         }
 
                     // Concatenate "num_of_codes_per_vector_" codes
@@ -197,9 +203,12 @@ void signal_generator_c::generate_codes()
                                                         (int)Galileo_E1_B_CODE_LENGTH_CHIPS-delay_chips_[sat], true);
 
                     // Obtain the desired CN0 assuming that Pn = 1.
-                    for (unsigned int i = 0; i < vector_length_; i++)
+                    if (noise_flag_)
                         {
-                            sampled_code_pilot_[sat][i] *= sqrt(pow(10,CN0_dB_[sat]/10)/BW_BB_/2);
+                            for (unsigned int i = 0; i < vector_length_; i++)
+                                {
+                                    sampled_code_pilot_[sat][i] *= sqrt(pow(10,CN0_dB_[sat]/10)/BW_BB_/2);
+                                }
                         }
                 }
         }
@@ -257,21 +266,20 @@ signal_generator_c::general_work (int noutput_items,
 
                     for (i = 0; i < num_of_codes_per_vector_[sat]; i++)
                         {
-                            gr_complex prev_data_bit = current_data_bits_[sat];
+                            for (k = 0; k < delay_samples; k++)
+                                {
+                                    out[out_idx] += sampled_code_data_[sat][out_idx]
+                                                    * current_data_bits_[sat]
+                                                    * complex_phase_[out_idx];
+                                    out_idx++;
+                                }
+
                             if (ms_counter_[sat] == 0 && data_flag_)
                                  {
                                      // New random data bit
                                      current_data_bits_[sat] = gr_complex((rand()%2) == 0 ? 1 : -1, 0);
                                  }
 
-                            for (k = 0; k < delay_samples; k++)
-                                {
-                                    out[out_idx] += sampled_code_data_[sat][out_idx]
-                                                    * prev_data_bit
-                                                    * complex_phase_[out_idx];
-                                    out_idx++;
-                                }
-
                             for (k = delay_samples; k < samples_per_code_[sat]; k++)
                                 {
                                     out[out_idx] += sampled_code_data_[sat][out_idx]
@@ -292,21 +300,20 @@ signal_generator_c::general_work (int noutput_items,
 
                     for (i = 0; i < num_of_codes_per_vector_[sat]; i++)
                         {
-                            gr_complex prev_data_bit = current_data_bits_[sat];
-                            if (ms_counter_[sat] == 0 && data_flag_)
-                                {
-                                    // New random data bit
-                                    current_data_bits_[sat] = gr_complex((rand()%2) == 0 ? -1 : 1, 0);
-                                }
-
                             for (k = 0; k < delay_samples; k++)
                                 {
-                                    out[out_idx] += (sampled_code_data_[sat][out_idx] * prev_data_bit
+                                    out[out_idx] += (sampled_code_data_[sat][out_idx] * current_data_bits_[sat]
                                                     -  sampled_code_pilot_[sat][out_idx])
                                                     * complex_phase_[out_idx];
                                     out_idx++;
                                 }
 
+                            if (ms_counter_[sat] == 0 && data_flag_)
+                                {
+                                    // New random data bit
+                                    current_data_bits_[sat] = gr_complex((rand()%2) == 0 ? 1 : -1, 0);
+                                }
+
                             for (k = delay_samples; k < samples_per_code_[sat]; k++)
                                 {
                                     out[out_idx] += (sampled_code_data_[sat][out_idx] * current_data_bits_[sat]

src/algorithms/signal_source/CMakeLists.txt

@@ -17,4 +17,4 @@
 #
 
 add_subdirectory(adapters)
-#add_subdirectory(gnuradio_blocks)
+#add_subdirectory(gnuradio_blocks)