2011-10-01 18:45:20 +00:00
|
|
|
/*!
|
|
|
|
* \file channel.cc
|
2016-05-04 22:26:59 +00:00
|
|
|
* \brief Implementation of a GNSS_Channel with a Finite State Machine
|
2011-10-01 18:45:20 +00:00
|
|
|
* \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com
|
|
|
|
* Luis Esteve, 2011. luis(at)epsilon-formacion.com
|
|
|
|
*
|
2020-07-28 14:57:15 +00:00
|
|
|
* -----------------------------------------------------------------------------
|
2011-10-01 18:45:20 +00:00
|
|
|
*
|
2020-12-30 12:35:06 +00:00
|
|
|
* GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
2011-10-01 18:45:20 +00:00
|
|
|
* This file is part of GNSS-SDR.
|
|
|
|
*
|
2020-12-30 12:35:06 +00:00
|
|
|
* Copyright (C) 2010-2020 (see AUTHORS file for a list of contributors)
|
2020-02-08 00:20:02 +00:00
|
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
2011-10-01 18:45:20 +00:00
|
|
|
*
|
2020-07-28 14:57:15 +00:00
|
|
|
* -----------------------------------------------------------------------------
|
2011-10-01 18:45:20 +00:00
|
|
|
*/
|
2017-09-03 21:56:41 +00:00
|
|
|
|
2011-10-01 18:45:20 +00:00
|
|
|
#include "channel.h"
|
2019-03-04 07:12:50 +00:00
|
|
|
#include "acquisition_interface.h"
|
2019-03-05 11:33:54 +00:00
|
|
|
#include "channel_fsm.h"
|
2014-01-12 20:07:38 +00:00
|
|
|
#include "configuration_interface.h"
|
2018-02-25 00:00:17 +00:00
|
|
|
#include "gnss_sdr_flags.h"
|
2019-03-04 07:12:50 +00:00
|
|
|
#include "telemetry_decoder_interface.h"
|
|
|
|
#include "tracking_interface.h"
|
2018-02-26 02:15:53 +00:00
|
|
|
#include <glog/logging.h>
|
2021-01-26 13:01:28 +00:00
|
|
|
#include <stdexcept> // for std::invalid_argument
|
|
|
|
#include <utility> // for std::move
|
2014-01-12 20:07:38 +00:00
|
|
|
|
2011-10-01 18:45:20 +00:00
|
|
|
|
2020-08-03 08:46:07 +00:00
|
|
|
Channel::Channel(const ConfigurationInterface* configuration,
|
|
|
|
uint32_t channel,
|
|
|
|
std::shared_ptr<AcquisitionInterface> acq,
|
|
|
|
std::shared_ptr<TrackingInterface> trk,
|
|
|
|
std::shared_ptr<TelemetryDecoderInterface> nav,
|
|
|
|
const std::string& role,
|
|
|
|
const std::string& signal_str,
|
2022-12-06 13:06:01 +00:00
|
|
|
Concurrent_Queue<pmt::pmt_t>* queue)
|
|
|
|
: acq_(std::move(acq)),
|
|
|
|
trk_(std::move(trk)),
|
|
|
|
nav_(std::move(nav)),
|
|
|
|
role_(role),
|
|
|
|
channel_(channel),
|
|
|
|
glonass_extend_correlation_ms_(configuration->property("Tracking_1G.extend_correlation_ms", 0) + configuration->property("Tracking_2G.extend_correlation_ms", 0)),
|
|
|
|
connected_(false),
|
|
|
|
repeat_(configuration->property("Acquisition_" + signal_str + ".repeat_satellite", false)),
|
|
|
|
flag_enable_fpga_(configuration->property("GNSS-SDR.enable_FPGA", false))
|
2011-10-01 18:45:20 +00:00
|
|
|
{
|
2018-01-08 11:03:32 +00:00
|
|
|
channel_fsm_ = std::make_shared<ChannelFsm>();
|
2016-04-15 14:33:41 +00:00
|
|
|
|
2011-10-01 18:45:20 +00:00
|
|
|
acq_->set_channel(channel_);
|
2019-03-20 14:13:17 +00:00
|
|
|
acq_->set_channel_fsm(channel_fsm_);
|
2011-10-01 18:45:20 +00:00
|
|
|
trk_->set_channel(channel_);
|
|
|
|
nav_->set_channel(channel_);
|
|
|
|
|
2018-12-02 04:29:11 +00:00
|
|
|
gnss_synchro_ = Gnss_Synchro();
|
2012-11-01 18:26:58 +00:00
|
|
|
gnss_synchro_.Channel_ID = channel_;
|
2012-01-27 18:01:17 +00:00
|
|
|
acq_->set_gnss_synchro(&gnss_synchro_);
|
|
|
|
trk_->set_gnss_synchro(&gnss_synchro_);
|
|
|
|
|
2022-12-06 13:06:01 +00:00
|
|
|
repeat_ = configuration->property("Acquisition_" + signal_str + std::to_string(channel_) + ".repeat_satellite", repeat_);
|
|
|
|
|
2017-09-03 21:56:41 +00:00
|
|
|
// Provide a warning to the user about the change of parameter name
|
2018-03-03 01:03:39 +00:00
|
|
|
if (channel_ == 0)
|
2017-09-03 21:56:41 +00:00
|
|
|
{
|
2020-07-19 23:20:15 +00:00
|
|
|
const int64_t deprecation_warning = configuration->property("GNSS-SDR.internal_fs_hz", 0);
|
2018-03-03 01:03:39 +00:00
|
|
|
if (deprecation_warning != 0)
|
2017-09-03 21:56:41 +00:00
|
|
|
{
|
2020-07-07 16:53:50 +00:00
|
|
|
std::cout << "WARNING: The global parameter name GNSS-SDR.internal_fs_hz has been DEPRECATED.\n";
|
|
|
|
std::cout << "WARNING: Please replace it by GNSS-SDR.internal_fs_sps in your configuration file.\n";
|
2017-09-03 21:56:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-06 17:30:36 +00:00
|
|
|
// IMPORTANT: Do not change the order between set_doppler_step and set_threshold
|
2013-05-26 23:59:04 +00:00
|
|
|
|
2020-07-17 09:39:26 +00:00
|
|
|
uint32_t doppler_step = configuration->property("Acquisition_" + signal_str + std::to_string(channel_) + ".doppler_step", 0);
|
2019-02-11 20:13:02 +00:00
|
|
|
if (doppler_step == 0)
|
|
|
|
{
|
2020-07-17 09:39:26 +00:00
|
|
|
doppler_step = configuration->property("Acquisition_" + signal_str + ".doppler_step", 500);
|
2019-02-11 20:13:02 +00:00
|
|
|
}
|
|
|
|
if (FLAGS_doppler_step != 0)
|
|
|
|
{
|
|
|
|
doppler_step = static_cast<uint32_t>(FLAGS_doppler_step);
|
|
|
|
}
|
2018-03-03 01:03:39 +00:00
|
|
|
DLOG(INFO) << "Channel " << channel_ << " Doppler_step = " << doppler_step;
|
2013-05-26 23:59:04 +00:00
|
|
|
|
|
|
|
acq_->set_doppler_step(doppler_step);
|
|
|
|
|
2020-07-17 09:39:26 +00:00
|
|
|
float threshold = configuration->property("Acquisition_" + signal_str + std::to_string(channel_) + ".threshold", static_cast<float>(0.0));
|
2019-02-11 20:13:02 +00:00
|
|
|
if (threshold == 0.0)
|
|
|
|
{
|
2020-07-17 09:39:26 +00:00
|
|
|
threshold = configuration->property("Acquisition_" + signal_str + ".threshold", static_cast<float>(0.0));
|
2019-02-11 20:13:02 +00:00
|
|
|
}
|
2013-05-26 23:59:04 +00:00
|
|
|
|
|
|
|
acq_->set_threshold(threshold);
|
2011-10-01 18:45:20 +00:00
|
|
|
|
2013-07-23 18:03:07 +00:00
|
|
|
acq_->init();
|
2011-10-01 18:45:20 +00:00
|
|
|
|
2018-01-08 11:03:32 +00:00
|
|
|
channel_fsm_->set_acquisition(acq_);
|
|
|
|
channel_fsm_->set_tracking(trk_);
|
2019-03-18 15:28:49 +00:00
|
|
|
channel_fsm_->set_telemetry(nav_);
|
2018-01-08 11:03:32 +00:00
|
|
|
channel_fsm_->set_channel(channel_);
|
2020-07-04 17:16:31 +00:00
|
|
|
channel_fsm_->set_queue(queue);
|
2011-10-01 18:45:20 +00:00
|
|
|
|
2020-07-17 09:39:26 +00:00
|
|
|
gnss_signal_ = Gnss_Signal(signal_str);
|
2016-04-18 12:17:09 +00:00
|
|
|
|
2020-06-19 10:39:28 +00:00
|
|
|
channel_msg_rx_ = channel_msg_receiver_make_cc(channel_fsm_, repeat_);
|
2011-10-01 18:45:20 +00:00
|
|
|
}
|
|
|
|
|
2017-08-19 18:05:52 +00:00
|
|
|
|
2013-07-04 13:47:40 +00:00
|
|
|
void Channel::connect(gr::top_block_sptr top_block)
|
2011-10-01 18:45:20 +00:00
|
|
|
{
|
2020-07-17 09:39:26 +00:00
|
|
|
if (!flag_enable_fpga_)
|
2019-03-20 15:57:50 +00:00
|
|
|
{
|
|
|
|
acq_->connect(top_block);
|
|
|
|
}
|
2011-10-01 18:45:20 +00:00
|
|
|
trk_->connect(top_block);
|
2021-01-26 13:01:28 +00:00
|
|
|
|
|
|
|
if (trk_->item_size() == 0)
|
|
|
|
{
|
|
|
|
std::string msg = trk_->role() + ".item_type is not defined for implementation " + trk_->implementation() + '\n';
|
|
|
|
throw std::invalid_argument(msg);
|
|
|
|
}
|
|
|
|
|
2011-10-01 18:45:20 +00:00
|
|
|
nav_->connect(top_block);
|
|
|
|
|
2019-04-27 11:09:36 +00:00
|
|
|
// Synchronous ports
|
2012-01-27 18:01:17 +00:00
|
|
|
top_block->connect(trk_->get_right_block(), 0, nav_->get_left_block(), 0);
|
2019-04-27 11:09:36 +00:00
|
|
|
|
2019-03-18 15:28:49 +00:00
|
|
|
// Message ports
|
|
|
|
top_block->msg_connect(nav_->get_left_block(), pmt::mp("telemetry_to_trk"), trk_->get_right_block(), pmt::mp("telemetry_to_trk"));
|
2022-07-12 02:28:49 +00:00
|
|
|
if (glonass_dll_pll_c_aid_tracking_check())
|
2022-05-17 10:40:30 +00:00
|
|
|
{
|
|
|
|
top_block->msg_connect(nav_->get_left_block(), pmt::mp("preamble_timestamp_samples"), trk_->get_right_block(), pmt::mp("preamble_timestamp_samples"));
|
|
|
|
}
|
2011-10-01 18:45:20 +00:00
|
|
|
DLOG(INFO) << "tracking -> telemetry_decoder";
|
2016-03-08 17:30:56 +00:00
|
|
|
|
2016-03-30 13:03:25 +00:00
|
|
|
// Message ports
|
2020-07-17 09:39:26 +00:00
|
|
|
if (!flag_enable_fpga_)
|
2019-03-20 15:57:50 +00:00
|
|
|
{
|
2020-06-19 10:39:28 +00:00
|
|
|
top_block->msg_connect(acq_->get_right_block(), pmt::mp("events"), channel_msg_rx_, pmt::mp("events"));
|
2019-03-20 15:57:50 +00:00
|
|
|
}
|
2020-06-19 10:39:28 +00:00
|
|
|
top_block->msg_connect(trk_->get_right_block(), pmt::mp("events"), channel_msg_rx_, pmt::mp("events"));
|
2016-04-15 14:33:41 +00:00
|
|
|
|
2011-10-01 18:45:20 +00:00
|
|
|
connected_ = true;
|
|
|
|
}
|
|
|
|
|
2012-01-10 09:49:09 +00:00
|
|
|
|
2013-07-04 13:47:40 +00:00
|
|
|
void Channel::disconnect(gr::top_block_sptr top_block)
|
2011-10-01 18:45:20 +00:00
|
|
|
{
|
|
|
|
if (!connected_)
|
2011-12-28 21:36:45 +00:00
|
|
|
{
|
2014-03-16 19:58:29 +00:00
|
|
|
LOG(WARNING) << "Channel already disconnected internally";
|
2011-12-28 21:36:45 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-05-05 15:08:49 +00:00
|
|
|
|
2012-01-11 09:01:24 +00:00
|
|
|
top_block->disconnect(trk_->get_right_block(), 0, nav_->get_left_block(), 0);
|
2020-07-17 09:39:26 +00:00
|
|
|
if (!flag_enable_fpga_)
|
2019-03-20 15:57:50 +00:00
|
|
|
{
|
|
|
|
acq_->disconnect(top_block);
|
|
|
|
}
|
2011-10-01 18:45:20 +00:00
|
|
|
trk_->disconnect(top_block);
|
|
|
|
nav_->disconnect(top_block);
|
2019-03-20 15:57:50 +00:00
|
|
|
|
2019-03-18 21:59:47 +00:00
|
|
|
top_block->msg_disconnect(nav_->get_left_block(), pmt::mp("telemetry_to_trk"), trk_->get_right_block(), pmt::mp("telemetry_to_trk"));
|
2022-07-12 02:28:49 +00:00
|
|
|
if (glonass_dll_pll_c_aid_tracking_check())
|
2022-05-17 10:40:30 +00:00
|
|
|
{
|
|
|
|
top_block->msg_disconnect(nav_->get_left_block(), pmt::mp("preamble_timestamp_samples"), trk_->get_right_block(), pmt::mp("preamble_timestamp_samples"));
|
|
|
|
}
|
2020-07-17 09:39:26 +00:00
|
|
|
if (!flag_enable_fpga_)
|
2019-03-20 15:57:50 +00:00
|
|
|
{
|
2020-06-19 10:39:28 +00:00
|
|
|
top_block->msg_disconnect(acq_->get_right_block(), pmt::mp("events"), channel_msg_rx_, pmt::mp("events"));
|
2019-03-20 15:57:50 +00:00
|
|
|
}
|
2020-06-19 10:39:28 +00:00
|
|
|
top_block->msg_disconnect(trk_->get_right_block(), pmt::mp("events"), channel_msg_rx_, pmt::mp("events"));
|
2011-10-01 18:45:20 +00:00
|
|
|
connected_ = false;
|
|
|
|
}
|
|
|
|
|
2016-04-25 18:34:27 +00:00
|
|
|
|
2013-07-04 13:47:40 +00:00
|
|
|
gr::basic_block_sptr Channel::get_left_block()
|
2011-10-01 18:45:20 +00:00
|
|
|
{
|
2018-12-03 16:58:18 +00:00
|
|
|
LOG(ERROR) << "Deprecated call to get_left_block() in channel interface";
|
2018-12-10 17:39:14 +00:00
|
|
|
return nullptr;
|
2018-12-03 16:58:18 +00:00
|
|
|
}
|
|
|
|
|
2019-03-04 07:12:50 +00:00
|
|
|
|
2018-12-03 16:58:18 +00:00
|
|
|
gr::basic_block_sptr Channel::get_left_block_trk()
|
|
|
|
{
|
|
|
|
return trk_->get_left_block();
|
2011-10-01 18:45:20 +00:00
|
|
|
}
|
|
|
|
|
2021-02-09 10:34:07 +00:00
|
|
|
|
2020-10-09 18:55:31 +00:00
|
|
|
gr::basic_block_sptr Channel::get_right_block_trk()
|
|
|
|
{
|
|
|
|
return trk_->get_right_block();
|
|
|
|
}
|
2019-03-04 07:12:50 +00:00
|
|
|
|
2021-02-09 10:34:07 +00:00
|
|
|
|
2018-12-03 16:58:18 +00:00
|
|
|
gr::basic_block_sptr Channel::get_left_block_acq()
|
|
|
|
{
|
|
|
|
return acq_->get_left_block();
|
|
|
|
}
|
2016-04-25 18:34:27 +00:00
|
|
|
|
2021-02-09 10:34:07 +00:00
|
|
|
|
2020-10-09 18:55:31 +00:00
|
|
|
gr::basic_block_sptr Channel::get_right_block_acq()
|
|
|
|
{
|
|
|
|
return acq_->get_right_block();
|
|
|
|
}
|
2019-03-04 07:12:50 +00:00
|
|
|
|
2021-02-09 10:34:07 +00:00
|
|
|
|
2013-07-04 13:47:40 +00:00
|
|
|
gr::basic_block_sptr Channel::get_right_block()
|
2011-10-01 18:45:20 +00:00
|
|
|
{
|
|
|
|
return nav_->get_right_block();
|
|
|
|
}
|
|
|
|
|
2012-01-10 09:49:09 +00:00
|
|
|
|
2023-12-02 11:54:28 +00:00
|
|
|
Gnss_Signal Channel::get_signal()
|
|
|
|
{
|
|
|
|
std::lock_guard<std::mutex> lk(mx_);
|
|
|
|
return gnss_signal_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-15 16:19:10 +00:00
|
|
|
void Channel::set_signal(const Gnss_Signal& gnss_signal)
|
2011-10-01 18:45:20 +00:00
|
|
|
{
|
2020-06-19 10:39:28 +00:00
|
|
|
std::lock_guard<std::mutex> lk(mx_);
|
2012-01-31 00:03:08 +00:00
|
|
|
gnss_signal_ = gnss_signal;
|
2020-07-19 23:20:15 +00:00
|
|
|
const std::string str_aux = gnss_signal_.get_signal_str();
|
2019-07-14 00:28:28 +00:00
|
|
|
gnss_synchro_.Signal[0] = str_aux[0];
|
|
|
|
gnss_synchro_.Signal[1] = str_aux[1];
|
|
|
|
gnss_synchro_.Signal[2] = '\0'; // make sure that string length is only two characters
|
2012-01-31 00:03:08 +00:00
|
|
|
gnss_synchro_.PRN = gnss_signal_.get_satellite().get_PRN();
|
|
|
|
gnss_synchro_.System = gnss_signal_.get_satellite().get_system_short().c_str()[0];
|
2013-07-23 18:03:07 +00:00
|
|
|
acq_->set_local_code();
|
2020-07-17 09:39:26 +00:00
|
|
|
if (flag_enable_fpga_)
|
2019-03-22 17:11:45 +00:00
|
|
|
{
|
|
|
|
trk_->set_gnss_synchro(&gnss_synchro_);
|
|
|
|
}
|
2012-01-30 14:13:34 +00:00
|
|
|
nav_->set_satellite(gnss_signal_.get_satellite());
|
2011-10-01 18:45:20 +00:00
|
|
|
}
|
|
|
|
|
2016-04-25 18:34:27 +00:00
|
|
|
|
2018-10-28 10:07:53 +00:00
|
|
|
void Channel::stop_channel()
|
|
|
|
{
|
2020-06-19 10:39:28 +00:00
|
|
|
std::lock_guard<std::mutex> lk(mx_);
|
2020-07-19 23:20:15 +00:00
|
|
|
const bool result = channel_fsm_->Event_stop_channel();
|
2018-10-28 10:07:53 +00:00
|
|
|
if (!result)
|
|
|
|
{
|
|
|
|
LOG(WARNING) << "Invalid channel event";
|
|
|
|
return;
|
|
|
|
}
|
2019-03-05 11:33:54 +00:00
|
|
|
DLOG(INFO) << "Channel stop_channel()";
|
2018-10-28 10:07:53 +00:00
|
|
|
}
|
|
|
|
|
2019-03-04 07:12:50 +00:00
|
|
|
|
2019-07-23 15:56:02 +00:00
|
|
|
void Channel::assist_acquisition_doppler(double Carrier_Doppler_hz)
|
|
|
|
{
|
|
|
|
acq_->set_doppler_center(static_cast<int>(Carrier_Doppler_hz));
|
|
|
|
}
|
2019-07-28 10:01:11 +00:00
|
|
|
|
|
|
|
|
2011-10-01 18:45:20 +00:00
|
|
|
void Channel::start_acquisition()
|
|
|
|
{
|
2020-06-19 10:39:28 +00:00
|
|
|
std::lock_guard<std::mutex> lk(mx_);
|
2018-01-08 09:57:01 +00:00
|
|
|
bool result = false;
|
2020-07-17 09:39:26 +00:00
|
|
|
if (!flag_enable_fpga_)
|
2019-03-22 15:03:09 +00:00
|
|
|
{
|
|
|
|
result = channel_fsm_->Event_start_acquisition();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
result = channel_fsm_->Event_start_acquisition_fpga();
|
|
|
|
channel_fsm_->start_acquisition();
|
|
|
|
}
|
2018-03-03 01:03:39 +00:00
|
|
|
if (!result)
|
2018-01-08 09:57:01 +00:00
|
|
|
{
|
|
|
|
LOG(WARNING) << "Invalid channel event";
|
|
|
|
return;
|
|
|
|
}
|
2018-01-04 11:33:13 +00:00
|
|
|
DLOG(INFO) << "Channel start_acquisition()";
|
2011-10-01 18:45:20 +00:00
|
|
|
}
|
2022-07-12 02:28:49 +00:00
|
|
|
|
2022-12-06 11:54:21 +00:00
|
|
|
bool Channel::glonass_dll_pll_c_aid_tracking_check() const
|
2022-07-12 02:28:49 +00:00
|
|
|
{
|
|
|
|
if (glonass_extend_correlation_ms_)
|
|
|
|
{
|
|
|
|
const pmt::pmt_t nav_ports_out = nav_->get_left_block()->message_ports_out();
|
|
|
|
const pmt::pmt_t trk_ports_in = trk_->get_right_block()->message_ports_in();
|
|
|
|
const pmt::pmt_t symbol = pmt::mp("preamble_timestamp_samples");
|
|
|
|
for (unsigned k = 0; k < pmt::length(nav_ports_out); k++)
|
|
|
|
{
|
|
|
|
if (pmt::vector_ref(nav_ports_out, k) == symbol)
|
|
|
|
{
|
|
|
|
for (unsigned j = 0; j < pmt::length(trk_ports_in); j++)
|
|
|
|
{
|
|
|
|
if (pmt::vector_ref(trk_ports_in, j) == symbol)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|