mirrors
/
gnss-sdr
mirror of https://github.com/gnss-sdr/gnss-sdr
1
0
Fork 0
Code Issues Releases Wiki Activity

Prefer initialization to assignment in constructors

This commit is contained in:
Carles Fernandez 2021-12-14 12:59:35 +01:00
parent 33366ef6df
commit 71321581ed
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
5 changed files with 120 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/algorithms/signal_source/libs/gnss_sdr_timestamp.cc
View File

@ -33,11 +33,11 @@ Gnss_Sdr_Timestamp::Gnss_Sdr_Timestamp(size_t sizeof_stream_item,
gr::io_signature::make(1, 20, sizeof_stream_item),
gr::io_signature::make(1, 20, sizeof_stream_item)),
d_timefile(std::move(timestamp_file)),
d_clock_offset_ms(clock_offset_ms)
d_clock_offset_ms(clock_offset_ms),
d_fraction_ms_offset(modf(d_clock_offset_ms, &d_integer_ms_offset)), // optional clockoffset parameter to convert UTC timestamps to GPS time in some receiver's configuration
d_next_timetag_samplecount(0),
d_get_next_timetag(true)
{
d_fraction_ms_offset = modf(d_clock_offset_ms, &d_integer_ms_offset); // optional clockoffset parameter to convert UTC timestamps to GPS time in some receiver's configuration
get_next_timetag = true;
next_timetag_samplecount = 0;
}
@ -50,7 +50,7 @@ gnss_shared_ptr<Gnss_Sdr_Timestamp> gnss_sdr_make_Timestamp(size_t sizeof_stream
bool Gnss_Sdr_Timestamp::read_next_timetag()
{
d_timefilestream.read(reinterpret_cast<char*>(&next_timetag_samplecount), sizeof(uint64_t));
d_timefilestream.read(reinterpret_cast<char*>(&d_next_timetag_samplecount), sizeof(uint64_t));
if (!d_timefilestream)
{
return false;
@ -98,20 +98,20 @@ int Gnss_Sdr_Timestamp::work(int noutput_items,
gr_vector_void_star& output_items)
{
// multichannel support
if (get_next_timetag == true)
if (d_get_next_timetag == true)
{
if (read_next_timetag() == false)
{
// std::cout << "End of TimeTag file reached!\n";
// return 0; // todo: find why return -1 does not stop gnss-sdr!
}
get_next_timetag = false;
d_get_next_timetag = false;
}
for (size_t ch = 0; ch < output_items.size(); ch++)
{
std::memcpy(output_items[ch], input_items[ch], noutput_items * input_signature()->sizeof_stream_item(ch));
uint64_t bytes_to_samples = 2; // todo: improve this.. hardcoded 2 bytes -> 1 complex sample!
int64_t diff_samplecount = uint64diff(this->nitems_written(ch), next_timetag_samplecount * bytes_to_samples);
int64_t diff_samplecount = uint64diff(this->nitems_written(ch), d_next_timetag_samplecount * bytes_to_samples);
// std::cout << "diff_samplecount: " << diff_samplecount << ", noutput_items: " << noutput_items << "\n";
if (diff_samplecount <= noutput_items and std::labs(diff_samplecount) <= noutput_items)
{
@ -121,8 +121,8 @@ int Gnss_Sdr_Timestamp::work(int noutput_items,
tmp_obj->tow_ms_fraction = d_fraction_ms_offset;
tmp_obj->rx_time = 0;
add_item_tag(ch, this->nitems_written(ch) - diff_samplecount, pmt::mp("timetag"), pmt::make_any(tmp_obj));
// std::cout << "[" << this->nitems_written(ch) - diff_samplecount << "] Sent TimeTag SC: " << next_timetag_samplecount * bytes_to_samples << ", Week: " << next_timetag.week << ", TOW: " << next_timetag.tow_ms << " [ms] \n";
get_next_timetag = true;
// std::cout << "[" << this->nitems_written(ch) - diff_samplecount << "] Sent TimeTag SC: " << d_next_timetag_samplecount * bytes_to_samples << ", Week: " << next_timetag.week << ", TOW: " << next_timetag.tow_ms << " [ms] \n";
d_get_next_timetag = true;
}
}

6
src/algorithms/signal_source/libs/gnss_sdr_timestamp.h
View File

@ -66,10 +66,10 @@ private:
std::fstream d_timefilestream;
GnssTime next_timetag{};
double d_clock_offset_ms;
double d_integer_ms_offset;
double d_fraction_ms_offset;
uint64_t next_timetag_samplecount;
bool get_next_timetag;
double d_integer_ms_offset;
uint64_t d_next_timetag_samplecount;
bool d_get_next_timetag;
};

4
src/algorithms/signal_source/libs/gnss_sdr_valve.cc
View File

@ -33,9 +33,9 @@ Gnss_Sdr_Valve::Gnss_Sdr_Valve(size_t sizeof_stream_item,
d_nitems(nitems),
d_ncopied_items(0),
d_queue(queue),
d_stop_flowgraph(stop_flowgraph)
d_stop_flowgraph(stop_flowgraph),
d_open_valve(false)
{
d_open_valve = false;
}

168
src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc
View File

@ -35,6 +35,7 @@
#include "galileo_e6_signal_replica.h"
#include "gnss_satellite.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_l2c_signal_replica.h"
#include "gps_l5_signal_replica.h"
@ -62,19 +63,13 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#if PMT_USES_BOOST_ANY
#include <boost/any.hpp>
namespace wht = boost;
#else
#include <filesystem>
namespace fs = std::filesystem;
#include <any>
namespace wht = std;
#endif
#else
#include <boost/filesystem/path.hpp>
namespace fs = boost::filesystem;
#endif
kf_vtl_tracking_sptr kf_vtl_make_tracking(const Kf_Conf &conf_)
{
@ -83,12 +78,60 @@ kf_vtl_tracking_sptr kf_vtl_make_tracking(const Kf_Conf &conf_)
kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
: gr::block("kf_vtl_tracking", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
: gr::block("kf_vtl_tracking",
gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_trk_parameters(conf_),
d_acquisition_gnss_synchro(nullptr),
d_signal_type(d_trk_parameters.signal),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_current_correlation_time_s(0.0),
d_carr_phase_error_disc_hz(0.0),
d_code_error_disc_chips(0.0),
d_code_error_kf_chips(0.0),
d_code_freq_kf_chips_s(0.0),
d_carrier_phase_kf_rad(0.0),
d_carrier_doppler_kf_hz(0.0),
d_carrier_doppler_rate_kf_hz_s(0.0),
d_acc_carrier_phase_rad(0.0),
d_T_chip_seconds(0.0),
d_T_prn_seconds(0.0),
d_T_prn_samples(0.0),
d_K_blk_samples(0.0),
d_carrier_lock_test(1.0),
d_CN0_SNV_dB_Hz(0.0),
d_carrier_lock_threshold(d_trk_parameters.carrier_lock_th),
d_carrier_phase_step_rad(0.0),
d_carrier_phase_rate_step_rad(0.0),
d_code_phase_step_chips(0.0),
d_code_phase_rate_step_chips(0.0),
d_rem_code_phase_chips(0.0),
d_rem_code_phase_samples(0.0),
d_sample_counter(0ULL),
d_acq_sample_stamp(0ULL),
d_rem_carr_phase_rad(0.0),
d_channel(0U),
d_secondary_code_length(0U),
d_data_secondary_code_length(0U),
d_state(0),
d_current_prn_length_samples(static_cast<int32_t>(d_trk_parameters.vector_length)),
d_extend_correlation_symbols_count(0),
d_cn0_estimation_counter(0),
d_carrier_lock_fail_counter(0),
d_code_lock_fail_counter(0),
d_pull_in_transitory(true),
d_corrected_doppler(false),
d_interchange_iq(false),
d_veml(false),
d_cloop(true),
d_dump(d_trk_parameters.dump),
d_dump_mat(d_trk_parameters.dump_mat && d_dump),
d_acc_carrier_phase_initialized(false)
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
d_trk_parameters = conf_;
// Telemetry bit synchronization message port input
this->message_port_register_out(pmt::mp("events"));
this->set_relative_rate(1.0 / static_cast<double>(d_trk_parameters.vector_length));
@ -122,16 +165,6 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
#endif
// initialize internal vars
d_veml = false;
d_cloop = true;
d_pull_in_transitory = true;
d_code_chip_rate = 0.0;
d_secondary_code_length = 0U;
d_data_secondary_code_length = 0U;
d_preamble_length_symbols = 0;
d_interchange_iq = false;
d_signal_type = std::string(d_trk_parameters.signal);
std::map<std::string, std::string> map_signal_pretty_name;
map_signal_pretty_name["1C"] = "L1 C/A";
map_signal_pretty_name["1B"] = "E1";
@ -409,12 +442,6 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
d_code_samples_per_chip = 0U;
d_symbols_per_bit = 0;
}
d_T_chip_seconds = 0.0;
d_T_prn_seconds = 0.0;
d_T_prn_samples = 0.0;
d_K_blk_samples = 0.0;
// Initialize tracking ==========================================
// Initialization of local code replica
// Get space for a vector with the sinboc(1,1) replica sampled 2x/chip
@ -485,33 +512,13 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
// --- Initializations ---
d_Prompt_circular_buffer.set_capacity(d_secondary_code_length);
d_multicorrelator_cpu.set_high_dynamics_resampler(d_trk_parameters.high_dyn);
// Initial code frequency basis of NCO
d_code_freq_kf_chips_s = d_code_chip_rate;
// Residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// Residual carrier phase
d_rem_carr_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL;
d_acq_sample_stamp = 0ULL;
d_current_prn_length_samples = static_cast<int32_t>(d_trk_parameters.vector_length);
d_current_correlation_time_s = 0.0;
d_carr_phase_error_disc_hz = 0.0;
d_code_error_disc_chips = 0.0;
d_code_error_kf_chips = 0.0;
d_code_freq_kf_chips_s = 0.0;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer.reserve(d_trk_parameters.cn0_samples);
d_carrier_lock_test = 1.0;
d_CN0_SNV_dB_Hz = 0.0;
d_carrier_lock_fail_counter = 0;
d_code_lock_fail_counter = 0;
d_carrier_lock_threshold = d_trk_parameters.carrier_lock_th;
d_Prompt_Data.reserve(1);
d_cn0_smoother = Exponential_Smoother();
d_cn0_smoother.set_alpha(d_trk_parameters.cn0_smoother_alpha);
@ -527,26 +534,8 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
d_carrier_lock_test_smoother.set_offset(0.0);
d_carrier_lock_test_smoother.set_samples_for_initialization(d_trk_parameters.carrier_lock_test_smoother_samples);
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_phase_kf_rad = 0;
d_carrier_doppler_kf_hz = 0.0;
d_carrier_doppler_rate_kf_hz_s = 0.0;
d_acc_carrier_phase_rad = 0.0;
d_extend_correlation_symbols_count = 0;
d_code_phase_step_chips = 0.0;
d_code_phase_rate_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
d_carrier_phase_rate_step_rad = 0.0;
d_rem_code_phase_chips = 0.0;
d_state = 0; // initial state: standby
clear_tracking_vars();
d_dump = d_trk_parameters.dump;
d_dump_mat = d_trk_parameters.dump_mat and d_dump;
if (d_dump)
{
d_dump_filename = d_trk_parameters.dump_filename;
@ -580,8 +569,6 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
d_dump = false;
}
}
d_corrected_doppler = false;
d_acc_carrier_phase_initialized = false;
}
@ -601,7 +588,7 @@ void kf_vtl_tracking::msg_handler_telemetry_to_trk(const pmt::pmt_t &msg)
{
if (pmt::any_ref(msg).type().hash_code() == d_int_type_hash_code)
{
const int tlm_event = boost::any_cast<int>(pmt::any_ref(msg));
const int tlm_event = wht::any_cast<int>(pmt::any_ref(msg));
if (tlm_event == 1)
{
DLOG(INFO) << "Telemetry fault received in ch " << this->d_channel;
@ -623,9 +610,9 @@ void kf_vtl_tracking::msg_handler_pvt_to_trk(const pmt::pmt_t &msg)
{
if (pmt::any_ref(msg).type().hash_code() == typeid(const std::shared_ptr<TrackingCmd>).hash_code())
{
const auto cmd = boost::any_cast<const std::shared_ptr<TrackingCmd>>(pmt::any_ref(msg));
// std::cout << "RX pvt-to-trk cmd with delay: "
// << static_cast<double>(nitems_read(0) - cmd->sample_counter) / d_trk_parameters.fs_in << " [s]\n";
const auto cmd = wht::any_cast<const std::shared_ptr<TrackingCmd>>(pmt::any_ref(msg));
// std::cout << "RX pvt-to-trk cmd with delay: "
// << static_cast<double>(nitems_read(0) - cmd->sample_counter) / d_trk_parameters.fs_in << " [s]\n";
}
else
{
@ -1173,24 +1160,21 @@ void kf_vtl_tracking::run_Kf()
// Measurement update
arma::mat K = d_P_new_old * d_H.t() * arma::inv(d_H * d_P_new_old * d_H.t() + d_R); // Kalman gain
x_new_new = d_x_new_old + K * z;
d_x_new_new = d_x_new_old + K * z;
d_P_new_new = (arma::eye(5, 5) - K * d_H) * d_P_new_old;
// new code phase estimation
d_code_error_kf_chips = x_new_new(0);
x_new_new(0) = 0; // reset error estimation because the NCO corrects the code phase
d_code_error_kf_chips = d_x_new_new(0);
d_x_new_new(0) = 0; // reset error estimation because the NCO corrects the code phase
// new carrier phase estimation
d_carrier_phase_kf_rad = x_new_new(1);
d_carrier_phase_kf_rad = d_x_new_new(1);
// New carrier Doppler frequency estimation
d_carrier_doppler_kf_hz = x_new_new(2); // d_carrier_loop_filter.get_carrier_error(0, static_cast<float>(d_carr_phase_error_hz), static_cast<float>(d_current_correlation_time_s));
d_carrier_doppler_kf_hz = d_x_new_new(2); // d_carrier_loop_filter.get_carrier_error(0, static_cast<float>(d_carr_phase_error_hz), static_cast<float>(d_current_correlation_time_s));
d_carrier_doppler_rate_kf_hz_s = x_new_new(3);
// std::cout << "d_carrier_doppler_hz: " << d_carrier_doppler_hz << '\n';
// std::cout << "d_CN0_SNV_dB_Hz: " << this->d_CN0_SNV_dB_Hz << '\n';
d_carrier_doppler_rate_kf_hz_s = d_x_new_new(3);
// New code Doppler frequency estimation
if (d_trk_parameters.carrier_aiding)
@ -1201,9 +1185,9 @@ void kf_vtl_tracking::run_Kf()
else
{
// use its own KF code rate estimation
d_code_freq_kf_chips_s -= x_new_new(4);
d_code_freq_kf_chips_s -= d_x_new_new(4);
}
x_new_new(4) = 0;
d_x_new_new(4) = 0;
// Experimental: detect Carrier Doppler vs. Code Doppler incoherence and correct the Carrier Doppler
// if (d_trk_parameters.enable_doppler_correction == true)
// {
@ -1218,7 +1202,7 @@ void kf_vtl_tracking::run_Kf()
d_rem_carr_phase_rad = d_carrier_phase_kf_rad;
// prepare data for next KF epoch
d_x_old_old = x_new_new;
d_x_old_old = d_x_new_new;
d_P_old_old = d_P_new_new;
}
@ -1271,7 +1255,8 @@ void kf_vtl_tracking::update_tracking_vars()
// d_rem_carr_phase_rad = d_carrier_phase_kf_rad;
// remnant carrier phase to prevent overflow in the code NCO
d_rem_carr_phase_rad += static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples));
d_rem_carr_phase_rad += static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples) +
0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples));
d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, TWO_PI);
// carrier phase rate step (NCO phase increment rate per sample) [rads/sample^2]
@ -1288,7 +1273,8 @@ void kf_vtl_tracking::update_tracking_vars()
// double a = d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples);
// double b = 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples);
// std::cout << fmod(b, TWO_PI) / fmod(a, TWO_PI) << '\n';
d_acc_carrier_phase_rad -= (d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples));
d_acc_carrier_phase_rad -= (d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples) +
0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples));
// ################### DLL COMMANDS #################################################
// code phase step (Code resampler phase increment per sample) [chips/sample]
@ -1488,7 +1474,7 @@ void kf_vtl_tracking::log_data()
// Carrier estimation
tmp_float = static_cast<float>(d_carr_phase_error_disc_hz);
d_dump_file.write(reinterpret_cast<char *>(&tmp_float), sizeof(float));
tmp_float = static_cast<float>(x_new_new(2));
tmp_float = static_cast<float>(d_x_new_new(2));
d_dump_file.write(reinterpret_cast<char *>(&tmp_float), sizeof(float));
// code estimation
tmp_float = static_cast<float>(d_code_error_disc_chips);

57
src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.h
View File

@ -126,7 +126,30 @@ private:
arma::mat d_P_new_new;
arma::vec d_x_old_old;
arma::vec d_x_new_old;
arma::vec x_new_new;
arma::vec d_x_new_new;
std::string d_secondary_code_string;
std::string d_data_secondary_code_string;
std::string d_systemName;
std::string d_signal_type;
std::string d_signal_pretty_name;
std::string d_dump_filename;
std::ofstream d_dump_file;
gr_complex *d_Very_Early;
gr_complex *d_Early;
gr_complex *d_Prompt;
gr_complex *d_Late;
gr_complex *d_Very_Late;
gr_complex d_VE_accu;
gr_complex d_E_accu;
gr_complex d_P_accu;
gr_complex d_P_accu_old;
gr_complex d_L_accu;
gr_complex d_VL_accu;
gr_complex d_P_data_accu;
// nominal signal parameters
double d_signal_carrier_freq;
@ -171,37 +194,17 @@ private:
double d_rem_code_phase_chips;
double d_rem_code_phase_samples;
gr_complex *d_Very_Early;
gr_complex *d_Early;
gr_complex *d_Prompt;
gr_complex *d_Late;
gr_complex *d_Very_Late;
gr_complex d_VE_accu;
gr_complex d_E_accu;
gr_complex d_P_accu;
gr_complex d_P_accu_old;
gr_complex d_L_accu;
gr_complex d_VL_accu;
gr_complex d_P_data_accu;
std::string d_secondary_code_string;
std::string d_data_secondary_code_string;
std::string d_systemName;
std::string d_signal_type;
std::string d_signal_pretty_name;
std::string d_dump_filename;
std::ofstream d_dump_file;
uint64_t d_sample_counter;
uint64_t d_acq_sample_stamp;
float *d_prompt_data_shift;
float d_rem_carr_phase_rad;
uint32_t d_channel;
uint32_t d_secondary_code_length;
uint32_t d_data_secondary_code_length;
int32_t d_symbols_per_bit;
int32_t d_preamble_length_symbols;
int32_t d_state;
int32_t d_correlation_length_ms;
int32_t d_n_correlator_taps;
@ -215,10 +218,6 @@ private:
int32_t d_code_samples_per_chip; // All signals have 1 sample per chip code except Gal. E1 which has 2 (CBOC disabled) or 12 (CBOC enabled)
int32_t d_code_length_chips;
uint32_t d_channel;
uint32_t d_secondary_code_length;
uint32_t d_data_secondary_code_length;
bool d_pull_in_transitory;
bool d_corrected_doppler;
bool d_interchange_iq;