From f1022385b07e102a5b6cc7a1a5c39aa6a7d87ab9 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Mon, 1 Jul 2019 21:54:52 +0200 Subject: [PATCH] Improve memory management In class definitions, first write the public interface, then private --- ...eo_e5a_noncoherent_iq_acquisition_caf_cc.h | 166 ++++++------ .../galileo_pcps_8ms_acquisition_cc.h | 122 ++++----- .../gnuradio_blocks/pcps_acquisition.cc | 124 +++------ .../gnuradio_blocks/pcps_acquisition.h | 138 +++++----- .../pcps_acquisition_fine_doppler_cc.cc | 44 +-- .../pcps_acquisition_fine_doppler_cc.h | 136 +++++----- .../gnuradio_blocks/pcps_acquisition_fpga.cc | 3 +- .../gnuradio_blocks/pcps_acquisition_fpga.h | 81 +++--- .../pcps_assisted_acquisition_cc.cc | 37 +-- .../pcps_assisted_acquisition_cc.h | 129 +++++---- .../pcps_cccwsr_acquisition_cc.h | 109 ++++---- .../pcps_opencl_acquisition_cc.h | 252 +++++++++--------- .../pcps_quicksync_acquisition_cc.h | 134 +++++----- .../pcps_tong_acquisition_cc.h | 111 ++++---- 14 files changed, 734 insertions(+), 852 deletions(-) diff --git a/src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.h b/src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.h index 7b6b9925f..3cc43bebb 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.h +++ b/src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.h @@ -52,8 +52,8 @@ class galileo_e5a_noncoherentIQ_acquisition_caf_cc; using galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr = boost::shared_ptr; -galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr -galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(unsigned int sampled_ms, +galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr galileo_e5a_noncoherentIQ_make_acquisition_caf_cc( + unsigned int sampled_ms, unsigned int max_dwells, unsigned int doppler_max, int64_t fs_in, int samples_per_ms, int samples_per_code, @@ -72,88 +72,6 @@ galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(unsigned int sampled_ms, */ class galileo_e5a_noncoherentIQ_acquisition_caf_cc : public gr::block { -private: - friend galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr - galileo_e5a_noncoherentIQ_make_acquisition_caf_cc( - unsigned int sampled_ms, - unsigned int max_dwells, - unsigned int doppler_max, int64_t fs_in, - int samples_per_ms, int samples_per_code, - bool bit_transition_flag, - bool dump, - std::string dump_filename, - bool both_signal_components_, - int CAF_window_hz_, - int Zero_padding_); - - galileo_e5a_noncoherentIQ_acquisition_caf_cc( - unsigned int sampled_ms, - unsigned int max_dwells, - unsigned int doppler_max, int64_t fs_in, - int samples_per_ms, int samples_per_code, - bool bit_transition_flag, - bool dump, - std::string dump_filename, - bool both_signal_components_, - int CAF_window_hz_, - int Zero_padding_); - - void calculate_magnitudes(gr_complex* fft_begin, int doppler_shift, - int doppler_offset); - float estimate_input_power(gr_complex* in); - - std::weak_ptr d_channel_fsm; - int64_t d_fs_in; - int d_samples_per_ms; - int d_sampled_ms; - int d_samples_per_code; - unsigned int d_doppler_resolution; - float d_threshold; - std::string d_satellite_str; - unsigned int d_doppler_max; - unsigned int d_doppler_step; - unsigned int d_max_dwells; - unsigned int d_well_count; - unsigned int d_fft_size; - uint64_t d_sample_counter; - gr_complex** d_grid_doppler_wipeoffs; - unsigned int d_num_doppler_bins; - gr_complex* d_fft_code_I_A; - gr_complex* d_fft_code_I_B; - gr_complex* d_fft_code_Q_A; - gr_complex* d_fft_code_Q_B; - gr_complex* d_inbuffer; - std::shared_ptr d_fft_if; - std::shared_ptr d_ifft; - Gnss_Synchro* d_gnss_synchro; - unsigned int d_code_phase; - float d_doppler_freq; - float d_mag; - float* d_magnitudeIA; - float* d_magnitudeIB; - float* d_magnitudeQA; - float* d_magnitudeQB; - float d_input_power; - float d_test_statistics; - bool d_bit_transition_flag; - std::ofstream d_dump_file; - bool d_active; - int d_state; - bool d_dump; - bool d_both_signal_components; - // bool d_CAF_filter; - int d_CAF_window_hz; - float* d_CAF_vector; - float* d_CAF_vector_I; - float* d_CAF_vector_Q; - // double* d_CAF_vector; - // double* d_CAF_vector_I; - // double* d_CAF_vector_Q; - unsigned int d_channel; - std::string d_dump_filename; - unsigned int d_buffer_count; - unsigned int d_gr_stream_buffer; - public: /*! * \brief Default destructor. @@ -257,5 +175,85 @@ public: int general_work(int noutput_items, gr_vector_int& ninput_items, gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); + +private: + friend galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr + galileo_e5a_noncoherentIQ_make_acquisition_caf_cc( + unsigned int sampled_ms, + unsigned int max_dwells, + unsigned int doppler_max, int64_t fs_in, + int samples_per_ms, int samples_per_code, + bool bit_transition_flag, + bool dump, + std::string dump_filename, + bool both_signal_components_, + int CAF_window_hz_, + int Zero_padding_); + + galileo_e5a_noncoherentIQ_acquisition_caf_cc( + unsigned int sampled_ms, + unsigned int max_dwells, + unsigned int doppler_max, int64_t fs_in, + int samples_per_ms, int samples_per_code, + bool bit_transition_flag, + bool dump, + std::string dump_filename, + bool both_signal_components_, + int CAF_window_hz_, + int Zero_padding_); + + void calculate_magnitudes(gr_complex* fft_begin, int doppler_shift, + int doppler_offset); + + float estimate_input_power(gr_complex* in); + + std::weak_ptr d_channel_fsm; + int64_t d_fs_in; + int d_samples_per_ms; + int d_sampled_ms; + int d_samples_per_code; + unsigned int d_doppler_resolution; + float d_threshold; + std::string d_satellite_str; + unsigned int d_doppler_max; + unsigned int d_doppler_step; + unsigned int d_max_dwells; + unsigned int d_well_count; + unsigned int d_fft_size; + uint64_t d_sample_counter; + gr_complex** d_grid_doppler_wipeoffs; + unsigned int d_num_doppler_bins; + gr_complex* d_fft_code_I_A; + gr_complex* d_fft_code_I_B; + gr_complex* d_fft_code_Q_A; + gr_complex* d_fft_code_Q_B; + gr_complex* d_inbuffer; + std::shared_ptr d_fft_if; + std::shared_ptr d_ifft; + Gnss_Synchro* d_gnss_synchro; + unsigned int d_code_phase; + float d_doppler_freq; + float d_mag; + float* d_magnitudeIA; + float* d_magnitudeIB; + float* d_magnitudeQA; + float* d_magnitudeQB; + float d_input_power; + float d_test_statistics; + bool d_bit_transition_flag; + std::ofstream d_dump_file; + bool d_active; + int d_state; + bool d_dump; + bool d_both_signal_components; + int d_CAF_window_hz; + float* d_CAF_vector; + float* d_CAF_vector_I; + float* d_CAF_vector_Q; + unsigned int d_channel; + std::string d_dump_filename; + unsigned int d_buffer_count; + unsigned int d_gr_stream_buffer; }; + #endif /* GALILEO_E5A_NONCOHERENT_IQ_ACQUISITION_CAF_CC_H_ */ diff --git a/src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.h b/src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.h index 1dd5b5e78..36dd9d7fe 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.h +++ b/src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.h @@ -62,67 +62,6 @@ galileo_pcps_8ms_make_acquisition_cc(uint32_t sampled_ms, */ class galileo_pcps_8ms_acquisition_cc : public gr::block { -private: - friend galileo_pcps_8ms_acquisition_cc_sptr - galileo_pcps_8ms_make_acquisition_cc( - uint32_t sampled_ms, - uint32_t max_dwells, - uint32_t doppler_max, - int64_t fs_in, - int32_t samples_per_ms, - int32_t samples_per_code, - bool dump, - std::string dump_filename); - - galileo_pcps_8ms_acquisition_cc( - uint32_t sampled_ms, - uint32_t max_dwells, - uint32_t doppler_max, - int64_t fs_in, - int32_t samples_per_ms, - int32_t samples_per_code, - bool dump, - std::string dump_filename); - - void calculate_magnitudes( - gr_complex* fft_begin, - int32_t doppler_shift, - int32_t doppler_offset); - - int64_t d_fs_in; - int32_t d_samples_per_ms; - int32_t d_samples_per_code; - uint32_t d_doppler_resolution; - float d_threshold; - std::string d_satellite_str; - uint32_t d_doppler_max; - uint32_t d_doppler_step; - uint32_t d_sampled_ms; - uint32_t d_max_dwells; - uint32_t d_well_count; - uint32_t d_fft_size; - uint64_t d_sample_counter; - gr_complex** d_grid_doppler_wipeoffs; - uint32_t d_num_doppler_bins; - gr_complex* d_fft_code_A; - gr_complex* d_fft_code_B; - std::shared_ptr d_fft_if; - std::shared_ptr d_ifft; - Gnss_Synchro* d_gnss_synchro; - uint32_t d_code_phase; - float d_doppler_freq; - float d_mag; - float* d_magnitude; - float d_input_power; - float d_test_statistics; - std::ofstream d_dump_file; - bool d_active; - int32_t d_state; - bool d_dump; - uint32_t d_channel; - std::weak_ptr d_channel_fsm; - std::string d_dump_filename; - public: /*! * \brief Default destructor. @@ -226,6 +165,67 @@ public: int general_work(int noutput_items, gr_vector_int& ninput_items, gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); + +private: + friend galileo_pcps_8ms_acquisition_cc_sptr + galileo_pcps_8ms_make_acquisition_cc( + uint32_t sampled_ms, + uint32_t max_dwells, + uint32_t doppler_max, + int64_t fs_in, + int32_t samples_per_ms, + int32_t samples_per_code, + bool dump, + std::string dump_filename); + + galileo_pcps_8ms_acquisition_cc( + uint32_t sampled_ms, + uint32_t max_dwells, + uint32_t doppler_max, + int64_t fs_in, + int32_t samples_per_ms, + int32_t samples_per_code, + bool dump, + std::string dump_filename); + + void calculate_magnitudes( + gr_complex* fft_begin, + int32_t doppler_shift, + int32_t doppler_offset); + + int64_t d_fs_in; + int32_t d_samples_per_ms; + int32_t d_samples_per_code; + uint32_t d_doppler_resolution; + float d_threshold; + std::string d_satellite_str; + uint32_t d_doppler_max; + uint32_t d_doppler_step; + uint32_t d_sampled_ms; + uint32_t d_max_dwells; + uint32_t d_well_count; + uint32_t d_fft_size; + uint64_t d_sample_counter; + gr_complex** d_grid_doppler_wipeoffs; + uint32_t d_num_doppler_bins; + gr_complex* d_fft_code_A; + gr_complex* d_fft_code_B; + std::shared_ptr d_fft_if; + std::shared_ptr d_ifft; + Gnss_Synchro* d_gnss_synchro; + uint32_t d_code_phase; + float d_doppler_freq; + float d_mag; + float* d_magnitude; + float d_input_power; + float d_test_statistics; + std::ofstream d_dump_file; + bool d_active; + int32_t d_state; + bool d_dump; + uint32_t d_channel; + std::weak_ptr d_channel_fsm; + std::string d_dump_filename; }; #endif /* GNSS_SDR_PCPS_8MS_ACQUISITION_CC_H_*/ diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc index 39270efe3..4947b9d2f 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc @@ -134,10 +134,9 @@ pcps_acquisition::pcps_acquisition(const Acq_Conf& conf_) : gr::block("pcps_acqu acq_parameters.max_dwells = 1; // Activation of acq_parameters.bit_transition_flag invalidates the value of acq_parameters.max_dwells } - d_tmp_buffer = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(float), volk_gnsssdr_get_alignment())); - d_fft_codes = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - d_magnitude = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(float), volk_gnsssdr_get_alignment())); - d_input_signal = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); + d_tmp_buffer = std::vector(d_fft_size); + d_fft_codes = std::vector>(d_fft_size); + d_input_signal = std::vector>(d_fft_size); // Direct FFT d_fft_if = std::make_shared(d_fft_size, true); @@ -146,18 +145,11 @@ pcps_acquisition::pcps_acquisition(const Acq_Conf& conf_) : gr::block("pcps_acqu d_ifft = std::make_shared(d_fft_size, false); d_gnss_synchro = nullptr; - d_grid_doppler_wipeoffs = nullptr; - d_grid_doppler_wipeoffs_step_two = nullptr; - d_magnitude_grid = nullptr; d_worker_active = false; - d_data_buffer = static_cast(volk_gnsssdr_malloc(d_consumed_samples * sizeof(gr_complex), volk_gnsssdr_get_alignment())); + d_data_buffer = std::vector>(d_consumed_samples); if (d_cshort) { - d_data_buffer_sc = static_cast(volk_gnsssdr_malloc(d_consumed_samples * sizeof(lv_16sc_t), volk_gnsssdr_get_alignment())); - } - else - { - d_data_buffer_sc = nullptr; + d_data_buffer_sc = std::vector(d_consumed_samples); } grid_ = arma::fmat(); narrow_grid_ = arma::fmat(); @@ -213,36 +205,7 @@ pcps_acquisition::pcps_acquisition(const Acq_Conf& conf_) : gr::block("pcps_acqu } -pcps_acquisition::~pcps_acquisition() -{ - if (d_num_doppler_bins > 0) - { - for (uint32_t i = 0; i < d_num_doppler_bins; i++) - { - volk_gnsssdr_free(d_grid_doppler_wipeoffs[i]); - volk_gnsssdr_free(d_magnitude_grid[i]); - } - delete[] d_grid_doppler_wipeoffs; - delete[] d_magnitude_grid; - } - if (acq_parameters.make_2_steps) - { - for (uint32_t i = 0; i < d_num_doppler_bins_step2; i++) - { - volk_gnsssdr_free(d_grid_doppler_wipeoffs_step_two[i]); - } - delete[] d_grid_doppler_wipeoffs_step_two; - } - volk_gnsssdr_free(d_fft_codes); - volk_gnsssdr_free(d_magnitude); - volk_gnsssdr_free(d_tmp_buffer); - volk_gnsssdr_free(d_input_signal); - volk_gnsssdr_free(d_data_buffer); - if (d_cshort) - { - volk_gnsssdr_free(d_data_buffer_sc); - } -} +pcps_acquisition::~pcps_acquisition() = default; void pcps_acquisition::set_resampler_latency(uint32_t latency_samples) @@ -286,7 +249,7 @@ void pcps_acquisition::set_local_code(std::complex* code) } d_fft_if->execute(); // We need the FFT of local code - volk_32fc_conjugate_32fc(d_fft_codes, d_fft_if->get_outbuf(), d_fft_size); + volk_32fc_conjugate_32fc(d_fft_codes.data(), d_fft_if->get_outbuf(), d_fft_size); } @@ -309,7 +272,7 @@ bool pcps_acquisition::is_fdma() } -void pcps_acquisition::update_local_carrier(gr_complex* carrier_vector, int32_t correlator_length_samples, float freq) +void pcps_acquisition::update_local_carrier(gsl::span carrier_vector, float freq) { float phase_step_rad; if (acq_parameters.use_automatic_resampler) @@ -322,7 +285,7 @@ void pcps_acquisition::update_local_carrier(gr_complex* carrier_vector, int32_t } float _phase[1]; _phase[0] = 0.0; - volk_gnsssdr_s32f_sincos_32fc(carrier_vector, -phase_step_rad, _phase, correlator_length_samples); + volk_gnsssdr_s32f_sincos_32fc(carrier_vector.data(), -phase_step_rad, _phase, carrier_vector.length()); } @@ -342,27 +305,18 @@ void pcps_acquisition::init() d_num_doppler_bins = static_cast(std::ceil(static_cast(static_cast(acq_parameters.doppler_max) - static_cast(-acq_parameters.doppler_max)) / static_cast(d_doppler_step))); // Create the carrier Doppler wipeoff signals - if (d_grid_doppler_wipeoffs == nullptr) + if (d_grid_doppler_wipeoffs.empty()) { - d_grid_doppler_wipeoffs = new gr_complex*[d_num_doppler_bins]; + d_grid_doppler_wipeoffs = std::vector>>(d_num_doppler_bins, std::vector>(d_fft_size)); } - if (acq_parameters.make_2_steps && (d_grid_doppler_wipeoffs_step_two == nullptr)) + if (acq_parameters.make_2_steps && (d_grid_doppler_wipeoffs_step_two.empty())) { - d_grid_doppler_wipeoffs_step_two = new gr_complex*[d_num_doppler_bins_step2]; - for (uint32_t doppler_index = 0; doppler_index < d_num_doppler_bins_step2; doppler_index++) - { - d_grid_doppler_wipeoffs_step_two[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - } + d_grid_doppler_wipeoffs_step_two = std::vector>>(d_num_doppler_bins_step2, std::vector>(d_fft_size)); } - if (d_magnitude_grid == nullptr) + if (d_magnitude_grid.empty()) { - d_magnitude_grid = new float*[d_num_doppler_bins]; - for (uint32_t doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) - { - d_grid_doppler_wipeoffs[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(gr_complex), volk_gnsssdr_get_alignment())); - d_magnitude_grid[doppler_index] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(float), volk_gnsssdr_get_alignment())); - } + d_magnitude_grid = std::vector>(d_num_doppler_bins, std::vector(d_fft_size)); } for (uint32_t doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) @@ -372,7 +326,7 @@ void pcps_acquisition::init() d_magnitude_grid[doppler_index][k] = 0.0; } int32_t doppler = -static_cast(acq_parameters.doppler_max) + d_doppler_step * doppler_index; - update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_old_freq + doppler); + update_local_carrier(gsl::span(d_grid_doppler_wipeoffs[doppler_index].data(), d_fft_size), d_old_freq + doppler); } d_worker_active = false; @@ -391,7 +345,7 @@ void pcps_acquisition::update_grid_doppler_wipeoffs() for (uint32_t doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) { int32_t doppler = -static_cast(acq_parameters.doppler_max) + d_doppler_step * doppler_index; - update_local_carrier(d_grid_doppler_wipeoffs[doppler_index], d_fft_size, d_old_freq + doppler); + update_local_carrier(gsl::span(d_grid_doppler_wipeoffs[doppler_index].data(), d_fft_size), d_old_freq + doppler); } } @@ -401,7 +355,7 @@ void pcps_acquisition::update_grid_doppler_wipeoffs_step2() for (uint32_t doppler_index = 0; doppler_index < d_num_doppler_bins_step2; doppler_index++) { float doppler = (static_cast(doppler_index) - static_cast(floor(d_num_doppler_bins_step2 / 2.0))) * acq_parameters.doppler_step2; - update_local_carrier(d_grid_doppler_wipeoffs_step_two[doppler_index], d_fft_size, d_doppler_center_step_two + doppler); + update_local_carrier(gsl::span(d_grid_doppler_wipeoffs_step_two[doppler_index].data(), d_fft_size), d_doppler_center_step_two + doppler); } } @@ -590,7 +544,7 @@ float pcps_acquisition::max_to_input_power_statistic(uint32_t& indext, int32_t& // Find the correlation peak and the carrier frequency for (uint32_t i = 0; i < num_doppler_bins; i++) { - volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_magnitude_grid[i], d_fft_size); + volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_magnitude_grid[i].data(), d_fft_size); if (d_magnitude_grid[i][tmp_intex_t] > grid_maximum) { grid_maximum = d_magnitude_grid[i][tmp_intex_t]; @@ -627,7 +581,7 @@ float pcps_acquisition::first_vs_second_peak_statistic(uint32_t& indext, int32_t // Find the correlation peak and the carrier frequency for (uint32_t i = 0; i < num_doppler_bins; i++) { - volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_magnitude_grid[i], d_fft_size); + volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_magnitude_grid[i].data(), d_fft_size); if (d_magnitude_grid[i][tmp_intex_t] > firstPeak) { firstPeak = d_magnitude_grid[i][tmp_intex_t]; @@ -661,7 +615,7 @@ float pcps_acquisition::first_vs_second_peak_statistic(uint32_t& indext, int32_t } int32_t idx = excludeRangeIndex1; - memcpy(d_tmp_buffer, d_magnitude_grid[index_doppler], d_fft_size); + memcpy(d_tmp_buffer.data(), d_magnitude_grid[index_doppler].data(), d_fft_size); do { d_tmp_buffer[idx] = 0.0; @@ -674,7 +628,7 @@ float pcps_acquisition::first_vs_second_peak_statistic(uint32_t& indext, int32_t while (idx != excludeRangeIndex2); // Find the second highest correlation peak in the same freq. bin --- - volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_tmp_buffer, d_fft_size); + volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_tmp_buffer.data(), d_fft_size); float secondPeak = d_tmp_buffer[tmp_intex_t]; // Compute the test statistics and compare to the threshold @@ -692,9 +646,9 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) int32_t effective_fft_size = (acq_parameters.bit_transition_flag ? d_fft_size / 2 : d_fft_size); if (d_cshort) { - volk_gnsssdr_16ic_convert_32fc(d_data_buffer, d_data_buffer_sc, d_consumed_samples); + volk_gnsssdr_16ic_convert_32fc(d_data_buffer.data(), d_data_buffer_sc.data(), d_consumed_samples); } - memcpy(d_input_signal, d_data_buffer, d_consumed_samples * sizeof(gr_complex)); + memcpy(d_input_signal.data(), d_data_buffer.data(), d_consumed_samples * sizeof(gr_complex)); if (d_fft_size > d_consumed_samples) { for (uint32_t i = d_consumed_samples; i < d_fft_size; i++) @@ -702,7 +656,7 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) d_input_signal[i] = gr_complex(0.0, 0.0); } } - const gr_complex* in = d_input_signal; // Get the input samples pointer + const gr_complex* in = d_input_signal.data(); // Get the input samples pointer d_input_power = 0.0; d_mag = 0.0; @@ -720,8 +674,8 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) if (d_use_CFAR_algorithm_flag or acq_parameters.bit_transition_flag) { // Compute the input signal power estimation - volk_32fc_magnitude_squared_32f(d_tmp_buffer, in, d_fft_size); - volk_32f_accumulator_s32f(&d_input_power, d_tmp_buffer, d_fft_size); + volk_32fc_magnitude_squared_32f(d_tmp_buffer.data(), in, d_fft_size); + volk_32f_accumulator_s32f(&d_input_power, d_tmp_buffer.data(), d_fft_size); d_input_power /= static_cast(d_fft_size); } @@ -731,14 +685,14 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) for (uint32_t doppler_index = 0; doppler_index < d_num_doppler_bins; doppler_index++) { // Remove Doppler - volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index], d_fft_size); + volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index].data(), d_fft_size); // Perform the FFT-based convolution (parallel time search) // Compute the FFT of the carrier wiped--off incoming signal d_fft_if->execute(); // Multiply carrier wiped--off, Fourier transformed incoming signal with the local FFT'd code reference - volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size); + volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes.data(), d_fft_size); // Compute the inverse FFT d_ifft->execute(); @@ -747,17 +701,17 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) size_t offset = (acq_parameters.bit_transition_flag ? effective_fft_size : 0); if (d_num_noncoherent_integrations_counter == 1) { - volk_32fc_magnitude_squared_32f(d_magnitude_grid[doppler_index], d_ifft->get_outbuf() + offset, effective_fft_size); + volk_32fc_magnitude_squared_32f(d_magnitude_grid[doppler_index].data(), d_ifft->get_outbuf() + offset, effective_fft_size); } else { - volk_32fc_magnitude_squared_32f(d_tmp_buffer, d_ifft->get_outbuf() + offset, effective_fft_size); - volk_32f_x2_add_32f(d_magnitude_grid[doppler_index], d_magnitude_grid[doppler_index], d_tmp_buffer, effective_fft_size); + volk_32fc_magnitude_squared_32f(d_tmp_buffer.data(), d_ifft->get_outbuf() + offset, effective_fft_size); + volk_32f_x2_add_32f(d_magnitude_grid[doppler_index].data(), d_magnitude_grid[doppler_index].data(), d_tmp_buffer.data(), effective_fft_size); } // Record results to file if required if (d_dump and d_channel == d_dump_channel) { - memcpy(grid_.colptr(doppler_index), d_magnitude_grid[doppler_index], sizeof(float) * effective_fft_size); + memcpy(grid_.colptr(doppler_index), d_magnitude_grid[doppler_index].data(), sizeof(float) * effective_fft_size); } } @@ -789,7 +743,7 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) { for (uint32_t doppler_index = 0; doppler_index < d_num_doppler_bins_step2; doppler_index++) { - volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs_step_two[doppler_index], d_fft_size); + volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs_step_two[doppler_index].data(), d_fft_size); // Perform the FFT-based convolution (parallel time search) // Compute the FFT of the carrier wiped--off incoming signal @@ -797,7 +751,7 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) // Multiply carrier wiped--off, Fourier transformed incoming signal // with the local FFT'd code reference using SIMD operations with VOLK library - volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size); + volk_32fc_x2_multiply_32fc(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes.data(), d_fft_size); // compute the inverse FFT d_ifft->execute(); @@ -805,17 +759,17 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count) size_t offset = (acq_parameters.bit_transition_flag ? effective_fft_size : 0); if (d_num_noncoherent_integrations_counter == 1) { - volk_32fc_magnitude_squared_32f(d_magnitude_grid[doppler_index], d_ifft->get_outbuf() + offset, effective_fft_size); + volk_32fc_magnitude_squared_32f(d_magnitude_grid[doppler_index].data(), d_ifft->get_outbuf() + offset, effective_fft_size); } else { - volk_32fc_magnitude_squared_32f(d_tmp_buffer, d_ifft->get_outbuf() + offset, effective_fft_size); - volk_32f_x2_add_32f(d_magnitude_grid[doppler_index], d_magnitude_grid[doppler_index], d_tmp_buffer, effective_fft_size); + volk_32fc_magnitude_squared_32f(d_tmp_buffer.data(), d_ifft->get_outbuf() + offset, effective_fft_size); + volk_32f_x2_add_32f(d_magnitude_grid[doppler_index].data(), d_magnitude_grid[doppler_index].data(), d_tmp_buffer.data(), effective_fft_size); } // Record results to file if required if (d_dump and d_channel == d_dump_channel) { - memcpy(narrow_grid_.colptr(doppler_index), d_magnitude_grid[doppler_index], sizeof(float) * effective_fft_size); + memcpy(narrow_grid_.colptr(doppler_index), d_magnitude_grid[doppler_index].data(), sizeof(float) * effective_fft_size); } } // Compute the test statistic diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h index b7b27c70c..cfdf5c103 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h @@ -61,18 +61,25 @@ #include // for scoped_lock #include // for gr_vector_const_void_star #include // for lv_16sc_t +#include #include #include #include #include +#include +#if HAS_SPAN +#include +namespace gsl = std; +#else +#include +#endif class Gnss_Synchro; class pcps_acquisition; using pcps_acquisition_sptr = boost::shared_ptr; -pcps_acquisition_sptr -pcps_make_acquisition(const Acq_Conf& conf_); +pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_); /*! * \brief This class implements a Parallel Code Phase Search Acquisition. @@ -82,75 +89,6 @@ pcps_make_acquisition(const Acq_Conf& conf_); */ class pcps_acquisition : public gr::block { -private: - friend pcps_acquisition_sptr - pcps_make_acquisition(const Acq_Conf& conf_); - - pcps_acquisition(const Acq_Conf& conf_); - - void update_local_carrier(gr_complex* carrier_vector, int32_t correlator_length_samples, float freq); - void update_grid_doppler_wipeoffs(); - void update_grid_doppler_wipeoffs_step2(); - bool is_fdma(); - - void acquisition_core(uint64_t samp_count); - - void send_negative_acquisition(); - - void send_positive_acquisition(); - - void dump_results(int32_t effective_fft_size); - - float first_vs_second_peak_statistic(uint32_t& indext, int32_t& doppler, uint32_t num_doppler_bins, int32_t doppler_max, int32_t doppler_step); - float max_to_input_power_statistic(uint32_t& indext, int32_t& doppler, float input_power, uint32_t num_doppler_bins, int32_t doppler_max, int32_t doppler_step); - - bool start(); - - - Acq_Conf acq_parameters; - bool d_active; - bool d_worker_active; - bool d_cshort; - bool d_step_two; - bool d_use_CFAR_algorithm_flag; - int32_t d_positive_acq; - float d_threshold; - float d_mag; - float d_input_power; - float d_test_statistics; - float* d_magnitude; - float** d_magnitude_grid; - float* d_tmp_buffer; - gr_complex* d_input_signal; - uint32_t d_samplesPerChip; - int64_t d_old_freq; - int32_t d_state; - uint32_t d_channel; - std::weak_ptr d_channel_fsm; - uint32_t d_doppler_step; - float d_doppler_center_step_two; - uint32_t d_num_noncoherent_integrations_counter; - uint32_t d_fft_size; - uint32_t d_consumed_samples; - uint32_t d_num_doppler_bins; - uint64_t d_sample_counter; - gr_complex** d_grid_doppler_wipeoffs; - gr_complex** d_grid_doppler_wipeoffs_step_two; - gr_complex* d_fft_codes; - gr_complex* d_data_buffer; - lv_16sc_t* d_data_buffer_sc; - std::shared_ptr d_fft_if; - std::shared_ptr d_ifft; - Gnss_Synchro* d_gnss_synchro; - arma::fmat grid_; - arma::fmat narrow_grid_; - uint32_t d_num_doppler_bins_step2; - int64_t d_dump_number; - uint32_t d_dump_channel; - uint32_t d_buffer_count; - bool d_dump; - std::string d_dump_filename; - public: ~pcps_acquisition(); @@ -250,7 +188,6 @@ public: d_doppler_step = doppler_step; } - void set_resampler_latency(uint32_t latency_samples); /*! @@ -259,6 +196,63 @@ public: int general_work(int noutput_items, gr_vector_int& ninput_items, gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); + +private: + friend pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_); + pcps_acquisition(const Acq_Conf& conf_); + bool d_active; + bool d_worker_active; + bool d_cshort; + bool d_step_two; + bool d_use_CFAR_algorithm_flag; + bool d_dump; + int32_t d_state; + int32_t d_positive_acq; + uint32_t d_channel; + uint32_t d_samplesPerChip; + uint32_t d_doppler_step; + uint32_t d_num_noncoherent_integrations_counter; + uint32_t d_fft_size; + uint32_t d_consumed_samples; + uint32_t d_num_doppler_bins; + uint32_t d_num_doppler_bins_step2; + uint32_t d_dump_channel; + uint32_t d_buffer_count; + uint64_t d_sample_counter; + int64_t d_dump_number; + int64_t d_old_freq; + float d_threshold; + float d_mag; + float d_input_power; + float d_test_statistics; + float d_doppler_center_step_two; + std::string d_dump_filename; + std::vector> d_magnitude_grid; + std::vector d_tmp_buffer; + std::vector> d_input_signal; + std::vector>> d_grid_doppler_wipeoffs; + std::vector>> d_grid_doppler_wipeoffs_step_two; + std::vector> d_fft_codes; + std::vector> d_data_buffer; + std::vector d_data_buffer_sc; + std::shared_ptr d_fft_if; + std::shared_ptr d_ifft; + std::weak_ptr d_channel_fsm; + Acq_Conf acq_parameters; + Gnss_Synchro* d_gnss_synchro; + arma::fmat grid_; + arma::fmat narrow_grid_; + void update_local_carrier(gsl::span carrier_vector, float freq); + void update_grid_doppler_wipeoffs(); + void update_grid_doppler_wipeoffs_step2(); + void acquisition_core(uint64_t samp_count); + void send_negative_acquisition(); + void send_positive_acquisition(); + void dump_results(int32_t effective_fft_size); + bool is_fdma(); + bool start(); + float first_vs_second_peak_statistic(uint32_t& indext, int32_t& doppler, uint32_t num_doppler_bins, int32_t doppler_max, int32_t doppler_step); + float max_to_input_power_statistic(uint32_t& indext, int32_t& doppler, float input_power, uint32_t num_doppler_bins, int32_t doppler_max, int32_t doppler_step); }; #endif /* GNSS_SDR_PCPS_ACQUISITION_H_*/ diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc index 1a3642af9..44f262388 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc @@ -138,8 +138,6 @@ pcps_acquisition_fine_doppler_cc::pcps_acquisition_fine_doppler_cc(const Acq_Con d_threshold = 0; d_num_doppler_points = 0; d_doppler_step = 0; - d_grid_data = nullptr; - d_grid_doppler_wipeoffs = nullptr; d_gnss_synchro = nullptr; d_code_phase = 0; d_doppler_freq = 0; @@ -176,11 +174,7 @@ void pcps_acquisition_fine_doppler_cc::set_doppler_step(unsigned int doppler_ste d_num_doppler_points = floor(std::abs(2 * d_config_doppler_max) / d_doppler_step); - d_grid_data = new float *[d_num_doppler_points]; - for (int i = 0; i < d_num_doppler_points; i++) - { - d_grid_data[i] = static_cast(volk_gnsssdr_malloc(d_fft_size * sizeof(float), volk_gnsssdr_get_alignment())); - } + d_grid_data = std::vector>(d_num_doppler_points, std::vector(d_fft_size)); if (d_dump) { @@ -191,25 +185,12 @@ void pcps_acquisition_fine_doppler_cc::set_doppler_step(unsigned int doppler_ste } -void pcps_acquisition_fine_doppler_cc::free_grid_memory() -{ - for (int i = 0; i < d_num_doppler_points; i++) - { - volk_gnsssdr_free(d_grid_data[i]); - delete[] d_grid_doppler_wipeoffs[i]; - } - delete d_grid_data; - delete d_grid_doppler_wipeoffs; -} - - pcps_acquisition_fine_doppler_cc::~pcps_acquisition_fine_doppler_cc() { volk_gnsssdr_free(d_carrier); volk_gnsssdr_free(d_fft_codes); volk_gnsssdr_free(d_magnitude); volk_gnsssdr_free(d_10_ms_buffer); - free_grid_memory(); } @@ -265,17 +246,16 @@ void pcps_acquisition_fine_doppler_cc::update_carrier_wipeoff() // create the carrier Doppler wipeoff signals int doppler_hz; float phase_step_rad; - d_grid_doppler_wipeoffs = new gr_complex *[d_num_doppler_points]; + d_grid_doppler_wipeoffs = std::vector>>(d_num_doppler_points, std::vector>(d_fft_size)); for (int doppler_index = 0; doppler_index < d_num_doppler_points; doppler_index++) { doppler_hz = d_doppler_step * doppler_index - d_config_doppler_max; // doppler search steps // compute the carrier doppler wipe-off signal and store it phase_step_rad = static_cast(GPS_TWO_PI) * doppler_hz / static_cast(d_fs_in); - d_grid_doppler_wipeoffs[doppler_index] = new gr_complex[d_fft_size]; float _phase[1]; _phase[0] = 0; - volk_gnsssdr_s32f_sincos_32fc(d_grid_doppler_wipeoffs[doppler_index], -phase_step_rad, _phase, d_fft_size); + volk_gnsssdr_s32f_sincos_32fc(d_grid_doppler_wipeoffs[doppler_index].data(), -phase_step_rad, _phase, d_fft_size); } } @@ -293,7 +273,7 @@ double pcps_acquisition_fine_doppler_cc::compute_CAF() //--- Find the correlation peak and the carrier frequency -------------- for (int i = 0; i < d_num_doppler_points; i++) { - volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_grid_data[i], d_fft_size); + volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_grid_data[i].data(), d_fft_size); if (d_grid_data[i][tmp_intex_t] > firstPeak) { firstPeak = d_grid_data[i][tmp_intex_t]; @@ -304,7 +284,7 @@ double pcps_acquisition_fine_doppler_cc::compute_CAF() // Record results to file if required if (d_dump and d_channel == d_dump_channel) { - memcpy(grid_.colptr(i), d_grid_data[i], sizeof(float) * d_fft_size); + memcpy(grid_.colptr(i), d_grid_data[i].data(), sizeof(float) * d_fft_size); } } @@ -336,7 +316,7 @@ double pcps_acquisition_fine_doppler_cc::compute_CAF() while (idx != excludeRangeIndex2); //--- Find the second highest correlation peak in the same freq. bin --- - volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_grid_data[index_doppler], d_fft_size); + volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_grid_data[index_doppler].data(), d_fft_size); float secondPeak = d_grid_data[index_doppler][tmp_intex_t]; // 5- Compute the test statistics and compare to the threshold @@ -382,7 +362,7 @@ int pcps_acquisition_fine_doppler_cc::compute_and_accumulate_grid(gr_vector_cons { // doppler search steps // Perform the carrier wipe-off - volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index], d_fft_size); + volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index].data(), d_fft_size); // 3- Perform the FFT-based convolution (parallel time search) // Compute the FFT of the carrier wiped--off incoming signal @@ -398,7 +378,7 @@ int pcps_acquisition_fine_doppler_cc::compute_and_accumulate_grid(gr_vector_cons // save the grid matrix delay file volk_32fc_magnitude_squared_32f(p_tmp_vector, d_ifft->get_outbuf(), d_fft_size); //accumulate grid values - volk_32f_x2_add_32f(d_grid_data[doppler_index], d_grid_data[doppler_index], p_tmp_vector, d_fft_size); + volk_32f_x2_add_32f(d_grid_data[doppler_index].data(), d_grid_data[doppler_index].data(), p_tmp_vector, d_fft_size); } volk_gnsssdr_free(p_tmp_vector); @@ -422,7 +402,7 @@ int pcps_acquisition_fine_doppler_cc::estimate_Doppler() int signal_samples = prn_replicas * d_fft_size; //int fft_size_extended = nextPowerOf2(signal_samples * zero_padding_factor); int fft_size_extended = signal_samples * zero_padding_factor; - auto *fft_operator = new gr::fft::fft_complex(fft_size_extended, true); + auto fft_operator = std::make_shared(fft_size_extended, true); //zero padding the entire vector std::fill_n(fft_operator->get_inbuf(), fft_size_extended, gr_complex(0.0, 0.0)); @@ -459,9 +439,7 @@ int pcps_acquisition_fine_doppler_cc::estimate_Doppler() //case even int counter = 0; - auto *fftFreqBins = new float[fft_size_extended]; - - std::fill_n(fftFreqBins, fft_size_extended, 0.0); + auto fftFreqBins = std::vector(fft_size_extended); for (int k = 0; k < (fft_size_extended / 2); k++) { @@ -488,10 +466,8 @@ int pcps_acquisition_fine_doppler_cc::estimate_Doppler() } // free memory!! - delete fft_operator; volk_gnsssdr_free(code_replica); volk_gnsssdr_free(p_tmp_vector); - delete[] fftFreqBins; return d_fft_size; } diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.h index 6da3e51e8..1919ec356 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.h @@ -61,13 +61,13 @@ #include #include #include +#include class pcps_acquisition_fine_doppler_cc; using pcps_acquisition_fine_doppler_cc_sptr = boost::shared_ptr; -pcps_acquisition_fine_doppler_cc_sptr -pcps_make_acquisition_fine_doppler_cc(const Acq_Conf& conf_); +pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(const Acq_Conf& conf_); /*! * \brief This class implements a Parallel Code Phase Search Acquisition. @@ -75,63 +75,6 @@ pcps_make_acquisition_fine_doppler_cc(const Acq_Conf& conf_); */ class pcps_acquisition_fine_doppler_cc : public gr::block { -private: - friend pcps_acquisition_fine_doppler_cc_sptr - pcps_make_acquisition_fine_doppler_cc(const Acq_Conf& conf_); - pcps_acquisition_fine_doppler_cc(const Acq_Conf& conf_); - - int compute_and_accumulate_grid(gr_vector_const_void_star& input_items); - int estimate_Doppler(); - float estimate_input_power(gr_vector_const_void_star& input_items); - double compute_CAF(); - void reset_grid(); - void update_carrier_wipeoff(); - void free_grid_memory(); - bool start(); - - Acq_Conf acq_parameters; - int64_t d_fs_in; - int d_samples_per_ms; - int d_max_dwells; - int d_gnuradio_forecast_samples; - float d_threshold; - std::string d_satellite_str; - int d_config_doppler_max; - - int d_num_doppler_points; - int d_doppler_step; - unsigned int d_fft_size; - uint64_t d_sample_counter; - gr_complex* d_carrier; - gr_complex* d_fft_codes; - gr_complex* d_10_ms_buffer; - float* d_magnitude; - - float** d_grid_data; - gr_complex** d_grid_doppler_wipeoffs; - - std::shared_ptr d_fft_if; - std::shared_ptr d_ifft; - Gnss_Synchro* d_gnss_synchro; - unsigned int d_code_phase; - float d_doppler_freq; - float d_test_statistics; - int d_positive_acq; - - int d_state; - bool d_active; - int d_well_count; - int d_n_samples_in_buffer; - bool d_dump; - unsigned int d_channel; - std::weak_ptr d_channel_fsm; - - std::string d_dump_filename; - - arma::fmat grid_; - int64_t d_dump_number; - unsigned int d_dump_channel; - public: /*! * \brief Default destructor. @@ -221,20 +164,11 @@ public: void set_doppler_step(unsigned int doppler_step); /*! - * \brief If set to 1, ensures that acquisition starts at the - * first available sample. - * \param state - int=1 forces start of acquisition - */ - void set_state(int state); - - /*! - * \brief Parallel Code Phase Search Acquisition signal processing. + * \brief If set to 1, ensures that acquisition starts at the + * first available sample. + * \param state - int=1 forces start of acquisition */ - int general_work(int noutput_items, gr_vector_int& ninput_items, - gr_vector_const_void_star& input_items, - gr_vector_void_star& output_items); - - void forecast(int noutput_items, gr_vector_int& ninput_items_required); + void set_state(int state); /*! * \brief Obtains the next power of 2 greater or equal to the input parameter @@ -243,6 +177,64 @@ public: unsigned int nextPowerOf2(unsigned int n); void dump_results(int effective_fft_size); + + void forecast(int noutput_items, gr_vector_int& ninput_items_required); + + /*! + * \brief Parallel Code Phase Search Acquisition signal processing. + */ + int general_work(int noutput_items, gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items); + +private: + friend pcps_acquisition_fine_doppler_cc_sptr + pcps_make_acquisition_fine_doppler_cc(const Acq_Conf& conf_); + pcps_acquisition_fine_doppler_cc(const Acq_Conf& conf_); + + int compute_and_accumulate_grid(gr_vector_const_void_star& input_items); + int estimate_Doppler(); + float estimate_input_power(gr_vector_const_void_star& input_items); + double compute_CAF(); + void reset_grid(); + void update_carrier_wipeoff(); + bool start(); + Acq_Conf acq_parameters; + int64_t d_fs_in; + int d_samples_per_ms; + int d_max_dwells; + int d_gnuradio_forecast_samples; + float d_threshold; + std::string d_satellite_str; + int d_config_doppler_max; + int d_num_doppler_points; + int d_doppler_step; + unsigned int d_fft_size; + uint64_t d_sample_counter; + gr_complex* d_carrier; + gr_complex* d_fft_codes; + gr_complex* d_10_ms_buffer; + float* d_magnitude; + std::vector> d_grid_data; + std::vector>> d_grid_doppler_wipeoffs; + std::shared_ptr d_fft_if; + std::shared_ptr d_ifft; + Gnss_Synchro* d_gnss_synchro; + unsigned int d_code_phase; + float d_doppler_freq; + float d_test_statistics; + int d_positive_acq; + int d_state; + bool d_active; + int d_well_count; + int d_n_samples_in_buffer; + bool d_dump; + unsigned int d_channel; + std::weak_ptr d_channel_fsm; + std::string d_dump_filename; + arma::fmat grid_; + int64_t d_dump_number; + unsigned int d_dump_channel; }; #endif /* pcps_acquisition_fine_doppler_cc*/ diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.cc b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.cc index 99de2d8ed..2d9929063 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.cc +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.cc @@ -34,7 +34,6 @@ #include "pcps_acquisition_fpga.h" #include "gnss_synchro.h" -//#include #include #include // for ceil #include // for operator<< @@ -87,6 +86,7 @@ pcps_acquisition_fpga::pcps_acquisition_fpga(pcpsconf_fpga_t conf_) pcps_acquisition_fpga::~pcps_acquisition_fpga() = default; + void pcps_acquisition_fpga::set_local_code() { acquisition_fpga->set_local_code(d_gnss_synchro->PRN); @@ -174,6 +174,7 @@ void pcps_acquisition_fpga::send_negative_acquisition() } } + void pcps_acquisition_fpga::acquisition_core(uint32_t num_doppler_bins, uint32_t doppler_step, int32_t doppler_min) { uint32_t indext = 0U; diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h index 307dcba45..81f75766d 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h @@ -62,7 +62,7 @@ typedef struct int32_t code_length; uint32_t select_queue_Fpga; std::string device_name; - uint32_t* all_fft_codes; // pointer to memory that contains all the code ffts + uint32_t* all_fft_codes; // pointer to memory that contains all the code ffts //float downsampling_factor; uint32_t downsampling_factor; uint32_t total_block_exp; @@ -78,8 +78,7 @@ class pcps_acquisition_fpga; using pcps_acquisition_fpga_sptr = boost::shared_ptr; -pcps_acquisition_fpga_sptr -pcps_make_acquisition_fpga(pcpsconf_fpga_t conf_); +pcps_acquisition_fpga_sptr pcps_make_acquisition_fpga(pcpsconf_fpga_t conf_); /*! * \brief This class implements a Parallel Code Phase Search Acquisition that uses the FPGA. @@ -89,49 +88,6 @@ pcps_make_acquisition_fpga(pcpsconf_fpga_t conf_); */ class pcps_acquisition_fpga { -private: - friend pcps_acquisition_fpga_sptr pcps_make_acquisition_fpga(pcpsconf_fpga_t conf_); - - pcps_acquisition_fpga(pcpsconf_fpga_t conf_); - - void send_negative_acquisition(); - - void send_positive_acquisition(); - - float first_vs_second_peak_statistic(uint32_t& indext, int32_t& doppler, uint32_t num_doppler_bins, int32_t doppler_max, int32_t doppler_step); - - void acquisition_core(uint32_t num_doppler_bins, uint32_t doppler_step, int32_t doppler_max); - - pcpsconf_fpga_t acq_parameters; - bool d_active; - float d_threshold; - float d_mag; - float d_input_power; - uint32_t d_doppler_index; - float d_test_statistics; - int32_t d_state; - uint32_t d_channel; - std::weak_ptr d_channel_fsm; - uint32_t d_doppler_step; - uint32_t d_doppler_max; - uint32_t d_fft_size; - uint32_t d_num_doppler_bins; - uint64_t d_sample_counter; - Gnss_Synchro* d_gnss_synchro; - std::shared_ptr acquisition_fpga; - - //float d_downsampling_factor; - uint32_t d_downsampling_factor; - uint32_t d_select_queue_Fpga; - - uint32_t d_total_block_exp; - - bool d_make_2_steps; - uint32_t d_num_doppler_bins_step2; - float d_doppler_step2; - float d_doppler_center_step_two; - uint32_t d_max_num_acqs; - public: ~pcps_acquisition_fpga(); @@ -229,6 +185,39 @@ public: * \brief This funciton triggers a HW reset of the FPGA PL. */ void reset_acquisition(void); + +private: + friend pcps_acquisition_fpga_sptr pcps_make_acquisition_fpga(pcpsconf_fpga_t conf_); + pcps_acquisition_fpga(pcpsconf_fpga_t conf_); + bool d_active; + bool d_make_2_steps; + uint32_t d_doppler_index; + uint32_t d_channel; + uint32_t d_doppler_step; + uint32_t d_doppler_max; + uint32_t d_fft_size; + uint32_t d_num_doppler_bins; + uint32_t d_downsampling_factor; + uint32_t d_select_queue_Fpga; + uint32_t d_total_block_exp; + uint32_t d_num_doppler_bins_step2; + uint32_t d_max_num_acqs; + int32_t d_state; + uint64_t d_sample_counter; + float d_threshold; + float d_mag; + float d_input_power; + float d_test_statistics; + float d_doppler_step2; + float d_doppler_center_step_two; + pcpsconf_fpga_t acq_parameters; + Gnss_Synchro* d_gnss_synchro; + std::shared_ptr acquisition_fpga; + std::weak_ptr d_channel_fsm; + void send_negative_acquisition(); + void send_positive_acquisition(); + void acquisition_core(uint32_t num_doppler_bins, uint32_t doppler_step, int32_t doppler_max); + float first_vs_second_peak_statistic(uint32_t& indext, int32_t& doppler, uint32_t num_doppler_bins, int32_t doppler_max, int32_t doppler_step); }; #endif /* GNSS_SDR_PCPS_ACQUISITION_FPGA_H_*/ diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc b/src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc index 20221f51b..a713357b2 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc @@ -97,8 +97,6 @@ pcps_assisted_acquisition_cc::pcps_assisted_acquisition_cc( d_doppler_min = 0; d_num_doppler_points = 0; d_doppler_step = 0; - d_grid_data = nullptr; - d_grid_doppler_wipeoffs = nullptr; d_gnss_synchro = nullptr; d_code_phase = 0; d_doppler_freq = 0; @@ -114,17 +112,6 @@ void pcps_assisted_acquisition_cc::set_doppler_step(uint32_t doppler_step) } -void pcps_assisted_acquisition_cc::free_grid_memory() -{ - for (int32_t i = 0; i < d_num_doppler_points; i++) - { - delete[] d_grid_data[i]; - delete[] d_grid_doppler_wipeoffs[i]; - } - delete d_grid_data; -} - - pcps_assisted_acquisition_cc::~pcps_assisted_acquisition_cc() { volk_gnsssdr_free(d_carrier); @@ -234,26 +221,21 @@ void pcps_assisted_acquisition_cc::redefine_grid() // Create the search grid array d_num_doppler_points = floor(std::abs(d_doppler_max - d_doppler_min) / d_doppler_step); - d_grid_data = new float *[d_num_doppler_points]; - for (int32_t i = 0; i < d_num_doppler_points; i++) - { - d_grid_data[i] = new float[d_fft_size]; - } + d_grid_data = std::vector>(d_num_doppler_points, std::vector(d_fft_size)); // create the carrier Doppler wipeoff signals int32_t doppler_hz; float phase_step_rad; - d_grid_doppler_wipeoffs = new gr_complex *[d_num_doppler_points]; + d_grid_doppler_wipeoffs = std::vector>>(d_num_doppler_points, std::vector>(d_fft_size)); for (int32_t doppler_index = 0; doppler_index < d_num_doppler_points; doppler_index++) { doppler_hz = d_doppler_min + d_doppler_step * doppler_index; // doppler search steps // compute the carrier doppler wipe-off signal and store it phase_step_rad = static_cast(GPS_TWO_PI) * doppler_hz / static_cast(d_fs_in); - d_grid_doppler_wipeoffs[doppler_index] = new gr_complex[d_fft_size]; float _phase[1]; _phase[0] = 0; - volk_gnsssdr_s32f_sincos_32fc(d_grid_doppler_wipeoffs[doppler_index], -phase_step_rad, _phase, d_fft_size); + volk_gnsssdr_s32f_sincos_32fc(d_grid_doppler_wipeoffs[doppler_index].data(), -phase_step_rad, _phase, d_fft_size); } } @@ -268,7 +250,7 @@ double pcps_assisted_acquisition_cc::search_maximum() for (int32_t i = 0; i < d_num_doppler_points; i++) { - volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_grid_data[i], d_fft_size); + volk_gnsssdr_32f_index_max_32u(&tmp_intex_t, d_grid_data[i].data(), d_fft_size); if (d_grid_data[i][tmp_intex_t] > magt) { magt = d_grid_data[i][index_time]; @@ -300,7 +282,7 @@ double pcps_assisted_acquisition_cc::search_maximum() << "_" << d_gnss_synchro->Signal << "_sat_" << d_gnss_synchro->PRN << "_doppler_" << d_gnss_synchro->Acq_doppler_hz << ".dat"; d_dump_file.open(filename.str().c_str(), std::ios::out | std::ios::binary); - d_dump_file.write(reinterpret_cast(d_grid_data[index_doppler]), n); //write directly |abs(x)|^2 in this Doppler bin? + d_dump_file.write(reinterpret_cast(d_grid_data[index_doppler].data()), n); //write directly |abs(x)|^2 in this Doppler bin? d_dump_file.close(); } @@ -343,7 +325,7 @@ int32_t pcps_assisted_acquisition_cc::compute_and_accumulate_grid(gr_vector_cons { // doppler search steps // Perform the carrier wipe-off - volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index], d_fft_size); + volk_32fc_x2_multiply_32fc(d_fft_if->get_inbuf(), in, d_grid_doppler_wipeoffs[doppler_index].data(), d_fft_size); // 3- Perform the FFT-based convolution (parallel time search) // Compute the FFT of the carrier wiped--off incoming signal d_fft_if->execute(); @@ -357,8 +339,8 @@ int32_t pcps_assisted_acquisition_cc::compute_and_accumulate_grid(gr_vector_cons // save the grid matrix delay file volk_32fc_magnitude_squared_32f(p_tmp_vector, d_ifft->get_outbuf(), d_fft_size); - const float *old_vector = d_grid_data[doppler_index]; - volk_32f_x2_add_32f(d_grid_data[doppler_index], old_vector, p_tmp_vector, d_fft_size); + const float *old_vector = d_grid_data[doppler_index].data(); + volk_32f_x2_add_32f(d_grid_data[doppler_index].data(), old_vector, p_tmp_vector, d_fft_size); } volk_gnsssdr_free(p_tmp_vector); return d_fft_size; @@ -439,7 +421,6 @@ int pcps_assisted_acquisition_cc::general_work(int noutput_items, consume_each(ninput_items[0]); break; case 4: // RedefineGrid - free_grid_memory(); redefine_grid(); reset_grid(); d_sample_counter += static_cast(ninput_items[0]); // sample counter @@ -458,7 +439,6 @@ int pcps_assisted_acquisition_cc::general_work(int noutput_items, d_active = false; // Send message to channel port //0=STOP_CHANNEL 1=ACQ_SUCCESS 2=ACQ_FAIL this->message_port_pub(pmt::mp("events"), pmt::from_long(1)); - free_grid_memory(); // consume samples to not block the GNU Radio flowgraph d_sample_counter += static_cast(ninput_items[0]); // sample counter consume_each(ninput_items[0]); @@ -476,7 +456,6 @@ int pcps_assisted_acquisition_cc::general_work(int noutput_items, d_active = false; // Send message to channel port //0=STOP_CHANNEL 1=ACQ_SUCCESS 2=ACQ_FAIL this->message_port_pub(pmt::mp("events"), pmt::from_long(2)); - free_grid_memory(); // consume samples to not block the GNU Radio flowgraph d_sample_counter += static_cast(ninput_items[0]); // sample counter consume_each(ninput_items[0]); diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.h index 208725b1f..3c57dd80b 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.h @@ -57,13 +57,13 @@ #include #include #include +#include class pcps_assisted_acquisition_cc; using pcps_assisted_acquisition_cc_sptr = boost::shared_ptr; -pcps_assisted_acquisition_cc_sptr -pcps_make_assisted_acquisition_cc( +pcps_assisted_acquisition_cc_sptr pcps_make_assisted_acquisition_cc( int32_t max_dwells, uint32_t sampled_ms, int32_t doppler_max, @@ -80,69 +80,6 @@ pcps_make_assisted_acquisition_cc( */ class pcps_assisted_acquisition_cc : public gr::block { -private: - friend pcps_assisted_acquisition_cc_sptr - pcps_make_assisted_acquisition_cc(int32_t max_dwells, uint32_t sampled_ms, - int32_t doppler_max, int32_t doppler_min, int64_t fs_in, - int32_t samples_per_ms, bool dump, - std::string dump_filename); - - pcps_assisted_acquisition_cc(int32_t max_dwells, uint32_t sampled_ms, - int32_t doppler_max, int32_t doppler_min, int64_t fs_in, - int32_t samples_per_ms, bool dump, - std::string dump_filename); - - void calculate_magnitudes(gr_complex* fft_begin, int32_t doppler_shift, - int32_t doppler_offset); - - int32_t compute_and_accumulate_grid(gr_vector_const_void_star& input_items); - float estimate_input_power(gr_vector_const_void_star& input_items); - double search_maximum(); - void get_assistance(); - void reset_grid(); - void redefine_grid(); - void free_grid_memory(); - - int64_t d_fs_in; - int32_t d_samples_per_ms; - int32_t d_max_dwells; - uint32_t d_doppler_resolution; - int32_t d_gnuradio_forecast_samples; - float d_threshold; - std::string d_satellite_str; - int32_t d_doppler_max; - int32_t d_doppler_min; - int32_t d_config_doppler_max; - int32_t d_config_doppler_min; - - int32_t d_num_doppler_points; - int32_t d_doppler_step; - uint32_t d_sampled_ms; - uint32_t d_fft_size; - uint64_t d_sample_counter; - gr_complex* d_carrier; - gr_complex* d_fft_codes; - - float** d_grid_data; - gr_complex** d_grid_doppler_wipeoffs; - - std::shared_ptr d_fft_if; - std::shared_ptr d_ifft; - Gnss_Synchro* d_gnss_synchro; - uint32_t d_code_phase; - float d_doppler_freq; - float d_input_power; - float d_test_statistics; - std::ofstream d_dump_file; - int32_t d_state; - bool d_active; - bool d_disable_assist; - int32_t d_well_count; - bool d_dump; - uint32_t d_channel; - std::weak_ptr d_channel_fsm; - std::string d_dump_filename; - public: /*! * \brief Default destructor. @@ -238,6 +175,68 @@ public: gr_vector_void_star& output_items); void forecast(int noutput_items, gr_vector_int& ninput_items_required); + +private: + friend pcps_assisted_acquisition_cc_sptr + pcps_make_assisted_acquisition_cc(int32_t max_dwells, uint32_t sampled_ms, + int32_t doppler_max, int32_t doppler_min, int64_t fs_in, + int32_t samples_per_ms, bool dump, + std::string dump_filename); + + pcps_assisted_acquisition_cc(int32_t max_dwells, uint32_t sampled_ms, + int32_t doppler_max, int32_t doppler_min, int64_t fs_in, + int32_t samples_per_ms, bool dump, + std::string dump_filename); + + void calculate_magnitudes(gr_complex* fft_begin, int32_t doppler_shift, + int32_t doppler_offset); + + int32_t compute_and_accumulate_grid(gr_vector_const_void_star& input_items); + float estimate_input_power(gr_vector_const_void_star& input_items); + double search_maximum(); + void get_assistance(); + void reset_grid(); + void redefine_grid(); + + int64_t d_fs_in; + int32_t d_samples_per_ms; + int32_t d_max_dwells; + uint32_t d_doppler_resolution; + int32_t d_gnuradio_forecast_samples; + float d_threshold; + std::string d_satellite_str; + int32_t d_doppler_max; + int32_t d_doppler_min; + int32_t d_config_doppler_max; + int32_t d_config_doppler_min; + + int32_t d_num_doppler_points; + int32_t d_doppler_step; + uint32_t d_sampled_ms; + uint32_t d_fft_size; + uint64_t d_sample_counter; + gr_complex* d_carrier; + gr_complex* d_fft_codes; + + std::vector> d_grid_data; + std::vector>> d_grid_doppler_wipeoffs; + + std::shared_ptr d_fft_if; + std::shared_ptr d_ifft; + Gnss_Synchro* d_gnss_synchro; + uint32_t d_code_phase; + float d_doppler_freq; + float d_input_power; + float d_test_statistics; + std::ofstream d_dump_file; + int32_t d_state; + bool d_active; + bool d_disable_assist; + int32_t d_well_count; + bool d_dump; + uint32_t d_channel; + std::weak_ptr d_channel_fsm; + std::string d_dump_filename; }; #endif /* GNSS_SDR_PCPS_assisted_acquisition_cc_H_*/ diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.h index 7d5bc3b0e..9fed31338 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.h @@ -52,8 +52,7 @@ class pcps_cccwsr_acquisition_cc; using pcps_cccwsr_acquisition_cc_sptr = boost::shared_ptr; -pcps_cccwsr_acquisition_cc_sptr -pcps_cccwsr_make_acquisition_cc( +pcps_cccwsr_acquisition_cc_sptr pcps_cccwsr_make_acquisition_cc( uint32_t sampled_ms, uint32_t max_dwells, uint32_t doppler_max, @@ -69,59 +68,6 @@ pcps_cccwsr_make_acquisition_cc( */ class pcps_cccwsr_acquisition_cc : public gr::block { -private: - friend pcps_cccwsr_acquisition_cc_sptr - pcps_cccwsr_make_acquisition_cc(uint32_t sampled_ms, uint32_t max_dwells, - uint32_t doppler_max, int64_t fs_in, - int32_t samples_per_ms, int32_t samples_per_code, - bool dump, std::string dump_filename); - - pcps_cccwsr_acquisition_cc(uint32_t sampled_ms, uint32_t max_dwells, - uint32_t doppler_max, int64_t fs_in, - int32_t samples_per_ms, int32_t samples_per_code, - bool dump, std::string dump_filename); - - void calculate_magnitudes(gr_complex* fft_begin, int32_t doppler_shift, - int32_t doppler_offset); - - int64_t d_fs_in; - int32_t d_samples_per_ms; - int32_t d_samples_per_code; - uint32_t d_doppler_resolution; - float d_threshold; - std::string d_satellite_str; - uint32_t d_doppler_max; - uint32_t d_doppler_step; - uint32_t d_sampled_ms; - uint32_t d_max_dwells; - uint32_t d_well_count; - uint32_t d_fft_size; - uint64_t d_sample_counter; - gr_complex** d_grid_doppler_wipeoffs; - uint32_t d_num_doppler_bins; - gr_complex* d_fft_code_data; - gr_complex* d_fft_code_pilot; - std::shared_ptr d_fft_if; - std::shared_ptr d_ifft; - Gnss_Synchro* d_gnss_synchro; - uint32_t d_code_phase; - float d_doppler_freq; - float d_mag; - float* d_magnitude; - gr_complex* d_data_correlation; - gr_complex* d_pilot_correlation; - gr_complex* d_correlation_plus; - gr_complex* d_correlation_minus; - float d_input_power; - float d_test_statistics; - std::ofstream d_dump_file; - bool d_active; - int32_t d_state; - bool d_dump; - uint32_t d_channel; - std::weak_ptr d_channel_fsm; - std::string d_dump_filename; - public: /*! * \brief Default destructor. @@ -226,6 +172,59 @@ public: int general_work(int noutput_items, gr_vector_int& ninput_items, gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); + +private: + friend pcps_cccwsr_acquisition_cc_sptr + pcps_cccwsr_make_acquisition_cc(uint32_t sampled_ms, uint32_t max_dwells, + uint32_t doppler_max, int64_t fs_in, + int32_t samples_per_ms, int32_t samples_per_code, + bool dump, std::string dump_filename); + + pcps_cccwsr_acquisition_cc(uint32_t sampled_ms, uint32_t max_dwells, + uint32_t doppler_max, int64_t fs_in, + int32_t samples_per_ms, int32_t samples_per_code, + bool dump, std::string dump_filename); + + void calculate_magnitudes(gr_complex* fft_begin, int32_t doppler_shift, + int32_t doppler_offset); + + int64_t d_fs_in; + int32_t d_samples_per_ms; + int32_t d_samples_per_code; + uint32_t d_doppler_resolution; + float d_threshold; + std::string d_satellite_str; + uint32_t d_doppler_max; + uint32_t d_doppler_step; + uint32_t d_sampled_ms; + uint32_t d_max_dwells; + uint32_t d_well_count; + uint32_t d_fft_size; + uint64_t d_sample_counter; + gr_complex** d_grid_doppler_wipeoffs; + uint32_t d_num_doppler_bins; + gr_complex* d_fft_code_data; + gr_complex* d_fft_code_pilot; + std::shared_ptr d_fft_if; + std::shared_ptr d_ifft; + Gnss_Synchro* d_gnss_synchro; + uint32_t d_code_phase; + float d_doppler_freq; + float d_mag; + float* d_magnitude; + gr_complex* d_data_correlation; + gr_complex* d_pilot_correlation; + gr_complex* d_correlation_plus; + gr_complex* d_correlation_minus; + float d_input_power; + float d_test_statistics; + std::ofstream d_dump_file; + bool d_active; + int32_t d_state; + bool d_dump; + uint32_t d_channel; + std::weak_ptr d_channel_fsm; + std::string d_dump_filename; }; #endif /* GNSS_SDR_PCPS_CCCWSR_ACQUISITION_CC_H_*/ diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.h index bab96e123..5eec41228 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.h @@ -54,11 +54,11 @@ #define CL_SILENCE_DEPRECATION #include "channel_fsm.h" #include "gnss_synchro.h" -#include "opencl/cl.hpp" #include "opencl/fft_internal.h" #include #include #include +#include "opencl/cl.hpp" #include #include #include @@ -68,10 +68,13 @@ class pcps_opencl_acquisition_cc; typedef boost::shared_ptr pcps_opencl_acquisition_cc_sptr; -pcps_opencl_acquisition_cc_sptr -pcps_make_opencl_acquisition_cc(uint32_t sampled_ms, uint32_t max_dwells, - uint32_t doppler_max, int64_t fs_in, - int samples_per_ms, int samples_per_code, +pcps_opencl_acquisition_cc_sptr pcps_make_opencl_acquisition_cc( + uint32_t sampled_ms, + uint32_t max_dwells, + uint32_t doppler_max, + int64_t fs_in, + int samples_per_ms, + int samples_per_code, bool bit_transition_flag, bool dump, std::string dump_filename); @@ -84,6 +87,124 @@ pcps_make_opencl_acquisition_cc(uint32_t sampled_ms, uint32_t max_dwells, */ class pcps_opencl_acquisition_cc : public gr::block { +public: + /*! + * \brief Default destructor. + */ + ~pcps_opencl_acquisition_cc(); + + /*! + * \brief Set acquisition/tracking common Gnss_Synchro object pointer + * to exchange synchronization data between acquisition and tracking blocks. + * \param p_gnss_synchro Satellite information shared by the processing blocks. + */ + inline void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) + { + d_gnss_synchro = p_gnss_synchro; + } + + /*! + * \brief Returns the maximum peak of grid search. + */ + inline uint32_t mag() const + { + return d_mag; + } + + /*! + * \brief Initializes acquisition algorithm. + */ + void init(); + + /*! + * \brief Sets local code for PCPS acquisition algorithm. + * \param code - Pointer to the PRN code. + */ + void set_local_code(std::complex* code); + + /*! + * \brief Starts acquisition algorithm, turning from standby mode to + * active mode + * \param active - bool that activates/deactivates the block. + */ + inline void set_active(bool active) + { + d_active = active; + } + + /*! + * \brief If set to 1, ensures that acquisition starts at the + * first available sample. + * \param state - int=1 forces start of acquisition + */ + void set_state(int state); + + /*! + * \brief Set acquisition channel unique ID + * \param channel - receiver channel. + */ + inline void set_channel(uint32_t channel) + { + d_channel = channel; + } + + /*! + * \brief Set channel fsm associated to this acquisition instance + */ + inline void set_channel_fsm(std::weak_ptr channel_fsm) + { + d_channel_fsm = channel_fsm; + } + + /*! + * \brief Set statistics threshold of PCPS algorithm. + * \param threshold - Threshold for signal detection (check \ref Navitec2012, + * Algorithm 1, for a definition of this threshold). + */ + inline void set_threshold(float threshold) + { + d_threshold = threshold; + } + + /*! + * \brief Set maximum Doppler grid search + * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz]. + */ + inline void set_doppler_max(uint32_t doppler_max) + { + d_doppler_max = doppler_max; + } + + /*! + * \brief Set Doppler steps for the grid search + * \param doppler_step - Frequency bin of the search grid [Hz]. + */ + inline void set_doppler_step(uint32_t doppler_step) + { + d_doppler_step = doppler_step; + } + + inline bool opencl_ready() const + { + bool ready = false; + if (d_opencl == 0) + { + ready = true; + } + return ready; + } + + void acquisition_core_volk(); + + void acquisition_core_opencl(); + + /*! + * \brief Parallel Code Phase Search Acquisition signal processing. + */ + int general_work(int noutput_items, gr_vector_int& ninput_items, + gr_vector_const_void_star& input_items, + gr_vector_void_star& output_items); + private: friend pcps_opencl_acquisition_cc_sptr pcps_make_opencl_acquisition_cc(uint32_t sampled_ms, uint32_t max_dwells, @@ -144,6 +265,8 @@ private: gr_complex** d_in_buffer; std::vector d_sample_counter_buffer; uint32_t d_in_dwell_count; + std::weak_ptr d_channel_fsm; + int d_opencl; cl::Platform d_cl_platform; cl::Device d_cl_device; @@ -158,125 +281,6 @@ private: cl::CommandQueue* d_cl_queue; clFFT_Plan d_cl_fft_plan; cl_int d_cl_fft_batch_size; - std::weak_ptr d_channel_fsm; - int d_opencl; - -public: - /*! - * \brief Default destructor. - */ - ~pcps_opencl_acquisition_cc(); - - /*! - * \brief Set acquisition/tracking common Gnss_Synchro object pointer - * to exchange synchronization data between acquisition and tracking blocks. - * \param p_gnss_synchro Satellite information shared by the processing blocks. - */ - inline void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) - { - d_gnss_synchro = p_gnss_synchro; - } - - /*! - * \brief Returns the maximum peak of grid search. - */ - inline uint32_t mag() const - { - return d_mag; - } - - /*! - * \brief Initializes acquisition algorithm. - */ - void init(); - - /*! - * \brief Sets local code for PCPS acquisition algorithm. - * \param code - Pointer to the PRN code. - */ - void set_local_code(std::complex* code); - - /*! - * \brief Starts acquisition algorithm, turning from standby mode to - * active mode - * \param active - bool that activates/deactivates the block. - */ - inline void set_active(bool active) - { - d_active = active; - } - - /*! - * \brief If set to 1, ensures that acquisition starts at the - * first available sample. - * \param state - int=1 forces start of acquisition - */ - void set_state(int state); - - /*! - * \brief Set acquisition channel unique ID - * \param channel - receiver channel. - */ - inline void set_channel(uint32_t channel) - { - d_channel = channel; - } - - /*! - * \brief Set channel fsm associated to this acquisition instance - */ - inline void set_channel_fsm(std::weak_ptr channel_fsm) - { - d_channel_fsm = channel_fsm; - } - /*! - * \brief Set statistics threshold of PCPS algorithm. - * \param threshold - Threshold for signal detection (check \ref Navitec2012, - * Algorithm 1, for a definition of this threshold). - */ - inline void set_threshold(float threshold) - { - d_threshold = threshold; - } - - /*! - * \brief Set maximum Doppler grid search - * \param doppler_max - Maximum Doppler shift considered in the grid search [Hz]. - */ - inline void set_doppler_max(uint32_t doppler_max) - { - d_doppler_max = doppler_max; - } - - /*! - * \brief Set Doppler steps for the grid search - * \param doppler_step - Frequency bin of the search grid [Hz]. - */ - inline void set_doppler_step(uint32_t doppler_step) - { - d_doppler_step = doppler_step; - } - - inline bool opencl_ready() const - { - bool ready = false; - if (d_opencl == 0) - { - ready = true; - } - return ready; - } - - /*! - * \brief Parallel Code Phase Search Acquisition signal processing. - */ - int general_work(int noutput_items, gr_vector_int& ninput_items, - gr_vector_const_void_star& input_items, - gr_vector_void_star& output_items); - - void acquisition_core_volk(); - - void acquisition_core_opencl(); }; #endif diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.h index 17e80aa95..2f0bdda3a 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.h @@ -67,8 +67,7 @@ class pcps_quicksync_acquisition_cc; using pcps_quicksync_acquisition_cc_sptr = boost::shared_ptr; -pcps_quicksync_acquisition_cc_sptr -pcps_quicksync_make_acquisition_cc( +pcps_quicksync_acquisition_cc_sptr pcps_quicksync_make_acquisition_cc( uint32_t folding_factor, uint32_t sampled_ms, uint32_t max_dwells, @@ -89,71 +88,6 @@ pcps_quicksync_make_acquisition_cc( */ class pcps_quicksync_acquisition_cc : public gr::block { -private: - friend pcps_quicksync_acquisition_cc_sptr - pcps_quicksync_make_acquisition_cc(uint32_t folding_factor, - uint32_t sampled_ms, uint32_t max_dwells, - uint32_t doppler_max, int64_t fs_in, - int32_t samples_per_ms, int32_t samples_per_code, - bool bit_transition_flag, - bool dump, - std::string dump_filename); - - pcps_quicksync_acquisition_cc(uint32_t folding_factor, - uint32_t sampled_ms, uint32_t max_dwells, - uint32_t doppler_max, int64_t fs_in, - int32_t samples_per_ms, int32_t samples_per_code, - bool bit_transition_flag, - bool dump, - std::string dump_filename); - - void calculate_magnitudes(gr_complex* fft_begin, int32_t doppler_shift, - int32_t doppler_offset); - - gr_complex* d_code; - uint32_t d_folding_factor; // also referred in the paper as 'p' - float* d_corr_acumulator; - uint32_t* d_possible_delay; - float* d_corr_output_f; - float* d_magnitude_folded; - gr_complex* d_signal_folded; - gr_complex* d_code_folded; - float d_noise_floor_power; - - int64_t d_fs_in; - int32_t d_samples_per_ms; - int32_t d_samples_per_code; - uint32_t d_doppler_resolution; - float d_threshold; - std::string d_satellite_str; - uint32_t d_doppler_max; - uint32_t d_doppler_step; - uint32_t d_sampled_ms; - uint32_t d_max_dwells; - uint32_t d_well_count; - uint32_t d_fft_size; - uint64_t d_sample_counter; - gr_complex** d_grid_doppler_wipeoffs; - uint32_t d_num_doppler_bins; - gr_complex* d_fft_codes; - std::shared_ptr d_fft_if; - std::shared_ptr d_ifft; - Gnss_Synchro* d_gnss_synchro; - uint32_t d_code_phase; - float d_doppler_freq; - float d_mag; - float* d_magnitude; - float d_input_power; - float d_test_statistics; - bool d_bit_transition_flag; - std::ofstream d_dump_file; - bool d_active; - int32_t d_state; - bool d_dump; - uint32_t d_channel; - std::weak_ptr d_channel_fsm; - std::string d_dump_filename; - public: /*! * \brief Default destructor. @@ -257,6 +191,70 @@ public: int general_work(int noutput_items, gr_vector_int& ninput_items, gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); + +private: + friend pcps_quicksync_acquisition_cc_sptr + pcps_quicksync_make_acquisition_cc(uint32_t folding_factor, + uint32_t sampled_ms, uint32_t max_dwells, + uint32_t doppler_max, int64_t fs_in, + int32_t samples_per_ms, int32_t samples_per_code, + bool bit_transition_flag, + bool dump, + std::string dump_filename); + + pcps_quicksync_acquisition_cc(uint32_t folding_factor, + uint32_t sampled_ms, uint32_t max_dwells, + uint32_t doppler_max, int64_t fs_in, + int32_t samples_per_ms, int32_t samples_per_code, + bool bit_transition_flag, + bool dump, + std::string dump_filename); + + void calculate_magnitudes(gr_complex* fft_begin, int32_t doppler_shift, + int32_t doppler_offset); + + gr_complex* d_code; + uint32_t d_folding_factor; // also referred in the paper as 'p' + float* d_corr_acumulator; + uint32_t* d_possible_delay; + float* d_corr_output_f; + float* d_magnitude_folded; + gr_complex* d_signal_folded; + gr_complex* d_code_folded; + float d_noise_floor_power; + int64_t d_fs_in; + int32_t d_samples_per_ms; + int32_t d_samples_per_code; + uint32_t d_doppler_resolution; + float d_threshold; + std::string d_satellite_str; + uint32_t d_doppler_max; + uint32_t d_doppler_step; + uint32_t d_sampled_ms; + uint32_t d_max_dwells; + uint32_t d_well_count; + uint32_t d_fft_size; + uint64_t d_sample_counter; + gr_complex** d_grid_doppler_wipeoffs; + uint32_t d_num_doppler_bins; + gr_complex* d_fft_codes; + std::shared_ptr d_fft_if; + std::shared_ptr d_ifft; + Gnss_Synchro* d_gnss_synchro; + uint32_t d_code_phase; + float d_doppler_freq; + float d_mag; + float* d_magnitude; + float d_input_power; + float d_test_statistics; + bool d_bit_transition_flag; + std::ofstream d_dump_file; + bool d_active; + int32_t d_state; + bool d_dump; + uint32_t d_channel; + std::weak_ptr d_channel_fsm; + std::string d_dump_filename; }; -#endif /* GNSS_SDR_PCPS_ACQUISITION_CC_H_*/ +#endif /* GNSS_SDR_PCPS_QUICKSYNC_ACQUISITION_CC_H_ */ diff --git a/src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h b/src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h index 5c8f4c81c..c4a9e77f0 100644 --- a/src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h +++ b/src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h @@ -65,8 +65,7 @@ class pcps_tong_acquisition_cc; using pcps_tong_acquisition_cc_sptr = boost::shared_ptr; -pcps_tong_acquisition_cc_sptr -pcps_tong_make_acquisition_cc( +pcps_tong_acquisition_cc_sptr pcps_tong_make_acquisition_cc( uint32_t sampled_ms, uint32_t doppler_max, int64_t fs_in, @@ -84,60 +83,6 @@ pcps_tong_make_acquisition_cc( */ class pcps_tong_acquisition_cc : public gr::block { -private: - friend pcps_tong_acquisition_cc_sptr - pcps_tong_make_acquisition_cc(uint32_t sampled_ms, uint32_t doppler_max, - int64_t fs_in, int32_t samples_per_ms, - int32_t samples_per_code, uint32_t tong_init_val, - uint32_t tong_max_val, uint32_t tong_max_dwells, - bool dump, std::string dump_filename); - - pcps_tong_acquisition_cc(uint32_t sampled_ms, uint32_t doppler_max, - int64_t fs_in, int32_t samples_per_ms, - int32_t samples_per_code, uint32_t tong_init_val, - uint32_t tong_max_val, uint32_t tong_max_dwells, - bool dump, std::string dump_filename); - - void calculate_magnitudes(gr_complex* fft_begin, int32_t doppler_shift, - int32_t doppler_offset); - - int64_t d_fs_in; - int32_t d_samples_per_ms; - int32_t d_samples_per_code; - uint32_t d_doppler_resolution; - float d_threshold; - std::string d_satellite_str; - uint32_t d_doppler_max; - uint32_t d_doppler_step; - uint32_t d_sampled_ms; - uint32_t d_dwell_count; - uint32_t d_tong_count; - uint32_t d_tong_init_val; - uint32_t d_tong_max_val; - uint32_t d_tong_max_dwells; - uint32_t d_fft_size; - uint64_t d_sample_counter; - gr_complex** d_grid_doppler_wipeoffs; - uint32_t d_num_doppler_bins; - gr_complex* d_fft_codes; - float** d_grid_data; - std::shared_ptr d_fft_if; - std::shared_ptr d_ifft; - Gnss_Synchro* d_gnss_synchro; - uint32_t d_code_phase; - float d_doppler_freq; - float d_mag; - float* d_magnitude; - float d_input_power; - float d_test_statistics; - std::ofstream d_dump_file; - bool d_active; - int32_t d_state; - bool d_dump; - uint32_t d_channel; - std::weak_ptr d_channel_fsm; - std::string d_dump_filename; - public: /*! * \brief Default destructor. @@ -241,6 +186,60 @@ public: int general_work(int noutput_items, gr_vector_int& ninput_items, gr_vector_const_void_star& input_items, gr_vector_void_star& output_items); + +private: + friend pcps_tong_acquisition_cc_sptr + pcps_tong_make_acquisition_cc(uint32_t sampled_ms, uint32_t doppler_max, + int64_t fs_in, int32_t samples_per_ms, + int32_t samples_per_code, uint32_t tong_init_val, + uint32_t tong_max_val, uint32_t tong_max_dwells, + bool dump, std::string dump_filename); + + pcps_tong_acquisition_cc(uint32_t sampled_ms, uint32_t doppler_max, + int64_t fs_in, int32_t samples_per_ms, + int32_t samples_per_code, uint32_t tong_init_val, + uint32_t tong_max_val, uint32_t tong_max_dwells, + bool dump, std::string dump_filename); + + void calculate_magnitudes(gr_complex* fft_begin, int32_t doppler_shift, + int32_t doppler_offset); + + int64_t d_fs_in; + int32_t d_samples_per_ms; + int32_t d_samples_per_code; + uint32_t d_doppler_resolution; + float d_threshold; + std::string d_satellite_str; + uint32_t d_doppler_max; + uint32_t d_doppler_step; + uint32_t d_sampled_ms; + uint32_t d_dwell_count; + uint32_t d_tong_count; + uint32_t d_tong_init_val; + uint32_t d_tong_max_val; + uint32_t d_tong_max_dwells; + uint32_t d_fft_size; + uint64_t d_sample_counter; + gr_complex** d_grid_doppler_wipeoffs; + uint32_t d_num_doppler_bins; + gr_complex* d_fft_codes; + float** d_grid_data; + std::shared_ptr d_fft_if; + std::shared_ptr d_ifft; + Gnss_Synchro* d_gnss_synchro; + uint32_t d_code_phase; + float d_doppler_freq; + float d_mag; + float* d_magnitude; + float d_input_power; + float d_test_statistics; + std::ofstream d_dump_file; + bool d_active; + int32_t d_state; + bool d_dump; + uint32_t d_channel; + std::weak_ptr d_channel_fsm; + std::string d_dump_filename; }; #endif /* GNSS_SDR_PCPS_TONG_ACQUISITION_CC_H_ */