From 71321581edfc040476f2a0267e785b7d9a9b2eed Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 12:59:35 +0100 Subject: [PATCH 01/10] Prefer initialization to assignment in constructors --- .../signal_source/libs/gnss_sdr_timestamp.cc | 20 +-- .../signal_source/libs/gnss_sdr_timestamp.h | 6 +- .../signal_source/libs/gnss_sdr_valve.cc | 4 +- .../gnuradio_blocks/kf_vtl_tracking.cc | 168 ++++++++---------- .../gnuradio_blocks/kf_vtl_tracking.h | 57 +++--- 5 files changed, 120 insertions(+), 135 deletions(-) diff --git a/src/algorithms/signal_source/libs/gnss_sdr_timestamp.cc b/src/algorithms/signal_source/libs/gnss_sdr_timestamp.cc index aba51c296..9ac458c04 100644 --- a/src/algorithms/signal_source/libs/gnss_sdr_timestamp.cc +++ b/src/algorithms/signal_source/libs/gnss_sdr_timestamp.cc @@ -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_make_Timestamp(size_t sizeof_stream bool Gnss_Sdr_Timestamp::read_next_timetag() { - d_timefilestream.read(reinterpret_cast(&next_timetag_samplecount), sizeof(uint64_t)); + d_timefilestream.read(reinterpret_cast(&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; } } diff --git a/src/algorithms/signal_source/libs/gnss_sdr_timestamp.h b/src/algorithms/signal_source/libs/gnss_sdr_timestamp.h index 13f50db1b..6a7f762e2 100644 --- a/src/algorithms/signal_source/libs/gnss_sdr_timestamp.h +++ b/src/algorithms/signal_source/libs/gnss_sdr_timestamp.h @@ -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; }; diff --git a/src/algorithms/signal_source/libs/gnss_sdr_valve.cc b/src/algorithms/signal_source/libs/gnss_sdr_valve.cc index 4866b5bb7..6054af6dd 100644 --- a/src/algorithms/signal_source/libs/gnss_sdr_valve.cc +++ b/src/algorithms/signal_source/libs/gnss_sdr_valve.cc @@ -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; } diff --git a/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc b/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc index 40eeb238b..c4e73a606 100644 --- a/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc +++ b/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.cc @@ -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 #endif -#if HAS_STD_FILESYSTEM -#if HAS_STD_FILESYSTEM_EXPERIMENTAL -#include -namespace fs = std::experimental::filesystem; +#if PMT_USES_BOOST_ANY +#include +namespace wht = boost; #else -#include -namespace fs = std::filesystem; +#include +namespace wht = std; #endif -#else -#include -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(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(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 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(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(pmt::any_ref(msg)); + const int tlm_event = wht::any_cast(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).hash_code()) { - const auto cmd = boost::any_cast>(pmt::any_ref(msg)); - // std::cout << "RX pvt-to-trk cmd with delay: " - // << static_cast(nitems_read(0) - cmd->sample_counter) / d_trk_parameters.fs_in << " [s]\n"; + const auto cmd = wht::any_cast>(pmt::any_ref(msg)); + // std::cout << "RX pvt-to-trk cmd with delay: " + // << static_cast(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(d_carr_phase_error_hz), static_cast(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(d_carr_phase_error_hz), static_cast(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(d_carrier_phase_step_rad * static_cast(d_current_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast(d_current_prn_length_samples) * static_cast(d_current_prn_length_samples)); + d_rem_carr_phase_rad += static_cast(d_carrier_phase_step_rad * static_cast(d_current_prn_length_samples) + + 0.5 * d_carrier_phase_rate_step_rad * static_cast(d_current_prn_length_samples) * static_cast(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(d_current_prn_length_samples); // double b = 0.5 * d_carrier_phase_rate_step_rad * static_cast(d_current_prn_length_samples) * static_cast(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(d_current_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast(d_current_prn_length_samples) * static_cast(d_current_prn_length_samples)); + d_acc_carrier_phase_rad -= (d_carrier_phase_step_rad * static_cast(d_current_prn_length_samples) + + 0.5 * d_carrier_phase_rate_step_rad * static_cast(d_current_prn_length_samples) * static_cast(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(d_carr_phase_error_disc_hz); d_dump_file.write(reinterpret_cast(&tmp_float), sizeof(float)); - tmp_float = static_cast(x_new_new(2)); + tmp_float = static_cast(d_x_new_new(2)); d_dump_file.write(reinterpret_cast(&tmp_float), sizeof(float)); // code estimation tmp_float = static_cast(d_code_error_disc_chips); diff --git a/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.h b/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.h index 76bf0c4c7..e37b6674a 100644 --- a/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.h +++ b/src/algorithms/tracking/gnuradio_blocks/kf_vtl_tracking.h @@ -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; From fdc378c04bd97a1c62c852c92a196dcf27bf04ab Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 13:04:55 +0100 Subject: [PATCH 02/10] Fix error computing the Galileo week --- src/core/system_parameters/galileo_inav_message.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/core/system_parameters/galileo_inav_message.cc b/src/core/system_parameters/galileo_inav_message.cc index 59a579716..e940e18e9 100644 --- a/src/core/system_parameters/galileo_inav_message.cc +++ b/src/core/system_parameters/galileo_inav_message.cc @@ -1016,6 +1016,7 @@ int32_t Galileo_Inav_Message::page_jk_decoder(const char* data_jk) DLOG(INFO) << "E1B_DVS_5= " << E1B_DVS_5; // GST WN_5 = static_cast(read_navigation_unsigned(data_jk_bits, WN_5_BIT)); + WN_0 = WN_5; DLOG(INFO) << "WN_5= " << WN_5; TOW_5 = static_cast(read_navigation_unsigned(data_jk_bits, TOW_5_BIT)); DLOG(INFO) << "TOW_5= " << TOW_5; @@ -1358,6 +1359,7 @@ int32_t Galileo_Inav_Message::page_jk_decoder(const char* data_jk) if (Time_0 == 2) // valid data { WN_0 = static_cast(read_navigation_unsigned(data_jk_bits, WN_0_BIT)); + WN_5 = WN_0; DLOG(INFO) << "WN_0= " << WN_0; TOW_0 = static_cast(read_navigation_unsigned(data_jk_bits, TOW_0_BIT)); flag_TOW_set = true; // set to false externally From 8d9875e8811a9d24c4d43b4b2c2b142b5c196826 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 14:06:37 +0100 Subject: [PATCH 03/10] Prefer initialization to assignment in constructors --- .../adapters/custom_udp_signal_source.cc | 7 ++-- .../adapters/gen_signal_source.cc | 9 ++-- .../spir_gss6450_file_signal_source.cc | 9 ++-- .../gr_complex_ip_packet_source.cc | 41 ++++++++----------- .../gr_complex_ip_packet_source.h | 3 -- .../gnuradio_blocks/labsat23_source.cc | 19 ++++----- .../unpack_spir_gss6450_samples.cc | 11 ++--- 7 files changed, 47 insertions(+), 52 deletions(-) diff --git a/src/algorithms/signal_source/adapters/custom_udp_signal_source.cc b/src/algorithms/signal_source/adapters/custom_udp_signal_source.cc index 6c260438d..2e0b240a5 100644 --- a/src/algorithms/signal_source/adapters/custom_udp_signal_source.cc +++ b/src/algorithms/signal_source/adapters/custom_udp_signal_source.cc @@ -27,7 +27,10 @@ using namespace std::string_literals; CustomUDPSignalSource::CustomUDPSignalSource(const ConfigurationInterface* configuration, const std::string& role, unsigned int in_stream, unsigned int out_stream, Concurrent_Queue* queue __attribute__((unused))) - : SignalSourceBase(configuration, role, "Custom_UDP_Signal_Source"s), in_stream_(in_stream), out_stream_(out_stream) + : SignalSourceBase(configuration, role, "Custom_UDP_Signal_Source"s), + item_size_(sizeof(gr_complex)), + in_stream_(in_stream), + out_stream_(out_stream) { // DUMP PARAMETERS const std::string default_dump_file("./data/signal_source.dat"); @@ -51,8 +54,6 @@ CustomUDPSignalSource::CustomUDPSignalSource(const ConfigurationInterface* confi const std::string default_sample_type("cbyte"); const std::string sample_type = configuration->property(role + ".sample_type", default_sample_type); item_type_ = configuration->property(role + ".item_type", default_item_type); - // output item size is always gr_complex - item_size_ = sizeof(gr_complex); udp_gnss_rx_source_ = Gr_Complex_Ip_Packet_Source::make(capture_device, address, diff --git a/src/algorithms/signal_source/adapters/gen_signal_source.cc b/src/algorithms/signal_source/adapters/gen_signal_source.cc index 06fee3486..db403234c 100644 --- a/src/algorithms/signal_source/adapters/gen_signal_source.cc +++ b/src/algorithms/signal_source/adapters/gen_signal_source.cc @@ -29,11 +29,12 @@ GenSignalSource::GenSignalSource(std::shared_ptr signal_generator, std::shared_ptr filter, std::string role, - Concurrent_Queue *queue __attribute__((unused))) : signal_generator_(std::move(signal_generator)), - filter_(std::move(filter)), - role_(std::move(role)) + Concurrent_Queue *queue __attribute__((unused))) + : signal_generator_(std::move(signal_generator)), + filter_(std::move(filter)), + role_(std::move(role)), + connected_(false) { - connected_ = false; } diff --git a/src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.cc b/src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.cc index 77069bd50..17dcc9205 100644 --- a/src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.cc +++ b/src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.cc @@ -30,11 +30,14 @@ using namespace std::string_literals; SpirGSS6450FileSignalSource::SpirGSS6450FileSignalSource(const ConfigurationInterface* configuration, const std::string& role, uint32_t in_streams, uint32_t out_streams, Concurrent_Queue* queue) - : SignalSourceBase(configuration, role, "Spir_GSS6450_File_Signal_Source"s), in_streams_(in_streams), out_streams_(out_streams) + : SignalSourceBase(configuration, role, "Spir_GSS6450_File_Signal_Source"s), + item_type_("int"), + item_size_(sizeof(int32_t)), + in_streams_(in_streams), + out_streams_(out_streams) { const std::string default_filename("../data/my_capture.dat"); const std::string default_dump_filename("../data/my_capture_dump.dat"); - item_type_ = "int"; samples_ = configuration->property(role + ".samples", static_cast(0)); sampling_frequency_ = configuration->property(role + ".sampling_frequency", static_cast(0)); @@ -47,7 +50,7 @@ SpirGSS6450FileSignalSource::SpirGSS6450FileSignalSource(const ConfigurationInte adc_bits_ = configuration->property(role + ".adc_bits", 4); n_channels_ = configuration->property(role + ".total_channels", 1); sel_ch_ = configuration->property(role + ".sel_ch", 1); - item_size_ = sizeof(int32_t); + const int64_t bytes_seek = configuration->property(role + ".bytes_to_skip", static_cast(65536)); const double sample_size_byte = static_cast(adc_bits_) / 4.0; diff --git a/src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.cc b/src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.cc index 0269dfd33..6cead4e46 100644 --- a/src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.cc +++ b/src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.cc @@ -94,19 +94,27 @@ Gr_Complex_Ip_Packet_Source::make(std::string src_device, Gr_Complex_Ip_Packet_Source::Gr_Complex_Ip_Packet_Source(std::string src_device, __attribute__((unused)) const std::string &origin_address, int udp_port, - int udp_packet_size, + int udp_packet_size __attribute__((unused)), int n_baseband_channels, const std::string &wire_sample_type, size_t item_size, bool IQ_swap_) : gr::sync_block("gr_complex_ip_packet_source", gr::io_signature::make(0, 0, 0), - gr::io_signature::make(1, 4, item_size)) // 1 to 4 baseband complex channels + gr::io_signature::make(1, 4, item_size)), // 1 to 4 baseband complex channels + d_pcap_thread(nullptr), + d_src_device(std::move(src_device)), + descr(nullptr), + fifo_buff(new char[FIFO_SIZE]), + fifo_read_ptr(0), + fifo_write_ptr(0), + fifo_items(0), + d_sock_raw(0), + d_udp_port(udp_port), + d_n_baseband_channels(n_baseband_channels), + d_IQ_swap(IQ_swap_) { - std::cout << "Start Ethernet packet capture\n"; - std::cout << "Overflow events will be indicated by o's\n"; - - d_n_baseband_channels = n_baseband_channels; + memset(reinterpret_cast(&si_me), 0, sizeof(si_me)); if (wire_sample_type == "cbyte") { d_wire_sample_type = 1; @@ -132,24 +140,9 @@ Gr_Complex_Ip_Packet_Source::Gr_Complex_Ip_Packet_Source(std::string src_device, std::cout << "Unknown wire sample type\n"; exit(0); } + std::cout << "Start Ethernet packet capture\n"; + std::cout << "Overflow events will be indicated by o's\n"; std::cout << "d_wire_sample_type:" << d_wire_sample_type << '\n'; - d_src_device = std::move(src_device); - d_udp_port = udp_port; - d_udp_payload_size = udp_packet_size; - d_fifo_full = false; - - // allocate signal samples buffer - fifo_buff = new char[FIFO_SIZE]; - fifo_read_ptr = 0; - fifo_write_ptr = 0; - fifo_items = 0; - d_item_size = item_size; - d_IQ_swap = IQ_swap_; - d_sock_raw = 0; - d_pcap_thread = nullptr; - descr = nullptr; - - memset(reinterpret_cast(&si_me), 0, sizeof(si_me)); } @@ -230,7 +223,7 @@ Gr_Complex_Ip_Packet_Source::~Gr_Complex_Ip_Packet_Source() { delete d_pcap_thread; } - delete fifo_buff; + delete[] fifo_buff; std::cout << "Stop Ethernet packet capture\n"; } diff --git a/src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.h b/src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.h index fc3a39da3..c24ee5417 100644 --- a/src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.h +++ b/src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.h @@ -90,19 +90,16 @@ private: std::string d_src_device; std::string d_origin_address; pcap_t *descr; // ethernet pcap device descriptor - size_t d_item_size; char *fifo_buff; int fifo_read_ptr; int fifo_write_ptr; int fifo_items; int d_sock_raw; int d_udp_port; - int d_udp_payload_size; int d_n_baseband_channels; int d_wire_sample_type; int d_bytes_per_sample; bool d_IQ_swap; - bool d_fifo_full; }; diff --git a/src/algorithms/signal_source/gnuradio_blocks/labsat23_source.cc b/src/algorithms/signal_source/gnuradio_blocks/labsat23_source.cc index 331141428..ea92274f3 100644 --- a/src/algorithms/signal_source/gnuradio_blocks/labsat23_source.cc +++ b/src/algorithms/signal_source/gnuradio_blocks/labsat23_source.cc @@ -45,18 +45,17 @@ labsat23_source::labsat23_source(const char *signal_file_basename, bool digital_io_enabled) : gr::block("labsat23_source", gr::io_signature::make(0, 0, 0), gr::io_signature::make(1, 3, sizeof(gr_complex))), - d_queue(queue) + d_queue(queue), + d_channel_selector_config(channel_selector), + d_current_file_number(0), + d_labsat_version(0), + d_channel_selector(0), + d_ref_clock(0), + d_bits_per_sample(0), + d_header_parsed(false), + d_ls3w_digital_io_enabled(digital_io_enabled) { - d_channel_selector_config = channel_selector; - d_header_parsed = false; - d_bits_per_sample = 0; - d_current_file_number = 0; - d_labsat_version = 0; - d_ref_clock = 0; - d_channel_selector = 0; d_signal_file_basename = std::string(signal_file_basename); - d_ls3w_digital_io_enabled = digital_io_enabled; - std::string signal_file; this->set_output_multiple(8); signal_file = generate_filename(); diff --git a/src/algorithms/signal_source/gnuradio_blocks/unpack_spir_gss6450_samples.cc b/src/algorithms/signal_source/gnuradio_blocks/unpack_spir_gss6450_samples.cc index d5e0070c9..4e8687bae 100644 --- a/src/algorithms/signal_source/gnuradio_blocks/unpack_spir_gss6450_samples.cc +++ b/src/algorithms/signal_source/gnuradio_blocks/unpack_spir_gss6450_samples.cc @@ -26,12 +26,13 @@ unpack_spir_gss6450_samples_sptr make_unpack_spir_gss6450_samples(int adc_nbit_) } -unpack_spir_gss6450_samples::unpack_spir_gss6450_samples(int adc_nbit) : gr::sync_interpolator("unpack_spir_gss6450_samples", - gr::io_signature::make(1, 1, sizeof(int32_t)), - gr::io_signature::make(1, 1, sizeof(gr_complex)), 16 / adc_nbit) +unpack_spir_gss6450_samples::unpack_spir_gss6450_samples(int adc_nbit) + : gr::sync_interpolator("unpack_spir_gss6450_samples", + gr::io_signature::make(1, 1, sizeof(int32_t)), + gr::io_signature::make(1, 1, sizeof(gr_complex)), 16 / adc_nbit), + adc_bits(adc_nbit), + samples_per_int(16 / adc_bits) { - adc_bits = adc_nbit; - samples_per_int = 16 / adc_bits; } From 47024cc283ccd45d43ad8554d3b90f329bd9f69d Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 15:27:57 +0100 Subject: [PATCH 04/10] Prefer initialization to assignment in constructors --- src/core/libs/INIReader.cc | 2 +- src/core/libs/channel_event.cc | 4 +- src/core/libs/command_event.cc | 4 +- src/core/libs/gnss_sdr_fpga_sample_counter.cc | 39 ++++++++++--------- src/core/libs/gnss_sdr_sample_counter.cc | 37 +++++++++--------- src/core/libs/gnss_sdr_supl_client.cc | 7 +--- src/core/libs/gnss_sdr_time_counter.cc | 25 ++++++------ 7 files changed, 58 insertions(+), 60 deletions(-) diff --git a/src/core/libs/INIReader.cc b/src/core/libs/INIReader.cc index 440a1fd75..c7eb2a073 100644 --- a/src/core/libs/INIReader.cc +++ b/src/core/libs/INIReader.cc @@ -33,8 +33,8 @@ INIReader::INIReader(const std::string& filename) + : _error(ini_parse(filename.c_str(), ValueHandler, this)) { - _error = ini_parse(filename.c_str(), ValueHandler, this); } diff --git a/src/core/libs/channel_event.cc b/src/core/libs/channel_event.cc index 818d25a7d..b23b004da 100644 --- a/src/core/libs/channel_event.cc +++ b/src/core/libs/channel_event.cc @@ -22,7 +22,7 @@ channel_event_sptr channel_event_make(int channel_id, int event_type) } Channel_Event::Channel_Event(int channel_id_, int event_type_) + : channel_id(channel_id_), + event_type(event_type_) { - channel_id = channel_id_; - event_type = event_type_; } diff --git a/src/core/libs/command_event.cc b/src/core/libs/command_event.cc index 9a4cc539f..1f5bdfcfd 100644 --- a/src/core/libs/command_event.cc +++ b/src/core/libs/command_event.cc @@ -22,7 +22,7 @@ command_event_sptr command_event_make(int command_id, int event_type) } Command_Event::Command_Event(int command_id_, int event_type_) + : command_id(command_id_), + event_type(event_type_) { - command_id = command_id_; - event_type = event_type_; } diff --git a/src/core/libs/gnss_sdr_fpga_sample_counter.cc b/src/core/libs/gnss_sdr_fpga_sample_counter.cc index 57bd274ed..a36540e92 100644 --- a/src/core/libs/gnss_sdr_fpga_sample_counter.cc +++ b/src/core/libs/gnss_sdr_fpga_sample_counter.cc @@ -46,30 +46,31 @@ gnss_sdr_fpga_sample_counter::gnss_sdr_fpga_sample_counter( double _fs, - int32_t _interval_ms) : gr::block("fpga_fpga_sample_counter", - gr::io_signature::make(0, 0, 0), - gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) + int32_t _interval_ms) + : gr::block("fpga_fpga_sample_counter", + gr::io_signature::make(0, 0, 0), + gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))), + fs(_fs), + sample_counter(0ULL), + last_sample_counter(0ULL), + current_T_rx_ms(0), + interval_ms(_interval_ms), + current_s(0), + current_m(0), + current_h(0), + current_days(0), + report_interval_ms(1000), // default reporting 1 second + flag_enable_send_msg(false), // enable it for reporting time with asynchronous message + flag_m(false), + flag_h(false), + flag_days(false), + is_open(true) { message_port_register_out(pmt::mp("fpga_sample_counter")); set_max_noutput_items(1); - interval_ms = _interval_ms; - fs = _fs; samples_per_output = std::round(fs * static_cast(interval_ms) / 1e3); - open_device(); - is_open = true; - sample_counter = 0ULL; - last_sample_counter = 0ULL; - current_T_rx_ms = 0; - current_s = 0; - current_m = 0; - current_h = 0; - current_days = 0; - report_interval_ms = 1000; // default reporting 1 second samples_per_report = std::round(fs * static_cast(report_interval_ms) / 1e3); - flag_enable_send_msg = false; // enable it for reporting time with asynchronous message - flag_m = false; - flag_h = false; - flag_days = false; + open_device(); } diff --git a/src/core/libs/gnss_sdr_sample_counter.cc b/src/core/libs/gnss_sdr_sample_counter.cc index 05ff03745..8a607ba50 100644 --- a/src/core/libs/gnss_sdr_sample_counter.cc +++ b/src/core/libs/gnss_sdr_sample_counter.cc @@ -31,27 +31,28 @@ gnss_sdr_sample_counter::gnss_sdr_sample_counter( double _fs, int32_t _interval_ms, - size_t _size) : gr::sync_decimator("sample_counter", - gr::io_signature::make(1, 1, _size), - gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)), - static_cast(std::round(_fs * static_cast(_interval_ms) / 1e3))) + size_t _size) + : gr::sync_decimator("sample_counter", + gr::io_signature::make(1, 1, _size), + gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)), + static_cast(std::round(_fs * static_cast(_interval_ms) / 1e3))), + fs(_fs), + current_T_rx_ms(0), + sample_counter(0), + interval_ms(_interval_ms), + report_interval_ms(1000), // default reporting 1 second + samples_per_output(std::round(fs * static_cast(interval_ms) / 1e3)), + current_s(0), + current_m(0), + current_h(0), + current_days(0), + flag_m(false), + flag_h(false), + flag_days(false), + flag_enable_send_msg(false) // enable it for reporting time with asynchronous message { message_port_register_out(pmt::mp("sample_counter")); set_max_noutput_items(1); - interval_ms = _interval_ms; - fs = _fs; - samples_per_output = std::round(fs * static_cast(interval_ms) / 1e3); - sample_counter = 0; - current_T_rx_ms = 0; - current_s = 0; - current_m = 0; - current_h = 0; - current_days = 0; - report_interval_ms = 1000; // default reporting 1 second - flag_enable_send_msg = false; // enable it for reporting time with asynchronous message - flag_m = false; - flag_h = false; - flag_days = false; set_tag_propagation_policy(TPP_DONT); // no tag propagation, the time tag will be adjusted and regenerated in work() } diff --git a/src/core/libs/gnss_sdr_supl_client.cc b/src/core/libs/gnss_sdr_supl_client.cc index d09b3c099..10dda2be4 100644 --- a/src/core/libs/gnss_sdr_supl_client.cc +++ b/src/core/libs/gnss_sdr_supl_client.cc @@ -31,15 +31,10 @@ #include Gnss_Sdr_Supl_Client::Gnss_Sdr_Supl_Client() + : server_port(0), request(0), mcc(0), mns(0), lac(0), ci(0) { - mcc = 0; - mns = 0; - lac = 0; - ci = 0; supl_ctx_new(&ctx); assist = supl_assist_t(); - server_port = 0; - request = 0; } diff --git a/src/core/libs/gnss_sdr_time_counter.cc b/src/core/libs/gnss_sdr_time_counter.cc index 434f9aad9..06d87f2fa 100644 --- a/src/core/libs/gnss_sdr_time_counter.cc +++ b/src/core/libs/gnss_sdr_time_counter.cc @@ -21,20 +21,21 @@ #include #include -gnss_sdr_time_counter::gnss_sdr_time_counter() : gr::block("time_counter", - gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)), - gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))) +gnss_sdr_time_counter::gnss_sdr_time_counter() + : gr::block("time_counter", + gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)), + gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))), + current_T_rx_ms(0), + report_interval_ms(1000), // default reporting 1 second + current_s(0), + current_m(0), + current_h(0), + current_days(0), + flag_m(false), + flag_h(false), + flag_days(false) { set_max_noutput_items(1); - current_T_rx_ms = 0; - current_s = 0; - current_m = 0; - current_h = 0; - current_days = 0; - report_interval_ms = 1000; // default reporting 1 second - flag_m = false; - flag_h = false; - flag_days = false; } From 2c7bead089ad807364305b96f7d1797a3dcb37fb Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 17:03:29 +0100 Subject: [PATCH 05/10] Prefer initialization to assignment in constructors --- src/core/monitor/gnss_synchro_monitor.cc | 12 ++++++------ src/core/monitor/gnss_synchro_udp_sink.cc | 7 +++++-- src/core/receiver/control_thread.cc | 16 ++++++++-------- src/core/receiver/file_configuration.cc | 4 ++-- src/core/receiver/gnss_flowgraph.cc | 15 ++++++++------- src/core/receiver/tcp_cmd_interface.cc | 10 +++++----- src/core/system_parameters/gnss_signal.cc | 6 +++--- 7 files changed, 37 insertions(+), 33 deletions(-) diff --git a/src/core/monitor/gnss_synchro_monitor.cc b/src/core/monitor/gnss_synchro_monitor.cc index 2f0d7ca96..502a5ed48 100644 --- a/src/core/monitor/gnss_synchro_monitor.cc +++ b/src/core/monitor/gnss_synchro_monitor.cc @@ -42,13 +42,13 @@ gnss_synchro_monitor::gnss_synchro_monitor(int n_channels, int decimation_factor, int udp_port, const std::vector& udp_addresses, - bool enable_protobuf) : gr::block("gnss_synchro_monitor", - gr::io_signature::make(n_channels, n_channels, sizeof(Gnss_Synchro)), - gr::io_signature::make(0, 0, 0)) + bool enable_protobuf) + : gr::block("gnss_synchro_monitor", + gr::io_signature::make(n_channels, n_channels, sizeof(Gnss_Synchro)), + gr::io_signature::make(0, 0, 0)), + d_nchannels(n_channels), + d_decimation_factor(decimation_factor) { - d_decimation_factor = decimation_factor; - d_nchannels = n_channels; - udp_sink_ptr = std::make_unique(udp_addresses, udp_port, enable_protobuf); } diff --git a/src/core/monitor/gnss_synchro_udp_sink.cc b/src/core/monitor/gnss_synchro_udp_sink.cc index 3eb61578d..ca613d460 100644 --- a/src/core/monitor/gnss_synchro_udp_sink.cc +++ b/src/core/monitor/gnss_synchro_udp_sink.cc @@ -21,9 +21,12 @@ #include #include -Gnss_Synchro_Udp_Sink::Gnss_Synchro_Udp_Sink(const std::vector& addresses, const uint16_t& port, bool enable_protobuf) : socket{io_context} +Gnss_Synchro_Udp_Sink::Gnss_Synchro_Udp_Sink(const std::vector& addresses, + const uint16_t& port, + bool enable_protobuf) + : socket{io_context}, + use_protobuf(enable_protobuf) { - use_protobuf = enable_protobuf; if (enable_protobuf) { serdes = Serdes_Gnss_Synchro(); diff --git a/src/core/receiver/control_thread.cc b/src/core/receiver/control_thread.cc index cac176f7f..5b0448799 100644 --- a/src/core/receiver/control_thread.cc +++ b/src/core/receiver/control_thread.cc @@ -129,15 +129,15 @@ ControlThread::ControlThread() ControlThread::ControlThread(std::shared_ptr configuration) + : configuration_(std::move(configuration)), + well_formatted_configuration_(true), + conf_file_has_section_(true), + conf_file_has_mandatory_globals_(true), + conf_has_signal_sources_(true), + conf_has_observables_(true), + conf_has_pvt_(true), + restart_(false) { - configuration_ = std::move(configuration); - conf_file_has_section_ = true; - conf_file_has_mandatory_globals_ = true; - conf_has_signal_sources_ = true; - conf_has_observables_ = true; - conf_has_pvt_ = true; - well_formatted_configuration_ = true; - restart_ = false; init(); } diff --git a/src/core/receiver/file_configuration.cc b/src/core/receiver/file_configuration.cc index 9828a332d..659895934 100644 --- a/src/core/receiver/file_configuration.cc +++ b/src/core/receiver/file_configuration.cc @@ -27,15 +27,15 @@ FileConfiguration::FileConfiguration(std::string filename) + : filename_(std::move(filename)) { - filename_ = std::move(filename); init(); } FileConfiguration::FileConfiguration() + : filename_("./default_config_file.txt") { - filename_ = "./default_config_file.txt"; init(); } diff --git a/src/core/receiver/gnss_flowgraph.cc b/src/core/receiver/gnss_flowgraph.cc index 3a15b03a0..17292c3f4 100644 --- a/src/core/receiver/gnss_flowgraph.cc +++ b/src/core/receiver/gnss_flowgraph.cc @@ -69,14 +69,15 @@ #define GNSS_SDR_ARRAY_SIGNAL_CONDITIONER_CHANNELS 8 -GNSSFlowgraph::GNSSFlowgraph(std::shared_ptr configuration, std::shared_ptr> queue) // NOLINT(performance-unnecessary-value-param) +GNSSFlowgraph::GNSSFlowgraph(std::shared_ptr configuration, + std::shared_ptr> queue) // NOLINT(performance-unnecessary-value-param) + : configuration_(std::move(configuration)), + queue_(std::move(queue)), + connected_(false), + running_(false), + multiband_(GNSSFlowgraph::is_multiband()), + enable_e6_has_rx_(false) { - connected_ = false; - running_ = false; - enable_e6_has_rx_ = false; - configuration_ = std::move(configuration); - queue_ = std::move(queue); - multiband_ = GNSSFlowgraph::is_multiband(); enable_fpga_offloading_ = configuration_->property("GNSS-SDR.enable_FPGA", false); init(); } diff --git a/src/core/receiver/tcp_cmd_interface.cc b/src/core/receiver/tcp_cmd_interface.cc index d18a2da62..1a47fb269 100644 --- a/src/core/receiver/tcp_cmd_interface.cc +++ b/src/core/receiver/tcp_cmd_interface.cc @@ -32,14 +32,14 @@ using b_io_context = boost::asio::io_service; #endif TcpCmdInterface::TcpCmdInterface() + : rx_latitude_(0.0), + rx_longitude_(0.0), + rx_altitude_(0.0), + receiver_utc_time_(0), + keep_running_(true) { register_functions(); - keep_running_ = true; control_queue_ = nullptr; - rx_latitude_ = 0.0; - rx_longitude_ = 0.0; - rx_altitude_ = 0.0; - receiver_utc_time_ = 0; } diff --git a/src/core/system_parameters/gnss_signal.cc b/src/core/system_parameters/gnss_signal.cc index f815edd5c..45d54a434 100644 --- a/src/core/system_parameters/gnss_signal.cc +++ b/src/core/system_parameters/gnss_signal.cc @@ -19,15 +19,15 @@ Gnss_Signal::Gnss_Signal(const std::string& signal_) + : signal(signal_) { - this->signal = signal_; } Gnss_Signal::Gnss_Signal(const Gnss_Satellite& satellite_, const std::string& signal_) + : satellite(satellite_), + signal(signal_) { - this->satellite = satellite_; - this->signal = signal_; } From ccbfc2a8efc836c0c2ad21ae535e7fd566ffc395 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 17:22:05 +0100 Subject: [PATCH 06/10] Prefer initialization to assignment in constructors --- ...lileo_e1_pcps_8ms_ambiguous_acquisition.cc | 19 +++++++++--------- ...eo_e1_pcps_cccwsr_ambiguous_acquisition.cc | 20 +++++++++---------- ...e1_pcps_quicksync_ambiguous_acquisition.cc | 19 +++++++++--------- ...ileo_e1_pcps_tong_ambiguous_acquisition.cc | 18 ++++++++--------- ...ileo_e5a_noncoherent_iq_acquisition_caf.cc | 18 ++++++++--------- .../gps_l1_ca_pcps_quicksync_acquisition.cc | 18 ++++++++--------- .../gps_l1_ca_pcps_tong_acquisition.cc | 18 ++++++++--------- 7 files changed, 66 insertions(+), 64 deletions(-) diff --git a/src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc index 69fae3408..a4e884c6f 100644 --- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc @@ -36,11 +36,16 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition( const ConfigurationInterface* configuration, const std::string& role, unsigned int in_streams, - unsigned int out_streams) : role_(role), - in_streams_(in_streams), - out_streams_(out_streams) + unsigned int out_streams) + : configuration_(configuration), + gnss_synchro_(nullptr), + role_(role), + threshold_(0.0), + channel_(0), + doppler_step_(0), + in_streams_(in_streams), + out_streams_(out_streams) { - configuration_ = configuration; const std::string default_item_type("gr_complex"); const std::string default_dump_filename("../data/acquisition.dat"); @@ -53,6 +58,7 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition( fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); dump_ = configuration_->property(role + ".dump", false); doppler_max_ = configuration_->property(role + ".doppler_max", 5000); + if (FLAGS_doppler_max != 0) { doppler_max_ = FLAGS_doppler_max; @@ -102,11 +108,6 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition( LOG(WARNING) << item_type_ << " unknown acquisition item type"; } - channel_ = 0; - threshold_ = 0.0; - doppler_step_ = 0; - gnss_synchro_ = nullptr; - if (in_streams_ > 1) { LOG(ERROR) << "This implementation only supports one input stream"; diff --git a/src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc index 5eabdb135..747cc57e5 100644 --- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc @@ -28,11 +28,16 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition const ConfigurationInterface* configuration, const std::string& role, unsigned int in_streams, - unsigned int out_streams) : role_(role), - in_streams_(in_streams), - out_streams_(out_streams) + unsigned int out_streams) + : configuration_(configuration), + role_(role), + gnss_synchro_(nullptr), + threshold_(0.0), + channel_(0), + doppler_step_(0), + in_streams_(in_streams), + out_streams_(out_streams) { - configuration_ = configuration; const std::string default_item_type("gr_complex"); const std::string default_dump_filename("../data/acquisition.dat"); @@ -44,6 +49,7 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); dump_ = configuration_->property(role + ".dump", false); doppler_max_ = configuration_->property(role + ".doppler_max", 5000); + if (FLAGS_doppler_max != 0) { doppler_max_ = FLAGS_doppler_max; @@ -64,7 +70,6 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition default_dump_filename); // -- Find number of samples per spreading code (4 ms) ----------------- - code_length_ = static_cast(round( fs_in_ / (GALILEO_E1_CODE_CHIP_RATE_CPS / GALILEO_E1_B_CODE_LENGTH_CHIPS))); @@ -95,11 +100,6 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition LOG(WARNING) << item_type_ << " unknown acquisition item type"; } - channel_ = 0; - threshold_ = 0.0; - doppler_step_ = 0; - gnss_synchro_ = nullptr; - if (in_streams_ > 1) { LOG(ERROR) << "This implementation only supports one input stream"; diff --git a/src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc index 501db7689..2ea421377 100644 --- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc @@ -36,11 +36,16 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui const ConfigurationInterface* configuration, const std::string& role, unsigned int in_streams, - unsigned int out_streams) : role_(role), - in_streams_(in_streams), - out_streams_(out_streams) + unsigned int out_streams) + : configuration_(configuration), + role_(role), + gnss_synchro_(nullptr), + threshold_(0.0), + channel_(0), + doppler_step_(0), + in_streams_(in_streams), + out_streams_(out_streams) { - configuration_ = configuration; const std::string default_item_type("gr_complex"); const std::string default_dump_filename("../data/acquisition.dat"); @@ -53,6 +58,7 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui fs_in_ = configuration_->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated); dump_ = configuration_->property(role + ".dump", false); doppler_max_ = configuration_->property(role + ".doppler_max", 5000); + if (FLAGS_doppler_max != 0) { doppler_max_ = FLAGS_doppler_max; @@ -136,11 +142,6 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui LOG(WARNING) << item_type_ << " unknown acquisition item type"; } - channel_ = 0; - threshold_ = 0.0; - doppler_step_ = 0; - gnss_synchro_ = nullptr; - if (in_streams_ > 1) { LOG(ERROR) << "This implementation only supports one input stream"; diff --git a/src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc index 83072a4dd..006159c74 100644 --- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc @@ -36,11 +36,16 @@ GalileoE1PcpsTongAmbiguousAcquisition::GalileoE1PcpsTongAmbiguousAcquisition( const ConfigurationInterface* configuration, const std::string& role, unsigned int in_streams, - unsigned int out_streams) : role_(role), - in_streams_(in_streams), - out_streams_(out_streams) + unsigned int out_streams) + : configuration_(configuration), + gnss_synchro_(nullptr), + role_(role), + threshold_(0.0), + channel_(0), + doppler_step_(0), + in_streams_(in_streams), + out_streams_(out_streams) { - configuration_ = configuration; const std::string default_item_type("gr_complex"); const std::string default_dump_filename("../data/acquisition.dat"); @@ -106,11 +111,6 @@ GalileoE1PcpsTongAmbiguousAcquisition::GalileoE1PcpsTongAmbiguousAcquisition( LOG(WARNING) << item_type_ << " unknown acquisition item type"; } - channel_ = 0; - threshold_ = 0.0; - doppler_step_ = 0; - gnss_synchro_ = nullptr; - if (in_streams_ > 1) { LOG(ERROR) << "This implementation only supports one input stream"; diff --git a/src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc b/src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc index 60fc1c031..2873c43c6 100644 --- a/src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc +++ b/src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc @@ -42,11 +42,16 @@ GalileoE5aNoncoherentIQAcquisitionCaf::GalileoE5aNoncoherentIQAcquisitionCaf( const ConfigurationInterface* configuration, const std::string& role, unsigned int in_streams, - unsigned int out_streams) : role_(role), - in_streams_(in_streams), - out_streams_(out_streams) + unsigned int out_streams) + : configuration_(configuration), + role_(role), + gnss_synchro_(nullptr), + threshold_(0.0), + channel_(0), + doppler_step_(0), + in_streams_(in_streams), + out_streams_(out_streams) { - configuration_ = configuration; const std::string default_item_type("gr_complex"); const std::string default_dump_filename("../data/acquisition.dat"); @@ -111,11 +116,6 @@ GalileoE5aNoncoherentIQAcquisitionCaf::GalileoE5aNoncoherentIQAcquisitionCaf( LOG(WARNING) << item_type_ << " unknown acquisition item type"; } - channel_ = 0; - threshold_ = 0.0; - doppler_step_ = 0; - gnss_synchro_ = nullptr; - if (in_streams_ > 1) { LOG(ERROR) << "This implementation only supports one input stream"; diff --git a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc index ed2366907..56f544d86 100644 --- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc @@ -37,11 +37,16 @@ GpsL1CaPcpsQuickSyncAcquisition::GpsL1CaPcpsQuickSyncAcquisition( const ConfigurationInterface* configuration, const std::string& role, unsigned int in_streams, - unsigned int out_streams) : role_(role), - in_streams_(in_streams), - out_streams_(out_streams) + unsigned int out_streams) + : configuration_(configuration), + role_(role), + gnss_synchro_(nullptr), + threshold_(0.0), + channel_(0), + doppler_step_(0), + in_streams_(in_streams), + out_streams_(out_streams) { - configuration_ = configuration; const std::string default_item_type("gr_complex"); std::string default_dump_filename = "./data/acquisition.dat"; @@ -129,11 +134,6 @@ GpsL1CaPcpsQuickSyncAcquisition::GpsL1CaPcpsQuickSyncAcquisition( LOG(WARNING) << item_type_ << " unknown acquisition item type"; } - channel_ = 0; - threshold_ = 0.0; - doppler_step_ = 0; - gnss_synchro_ = nullptr; - if (in_streams_ > 1) { LOG(ERROR) << "This implementation only supports one input stream"; diff --git a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc index d120d9877..d7b71ef97 100644 --- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc +++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc @@ -36,11 +36,16 @@ GpsL1CaPcpsTongAcquisition::GpsL1CaPcpsTongAcquisition( const ConfigurationInterface* configuration, const std::string& role, unsigned int in_streams, - unsigned int out_streams) : role_(role), - in_streams_(in_streams), - out_streams_(out_streams) + unsigned int out_streams) + : configuration_(configuration), + gnss_synchro_(nullptr), + role_(role), + threshold_(0.0), + channel_(0), + doppler_step_(0), + in_streams_(in_streams), + out_streams_(out_streams) { - configuration_ = configuration; const std::string default_item_type("gr_complex"); std::string default_dump_filename = "./data/acquisition.dat"; @@ -91,11 +96,6 @@ GpsL1CaPcpsTongAcquisition::GpsL1CaPcpsTongAcquisition( LOG(WARNING) << item_type_ << " unknown acquisition item type"; } - channel_ = 0; - threshold_ = 0.0; - doppler_step_ = 0; - gnss_synchro_ = nullptr; - if (in_streams_ > 1) { LOG(ERROR) << "This implementation only supports one input stream"; From 158abd06db3db09ccdace3fe91ad7711456c6982 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 17:28:04 +0100 Subject: [PATCH 07/10] Prefer initialization to assignment in constructors --- .../observables/gnuradio_blocks/hybrid_observables_gs.cc | 7 ++++--- .../observables/gnuradio_blocks/hybrid_observables_gs.h | 4 ++-- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc index e533c3ef0..0ca0fc3a8 100644 --- a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc +++ b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc @@ -63,6 +63,7 @@ hybrid_observables_gs::hybrid_observables_gs(const Obs_Conf &conf_) d_dump_filename(conf_.dump_filename), d_smooth_filter_M(static_cast(conf_.smoothing_factor)), d_T_rx_step_s(static_cast(conf_.observable_interval_ms) / 1000.0), + d_last_rx_clock_round20ms_error(0.0), d_T_rx_TOW_ms(0U), d_T_rx_step_ms(conf_.observable_interval_ms), d_T_status_report_timer_ms(0), @@ -113,7 +114,7 @@ hybrid_observables_gs::hybrid_observables_gs(const Obs_Conf &conf_) d_SourceTagTimestamps = std::vector>(d_nchannels_out); - last_rx_clock_round20ms_error = 0; + set_tag_propagation_policy(TPP_DONT); // no tag propagation, the time tag will be adjusted and regenerated in work() // ############# ENABLE DATA FILE LOG ################# @@ -216,7 +217,7 @@ void hybrid_observables_gs::msg_handler_pvt_to_observables(const pmt::pmt_t &msg { d_T_rx_TOW_ms += d_T_rx_step_ms - d_T_rx_TOW_ms % d_T_rx_step_ms; } - last_rx_clock_round20ms_error = static_cast(d_T_rx_TOW_ms) - old_tow_corrected; + d_last_rx_clock_round20ms_error = static_cast(d_T_rx_TOW_ms) - old_tow_corrected; // d_Rx_clock_buffer.clear(); // Clear all the elements in the buffer for (uint32_t n = 0; n < d_nchannels_out; n++) { @@ -659,7 +660,7 @@ void hybrid_observables_gs::set_tag_timestamp_in_sdr_timeframe(const std::vector // << "] OBS RX TimeTag Week: " << current_tag.week // << ", TOW: " << current_tag.tow_ms // << " [ms], TOW fraction: " << current_tag.tow_ms_fraction - // << " [ms], DELTA TLM TOW: " << last_rx_clock_round20ms_error + delta_rxtime_to_tag * 1000.0 + static_cast(current_tag.tow_ms) - static_cast(d_T_rx_TOW_ms) + current_tag.tow_ms_fraction << " [ms] \n"; + // << " [ms], DELTA TLM TOW: " << d_last_rx_clock_round20ms_error + delta_rxtime_to_tag * 1000.0 + static_cast(current_tag.tow_ms) - static_cast(d_T_rx_TOW_ms) + current_tag.tow_ms_fraction << " [ms] \n"; const std::shared_ptr tmp_obj = std::make_shared(GnssTime()); *tmp_obj = current_tag; double intpart; diff --git a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.h b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.h index b0d323a07..8ec473259 100644 --- a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.h +++ b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.h @@ -118,9 +118,9 @@ private: double d_smooth_filter_M; double d_T_rx_step_s; - + double d_last_rx_clock_round20ms_error; + uint32_t d_T_rx_TOW_ms; - double last_rx_clock_round20ms_error; uint32_t d_T_rx_step_ms; uint32_t d_T_status_report_timer_ms; uint32_t d_nchannels_in; From 7fa437232ae670ccffb67c0b848528cad546ea04 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 17:34:35 +0100 Subject: [PATCH 08/10] Prefer initialization to assignment in constructors --- .../signal_source/libs/fpga_buffer_monitor.cc | 18 +++++++++--------- .../signal_source/libs/fpga_buffer_monitor.h | 5 +++-- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/src/algorithms/signal_source/libs/fpga_buffer_monitor.cc b/src/algorithms/signal_source/libs/fpga_buffer_monitor.cc index e98988137..0f97b93a7 100644 --- a/src/algorithms/signal_source/libs/fpga_buffer_monitor.cc +++ b/src/algorithms/signal_source/libs/fpga_buffer_monitor.cc @@ -34,12 +34,16 @@ #include // for move -Fpga_buffer_monitor::Fpga_buffer_monitor(const std::string &device_name, uint32_t num_freq_bands, bool dump, std::string dump_filename) +Fpga_buffer_monitor::Fpga_buffer_monitor(const std::string &device_name, + uint32_t num_freq_bands, + bool dump, + std::string dump_filename) + : d_dump_filename(std::move(dump_filename)), + d_num_freq_bands(num_freq_bands), + d_max_buff_occ_freq_band_0(0), + d_max_buff_occ_freq_band_1(0), + d_dump(dump) { - d_num_freq_bands = num_freq_bands; - d_dump = dump; - d_dump_filename = std::move(dump_filename); - // open device descriptor if ((d_device_descriptor = open(device_name.c_str(), O_RDWR | O_SYNC)) == -1) { @@ -69,10 +73,6 @@ Fpga_buffer_monitor::Fpga_buffer_monitor(const std::string &device_name, uint32_ DLOG(INFO) << "FPGA buffer monitor class created"; - // initialize maximum buffer occupancy in case buffer monitoring is enabled - d_max_buff_occ_freq_band_0 = 0; - d_max_buff_occ_freq_band_1 = 0; - if (d_dump) { std::string dump_path; diff --git a/src/algorithms/signal_source/libs/fpga_buffer_monitor.h b/src/algorithms/signal_source/libs/fpga_buffer_monitor.h index 88d589d8a..a58aa6c31 100644 --- a/src/algorithms/signal_source/libs/fpga_buffer_monitor.h +++ b/src/algorithms/signal_source/libs/fpga_buffer_monitor.h @@ -81,6 +81,9 @@ private: int32_t buffer_monitor_test_register(); void close_device(); + std::string d_dump_filename; + std::ofstream d_dump_file; + volatile unsigned* d_map_base; // driver memory map corresponding to the FPGA buffer monitor int d_device_descriptor; // driver descriptor corresponding to the FPGA buffer monitor @@ -90,8 +93,6 @@ private: uint32_t d_max_buff_occ_freq_band_1; bool d_dump; - std::string d_dump_filename; - std::ofstream d_dump_file; }; From 2f04da621d050e9efce7602508636aff521be651 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 17:36:12 +0100 Subject: [PATCH 09/10] Prefer initialization to assignment in constructors --- .../conditioner/adapters/array_signal_conditioner.cc | 4 ++-- src/algorithms/conditioner/adapters/signal_conditioner.cc | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/algorithms/conditioner/adapters/array_signal_conditioner.cc b/src/algorithms/conditioner/adapters/array_signal_conditioner.cc index a22987aaf..206d76793 100644 --- a/src/algorithms/conditioner/adapters/array_signal_conditioner.cc +++ b/src/algorithms/conditioner/adapters/array_signal_conditioner.cc @@ -28,9 +28,9 @@ ArraySignalConditioner::ArraySignalConditioner(std::shared_ptr data_ty std::string role) : data_type_adapt_(std::move(data_type_adapt)), in_filt_(std::move(in_filt)), res_(std::move(res)), - role_(std::move(role)) + role_(std::move(role)), + connected_(false) { - connected_ = false; } From 31592f7eb388cbe32eae83ab67700f5699d72c61 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 14 Dec 2021 17:41:18 +0100 Subject: [PATCH 10/10] Prefer initialization to assignment in constructors --- src/algorithms/channel/libs/channel_fsm.cc | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/algorithms/channel/libs/channel_fsm.cc b/src/algorithms/channel/libs/channel_fsm.cc index aa2442630..48f001238 100644 --- a/src/algorithms/channel/libs/channel_fsm.cc +++ b/src/algorithms/channel/libs/channel_fsm.cc @@ -22,21 +22,22 @@ #include ChannelFsm::ChannelFsm() + : queue_(nullptr), + channel_(0U), + state_(0U) { acq_ = nullptr; trk_ = nullptr; - channel_ = 0U; - state_ = 0U; - queue_ = nullptr; } -ChannelFsm::ChannelFsm(std::shared_ptr acquisition) : acq_(std::move(acquisition)) +ChannelFsm::ChannelFsm(std::shared_ptr acquisition) + : acq_(std::move(acquisition)), + queue_(nullptr), + channel_(0U), + state_(0U) { trk_ = nullptr; - channel_ = 0U; - state_ = 0U; - queue_ = nullptr; }