mirror of
https://github.com/gnss-sdr/gnss-sdr
synced 2024-06-18 11:09:56 +00:00
![Carles Fernandez](/assets/img/avatar_default.png)
GNSS-SDR.internal_fs_sps The old name was misleading, since the units are samples per second and not Hertz. Backward compatibility is kept, so this change does not break any existing configuration.
399 lines
11 KiB
C++
399 lines
11 KiB
C++
/*!
|
|
* \file gps_l2_m_pcps_acquisition.cc
|
|
* \brief Adapts a PCPS acquisition block to an AcquisitionInterface for
|
|
* GPS L2 M signals
|
|
* \authors <ul>
|
|
* <li> Javier Arribas, 2015. jarribas(at)cttc.es
|
|
* </ul>
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*
|
|
* Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors)
|
|
*
|
|
* GNSS-SDR is a software defined Global Navigation
|
|
* Satellite Systems receiver
|
|
*
|
|
* This file is part of GNSS-SDR.
|
|
*
|
|
* GNSS-SDR is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GNSS-SDR is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "gps_l2_m_pcps_acquisition.h"
|
|
#include <boost/math/distributions/exponential.hpp>
|
|
#include <glog/logging.h>
|
|
#include "gps_l2c_signal.h"
|
|
#include "GPS_L2C.h"
|
|
#include "configuration_interface.h"
|
|
|
|
|
|
using google::LogMessage;
|
|
|
|
GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition(
|
|
ConfigurationInterface* configuration, std::string role,
|
|
unsigned int in_streams, unsigned int out_streams) :
|
|
role_(role), in_streams_(in_streams), out_streams_(out_streams)
|
|
{
|
|
configuration_ = configuration;
|
|
std::string default_item_type = "gr_complex";
|
|
std::string default_dump_filename = "./data/acquisition.dat";
|
|
|
|
LOG(INFO) << "role " << role;
|
|
|
|
item_type_ = configuration_->property(role + ".item_type", default_item_type);
|
|
//float pfa = configuration_->property(role + ".pfa", 0.0);
|
|
|
|
long fs_in_deprecated = configuration_->property("GNSS-SDR.internal_fs_hz", 2048000);
|
|
fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
|
|
if_ = configuration_->property(role + ".if", 0);
|
|
dump_ = configuration_->property(role + ".dump", false);
|
|
doppler_max_ = configuration->property(role + ".doppler_max", 5000);
|
|
|
|
bit_transition_flag_ = configuration_->property(role + ".bit_transition_flag", false);
|
|
use_CFAR_algorithm_flag_=configuration_->property(role + ".use_CFAR_algorithm", true); //will be false in future versions
|
|
|
|
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 -------------------------
|
|
code_length_ = round(static_cast<double>(fs_in_)
|
|
/ (GPS_L2_M_CODE_RATE_HZ / static_cast<double>(GPS_L2_M_CODE_LENGTH_CHIPS)));
|
|
|
|
vector_length_ = code_length_;
|
|
|
|
if( bit_transition_flag_ )
|
|
{
|
|
vector_length_ *= 2;
|
|
}
|
|
|
|
code_ = new gr_complex[vector_length_];
|
|
|
|
if (item_type_.compare("cshort") == 0 )
|
|
{
|
|
item_size_ = sizeof(lv_16sc_t);
|
|
acquisition_sc_ = pcps_make_acquisition_sc(1, max_dwells_,
|
|
doppler_max_, if_, fs_in_, code_length_, code_length_,
|
|
bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, dump_filename_);
|
|
DLOG(INFO) << "acquisition(" << acquisition_sc_->unique_id() << ")";
|
|
|
|
}
|
|
else
|
|
{
|
|
item_size_ = sizeof(gr_complex);
|
|
acquisition_cc_ = pcps_make_acquisition_cc(1, max_dwells_,
|
|
doppler_max_, if_, fs_in_, code_length_, code_length_,
|
|
bit_transition_flag_, use_CFAR_algorithm_flag_, dump_, dump_filename_);
|
|
DLOG(INFO) << "acquisition(" << acquisition_cc_->unique_id() << ")";
|
|
}
|
|
|
|
stream_to_vector_ = gr::blocks::stream_to_vector::make(item_size_, vector_length_);
|
|
DLOG(INFO) << "stream_to_vector(" << stream_to_vector_->unique_id() << ")";
|
|
|
|
if (item_type_.compare("cbyte") == 0)
|
|
{
|
|
cbyte_to_float_x2_ = make_complex_byte_to_float_x2();
|
|
float_to_complex_ = gr::blocks::float_to_complex::make();
|
|
}
|
|
|
|
channel_ = 0;
|
|
threshold_ = 0.0;
|
|
doppler_step_ = 0;
|
|
gnss_synchro_ = 0;
|
|
}
|
|
|
|
|
|
GpsL2MPcpsAcquisition::~GpsL2MPcpsAcquisition()
|
|
{
|
|
delete[] code_;
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::set_channel(unsigned int channel)
|
|
{
|
|
channel_ = channel;
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
acquisition_sc_->set_channel(channel_);
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->set_channel(channel_);
|
|
}
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::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("cshort") == 0)
|
|
{
|
|
acquisition_sc_->set_threshold(threshold_);
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->set_threshold(threshold_);
|
|
}
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::set_doppler_max(unsigned int doppler_max)
|
|
{
|
|
doppler_max_ = doppler_max;
|
|
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
acquisition_sc_->set_doppler_max(doppler_max_);
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->set_doppler_max(doppler_max_);
|
|
}
|
|
}
|
|
|
|
|
|
// Be aware that Doppler step should be set to 2/(3T) Hz, where T is the coherent integration time (GPS L2 period is 0.02s)
|
|
// Doppler bin minimum size= 33 Hz
|
|
void GpsL2MPcpsAcquisition::set_doppler_step(unsigned int doppler_step)
|
|
{
|
|
doppler_step_ = doppler_step;
|
|
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
acquisition_sc_->set_doppler_step(doppler_step_);
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->set_doppler_step(doppler_step_);
|
|
}
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::set_gnss_synchro(Gnss_Synchro* gnss_synchro)
|
|
{
|
|
gnss_synchro_ = gnss_synchro;
|
|
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
acquisition_sc_->set_gnss_synchro(gnss_synchro_);
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->set_gnss_synchro(gnss_synchro_);
|
|
}
|
|
}
|
|
|
|
|
|
signed int GpsL2MPcpsAcquisition::mag()
|
|
{
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
return acquisition_sc_->mag();
|
|
}
|
|
else
|
|
{
|
|
return acquisition_cc_->mag();
|
|
}
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::init()
|
|
{
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
acquisition_sc_->init();
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->init();
|
|
}
|
|
|
|
//set_local_code();
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::set_local_code()
|
|
{
|
|
|
|
gps_l2c_m_code_gen_complex_sampled(code_, gnss_synchro_->PRN, fs_in_);
|
|
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
acquisition_sc_->set_local_code(code_);
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->set_local_code(code_);
|
|
}
|
|
|
|
// //debug
|
|
// std::ofstream d_dump_file;
|
|
// std::stringstream filename;
|
|
// std::streamsize n = 2 * sizeof(float) * (code_length_); // complex file write
|
|
// filename.str("");
|
|
// filename << "../data/local_prn_sampled.dat";
|
|
// d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary);
|
|
// d_dump_file.write(reinterpret_cast<char*>(code_), n);
|
|
// d_dump_file.close();
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::reset()
|
|
{
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
acquisition_sc_->set_active(true);
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->set_active(true);
|
|
}
|
|
}
|
|
|
|
void GpsL2MPcpsAcquisition::set_state(int state)
|
|
{
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
acquisition_sc_->set_state(state);
|
|
}
|
|
else
|
|
{
|
|
acquisition_cc_->set_state(state);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
float GpsL2MPcpsAcquisition::calculate_threshold(float pfa)
|
|
{
|
|
//Calculate the threshold
|
|
unsigned int frequency_bins = 0;
|
|
for (int doppler = static_cast<int>(-doppler_max_); doppler <= static_cast<int>(doppler_max_); doppler += doppler_step_)
|
|
{
|
|
frequency_bins++;
|
|
}
|
|
DLOG(INFO) << "Channel " << channel_<< " Pfa = " << pfa;
|
|
unsigned int ncells = vector_length_ * frequency_bins;
|
|
double exponent = 1.0 / static_cast<double>(ncells);
|
|
double val = pow(1.0 - pfa, exponent);
|
|
double lambda = double(vector_length_);
|
|
boost::math::exponential_distribution<double> mydist (lambda);
|
|
float threshold = static_cast<float>(quantile(mydist,val));
|
|
|
|
return threshold;
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::connect(gr::top_block_sptr top_block)
|
|
{
|
|
if (item_type_.compare("gr_complex") == 0)
|
|
{
|
|
top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0);
|
|
}
|
|
else if (item_type_.compare("cshort") == 0)
|
|
{
|
|
top_block->connect(stream_to_vector_, 0, acquisition_sc_, 0);
|
|
}
|
|
else if (item_type_.compare("cbyte") == 0)
|
|
{
|
|
top_block->connect(cbyte_to_float_x2_, 0, float_to_complex_, 0);
|
|
top_block->connect(cbyte_to_float_x2_, 1, float_to_complex_, 1);
|
|
top_block->connect(float_to_complex_, 0, stream_to_vector_, 0);
|
|
top_block->connect(stream_to_vector_, 0, acquisition_cc_, 0);
|
|
}
|
|
else
|
|
{
|
|
LOG(WARNING) << item_type_ << " unknown acquisition item type";
|
|
}
|
|
}
|
|
|
|
|
|
void GpsL2MPcpsAcquisition::disconnect(gr::top_block_sptr top_block)
|
|
{
|
|
if (item_type_.compare("gr_complex") == 0)
|
|
{
|
|
top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0);
|
|
}
|
|
else if (item_type_.compare("cshort") == 0)
|
|
{
|
|
top_block->disconnect(stream_to_vector_, 0, acquisition_sc_, 0);
|
|
}
|
|
else if (item_type_.compare("cbyte") == 0)
|
|
{
|
|
// Since a byte-based acq implementation is not available,
|
|
// we just convert cshorts to gr_complex
|
|
top_block->disconnect(cbyte_to_float_x2_, 0, float_to_complex_, 0);
|
|
top_block->disconnect(cbyte_to_float_x2_, 1, float_to_complex_, 1);
|
|
top_block->disconnect(float_to_complex_, 0, stream_to_vector_, 0);
|
|
top_block->disconnect(stream_to_vector_, 0, acquisition_cc_, 0);
|
|
}
|
|
else
|
|
{
|
|
LOG(WARNING) << item_type_ << " unknown acquisition item type";
|
|
}
|
|
}
|
|
|
|
|
|
gr::basic_block_sptr GpsL2MPcpsAcquisition::get_left_block()
|
|
{
|
|
if (item_type_.compare("gr_complex") == 0)
|
|
{
|
|
return stream_to_vector_;
|
|
}
|
|
else if (item_type_.compare("cshort") == 0)
|
|
{
|
|
return stream_to_vector_;
|
|
}
|
|
else if (item_type_.compare("cbyte") == 0)
|
|
{
|
|
return cbyte_to_float_x2_;
|
|
}
|
|
else
|
|
{
|
|
LOG(WARNING) << item_type_ << " unknown acquisition item type";
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
|
|
gr::basic_block_sptr GpsL2MPcpsAcquisition::get_right_block()
|
|
{
|
|
if (item_type_.compare("cshort") == 0)
|
|
{
|
|
return acquisition_sc_;
|
|
}
|
|
else
|
|
{
|
|
return acquisition_cc_;
|
|
}
|
|
}
|
|
|