mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-14 20:20:35 +00:00
Code Issues Releases Wiki Activity

Merge branch 'next' of https://github.com/mmajoral/gnss-sdr into fpga_extended_coherent_integration

Browse Source
This commit is contained in:
Marc Majoral 2019-07-26 10:11:55 +02:00
commit 694c5d9dcb
46 changed files with 138 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/algorithms/PVT/libs/monitor_pvt_udp_sink.h
View File

@ -53,7 +53,6 @@ private:
boost::asio::ip::udp::socket socket;
boost::system::error_code error;
std::vector<boost::asio::ip::udp::endpoint> endpoints;
Monitor_Pvt monitor_pvt{};
Serdes_Monitor_Pvt serdes;
bool use_protobuf;
};

6
src/algorithms/acquisition/adapters/beidou_b1i_pcps_acquisition.cc
View File

@ -199,14 +199,14 @@ void BeidouB1iPcpsAcquisition::init()
void BeidouB1iPcpsAcquisition::set_local_code()
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
beidou_b1i_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
beidou_b1i_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < num_codes_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());

6
src/algorithms/acquisition/adapters/beidou_b3i_pcps_acquisition.cc
View File

@ -200,14 +200,14 @@ void BeidouB3iPcpsAcquisition::init()
void BeidouB3iPcpsAcquisition::set_local_code()
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
beidou_b3i_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < num_codes_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());

6
src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc
View File

@ -210,19 +210,19 @@ void GalileoE1Pcps8msAmbiguousAcquisition::set_local_code()
bool cboc = configuration_->property(
"Acquisition" + std::to_string(channel_) + ".cboc", false);
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
std::array<char, 3> Signal_{};
Signal_[0] = gnss_synchro_->Signal[0];
Signal_[1] = gnss_synchro_->Signal[1];
Signal_[2] = '\0';
galileo_e1_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), Signal_,
galileo_e1_code_gen_complex_sampled(code, Signal_,
cboc, gnss_synchro_->PRN, fs_in_, 0, false);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_ / 4; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_cc_->set_local_code(code_.data());

13
src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc
View File

@ -245,8 +245,7 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
bool cboc = configuration_->property(
"Acquisition" + std::to_string(channel_) + ".cboc", false);
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
gsl::span<std::complex<float>> code_span(code.get(), code_length_);
std::vector<std::complex<float>> code(code_length_);
if (acquire_pilot_ == true)
{
@ -254,12 +253,12 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
std::array<char, 3> pilot_signal = {{'1', 'C', '\0'}};
if (acq_parameters_.use_automatic_resampler)
{
galileo_e1_code_gen_complex_sampled(code_span, pilot_signal,
galileo_e1_code_gen_complex_sampled(code, pilot_signal,
cboc, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0, false);
}
else
{
galileo_e1_code_gen_complex_sampled(code_span, pilot_signal,
galileo_e1_code_gen_complex_sampled(code, pilot_signal,
cboc, gnss_synchro_->PRN, fs_in_, 0, false);
}
}
@ -271,12 +270,12 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
Signal_[2] = '\0';
if (acq_parameters_.use_automatic_resampler)
{
galileo_e1_code_gen_complex_sampled(code_span, Signal_,
galileo_e1_code_gen_complex_sampled(code, Signal_,
cboc, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0, false);
}
else
{
galileo_e1_code_gen_complex_sampled(code_span, Signal_,
galileo_e1_code_gen_complex_sampled(code, Signal_,
cboc, gnss_synchro_->PRN, fs_in_, 0, false);
}
}
@ -284,7 +283,7 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code()
gsl::span<gr_complex> code__span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_ / 4; i++)
{
std::copy_n(code.get(), code_length_, code__span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code__span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());

6
src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc
View File

@ -244,19 +244,19 @@ void GalileoE1PcpsQuickSyncAmbiguousAcquisition::set_local_code()
bool cboc = configuration_->property(
"Acquisition" + std::to_string(channel_) + ".cboc", false);
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
std::array<char, 3> Signal_{};
Signal_[0] = gnss_synchro_->Signal[0];
Signal_[1] = gnss_synchro_->Signal[1];
Signal_[2] = '\0';
galileo_e1_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), Signal_,
galileo_e1_code_gen_complex_sampled(code, Signal_,
cboc, gnss_synchro_->PRN, fs_in_, 0, false);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < (sampled_ms_ / (folding_factor_ * 4)); i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_cc_->set_local_code(code_.data());

6
src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc
View File

@ -214,18 +214,18 @@ void GalileoE1PcpsTongAmbiguousAcquisition::set_local_code()
bool cboc = configuration_->property(
"Acquisition" + std::to_string(channel_) + ".cboc", false);
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
std::array<char, 3> Signal_{};
Signal_[0] = gnss_synchro_->Signal[0];
Signal_[1] = gnss_synchro_->Signal[1];
Signal_[2] = '\0';
galileo_e1_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), Signal_,
galileo_e1_code_gen_complex_sampled(code, Signal_,
cboc, gnss_synchro_->PRN, fs_in_, 0, false);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_ / 4; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_cc_->set_local_code(code_.data());

10
src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc
View File

@ -209,6 +209,7 @@ void GalileoE5aPcpsAcquisition::set_doppler_step(unsigned int doppler_step)
acquisition_->set_doppler_step(doppler_step_);
}
void GalileoE5aPcpsAcquisition::set_doppler_center(int doppler_center)
{
doppler_center_ = doppler_center;
@ -216,6 +217,7 @@ void GalileoE5aPcpsAcquisition::set_doppler_center(int doppler_center)
acquisition_->set_doppler_center(doppler_center_);
}
void GalileoE5aPcpsAcquisition::set_gnss_synchro(Gnss_Synchro* gnss_synchro)
{
gnss_synchro_ = gnss_synchro;
@ -237,7 +239,7 @@ void GalileoE5aPcpsAcquisition::init()
void GalileoE5aPcpsAcquisition::set_local_code()
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
std::array<char, 3> signal_{};
signal_[0] = '5';
signal_[2] = '\0';
@ -257,16 +259,16 @@ void GalileoE5aPcpsAcquisition::set_local_code()
if (acq_parameters_.use_automatic_resampler)
{
galileo_e5_a_code_gen_complex_sampled(gsl::span<gr_complex>(code.get(), code_length_), signal_, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0);
galileo_e5_a_code_gen_complex_sampled(code, signal_, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0);
}
else
{
galileo_e5_a_code_gen_complex_sampled(gsl::span<gr_complex>(code.get(), code_length_), signal_, gnss_synchro_->PRN, fs_in_, 0);
galileo_e5_a_code_gen_complex_sampled(code, signal_, gnss_synchro_->PRN, fs_in_, 0);
}
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());

6
src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc
View File

@ -202,14 +202,14 @@ void GlonassL1CaPcpsAcquisition::init()
void GlonassL1CaPcpsAcquisition::set_local_code()
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), /* gnss_synchro_->PRN,*/ fs_in_, 0);
glonass_l1_ca_code_gen_complex_sampled(code, fs_in_, 0);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());

6
src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc
View File

@ -201,14 +201,14 @@ void GlonassL2CaPcpsAcquisition::init()
void GlonassL2CaPcpsAcquisition::set_local_code()
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), /* gnss_synchro_->PRN,*/ fs_in_, 0);
glonass_l2_ca_code_gen_complex_sampled(code, fs_in_, 0);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());

13
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc
View File

@ -201,6 +201,7 @@ void GpsL1CaPcpsAcquisition::set_doppler_step(unsigned int doppler_step)
acquisition_->set_doppler_step(doppler_step_);
}
void GpsL1CaPcpsAcquisition::set_doppler_center(int doppler_center)
{
doppler_center_ = doppler_center;
@ -208,6 +209,7 @@ void GpsL1CaPcpsAcquisition::set_doppler_center(int doppler_center)
acquisition_->set_doppler_center(doppler_center_);
}
void GpsL1CaPcpsAcquisition::set_gnss_synchro(Gnss_Synchro* gnss_synchro)
{
gnss_synchro_ = gnss_synchro;
@ -230,20 +232,20 @@ void GpsL1CaPcpsAcquisition::init()
void GpsL1CaPcpsAcquisition::set_local_code()
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
if (acq_parameters_.use_automatic_resampler)
{
gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0);
gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, acq_parameters_.resampled_fs, 0);
}
else
{
gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
}
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());
@ -264,7 +266,7 @@ void GpsL1CaPcpsAcquisition::set_state(int state)
float GpsL1CaPcpsAcquisition::calculate_threshold(float pfa)
{
//Calculate the threshold
// 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_)
{
@ -355,6 +357,7 @@ gr::basic_block_sptr GpsL1CaPcpsAcquisition::get_right_block()
return acquisition_;
}
void GpsL1CaPcpsAcquisition::set_resampler_latency(uint32_t latency_samples)
{
acquisition_->set_resampler_latency(latency_samples);

6
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc
View File

@ -206,14 +206,14 @@ void GpsL1CaPcpsOpenClAcquisition::set_local_code()
{
if (item_type_ == "gr_complex")
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_cc_->set_local_code(code_.data());

6
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc
View File

@ -232,14 +232,14 @@ void GpsL1CaPcpsQuickSyncAcquisition::set_local_code()
{
if (item_type_ == "gr_complex")
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < (sampled_ms_ / folding_factor_); i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_cc_->set_local_code(code_.data());

6
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc
View File

@ -194,14 +194,14 @@ void GpsL1CaPcpsTongAcquisition::set_local_code()
{
if (item_type_ == "gr_complex")
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
gps_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>>(code, code_length_), gnss_synchro_->PRN, fs_in_, 0);
gps_l1_ca_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_, 0);
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < sampled_ms_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_cc_->set_local_code(code_.data());

8
src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc
View File

@ -241,21 +241,21 @@ void GpsL2MPcpsAcquisition::init()
void GpsL2MPcpsAcquisition::set_local_code()
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
if (acq_parameters_.use_automatic_resampler)
{
gps_l2c_m_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), gnss_synchro_->PRN, acq_parameters_.resampled_fs);
gps_l2c_m_code_gen_complex_sampled(code, gnss_synchro_->PRN, acq_parameters_.resampled_fs);
}
else
{
gps_l2c_m_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), gnss_synchro_->PRN, fs_in_);
gps_l2c_m_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_);
}
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < num_codes_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());

8
src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc
View File

@ -235,21 +235,21 @@ void GpsL5iPcpsAcquisition::init()
void GpsL5iPcpsAcquisition::set_local_code()
{
std::unique_ptr<std::complex<float>> code{new std::complex<float>[code_length_]};
std::vector<std::complex<float>> code(code_length_);
if (acq_parameters_.use_automatic_resampler)
{
gps_l5i_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), gnss_synchro_->PRN, acq_parameters_.resampled_fs);
gps_l5i_code_gen_complex_sampled(code, gnss_synchro_->PRN, acq_parameters_.resampled_fs);
}
else
{
gps_l5i_code_gen_complex_sampled(gsl::span<std::complex<float>>(code.get(), code_length_), gnss_synchro_->PRN, fs_in_);
gps_l5i_code_gen_complex_sampled(code, gnss_synchro_->PRN, fs_in_);
}
gsl::span<gr_complex> code_span(code_.data(), vector_length_);
for (unsigned int i = 0; i < num_codes_; i++)
{
std::copy_n(code.get(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data());
}
acquisition_->set_local_code(code_.data());

33
src/algorithms/libs/beidou_b3i_signal_processing.cc
View File

@ -35,11 +35,11 @@
#include <bitset>
#include <string>
auto auxCeil = [](float x) { return static_cast<int>(static_cast<long>((x) + 1)); };
auto auxCeil = [](float x) { return static_cast<int32_t>(static_cast<int64_t>((x) + 1)); };
void beidou_b3i_code_gen_int(gsl::span<int> _dest, signed int _prn, unsigned int _chip_shift)
void beidou_b3i_code_gen_int(gsl::span<int> _dest, int32_t _prn, uint32_t _chip_shift)
{
const unsigned int _code_length = 10230;
const uint32_t _code_length = 10230;
std::bitset<_code_length> G1{};
std::bitset<_code_length> G2{};
auto G1_register = std::bitset<13>{}.set(); // All true
@ -175,54 +175,54 @@ void beidou_b3i_code_gen_int(gsl::span<int> _dest, signed int _prn, unsigned int
}
void beidou_b3i_code_gen_float(gsl::span<float> _dest, signed int _prn, unsigned int _chip_shift)
void beidou_b3i_code_gen_float(gsl::span<float> _dest, int32_t _prn, uint32_t _chip_shift)
{
const unsigned int _code_length = 10230;
const uint32_t _code_length = 10230;
std::array<int, _code_length> b3i_code_int{};
beidou_b3i_code_gen_int(b3i_code_int, _prn, _chip_shift);
for (unsigned int ii = 0; ii < _code_length; ++ii)
for (uint32_t ii = 0; ii < _code_length; ++ii)
{
_dest[ii] = static_cast<float>(b3i_code_int[ii]);
}
}
void beidou_b3i_code_gen_complex(gsl::span<std::complex<float>> _dest, signed int _prn, unsigned int _chip_shift)
void beidou_b3i_code_gen_complex(gsl::span<std::complex<float>> _dest, int32_t _prn, uint32_t _chip_shift)
{
const unsigned int _code_length = 10230;
const uint32_t _code_length = 10230;
std::array<int, _code_length> b3i_code_int{};
beidou_b3i_code_gen_int(b3i_code_int, _prn, _chip_shift);
for (unsigned int ii = 0; ii < _code_length; ++ii)
for (uint32_t ii = 0; ii < _code_length; ++ii)
{
_dest[ii] = std::complex<float>(static_cast<float>(b3i_code_int[ii]), 0.0F);
}
}
void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, unsigned int _prn, int _fs, unsigned int _chip_shift)
void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift)
{
// This function is based on the GNU software GPS for MATLAB in the Kay Borre book
std::array<std::complex<float>, 10230> _code{};
signed int _samplesPerCode, _codeValueIndex;
int32_t _samplesPerCode, _codeValueIndex;
float _ts;
float _tc;
float aux;
const signed int _codeFreqBasis = 10230000; // Hz
const signed int _codeLength = 10230;
const int32_t _codeFreqBasis = 10230000; // Hz
const int32_t _codeLength = 10230;
//--- Find number of samples per spreading code ----------------------------
_samplesPerCode = static_cast<signed int>(static_cast<double>(_fs) / static_cast<double>(_codeFreqBasis / _codeLength));
_samplesPerCode = static_cast<int32_t>(static_cast<double>(_fs) / static_cast<double>(_codeFreqBasis / _codeLength));
//--- Find time constants --------------------------------------------------
_ts = 1.0 / static_cast<float>(_fs); // Sampling period in sec
_tc = 1.0 / static_cast<float>(_codeFreqBasis); // C/A chip period in sec
beidou_b3i_code_gen_complex(_code, _prn, _chip_shift); // generate C/A code 1 sample per chip
for (signed int i = 0; i < _samplesPerCode; i++)
for (int32_t i = 0; i < _samplesPerCode; i++)
{
//=== Digitizing =======================================================
@ -231,7 +231,6 @@ void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, u
// number of samples per millisecond (because one C/A code period is one
// millisecond).
// _codeValueIndex = ceil((_ts * ((float)i + 1)) / _tc) - 1;
aux = (_ts * (i + 1)) / _tc;
_codeValueIndex = auxCeil(aux) - 1;
@ -245,7 +244,7 @@ void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, u
}
else
{
_dest[i] = _code[_codeValueIndex]; //repeat the chip -> upsample
_dest[i] = _code[_codeValueIndex]; // repeat the chip -> upsample
}
}
}

13
src/algorithms/libs/beidou_b3i_signal_processing.h
View File

@ -34,10 +34,7 @@
#define GNSS_SDR_BEIDOU_B3I_SIGNAL_PROCESSING_H_
#include <complex>
#include <iostream>
#include <cstdint>
#include <array>
#include <algorithm>
#if HAS_SPAN
#include <span>
@ -47,18 +44,18 @@ namespace gsl = std;
#endif
//! Generates int BeiDou B3I code for the desired SV ID and code shift
void beidou_b3i_code_gen_int(gsl::span<int> _dest, signed int _prn, unsigned int _chip_shift);
void beidou_b3i_code_gen_int(gsl::span<int> _dest, int32_t _prn, uint32_t _chip_shift);
//! Generates float BeiDou B3I code for the desired SV ID and code shift
void beidou_b3i_code_gen_float(gsl::span<float> _dest, signed int _prn, unsigned int _chip_shift);
void beidou_b3i_code_gen_float(gsl::span<float> _dest, int32_t _prn, uint32_t _chip_shift);
//! Generates complex BeiDou B3I code for the desired SV ID and code shift, and sampled to specific sampling frequency
void beidou_b3i_code_gen_complex(gsl::span<std::complex<float>> _dest, signed int _prn, unsigned int _chip_shift);
void beidou_b3i_code_gen_complex(gsl::span<std::complex<float>> _dest, int32_t _prn, uint32_t _chip_shift);
//! Generates N complex BeiDou B3I codes for the desired SV ID and code shift
void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, unsigned int _prn, int _fs, unsigned int _chip_shift, unsigned int _ncodes);
void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift, uint32_t _ncodes);
//! Generates complex BeiDou B3I code for the desired SV ID and code shift
void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, unsigned int _prn, int _fs, unsigned int _chip_shift);
void beidou_b3i_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift);
#endif /* GNSS_SDR_BEIDOU_B3I_SIGNAL_PROCESSING_H_ */

1
src/algorithms/libs/galileo_e1_signal_processing.cc
View File

@ -33,7 +33,6 @@
#include "galileo_e1_signal_processing.h"
#include "Galileo_E1.h"
#include "gnss_signal_processing.h"
#include <array>
#include <memory>
#include <string>
#include <vector>

1
src/algorithms/libs/galileo_e5_signal_processing.cc
View File

@ -35,7 +35,6 @@
#include "Galileo_E5a.h"
#include "gnss_signal_processing.h"
#include <gnuradio/gr_complex.h>
#include <array>
#include <memory>

1
src/algorithms/libs/galileo_e5_signal_processing.h
View File

@ -34,6 +34,7 @@
#ifndef GNSS_SDR_GALILEO_E5_SIGNAL_PROCESSING_H_
#define GNSS_SDR_GALILEO_E5_SIGNAL_PROCESSING_H_
#include <array>
#include <complex>
#include <cstdint>
#if HAS_SPAN

2
src/algorithms/libs/geofunctions.cc
View File

@ -232,7 +232,7 @@ int togeod(double *dphi, double *dlambda, double *h, double a, double finv, doub
}
arma::mat Gravity_ECEF(const arma::vec &r_eb_e)
arma::vec Gravity_ECEF(const arma::vec &r_eb_e)
{
// Parameters
const double R_0 = 6378137.0; // WGS84 Equatorial radius in meters

2
src/algorithms/libs/geofunctions.h
View File

@ -79,7 +79,7 @@ int topocent(double *Az, double *El, double *D, const arma::vec &x, const arma::
*/
int togeod(double *dphi, double *dlambda, double *h, double a, double finv, double X, double Y, double Z);
arma::mat Gravity_ECEF(const arma::vec &r_eb_e); //!< Calculates acceleration due to gravity resolved about ECEF-frame
arma::vec Gravity_ECEF(const arma::vec &r_eb_e); //!< Calculates acceleration due to gravity resolved about ECEF-frame
/*!
* \brief Conversion of Cartesian coordinates (X,Y,Z) to geographical

4
src/algorithms/libs/glonass_l1_signal_processing.cc
View File

@ -36,7 +36,7 @@
auto auxCeil = [](float x) { return static_cast<int32_t>(static_cast<int64_t>((x) + 1)); };
void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /* int32_t _prn,*/ uint32_t _chip_shift)
void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, uint32_t _chip_shift)
{
const uint32_t _code_length = 511;
std::bitset<_code_length> G1{};
@ -101,7 +101,7 @@ void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /* int
/*
* Generates complex GLONASS L1 C/A code for the desired SV ID and sampled to specific sampling frequency
*/
void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift)
void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift)
{
// This function is based on the GNU software GPS for MATLAB in the Kay Borre book
std::array<std::complex<float>, 511> _code{};

8
src/algorithms/libs/glonass_l1_signal_processing.h
View File

@ -43,13 +43,13 @@ namespace gsl = std;
#include <gsl/gsl>
#endif
//!Generates complex GLONASS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /*int32_t _prn,*/ uint32_t _chip_shift);
//! Generates complex GLONASS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
void glonass_l1_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, uint32_t _chip_shift);
//! Generates N complex GLONASS L1 C/A codes for the desired SV ID and code shift
void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes);
void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes);
//! Generates complex GLONASS L1 C/A code for the desired SV ID and code shift
void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift);
void glonass_l1_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift);
#endif /* GNSS_SDR_GLONASS_SDR_SIGNAL_PROCESSING_H_ */

4
src/algorithms/libs/glonass_l2_signal_processing.cc
View File

@ -36,7 +36,7 @@
auto auxCeil = [](float x) { return static_cast<int32_t>(static_cast<int64_t>((x) + 1)); };
void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /* int32_t _prn,*/ uint32_t _chip_shift)
void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, uint32_t _chip_shift)
{
const uint32_t _code_length = 511;
std::bitset<_code_length> G1{};
@ -101,7 +101,7 @@ void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /* int
/*
* Generates complex GLONASS L2 C/A code for the desired SV ID and sampled to specific sampling frequency
*/
void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift)
void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift)
{
// This function is based on the GNU software GPS for MATLAB in the Kay Borre book
std::array<std::complex<float>, 511> _code{};

8
src/algorithms/libs/glonass_l2_signal_processing.h
View File

@ -43,13 +43,13 @@ namespace gsl = std;
#include <gsl/gsl>
#endif
//!Generates complex GLONASS L2 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, /*int32_t _prn,*/ uint32_t _chip_shift);
//! Generates complex GLONASS L2 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency
void glonass_l2_ca_code_gen_complex(gsl::span<std::complex<float>> _dest, uint32_t _chip_shift);
//! Generates N complex GLONASS L2 C/A codes for the desired SV ID and code shift
void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes);
void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes);
//! Generates complex GLONASS L2 C/A code for the desired SV ID and code shift
void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, /* uint32_t _prn,*/ int32_t _fs, uint32_t _chip_shift);
void glonass_l2_ca_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, int32_t _fs, uint32_t _chip_shift);
#endif /* GNSS_SDR_GLONASS_L2_SIGNAL_PROCESSING_H_ */

4
src/algorithms/libs/gps_l2c_signal.cc
View File

@ -106,7 +106,7 @@ void gps_l2c_m_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, ui
//--- Find time constants --------------------------------------------------
_ts = 1.0 / static_cast<float>(_fs); // Sampling period in sec
_tc = 1.0 / static_cast<float>(GPS_L2_M_CODE_RATE_HZ); // C/A chip period in sec
_tc = 1.0 / static_cast<float>(GPS_L2_M_CODE_RATE_HZ); // L2C chip period in sec
for (int32_t i = 0; i < _samplesPerCode; i++)
{
@ -123,7 +123,7 @@ void gps_l2c_m_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, ui
}
else
{
_dest[i] = std::complex<float>(1.0 - 2.0 * _code[_codeValueIndex], 0); //repeat the chip -> upsample
_dest[i] = std::complex<float>(1.0 - 2.0 * _code[_codeValueIndex], 0); // repeat the chip -> upsample
}
}
}

2
src/algorithms/libs/gps_l5_signal.cc
View File

@ -33,6 +33,7 @@
#include "gps_l5_signal.h"
#include "GPS_L5.h"
#include <array>
#include <cmath>
#include <deque>
std::deque<bool> l5i_xa_shift(std::deque<bool> xa) // GPS-IS-705E Figure 3-4 pp. 15
@ -298,7 +299,6 @@ void gps_l5q_code_gen_complex_sampled(gsl::span<std::complex<float>> _dest, uint
_ts = 1.0 / static_cast<float>(_fs); // Sampling period in sec
_tc = 1.0 / static_cast<float>(GPS_L5Q_CODE_RATE_HZ); // L5Q chip period in sec
//float aux;
for (int32_t i = 0; i < _samplesPerCode; i++)
{
//=== Digitizing =======================================================

6
src/algorithms/libs/rtklib/rtklib_stream.cc
View File

@ -975,9 +975,8 @@ void discontcp(tcp_t *tcp, int tcon)
/* open tcp server -----------------------------------------------------------*/
tcpsvr_t *opentcpsvr(const char *path, char *msg)
{
tcpsvr_t *tcpsvr, tcpsvr0; // = {{0}};
tcpsvr_t *tcpsvr, tcpsvr0{};
char port[256] = "";
tcpsvr0 = {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}, {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}}};
tracet(3, "opentcpsvr: path=%s\n", path);
if (!(tcpsvr = static_cast<tcpsvr_t *>(malloc(sizeof(tcpsvr_t)))))
@ -1265,9 +1264,8 @@ int consock(tcpcli_t *tcpcli, char *msg)
/* open tcp client -----------------------------------------------------------*/
tcpcli_t *opentcpcli(const char *path, char *msg)
{
tcpcli_t *tcpcli, tcpcli0; // = {{0}};
tcpcli_t *tcpcli, tcpcli0{};
char port[256] = "";
tcpcli0 = {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}, 0, 0};
tracet(3, "opentcpcli: path=%s\n", path);

1
src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l1_ca_telemetry_decoder_gs.h
View File

@ -92,7 +92,6 @@ private:
// Preamble decoding
const std::array<uint16_t, GLONASS_GNAV_PREAMBLE_LENGTH_BITS> d_preambles_bits{GLONASS_GNAV_PREAMBLE};
std::array<int32_t, GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS> d_preambles_symbols{};
uint32_t d_samples_per_symbol = (GLONASS_L1_CA_CODE_RATE_HZ / GLONASS_L1_CA_CODE_LENGTH_CHIPS) / GLONASS_L1_CA_SYMBOL_RATE_BPS;
const int32_t d_symbols_per_preamble = GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS;
// Storage for incoming data

1
src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l2_ca_telemetry_decoder_gs.h
View File

@ -90,7 +90,6 @@ private:
// Preamble decoding
const std::array<uint16_t, GLONASS_GNAV_PREAMBLE_LENGTH_BITS> d_preambles_bits{GLONASS_GNAV_PREAMBLE};
std::array<int32_t, GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS> d_preambles_symbols{};
uint32_t d_samples_per_symbol = (GLONASS_L2_CA_CODE_RATE_HZ / GLONASS_L2_CA_CODE_LENGTH_CHIPS) / GLONASS_L2_CA_SYMBOL_RATE_BPS;
const int32_t d_symbols_per_preamble = GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS;
// Storage for incoming data

1
src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc
View File

@ -194,6 +194,7 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(
void GalileoE1DllPllVemlTracking::stop_tracking()
{
tracking_->stop_tracking();
}

1
src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc
View File

@ -190,6 +190,7 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking(
void GalileoE5aDllPllTracking::stop_tracking()
{
tracking_->stop_tracking();
}

1
src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc
View File

@ -172,6 +172,7 @@ GpsL2MDllPllTracking::GpsL2MDllPllTracking(
void GpsL2MDllPllTracking::stop_tracking()
{
tracking_->stop_tracking();
}

1
src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking_fpga.cc
View File

@ -158,6 +158,7 @@ void GpsL2MDllPllTrackingFpga::start_tracking()
void GpsL2MDllPllTrackingFpga::stop_tracking()
{
tracking_fpga_sc->stop_tracking();
}

1
src/algorithms/tracking/adapters/gps_l5_dll_pll_tracking.cc
View File

@ -192,6 +192,7 @@ GpsL5DllPllTracking::GpsL5DllPllTracking(
void GpsL5DllPllTracking::stop_tracking()
{
tracking_->stop_tracking();
}

1
src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_c_aid_tracking_cc.cc
View File

@ -676,7 +676,6 @@ int glonass_l1_ca_dll_pll_c_aid_tracking_cc::general_work(int noutput_items __at
d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GLONASS_TWO_PI);
// UPDATE ACCUMULATED CARRIER PHASE
CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GLONASS_TWO_PI;
// disable tracking loop and inform telemetry decoder

1
src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_c_aid_tracking_sc.cc
View File

@ -667,7 +667,6 @@ int glonass_l1_ca_dll_pll_c_aid_tracking_sc::general_work(int noutput_items __at
d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GLONASS_TWO_PI);
// UPDATE ACCUMULATED CARRIER PHASE
CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GLONASS_TWO_PI;
// disable tracking loop and inform telemetry decoder

1
src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_c_aid_tracking_cc.cc
View File

@ -674,7 +674,6 @@ int glonass_l2_ca_dll_pll_c_aid_tracking_cc::general_work(int noutput_items __at
d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GLONASS_TWO_PI);
// UPDATE ACCUMULATED CARRIER PHASE
CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GLONASS_TWO_PI;
// disable tracking loop and inform telemetry decoder

1
src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_c_aid_tracking_sc.cc
View File

@ -666,7 +666,6 @@ int glonass_l2_ca_dll_pll_c_aid_tracking_sc::general_work(int noutput_items __at
d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GLONASS_TWO_PI);
// UPDATE ACCUMULATED CARRIER PHASE
CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GLONASS_TWO_PI;
// disable tracking loop and inform telemetry decoder

2
src/algorithms/tracking/libs/exponential_smoother.cc
View File

@ -76,7 +76,7 @@ void Exponential_Smoother::set_samples_for_initialization(int num_samples)
{
ns = 1;
}
samples_for_initialization_ = num_samples;
samples_for_initialization_ = ns;
init_buffer_.reserve(samples_for_initialization_);
}

34
src/core/receiver/control_thread.cc
View File

@ -194,6 +194,8 @@ void ControlThread::init()
agnss_ref_time_.valid = false;
}
}
receiver_on_standby_ = false;
}
@ -234,11 +236,14 @@ void ControlThread::event_dispatcher(bool &valid_event, pmt::pmt_t &msg)
processed_control_messages_++;
if (pmt::any_ref(msg).type() == typeid(channel_event_sptr))
{
channel_event_sptr new_event;
new_event = boost::any_cast<channel_event_sptr>(pmt::any_ref(msg));
DLOG(INFO) << "New channel event rx from ch id: " << new_event->channel_id
<< " what: " << new_event->event_type;
flowgraph_->apply_action(new_event->channel_id, new_event->event_type);
if (receiver_on_standby_ == false)
{
channel_event_sptr new_event;
new_event = boost::any_cast<channel_event_sptr>(pmt::any_ref(msg));
DLOG(INFO) << "New channel event rx from ch id: " << new_event->channel_id
<< " what: " << new_event->event_type;
flowgraph_->apply_action(new_event->channel_id, new_event->event_type);
}
}
else if (pmt::any_ref(msg).type() == typeid(command_event_sptr))
{
@ -267,8 +272,11 @@ void ControlThread::event_dispatcher(bool &valid_event, pmt::pmt_t &msg)
}
else
{
//perform non-priority tasks
flowgraph_->acquisition_manager(0); //start acquisition of untracked satellites
if (receiver_on_standby_ == false)
{
//perform non-priority tasks
flowgraph_->acquisition_manager(0); //start acquisition of untracked satellites
}
}
}
@ -852,6 +860,10 @@ void ControlThread::apply_action(unsigned int what)
stop_ = true;
restart_ = true;
break;
case 10: // request standby mode
LOG(INFO) << "TC request standby mode";
receiver_on_standby_ = true;
break;
case 11:
LOG(INFO) << "Receiver action COLDSTART";
// delete all ephemeris and almanac information from maps (also the PVT map queue)
@ -859,13 +871,16 @@ void ControlThread::apply_action(unsigned int what)
pvt_ptr->clear_ephemeris();
// todo: reorder the satellite queues to the receiver default startup order.
// This is required to allow repeatability. Otherwise the satellite search order will depend on the last tracked satellites
// start again the satellite acquisitions
receiver_on_standby_ = false;
break;
case 12:
LOG(INFO) << "Receiver action HOTSTART";
visible_satellites = get_visible_sats(cmd_interface_.get_utc_time(), cmd_interface_.get_LLH());
// reorder the satellite queue to acquire first those visible satellites
flowgraph_->priorize_satellites(visible_satellites);
// start again the satellite acquisitions (done in chained apply_action to flowgraph)
// start again the satellite acquisitions
receiver_on_standby_ = false;
break;
case 13:
LOG(INFO) << "Receiver action WARMSTART";
@ -879,7 +894,8 @@ void ControlThread::apply_action(unsigned int what)
get_visible_sats(cmd_interface_.get_utc_time(), cmd_interface_.get_LLH());
// reorder the satellite queue to acquire first those visible satellites
flowgraph_->priorize_satellites(visible_satellites);
// start again the satellite acquisitions (done in chained apply_action to flowgraph)
// start again the satellite acquisitions
receiver_on_standby_ = false;
break;
default:
LOG(INFO) << "Unrecognized action.";

1
src/core/receiver/control_thread.h
View File

@ -129,6 +129,7 @@ private:
/*
* New receiver event dispatcher
*/
bool receiver_on_standby_;
void event_dispatcher(bool &valid_event, pmt::pmt_t &msg);
std::thread cmd_interface_thread_;

23
src/core/receiver/gnss_flowgraph.cc
View File

@ -1288,8 +1288,8 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
std::lock_guard<std::mutex> lock(signal_list_mutex);
DLOG(INFO) << "Received " << what << " from " << who;
Gnss_Signal gs = channels_[who]->get_signal();
unsigned int sat = 0;
Gnss_Signal gs;
if (who < 200)
{
try
@ -1304,6 +1304,7 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
switch (what)
{
case 0:
gs = channels_[who]->get_signal();
DLOG(INFO) << "Channel " << who << " ACQ FAILED satellite " << gs.get_satellite() << ", Signal " << gs.get_signal_str();
channels_state_[who] = 0;
if (acq_channels_count_ > 0)
@ -1319,6 +1320,7 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
}
break;
case 1:
gs = channels_[who]->get_signal();
DLOG(INFO) << "Channel " << who << " ACQ SUCCESS satellite " << gs.get_satellite();
// If the satellite is in the list of available ones, remove it.
remove_signal(gs);
@ -1333,6 +1335,7 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
break;
case 2:
gs = channels_[who]->get_signal();
DLOG(INFO) << "Channel " << who << " TRK FAILED satellite " << gs.get_satellite();
if (acq_channels_count_ < max_acq_channels_)
{
@ -1359,7 +1362,6 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
}
break;
case 10: // request standby mode
LOG(INFO) << "TC request standby mode";
for (size_t n = 0; n < channels_.size(); n++)
{
if (channels_state_[n] == 1 or channels_state_[n] == 2) // channel in acquisition or in tracking
@ -1372,22 +1374,7 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
channels_state_[n] = 0;
}
}
acq_channels_count_ = 0; // all channels are in standby now
break;
case 11: // request coldstart mode
LOG(INFO) << "TC request flowgraph coldstart";
// call the acquisition manager to assign new satellite and start next acquisition (if required)
acquisition_manager(who);
break;
case 12: // request hotstart mode
LOG(INFO) << "TC request flowgraph hotstart";
// call the acquisition manager to assign new satellite and start next acquisition (if required)
acquisition_manager(who);
break;
case 13: // request warmstart mode
LOG(INFO) << "TC request flowgraph warmstart";
// call the acquisition manager to assign new satellite and start next acquisition (if required)
acquisition_manager(who);
acq_channels_count_ = 0; // all channels are in standby now and no new acquisition should be started
break;
default:
break;

4
src/core/system_parameters/gnss_satellite.cc
View File

@ -124,9 +124,9 @@ Gnss_Satellite& Gnss_Satellite::operator=(Gnss_Satellite&& other) noexcept
{
if (this != &other)
{
this->system = std::move(other.get_system());
this->system = other.get_system();
this->PRN = other.get_PRN();
this->block = std::move(other.get_block());
this->block = other.get_block();
this->rf_link = other.get_rf_link();
}
return *this;