mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-11-17 07:14:55 +00:00
Code Issues Releases Wiki Activity

Merge branch 'next' of https://github.com/gnss-sdr/gnss-sdr into galileo-e6

Browse Source
This commit is contained in:
Carles Fernandez 2021-12-15 02:49:22 +01:00
commit 44d716b957
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
30 changed files with 736 additions and 950 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -36,11 +36,16 @@ GpsL1CaPcpsOpenClAcquisition::GpsL1CaPcpsOpenClAcquisition(
const ConfigurationInterface* configuration,
const std::string& role,
unsigned int in_streams,
unsigned int out_streams) : role_(role),
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";
@ -98,11 +103,6 @@ GpsL1CaPcpsOpenClAcquisition::GpsL1CaPcpsOpenClAcquisition(
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";

66
src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc
View File

@ -64,20 +64,42 @@ galileo_e5a_noncoherentIQ_acquisition_caf_cc::galileo_e5a_noncoherentIQ_acquisit
bool both_signal_components_,
int CAF_window_hz_,
int Zero_padding_,
bool enable_monitor_output) : gr::block("galileo_e5a_noncoherentIQ_acquisition_caf_cc",
bool enable_monitor_output)
: gr::block("galileo_e5a_noncoherentIQ_acquisition_caf_cc",
gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_sample_counter(0ULL),
d_threshold(0),
d_doppler_freq(0),
d_mag(0),
d_input_power(0.0),
d_test_statistics(0),
d_state(0),
d_samples_per_ms(samples_per_ms),
d_samples_per_code(samples_per_code),
d_CAF_window_hz(CAF_window_hz_),
d_buffer_count(0),
d_doppler_resolution(0),
d_doppler_max(static_cast<int>(doppler_max)),
d_doppler_step(250),
d_fft_size(static_cast<int>(sampled_ms) * d_samples_per_ms),
d_num_doppler_bins(0),
d_gr_stream_buffer(0),
d_channel(0),
d_max_dwells(max_dwells),
d_well_count(0),
d_code_phase(0),
d_bit_transition_flag(bit_transition_flag),
d_active(false),
d_dump(dump),
d_both_signal_components(both_signal_components_),
d_enable_monitor_output(enable_monitor_output)
{
this->message_port_register_out(pmt::mp("events"));
d_sample_counter = 0ULL; // SAMPLE COUNTER
d_active = false;
d_state = 0;
d_fs_in = fs_in;
d_samples_per_ms = samples_per_ms;
d_samples_per_code = samples_per_code;
d_max_dwells = max_dwells;
d_well_count = 0;
d_doppler_max = static_cast<int>(doppler_max);
if (Zero_padding_ > 0)
{
d_sampled_ms = 1;
@ -86,15 +108,6 @@ galileo_e5a_noncoherentIQ_acquisition_caf_cc::galileo_e5a_noncoherentIQ_acquisit
{
d_sampled_ms = sampled_ms;
}
d_fft_size = static_cast<int>(sampled_ms) * d_samples_per_ms;
d_mag = 0;
d_input_power = 0.0;
d_num_doppler_bins = 0;
d_bit_transition_flag = bit_transition_flag;
d_buffer_count = 0;
d_both_signal_components = both_signal_components_;
d_CAF_window_hz = CAF_window_hz_;
d_enable_monitor_output = enable_monitor_output;
d_inbuffer = std::vector<gr_complex>(d_fft_size);
d_fft_code_I_A = std::vector<gr_complex>(d_fft_size);
@ -120,19 +133,6 @@ galileo_e5a_noncoherentIQ_acquisition_caf_cc::galileo_e5a_noncoherentIQ_acquisit
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
d_dump = dump;
d_dump_filename = dump_filename;
d_doppler_resolution = 0;
d_threshold = 0;
d_doppler_step = 250;
d_gnss_synchro = nullptr;
d_code_phase = 0;
d_doppler_freq = 0;
d_test_statistics = 0;
d_channel = 0;
d_gr_stream_buffer = 0;
}

59
src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.cc
View File

@ -52,46 +52,43 @@ galileo_pcps_8ms_acquisition_cc::galileo_pcps_8ms_acquisition_cc(
int32_t samples_per_code,
bool dump,
const std::string &dump_filename,
bool enable_monitor_output) : gr::block("galileo_pcps_8ms_acquisition_cc",
bool enable_monitor_output)
: gr::block("galileo_pcps_8ms_acquisition_cc",
gr::io_signature::make(1, 1, static_cast<int>(sizeof(gr_complex) * sampled_ms * samples_per_ms)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_sample_counter(0ULL),
d_threshold(0),
d_doppler_freq(0),
d_mag(0),
d_input_power(0.0),
d_test_statistics(0),
d_state(0),
d_samples_per_ms(samples_per_ms),
d_samples_per_code(samples_per_code),
d_channel(0),
d_doppler_resolution(0),
d_doppler_max(doppler_max),
d_doppler_step(0),
d_sampled_ms(sampled_ms),
d_max_dwells(max_dwells),
d_well_count(0),
d_fft_size(d_sampled_ms * d_samples_per_ms),
d_num_doppler_bins(0),
d_code_phase(0),
d_active(false),
d_dump(dump),
d_enable_monitor_output(enable_monitor_output)
{
this->message_port_register_out(pmt::mp("events"));
d_sample_counter = 0ULL; // SAMPLE COUNTER
d_active = false;
d_state = 0;
d_fs_in = fs_in;
d_samples_per_ms = samples_per_ms;
d_samples_per_code = samples_per_code;
d_sampled_ms = sampled_ms;
d_max_dwells = max_dwells;
d_well_count = 0;
d_doppler_max = doppler_max;
d_fft_size = d_sampled_ms * d_samples_per_ms;
d_mag = 0;
d_input_power = 0.0;
d_num_doppler_bins = 0;
d_fft_code_A = std::vector<gr_complex>(d_fft_size, lv_cmake(0.0F, 0.0F));
d_fft_code_B = std::vector<gr_complex>(d_fft_size, lv_cmake(0.0F, 0.0F));
d_magnitude = std::vector<float>(d_fft_size, 0.0F);
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;
d_dump_filename = dump_filename;
d_enable_monitor_output = enable_monitor_output;
d_doppler_resolution = 0;
d_threshold = 0;
d_doppler_step = 0;
d_gnss_synchro = nullptr;
d_code_phase = 0;
d_doppler_freq = 0;
d_test_statistics = 0;
d_channel = 0;
}

58
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc
View File

@ -41,30 +41,41 @@ pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(cons
pcps_acquisition_fine_doppler_cc::pcps_acquisition_fine_doppler_cc(const Acq_Conf &conf_)
: gr::block("pcps_acquisition_fine_doppler_cc",
gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro))),
d_dump_filename(conf_.dump_filename),
d_gnss_synchro(nullptr),
acq_parameters(conf_),
d_fs_in(conf_.fs_in),
d_dump_number(0),
d_sample_counter(0ULL),
d_threshold(0),
d_test_statistics(0),
d_positive_acq(0),
d_state(0),
d_samples_per_ms(static_cast<int>(conf_.samples_per_ms)),
d_max_dwells(conf_.max_dwells),
d_config_doppler_max(conf_.doppler_max),
d_num_doppler_points(0),
d_well_count(0),
d_n_samples_in_buffer(0),
d_fft_size(d_samples_per_ms),
d_gnuradio_forecast_samples(d_fft_size),
d_doppler_step(0),
d_channel(0),
d_dump_channel(0),
d_active(false),
d_dump(conf_.dump)
{
this->message_port_register_out(pmt::mp("events"));
acq_parameters = conf_;
d_sample_counter = 0ULL; // SAMPLE COUNTER
d_active = false;
d_fs_in = conf_.fs_in;
d_samples_per_ms = static_cast<int>(conf_.samples_per_ms);
d_config_doppler_max = conf_.doppler_max;
d_fft_size = d_samples_per_ms;
// HS Acquisition
d_max_dwells = conf_.max_dwells;
d_gnuradio_forecast_samples = d_fft_size;
d_state = 0;
d_fft_codes = volk_gnsssdr::vector<gr_complex>(d_fft_size);
d_magnitude = volk_gnsssdr::vector<float>(d_fft_size);
d_10_ms_buffer = volk_gnsssdr::vector<gr_complex>(50 * d_samples_per_ms);
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = conf_.dump;
d_dump_filename = conf_.dump_filename;
// this implementation can only produce dumps in channel 0
// todo: migrate config parameters to the unified acquisition config class
if (d_dump)
{
std::string dump_path;
@ -96,21 +107,6 @@ pcps_acquisition_fine_doppler_cc::pcps_acquisition_fine_doppler_cc(const Acq_Con
d_dump = false;
}
}
d_n_samples_in_buffer = 0;
d_threshold = 0;
d_num_doppler_points = 0;
d_doppler_step = 0;
d_gnss_synchro = nullptr;
d_code_phase = 0;
d_doppler_freq = 0;
d_test_statistics = 0;
d_well_count = 0;
d_channel = 0;
d_positive_acq = 0;
d_dump_number = 0;
d_dump_channel = 0; // this implementation can only produce dumps in channel 0
// todo: migrate config parameters to the unified acquisition config class
}

4
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.h
View File

@ -219,7 +219,6 @@ private:
int64_t d_dump_number;
uint64_t d_sample_counter;
float d_doppler_freq;
float d_threshold;
float d_test_statistics;
@ -227,15 +226,14 @@ private:
int d_state;
int d_samples_per_ms;
int d_max_dwells;
int d_gnuradio_forecast_samples;
int d_config_doppler_max;
int d_num_doppler_points;
int d_well_count;
int d_n_samples_in_buffer;
int d_fft_size;
int d_gnuradio_forecast_samples;
unsigned int d_doppler_step;
unsigned int d_channel;
unsigned int d_code_phase;
unsigned int d_dump_channel;
bool d_active;

67
src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc
View File

@ -47,48 +47,45 @@ pcps_assisted_acquisition_cc_sptr pcps_make_assisted_acquisition_cc(
pcps_assisted_acquisition_cc::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, const std::string &dump_filename,
bool enable_monitor_output) : gr::block("pcps_assisted_acquisition_cc",
bool enable_monitor_output)
: gr::block("pcps_assisted_acquisition_cc",
gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_sample_counter(0ULL),
d_threshold(0),
d_doppler_freq(0),
d_input_power(0.0),
d_test_statistics(0),
d_doppler_resolution(0),
d_channel(0),
d_sampled_ms(sampled_ms),
d_code_phase(0),
d_samples_per_ms(samples_per_ms),
d_fft_size(d_sampled_ms * d_samples_per_ms),
d_max_dwells(max_dwells),
d_gnuradio_forecast_samples(d_fft_size * 4),
d_doppler_max(0),
d_doppler_min(0),
d_config_doppler_max(doppler_max),
d_config_doppler_min(doppler_min),
d_num_doppler_points(0),
d_doppler_step(0),
d_state(0),
d_well_count(0),
d_active(false),
d_disable_assist(false),
d_dump(dump),
d_enable_monitor_output(enable_monitor_output)
{
this->message_port_register_out(pmt::mp("events"));
d_sample_counter = 0ULL; // SAMPLE COUNTER
d_active = false;
d_fs_in = fs_in;
d_samples_per_ms = samples_per_ms;
d_sampled_ms = sampled_ms;
d_config_doppler_max = doppler_max;
d_config_doppler_min = doppler_min;
d_fft_size = d_sampled_ms * d_samples_per_ms;
// HS Acquisition
d_max_dwells = max_dwells;
d_gnuradio_forecast_samples = d_fft_size * 4;
d_input_power = 0.0;
d_state = 0;
d_disable_assist = false;
d_fft_codes = std::vector<gr_complex>(d_fft_size);
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;
d_dump_filename = dump_filename;
d_enable_monitor_output = enable_monitor_output;
d_doppler_resolution = 0;
d_threshold = 0;
d_doppler_max = 0;
d_doppler_min = 0;
d_num_doppler_points = 0;
d_doppler_step = 0;
d_gnss_synchro = nullptr;
d_code_phase = 0;
d_doppler_freq = 0;
d_test_statistics = 0;
d_well_count = 0;
d_channel = 0;
}

14
src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.h
View File

@ -219,7 +219,16 @@ private:
float d_doppler_freq;
float d_input_power;
float d_test_statistics;
uint32_t d_doppler_resolution;
uint32_t d_channel;
uint32_t d_sampled_ms;
uint32_t d_code_phase;
int32_t d_samples_per_ms;
uint32_t d_fft_size;
int32_t d_max_dwells;
int32_t d_gnuradio_forecast_samples;
int32_t d_doppler_max;
@ -230,11 +239,6 @@ private:
int32_t d_doppler_step;
int32_t d_state;
int32_t d_well_count;
uint32_t d_doppler_resolution;
uint32_t d_channel;
uint32_t d_sampled_ms;
uint32_t d_fft_size;
uint32_t d_code_phase;
bool d_active;
bool d_disable_assist;

59
src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.cc
View File

@ -57,25 +57,37 @@ pcps_cccwsr_acquisition_cc::pcps_cccwsr_acquisition_cc(
int32_t samples_per_code,
bool dump,
const std::string &dump_filename,
bool enable_monitor_output) : gr::block("pcps_cccwsr_acquisition_cc",
bool enable_monitor_output)
: gr::block("pcps_cccwsr_acquisition_cc",
gr::io_signature::make(1, 1, static_cast<int>(sizeof(gr_complex) * sampled_ms * samples_per_ms)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_sample_counter(0ULL),
d_threshold(0),
d_doppler_freq(0),
d_mag(0),
d_input_power(0.0),
d_test_statistics(0),
d_state(0),
d_samples_per_ms(samples_per_ms),
d_samples_per_code(samples_per_code),
d_doppler_resolution(0),
d_doppler_max(doppler_max),
d_doppler_step(0),
d_sampled_ms(sampled_ms),
d_max_dwells(max_dwells),
d_well_count(0),
d_fft_size(d_sampled_ms * d_samples_per_ms),
d_num_doppler_bins(0),
d_code_phase(0),
d_channel(0),
d_active(false),
d_dump(dump),
d_enable_monitor_output(enable_monitor_output)
{
this->message_port_register_out(pmt::mp("events"));
d_sample_counter = 0ULL; // SAMPLE COUNTER
d_active = false;
d_state = 0;
d_fs_in = fs_in;
d_samples_per_ms = samples_per_ms;
d_samples_per_code = samples_per_code;
d_sampled_ms = sampled_ms;
d_max_dwells = max_dwells;
d_well_count = 0;
d_doppler_max = doppler_max;
d_fft_size = d_sampled_ms * d_samples_per_ms;
d_mag = 0;
d_input_power = 0.0;
d_num_doppler_bins = 0;
d_fft_code_data = std::vector<gr_complex>(d_fft_size);
d_fft_code_pilot = std::vector<gr_complex>(d_fft_size);
@ -87,21 +99,6 @@ pcps_cccwsr_acquisition_cc::pcps_cccwsr_acquisition_cc(
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;
d_dump_filename = dump_filename;
d_enable_monitor_output = enable_monitor_output;
d_doppler_resolution = 0;
d_threshold = 0;
d_doppler_step = 0;
d_gnss_synchro = nullptr;
d_code_phase = 0;
d_doppler_freq = 0;
d_test_statistics = 0;
d_channel = 0;
}

54
src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.cc
View File

@ -76,34 +76,38 @@ pcps_opencl_acquisition_cc::pcps_opencl_acquisition_cc(
bool bit_transition_flag,
bool dump,
const std::string &dump_filename,
bool enable_monitor_output) : gr::block("pcps_opencl_acquisition_cc",
bool enable_monitor_output)
: gr::block("pcps_opencl_acquisition_cc",
gr::io_signature::make(1, 1, static_cast<int>(sizeof(gr_complex) * sampled_ms * samples_per_ms)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro))),
d_cl_fft_batch_size(1),
d_dump_filename(dump_filename),
d_fs_in(fs_in),
d_sample_counter(0ULL),
d_mag(0),
d_input_power(0.0),
d_samples_per_ms(samples_per_ms),
d_samples_per_code(samples_per_code),
d_state(0),
d_doppler_max(doppler_max),
d_sampled_ms(sampled_ms),
d_max_dwells(max_dwells),
d_well_count(0),
d_fft_size(d_sampled_ms * d_samples_per_ms),
d_fft_size_pow2(pow(2, ceil(log2(2 * d_fft_size)))),
d_num_doppler_bins(0),
d_in_dwell_count(0),
d_bit_transition_flag(bit_transition_flag),
d_active(false),
d_core_working(false),
d_dump(dump),
d_enable_monitor_output(enable_monitor_output)
{
this->message_port_register_out(pmt::mp("events"));
d_sample_counter = 0ULL; // SAMPLE COUNTER
d_active = false;
d_state = 0;
d_core_working = false;
d_fs_in = fs_in;
d_samples_per_ms = samples_per_ms;
d_samples_per_code = samples_per_code;
d_sampled_ms = sampled_ms;
d_max_dwells = max_dwells;
d_well_count = 0;
d_doppler_max = doppler_max;
d_fft_size = d_sampled_ms * d_samples_per_ms;
d_fft_size_pow2 = pow(2, ceil(log2(2 * d_fft_size)));
d_mag = 0;
d_input_power = 0.0;
d_num_doppler_bins = 0;
d_bit_transition_flag = bit_transition_flag;
d_in_dwell_count = 0;
d_cl_fft_batch_size = 1;
d_in_buffer = std::vector<std::vector<gr_complex>>(d_max_dwells, std::vector<gr_complex>(d_fft_size));
d_magnitude = std::vector<float>(d_fft_size);
d_fft_codes = std::vector<gr_complex>(_fft_size_pow2);
d_fft_codes = std::vector<gr_complex>(d_fft_size_pow2);
d_zero_vector = std::vector<gr_complex>(d_fft_size_pow2 - d_fft_size, 0.0);
d_opencl = init_opencl_environment("math_kernel.cl");
@ -116,12 +120,6 @@ pcps_opencl_acquisition_cc::pcps_opencl_acquisition_cc(
// Inverse FFT
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
}
// For dumping samples into a file
d_dump = dump;
d_dump_filename = dump_filename;
d_enable_monitor_output = enable_monitor_output;
}

67
src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.cc
View File

@ -59,29 +59,40 @@ pcps_quicksync_acquisition_cc::pcps_quicksync_acquisition_cc(
bool bit_transition_flag,
bool dump,
const std::string& dump_filename,
bool enable_monitor_output) : gr::block("pcps_quicksync_acquisition_cc",
bool enable_monitor_output)
: gr::block("pcps_quicksync_acquisition_cc",
gr::io_signature::make(1, 1, static_cast<int>(sizeof(gr_complex) * sampled_ms * samples_per_ms)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_sample_counter(0ULL),
d_noise_floor_power(0),
d_threshold(0),
d_doppler_freq(0),
d_mag(0),
d_input_power(0.0),
d_test_statistics(0),
d_samples_per_ms(samples_per_ms),
d_samples_per_code(samples_per_code),
d_state(0),
d_channel(0),
d_folding_factor(folding_factor),
d_doppler_resolution(0),
d_doppler_max(doppler_max),
d_doppler_step(0),
d_sampled_ms(sampled_ms),
d_max_dwells(max_dwells),
d_well_count(0),
d_fft_size((d_samples_per_code) / d_folding_factor),
d_num_doppler_bins(0),
d_code_phase(0),
d_bit_transition_flag(bit_transition_flag),
d_active(false),
d_dump(dump),
d_enable_monitor_output(enable_monitor_output)
{
this->message_port_register_out(pmt::mp("events"));
d_sample_counter = 0ULL; // SAMPLE COUNTER
d_active = false;
d_state = 0;
d_fs_in = fs_in;
d_samples_per_ms = samples_per_ms;
d_samples_per_code = samples_per_code;
d_sampled_ms = sampled_ms;
d_max_dwells = max_dwells;
d_well_count = 0;
d_doppler_max = doppler_max;
d_mag = 0;
d_input_power = 0.0;
d_num_doppler_bins = 0;
d_bit_transition_flag = bit_transition_flag;
d_folding_factor = folding_factor;
// fft size is reduced.
d_fft_size = (d_samples_per_code) / d_folding_factor;
d_fft_codes = std::vector<gr_complex>(d_fft_size);
d_magnitude = std::vector<float>(d_samples_per_code * d_folding_factor);
@ -96,24 +107,8 @@ pcps_quicksync_acquisition_cc::pcps_quicksync_acquisition_cc(
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;
d_dump_filename = dump_filename;
d_enable_monitor_output = enable_monitor_output;
d_code_folded = std::vector<gr_complex>(d_fft_size, lv_cmake(0.0F, 0.0F));
d_signal_folded = std::vector<gr_complex>(d_fft_size);
d_noise_floor_power = 0;
d_doppler_resolution = 0;
d_threshold = 0;
d_doppler_step = 0;
d_gnss_synchro = nullptr;
d_code_phase = 0;
d_doppler_freq = 0;
d_test_statistics = 0;
d_channel = 0;
}

65
src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.cc
View File

@ -75,49 +75,46 @@ pcps_tong_acquisition_cc::pcps_tong_acquisition_cc(
uint32_t tong_max_dwells,
bool dump,
const std::string &dump_filename,
bool enable_monitor_output) : gr::block("pcps_tong_acquisition_cc",
bool enable_monitor_output)
: gr::block("pcps_tong_acquisition_cc",
gr::io_signature::make(1, 1, static_cast<int>(sizeof(gr_complex) * sampled_ms * samples_per_ms)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_sample_counter(0ULL),
d_threshold(0),
d_doppler_freq(0),
d_mag(0),
d_input_power(0.0),
d_test_statistics(0),
d_state(0),
d_samples_per_ms(samples_per_ms),
d_samples_per_code(samples_per_code),
d_channel(0),
d_doppler_resolution(0),
d_doppler_max(doppler_max),
d_doppler_step(0),
d_sampled_ms(sampled_ms),
d_dwell_count(0),
d_tong_init_val(tong_init_val),
d_tong_max_val(tong_max_val),
d_tong_max_dwells(tong_max_dwells),
d_tong_count(d_tong_init_val),
d_fft_size(d_sampled_ms * d_samples_per_ms),
d_num_doppler_bins(0),
d_code_phase(0),
d_active(false),
d_dump(dump),
d_enable_monitor_output(enable_monitor_output)
{
this->message_port_register_out(pmt::mp("events"));
d_sample_counter = 0ULL; // SAMPLE COUNTER
d_active = false;
d_state = 0;
d_fs_in = fs_in;
d_samples_per_ms = samples_per_ms;
d_samples_per_code = samples_per_code;
d_sampled_ms = sampled_ms;
d_dwell_count = 0;
d_tong_max_val = tong_max_val;
d_tong_max_dwells = tong_max_dwells;
d_tong_init_val = tong_init_val;
d_tong_count = d_tong_init_val;
d_doppler_max = doppler_max;
d_fft_size = d_sampled_ms * d_samples_per_ms;
d_mag = 0;
d_input_power = 0.0;
d_num_doppler_bins = 0;
d_fft_codes = std::vector<gr_complex>(d_fft_size);
d_magnitude = std::vector<float>(d_fft_size);
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;
d_dump_filename = dump_filename;
d_enable_monitor_output = enable_monitor_output;
d_doppler_resolution = 0;
d_threshold = 0;
d_doppler_step = 0;
d_gnss_synchro = nullptr;
d_code_phase = 0;
d_doppler_freq = 0;
d_test_statistics = 0;
d_channel = 0;
}

2
src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h
View File

@ -231,10 +231,10 @@ private:
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_tong_count;
uint32_t d_fft_size;
uint32_t d_num_doppler_bins;
uint32_t d_code_phase;

2
src/algorithms/tracking/adapters/gps_l1_ca_kf_tracking.cc
View File

@ -42,7 +42,6 @@ GpsL1CaKfTracking::GpsL1CaKfTracking(
int order = configuration->property(role + ".order", 2);
int fs_in_deprecated = configuration->property("GNSS-SDR.internal_fs_hz", 2048000);
int fs_in = configuration->property("GNSS-SDR.internal_fs_sps", fs_in_deprecated);
int f_if = configuration->property(role + ".if", 0);
bool dump = configuration->property(role + ".dump", false);
float dll_bw_hz = configuration->property(role + ".dll_bw_hz", static_cast<float>(2.0));
if (FLAGS_dll_bw_hz != 0.0)
@ -66,7 +65,6 @@ GpsL1CaKfTracking::GpsL1CaKfTracking(
item_size_ = sizeof(gr_complex);
tracking_ = gps_l1_ca_kf_make_tracking_cc(
order,
f_if,
fs_in,
vector_length,
dump,

99
src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.cc
View File

@ -78,37 +78,57 @@ Galileo_E1_Tcp_Connector_Tracking_cc::Galileo_E1_Tcp_Connector_Tracking_cc(
float dll_bw_hz __attribute__((unused)),
float early_late_space_chips,
float very_early_late_space_chips,
size_t port_ch0) : gr::block("Galileo_E1_Tcp_Connector_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
size_t port_ch0)
: gr::block("Galileo_E1_Tcp_Connector_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_vector_length(vector_length),
d_dump(dump),
d_acquisition_gnss_synchro(nullptr),
d_channel(0),
d_fs_in(fs_in),
d_correlation_length_samples(d_vector_length),
d_n_correlator_taps(5),
d_early_late_spc_chips(early_late_space_chips),
d_very_early_late_spc_chips(very_early_late_space_chips),
d_rem_code_phase_samples(0.0),
d_next_rem_code_phase_samples(0),
d_rem_carr_phase_rad(0.0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_code_freq_chips(GALILEO_E1_CODE_CHIP_RATE_CPS),
d_carrier_doppler_hz(0.0),
d_acc_carrier_phase_rad(0.0),
d_acc_code_phase_secs(0.0),
d_code_phase_samples(0),
d_port_ch0(port_ch0),
d_port(0),
d_listen_connection(true),
d_control_id(0),
d_current_prn_length_samples(static_cast<int32_t>(d_vector_length)),
d_next_prn_length_samples(0),
d_sample_counter(0ULL),
d_acq_sample_stamp(0),
d_cn0_estimation_counter(0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(static_cast<float>(FLAGS_carrier_lock_th)),
d_carrier_lock_fail_counter(0),
d_enable_tracking(false),
d_pull_in(false),
d_dump_filename(dump_filename)
{
this->message_port_register_out(pmt::mp("events"));
this->set_relative_rate(1.0 / vector_length);
// Telemetry message port input
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
// Initialize tracking ==========================================
// -- DLL variables --------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
d_very_early_late_spc_chips = very_early_late_space_chips; // Define very-early-late offset (in chips)
// -- TCP CONNECTOR variables --------------------------------------------------------
d_port_ch0 = port_ch0;
d_port = 0;
d_listen_connection = true;
d_control_id = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
// Initialization of local code replica
// Get space for a vector with the sinboc(1,1) replica sampled 2x/chip
d_ca_code.resize(2 * GALILEO_E1_B_CODE_LENGTH_CHIPS, gr_complex(0.0, 0.0));
d_ca_code = volk_gnsssdr::vector<gr_complex>(2 * GALILEO_E1_B_CODE_LENGTH_CHIPS, gr_complex(0.0, 0.0));
// correlator outputs (scalar)
d_n_correlator_taps = 5; // Very-Early, Early, Prompt, Late, Very-Late
d_correlator_outs.resize(d_n_correlator_taps, gr_complex(0.0, 0.0));
d_correlator_outs = volk_gnsssdr::vector<gr_complex>(d_n_correlator_taps, gr_complex(0.0, 0.0));
// map memory pointers of correlator outputs
d_Very_Early = &d_correlator_outs[0];
d_Early = &d_correlator_outs[1];
@ -124,46 +144,9 @@ Galileo_E1_Tcp_Connector_Tracking_cc::Galileo_E1_Tcp_Connector_Tracking_cc(
d_local_code_shift_chips[3] = d_early_late_spc_chips;
d_local_code_shift_chips[4] = d_very_early_late_spc_chips;
d_correlation_length_samples = d_vector_length;
multicorrelator_cpu.init(2 * d_correlation_length_samples, d_n_correlator_taps);
// --- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_chips = GALILEO_E1_CODE_CHIP_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carr_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL;
d_acq_sample_stamp = 0;
d_enable_tracking = false;
d_pull_in = false;
d_current_prn_length_samples = static_cast<int32_t>(d_vector_length);
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = static_cast<float>(FLAGS_carrier_lock_th);
systemName["E"] = std::string("Galileo");
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_next_rem_code_phase_samples = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_acc_carrier_phase_rad = 0.0;
d_acc_code_phase_secs = 0.0;
d_code_phase_samples = 0;
d_next_prn_length_samples = 0;
d_carrier_doppler_hz = 0.0;
}

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

@ -104,8 +104,56 @@ glonass_l1_ca_dll_pll_c_aid_tracking_cc::glonass_l1_ca_dll_pll_c_aid_tracking_cc
float pll_bw_narrow_hz,
float dll_bw_narrow_hz,
int32_t extend_correlation_ms,
float early_late_space_chips) : gr::block("glonass_l1_ca_dll_pll_c_aid_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
float early_late_space_chips)
: gr::block("glonass_l1_ca_dll_pll_c_aid_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_acquisition_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_glonass_freq_ch(0),
d_early_late_spc_chips(early_late_space_chips),
d_vector_length(vector_length),
d_channel(0),
d_n_correlator_taps(3),
d_rem_code_phase_samples(0.0),
d_rem_code_phase_chips(0.0),
d_rem_carrier_phase_rad(0.0),
d_rem_code_phase_integer_samples(0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_dll_bw_hz(dll_bw_hz),
d_pll_bw_hz(pll_bw_hz),
d_dll_bw_narrow_hz(dll_bw_narrow_hz),
d_pll_bw_narrow_hz(pll_bw_narrow_hz),
d_code_freq_chips(GLONASS_L1_CA_CODE_RATE_CPS),
d_code_phase_step_chips(0.0),
d_carrier_doppler_hz(0.0),
d_carrier_frequency_hz(0.0),
d_carrier_doppler_old_hz(0.0),
d_carrier_phase_step_rad(0.0),
d_acc_carrier_phase_cycles(0.0),
d_code_phase_samples(0.0),
d_pll_to_dll_assist_secs_Ti(0.0),
d_code_error_chips_Ti(0.0),
d_code_error_filt_chips_s(0.0),
d_code_error_filt_chips_Ti(0.0),
d_carr_phase_error_secs_Ti(0.0),
d_preamble_timestamp_s(0.0),
d_extend_correlation_ms(extend_correlation_ms),
d_correlation_length_samples(static_cast<int32_t>(d_vector_length)),
d_sample_counter(0ULL),
d_acq_sample_stamp(0),
d_cn0_estimation_counter(0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(FLAGS_carrier_lock_th),
d_carrier_lock_fail_counter(0),
d_enable_extended_integration(false),
d_preamble_synchronized(false),
d_enable_tracking(false),
d_pull_in(false),
d_acc_carrier_phase_initialized(false),
d_dump(dump)
{
// Telemetry bit synchronization message port input
this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
@ -122,31 +170,16 @@ glonass_l1_ca_dll_pll_c_aid_tracking_cc::glonass_l1_ca_dll_pll_c_aid_tracking_cc
#endif
this->message_port_register_out(pmt::mp("events"));
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
d_correlation_length_samples = static_cast<int32_t>(d_vector_length);
// Initialize tracking ==========================================
d_pll_bw_hz = pll_bw_hz;
d_dll_bw_hz = dll_bw_hz;
d_pll_bw_narrow_hz = pll_bw_narrow_hz;
d_dll_bw_narrow_hz = dll_bw_narrow_hz;
d_extend_correlation_ms = extend_correlation_ms;
d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
d_carrier_loop_filter.set_params(10.0, d_pll_bw_hz, 2);
// --- DLL variables --------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code = volk_gnsssdr::vector<gr_complex>(static_cast<size_t>(GLONASS_L1_CA_CODE_LENGTH_CHIPS));
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Early, Prompt, and Late
// correlator outputs
d_correlator_outs = volk_gnsssdr::vector<gr_complex>(d_n_correlator_taps);
d_local_code_shift_chips = volk_gnsssdr::vector<float>(d_n_correlator_taps);
@ -157,59 +190,10 @@ glonass_l1_ca_dll_pll_c_aid_tracking_cc::glonass_l1_ca_dll_pll_c_aid_tracking_cc
multicorrelator_cpu.init(2 * d_correlation_length_samples, d_n_correlator_taps);
// --- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_chips = GLONASS_L1_CA_CODE_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carrier_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL; // (from trk to tlm)
d_acq_sample_stamp = 0;
d_enable_tracking = false;
d_pull_in = false;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = FLAGS_carrier_lock_th;
systemName["R"] = std::string("Glonass");
set_relative_rate(1.0 / static_cast<double>(d_vector_length));
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_doppler_hz = 0.0;
d_code_error_filt_chips_Ti = 0.0;
d_acc_carrier_phase_cycles = 0.0;
d_code_phase_samples = 0.0;
d_pll_to_dll_assist_secs_Ti = 0.0;
d_rem_code_phase_chips = 0.0;
d_code_phase_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
d_enable_extended_integration = false;
d_preamble_synchronized = false;
d_rem_code_phase_integer_samples = 0;
d_code_error_chips_Ti = 0.0;
d_code_error_filt_chips_s = 0.0;
d_carr_phase_error_secs_Ti = 0.0;
d_preamble_timestamp_s = 0.0;
d_carrier_frequency_hz = 0.0;
d_carrier_doppler_old_hz = 0.0;
d_glonass_freq_ch = 0;
d_acc_carrier_phase_initialized = false;
// set_min_output_buffer((int64_t)300);
}

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

@ -102,8 +102,56 @@ glonass_l1_ca_dll_pll_c_aid_tracking_sc::glonass_l1_ca_dll_pll_c_aid_tracking_sc
float pll_bw_narrow_hz,
float dll_bw_narrow_hz,
int32_t extend_correlation_ms,
float early_late_space_chips) : gr::block("glonass_l1_ca_dll_pll_c_aid_tracking_sc", gr::io_signature::make(1, 1, sizeof(lv_16sc_t)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
float early_late_space_chips)
: gr::block("glonass_l1_ca_dll_pll_c_aid_tracking_sc", gr::io_signature::make(1, 1, sizeof(lv_16sc_t)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_acquisition_gnss_synchro(nullptr),
d_dump_filename(dump_filename),
d_fs_in(fs_in),
d_glonass_freq_ch(0),
d_early_late_spc_chips(early_late_space_chips),
d_vector_length(vector_length),
d_channel(0),
d_n_correlator_taps(3),
d_rem_code_phase_samples(0.0),
d_rem_code_phase_chips(0.0),
d_rem_carrier_phase_rad(0.0),
d_rem_code_phase_integer_samples(0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_dll_bw_hz(dll_bw_hz),
d_pll_bw_hz(pll_bw_hz),
d_dll_bw_narrow_hz(dll_bw_narrow_hz),
d_pll_bw_narrow_hz(pll_bw_narrow_hz),
d_code_freq_chips(GLONASS_L1_CA_CODE_RATE_CPS),
d_code_phase_step_chips(0.0),
d_carrier_doppler_hz(0.0),
d_carrier_frequency_hz(0.0),
d_carrier_doppler_old_hz(0.0),
d_carrier_phase_step_rad(0.0),
d_acc_carrier_phase_cycles(0.0),
d_code_phase_samples(0.0),
d_pll_to_dll_assist_secs_Ti(0.0),
d_carr_phase_error_secs_Ti(0.0),
d_code_error_chips_Ti(0.0),
d_preamble_timestamp_s(0.0),
d_extend_correlation_ms(extend_correlation_ms),
d_code_error_filt_chips_s(0.0),
d_code_error_filt_chips_Ti(0.0),
d_correlation_length_samples(static_cast<int32_t>(d_vector_length)),
d_sample_counter(0ULL),
d_acq_sample_stamp(0),
d_cn0_estimation_counter(0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(FLAGS_carrier_lock_th),
d_carrier_lock_fail_counter(0),
d_enable_extended_integration(false),
d_preamble_synchronized(false),
d_enable_tracking(false),
d_pull_in(false),
d_acc_carrier_phase_initialized(false),
d_dump(dump)
{
// Telemetry bit synchronization message port input
this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
@ -119,31 +167,14 @@ glonass_l1_ca_dll_pll_c_aid_tracking_sc::glonass_l1_ca_dll_pll_c_aid_tracking_sc
#endif
this->message_port_register_out(pmt::mp("events"));
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
d_correlation_length_samples = static_cast<int32_t>(d_vector_length);
// Initialize tracking ==========================================
d_pll_bw_hz = pll_bw_hz;
d_dll_bw_hz = dll_bw_hz;
d_pll_bw_narrow_hz = pll_bw_narrow_hz;
d_dll_bw_narrow_hz = dll_bw_narrow_hz;
d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
d_carrier_loop_filter.set_params(10.0, d_pll_bw_hz, 2);
d_extend_correlation_ms = extend_correlation_ms;
// --- DLL variables --------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code = volk_gnsssdr::vector<gr_complex>(static_cast<size_t>(GLONASS_L1_CA_CODE_LENGTH_CHIPS));
d_ca_code_16sc = volk_gnsssdr::vector<lv_16sc_t>(static_cast<size_t>(GLONASS_L1_CA_CODE_LENGTH_CHIPS));
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Early, Prompt, and Late
d_correlator_outs_16sc = volk_gnsssdr::vector<lv_16sc_t>(d_n_correlator_taps);
@ -155,58 +186,11 @@ glonass_l1_ca_dll_pll_c_aid_tracking_sc::glonass_l1_ca_dll_pll_c_aid_tracking_sc
multicorrelator_cpu_16sc.init(2 * d_correlation_length_samples, d_n_correlator_taps);
// -- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_chips = GLONASS_L1_CA_CODE_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carrier_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL; // (from trk to tlm)
d_acq_sample_stamp = 0;
d_enable_tracking = false;
d_pull_in = false;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = FLAGS_carrier_lock_th;
systemName["R"] = std::string("Glonass");
set_relative_rate(1.0 / static_cast<double>(d_vector_length));
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_doppler_hz = 0.0;
d_acc_carrier_phase_cycles = 0.0;
d_code_phase_samples = 0.0;
d_enable_extended_integration = false;
d_preamble_synchronized = false;
d_rem_code_phase_integer_samples = 0;
d_code_error_chips_Ti = 0.0;
d_pll_to_dll_assist_secs_Ti = 0.0;
d_rem_code_phase_chips = 0.0;
d_code_phase_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
d_code_error_filt_chips_s = 0.0;
d_code_error_filt_chips_Ti = 0.0;
d_preamble_timestamp_s = 0.0;
d_carr_phase_error_secs_Ti = 0.0;
d_carrier_frequency_hz = 0.0;
d_carrier_doppler_old_hz = 0.0;
d_glonass_freq_ch = 0;
d_acc_carrier_phase_initialized = false;
// set_min_output_buffer((int64_t)300);
}

89
src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_tracking_cc.cc
View File

@ -77,32 +77,53 @@ Glonass_L1_Ca_Dll_Pll_Tracking_cc::Glonass_L1_Ca_Dll_Pll_Tracking_cc(
const std::string &dump_filename,
float pll_bw_hz,
float dll_bw_hz,
float early_late_space_chips) : gr::block("Glonass_L1_Ca_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
float early_late_space_chips)
: gr::block("Glonass_L1_Ca_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_acquisition_gnss_synchro(nullptr),
d_dump_filename(dump_filename),
d_fs_in(fs_in),
d_glonass_freq_ch(0),
d_early_late_spc_chips(early_late_space_chips),
d_vector_length(vector_length),
d_channel(0),
d_rem_code_phase_samples(0.0),
d_rem_code_phase_chips(0.0),
d_rem_carr_phase_rad(0.0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_code_freq_chips(GLONASS_L1_CA_CODE_RATE_CPS),
d_code_phase_step_chips(0.0),
d_carrier_doppler_hz(0.0),
d_carrier_doppler_phase_step_rad(0.0),
d_carrier_frequency_hz(0.0),
d_carrier_phase_step_rad(0.0),
d_acc_carrier_phase_rad(0.0),
d_code_phase_samples(0.0),
d_n_correlator_taps(3),
d_current_prn_length_samples(static_cast<int32_t>(d_vector_length)),
d_sample_counter(0ULL),
d_acq_sample_stamp(0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(FLAGS_carrier_lock_th),
d_carrier_lock_fail_counter(0),
d_cn0_estimation_counter(0),
d_enable_tracking(false),
d_pull_in(false),
d_acc_carrier_phase_initialized(false),
d_dump(dump)
{
this->message_port_register_out(pmt::mp("events"));
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
d_current_prn_length_samples = static_cast<int32_t>(d_vector_length);
// Initialize tracking ==========================================
d_code_loop_filter.set_DLL_BW(dll_bw_hz);
d_carrier_loop_filter.set_PLL_BW(pll_bw_hz);
// --- DLL variables -------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code = volk_gnsssdr::vector<gr_complex>(static_cast<size_t>(GLONASS_L1_CA_CODE_LENGTH_CHIPS));
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Early, Prompt, and Late
d_correlator_outs = volk_gnsssdr::vector<gr_complex>(d_n_correlator_taps);
d_local_code_shift_chips = volk_gnsssdr::vector<float>(d_n_correlator_taps);
@ -113,48 +134,10 @@ Glonass_L1_Ca_Dll_Pll_Tracking_cc::Glonass_L1_Ca_Dll_Pll_Tracking_cc(
multicorrelator_cpu.init(2 * d_current_prn_length_samples, d_n_correlator_taps);
// --- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_chips = GLONASS_L1_CA_CODE_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carr_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL;
// d_sample_counter_seconds = 0;
d_acq_sample_stamp = 0;
d_enable_tracking = false;
d_pull_in = false;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = FLAGS_carrier_lock_th;
systemName["R"] = std::string("Glonass");
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_doppler_hz = 0.0;
d_carrier_doppler_phase_step_rad = 0.0;
d_carrier_frequency_hz = 0.0;
d_acc_carrier_phase_rad = 0.0;
d_code_phase_samples = 0.0;
d_rem_code_phase_chips = 0.0;
d_code_phase_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
d_glonass_freq_ch = 0;
d_acc_carrier_phase_initialized = false;
set_relative_rate(1.0 / static_cast<double>(d_vector_length));
}

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

@ -101,8 +101,56 @@ glonass_l2_ca_dll_pll_c_aid_tracking_cc::glonass_l2_ca_dll_pll_c_aid_tracking_cc
float pll_bw_narrow_hz,
float dll_bw_narrow_hz,
int32_t extend_correlation_ms,
float early_late_space_chips) : gr::block("glonass_l2_ca_dll_pll_c_aid_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
float early_late_space_chips)
: gr::block("glonass_l2_ca_dll_pll_c_aid_tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_acquisition_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_glonass_freq_ch(0),
d_early_late_spc_chips(early_late_space_chips),
d_vector_length(vector_length),
d_channel(0),
d_n_correlator_taps(3),
d_rem_code_phase_samples(0.0),
d_rem_code_phase_chips(0.0),
d_rem_carrier_phase_rad(0.0),
d_rem_code_phase_integer_samples(0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_dll_bw_hz(dll_bw_hz),
d_pll_bw_hz(pll_bw_hz),
d_dll_bw_narrow_hz(dll_bw_narrow_hz),
d_pll_bw_narrow_hz(pll_bw_narrow_hz),
d_code_freq_chips(GLONASS_L2_CA_CODE_RATE_CPS),
d_code_phase_step_chips(0.0),
d_carrier_doppler_hz(0.0),
d_carrier_frequency_hz(0.0),
d_carrier_doppler_old_hz(0.0),
d_carrier_phase_step_rad(0.0),
d_acc_carrier_phase_cycles(0.0),
d_code_phase_samples(0.0),
d_pll_to_dll_assist_secs_Ti(0.0),
d_code_error_chips_Ti(0.0),
d_code_error_filt_chips_s(0.0),
d_code_error_filt_chips_Ti(0.0),
d_carr_phase_error_secs_Ti(0.0),
d_preamble_timestamp_s(0.0),
d_extend_correlation_ms(extend_correlation_ms),
d_correlation_length_samples(static_cast<int32_t>(d_vector_length)),
d_sample_counter(0ULL),
d_acq_sample_stamp(0),
d_cn0_estimation_counter(0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(FLAGS_carrier_lock_th),
d_carrier_lock_fail_counter(0),
d_enable_extended_integration(false),
d_preamble_synchronized(false),
d_enable_tracking(false),
d_pull_in(false),
d_acc_carrier_phase_initialized(false),
d_dump(dump)
{
// Telemetry bit synchronization message port input
this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
@ -119,31 +167,14 @@ glonass_l2_ca_dll_pll_c_aid_tracking_cc::glonass_l2_ca_dll_pll_c_aid_tracking_cc
#endif
this->message_port_register_out(pmt::mp("events"));
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
d_correlation_length_samples = static_cast<int32_t>(d_vector_length);
// Initialize tracking ==========================================
d_pll_bw_hz = pll_bw_hz;
d_dll_bw_hz = dll_bw_hz;
d_pll_bw_narrow_hz = pll_bw_narrow_hz;
d_dll_bw_narrow_hz = dll_bw_narrow_hz;
d_extend_correlation_ms = extend_correlation_ms;
d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
d_carrier_loop_filter.set_params(10.0, d_pll_bw_hz, 2);
// --- DLL variables --------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code = volk_gnsssdr::vector<gr_complex>(static_cast<size_t>(GLONASS_L2_CA_CODE_LENGTH_CHIPS));
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Early, Prompt, and Late
d_correlator_outs = volk_gnsssdr::vector<gr_complex>(d_n_correlator_taps);
d_local_code_shift_chips = volk_gnsssdr::vector<float>(d_n_correlator_taps);
@ -154,59 +185,11 @@ glonass_l2_ca_dll_pll_c_aid_tracking_cc::glonass_l2_ca_dll_pll_c_aid_tracking_cc
multicorrelator_cpu.init(2 * d_correlation_length_samples, d_n_correlator_taps);
// --- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_chips = GLONASS_L2_CA_CODE_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carrier_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL; // (from trk to tlm)
d_acq_sample_stamp = 0;
d_enable_tracking = false;
d_pull_in = false;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = FLAGS_carrier_lock_th;
systemName["R"] = std::string("Glonass");
set_relative_rate(1.0 / static_cast<double>(d_vector_length));
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_doppler_hz = 0.0;
d_code_error_filt_chips_Ti = 0.0;
d_acc_carrier_phase_cycles = 0.0;
d_code_phase_samples = 0.0;
d_pll_to_dll_assist_secs_Ti = 0.0;
d_rem_code_phase_chips = 0.0;
d_code_phase_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
d_enable_extended_integration = false;
d_preamble_synchronized = false;
d_rem_code_phase_integer_samples = 0;
d_code_error_chips_Ti = 0.0;
d_code_error_filt_chips_s = 0.0;
d_carr_phase_error_secs_Ti = 0.0;
d_preamble_timestamp_s = 0.0;
d_carrier_frequency_hz = 0.0;
d_carrier_doppler_old_hz = 0.0;
d_glonass_freq_ch = 0;
d_acc_carrier_phase_initialized = false;
// set_min_output_buffer((int64_t)300);
}

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

@ -100,8 +100,56 @@ glonass_l2_ca_dll_pll_c_aid_tracking_sc::glonass_l2_ca_dll_pll_c_aid_tracking_sc
float pll_bw_narrow_hz,
float dll_bw_narrow_hz,
int32_t extend_correlation_ms,
float early_late_space_chips) : gr::block("glonass_l1_ca_dll_pll_c_aid_tracking_sc", gr::io_signature::make(1, 1, sizeof(lv_16sc_t)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
float early_late_space_chips)
: gr::block("glonass_l1_ca_dll_pll_c_aid_tracking_sc", gr::io_signature::make(1, 1, sizeof(lv_16sc_t)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_acquisition_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_glonass_freq_ch(0),
d_early_late_spc_chips(early_late_space_chips),
d_vector_length(vector_length),
d_channel(0),
d_n_correlator_taps(3),
d_rem_code_phase_samples(0.0),
d_rem_code_phase_chips(0.0),
d_rem_carrier_phase_rad(0.0),
d_rem_code_phase_integer_samples(0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_dll_bw_hz(dll_bw_hz),
d_pll_bw_hz(pll_bw_hz),
d_dll_bw_narrow_hz(dll_bw_narrow_hz),
d_pll_bw_narrow_hz(pll_bw_narrow_hz),
d_code_freq_chips(GLONASS_L2_CA_CODE_RATE_CPS),
d_code_phase_step_chips(0.0),
d_carrier_doppler_hz(0.0),
d_carrier_frequency_hz(0.0),
d_carrier_doppler_old_hz(0.0),
d_carrier_phase_step_rad(0.0),
d_acc_carrier_phase_cycles(0.0),
d_code_phase_samples(0.0),
d_pll_to_dll_assist_secs_Ti(0.0),
d_carr_phase_error_secs_Ti(0.0),
d_code_error_chips_Ti(0.0),
d_preamble_timestamp_s(0.0),
d_extend_correlation_ms(extend_correlation_ms),
d_code_error_filt_chips_s(0.0),
d_code_error_filt_chips_Ti(0.0),
d_correlation_length_samples(static_cast<int32_t>(d_vector_length)),
d_sample_counter(0ULL),
d_acq_sample_stamp(0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(FLAGS_carrier_lock_th),
d_carrier_lock_fail_counter(0),
d_cn0_estimation_counter(0),
d_enable_extended_integration(false),
d_preamble_synchronized(false),
d_enable_tracking(false),
d_pull_in(false),
d_acc_carrier_phase_initialized(false),
d_dump(dump)
{
// Telemetry bit synchronization message port input
this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
@ -117,33 +165,15 @@ glonass_l2_ca_dll_pll_c_aid_tracking_sc::glonass_l2_ca_dll_pll_c_aid_tracking_sc
#endif
this->message_port_register_out(pmt::mp("events"));
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
d_correlation_length_samples = static_cast<int32_t>(d_vector_length);
// Initialize tracking ==========================================
d_pll_bw_hz = pll_bw_hz;
d_dll_bw_hz = dll_bw_hz;
d_pll_bw_narrow_hz = pll_bw_narrow_hz;
d_dll_bw_narrow_hz = dll_bw_narrow_hz;
d_code_loop_filter.set_DLL_BW(d_dll_bw_hz);
d_carrier_loop_filter.set_params(10.0, d_pll_bw_hz, 2);
d_extend_correlation_ms = extend_correlation_ms;
// --- DLL variables --------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code = volk_gnsssdr::vector<gr_complex>(static_cast<size_t>(GLONASS_L2_CA_CODE_LENGTH_CHIPS));
d_ca_code_16sc = volk_gnsssdr::vector<lv_16sc_t>(static_cast<size_t>(GLONASS_L2_CA_CODE_LENGTH_CHIPS));
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Early, Prompt, and Late
d_correlator_outs_16sc = volk_gnsssdr::vector<lv_16sc_t>(d_n_correlator_taps);
d_local_code_shift_chips = volk_gnsssdr::vector<float>(d_n_correlator_taps);
// Set TAPs delay values [chips]
@ -153,58 +183,11 @@ glonass_l2_ca_dll_pll_c_aid_tracking_sc::glonass_l2_ca_dll_pll_c_aid_tracking_sc
multicorrelator_cpu_16sc.init(2 * d_correlation_length_samples, d_n_correlator_taps);
// -- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_chips = GLONASS_L2_CA_CODE_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carrier_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL; // (from trk to tlm)
d_acq_sample_stamp = 0;
d_enable_tracking = false;
d_pull_in = false;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = FLAGS_carrier_lock_th;
systemName["R"] = std::string("Glonass");
set_relative_rate(1.0 / static_cast<double>(d_vector_length));
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_doppler_hz = 0.0;
d_acc_carrier_phase_cycles = 0.0;
d_code_phase_samples = 0.0;
d_enable_extended_integration = false;
d_preamble_synchronized = false;
d_rem_code_phase_integer_samples = 0;
d_code_error_chips_Ti = 0.0;
d_pll_to_dll_assist_secs_Ti = 0.0;
d_rem_code_phase_chips = 0.0;
d_code_phase_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
d_code_error_filt_chips_s = 0.0;
d_code_error_filt_chips_Ti = 0.0;
d_preamble_timestamp_s = 0.0;
d_carr_phase_error_secs_Ti = 0.0;
d_carrier_frequency_hz = 0.0;
d_carrier_doppler_old_hz = 0.0;
d_glonass_freq_ch = 0;
d_acc_carrier_phase_initialized = false;
// set_min_output_buffer((int64_t)300);
}

90
src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_tracking_cc.cc
View File

@ -78,32 +78,53 @@ Glonass_L2_Ca_Dll_Pll_Tracking_cc::Glonass_L2_Ca_Dll_Pll_Tracking_cc(
const std::string &dump_filename,
float pll_bw_hz,
float dll_bw_hz,
float early_late_space_chips) : gr::block("Glonass_L2_Ca_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
float early_late_space_chips)
: gr::block("Glonass_L1_Ca_Dll_Pll_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_dump_filename(dump_filename),
d_acquisition_gnss_synchro(nullptr),
d_fs_in(fs_in),
d_glonass_freq_ch(0),
d_early_late_spc_chips(early_late_space_chips),
d_vector_length(vector_length),
d_channel(0),
d_rem_code_phase_samples(0.0),
d_rem_code_phase_chips(0.0),
d_rem_carr_phase_rad(0.0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_n_correlator_taps(3),
d_code_freq_chips(GLONASS_L2_CA_CODE_RATE_CPS),
d_code_phase_step_chips(0.0),
d_carrier_doppler_hz(0.0),
d_carrier_doppler_phase_step_rad(0.0),
d_carrier_frequency_hz(0.0),
d_carrier_phase_step_rad(0.0),
d_acc_carrier_phase_rad(0.0),
d_code_phase_samples(0.0),
d_current_prn_length_samples(static_cast<int32_t>(d_vector_length)),
d_sample_counter(0ULL),
d_acq_sample_stamp(0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(FLAGS_carrier_lock_th),
d_cn0_estimation_counter(0),
d_carrier_lock_fail_counter(0),
d_enable_tracking(false),
d_pull_in(false),
d_acc_carrier_phase_initialized(false),
d_dump(dump)
{
this->message_port_register_out(pmt::mp("events"));
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
d_current_prn_length_samples = static_cast<int32_t>(d_vector_length);
// Initialize tracking ==========================================
d_code_loop_filter.set_DLL_BW(dll_bw_hz);
d_carrier_loop_filter.set_PLL_BW(pll_bw_hz);
// --- DLL variables -------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code = volk_gnsssdr::vector<gr_complex>(static_cast<size_t>(GLONASS_L2_CA_CODE_LENGTH_CHIPS));
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Early, Prompt, and Late
d_correlator_outs = volk_gnsssdr::vector<gr_complex>(d_n_correlator_taps);
d_local_code_shift_chips = volk_gnsssdr::vector<float>(d_n_correlator_taps);
@ -114,49 +135,10 @@ Glonass_L2_Ca_Dll_Pll_Tracking_cc::Glonass_L2_Ca_Dll_Pll_Tracking_cc(
multicorrelator_cpu.init(2 * d_current_prn_length_samples, d_n_correlator_taps);
// --- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_chips = GLONASS_L2_CA_CODE_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carr_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL;
// d_sample_counter_seconds = 0;
d_acq_sample_stamp = 0;
d_enable_tracking = false;
d_pull_in = false;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = FLAGS_carrier_lock_th;
systemName["R"] = std::string("Glonass");
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_doppler_hz = 0.0;
d_carrier_doppler_phase_step_rad = 0.0;
d_carrier_frequency_hz = 0.0;
d_acc_carrier_phase_rad = 0.0;
d_code_phase_samples = 0.0;
d_rem_code_phase_chips = 0.0;
d_code_phase_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
d_glonass_freq_ch = 0;
d_acc_carrier_phase_initialized = false;
set_relative_rate(1.0 / static_cast<double>(d_vector_length));
}

130
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_kf_tracking_cc.cc
View File

@ -47,7 +47,6 @@
gps_l1_ca_kf_tracking_cc_sptr gps_l1_ca_kf_make_tracking_cc(
uint32_t order,
int64_t if_freq,
int64_t fs_in,
uint32_t vector_length,
bool dump,
@ -60,7 +59,7 @@ gps_l1_ca_kf_tracking_cc_sptr gps_l1_ca_kf_make_tracking_cc(
int32_t bce_nu,
int32_t bce_kappa)
{
return gps_l1_ca_kf_tracking_cc_sptr(new Gps_L1_Ca_Kf_Tracking_cc(order, if_freq,
return gps_l1_ca_kf_tracking_cc_sptr(new Gps_L1_Ca_Kf_Tracking_cc(order,
fs_in, vector_length, dump, dump_filename, dll_bw_hz, early_late_space_chips,
bce_run, bce_ptrans, bce_strans, bce_nu, bce_kappa));
}
@ -78,7 +77,6 @@ void Gps_L1_Ca_Kf_Tracking_cc::forecast(int noutput_items,
Gps_L1_Ca_Kf_Tracking_cc::Gps_L1_Ca_Kf_Tracking_cc(
uint32_t order,
int64_t if_freq,
int64_t fs_in,
uint32_t vector_length,
bool dump,
@ -89,36 +87,64 @@ Gps_L1_Ca_Kf_Tracking_cc::Gps_L1_Ca_Kf_Tracking_cc(
uint32_t bce_ptrans,
uint32_t bce_strans,
int32_t bce_nu,
int32_t bce_kappa) : gr::block("Gps_L1_Ca_Kf_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
int32_t bce_kappa)
: gr::block("Gps_L1_Ca_Kf_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_order(order),
d_vector_length(vector_length),
d_dump(dump),
d_acquisition_gnss_synchro(nullptr),
d_channel(0),
d_fs_in(fs_in),
d_early_late_spc_chips(early_late_space_chips),
d_rem_code_phase_samples(0.0),
d_rem_code_phase_chips(0.0),
d_rem_carr_phase_rad(0.0),
bayes_ptrans(bce_ptrans),
bayes_strans(bce_strans),
bayes_nu(bce_nu),
bayes_kappa(bce_kappa),
bayes_run(bce_run),
kf_iter(0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_n_correlator_taps(3),
d_code_freq_chips(GPS_L1_CA_CODE_RATE_CPS),
d_code_phase_step_chips(0.0),
d_code_phase_rate_step_chips(0.0),
d_carrier_doppler_hz(0.0),
d_carrier_dopplerrate_hz2(0.0),
d_carrier_phase_step_rad(0.0),
d_acc_carrier_phase_rad(0.0),
d_carr_phase_sigma2(0.0),
d_code_phase_samples(0.0),
code_error_chips(0.0),
code_error_filt_chips(0.0),
d_current_prn_length_samples(static_cast<int>(d_vector_length)),
d_sample_counter(0),
d_acq_sample_stamp(0),
d_cn0_estimation_counter(0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(FLAGS_carrier_lock_th),
d_carrier_lock_fail_counter(0),
d_enable_tracking(false),
d_pull_in(false),
d_dump_filename(dump_filename)
{
// Telemetry bit synchronization message port input
this->message_port_register_in(pmt::mp("preamble_timestamp_s"));
this->message_port_register_out(pmt::mp("events"));
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_order = order;
d_dump = dump;
d_if_freq = if_freq;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
d_current_prn_length_samples = static_cast<int>(d_vector_length);
// Initialize tracking ==========================================
d_code_loop_filter.set_DLL_BW(dll_bw_hz);
// --- DLL variables --------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code.resize(static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS));
d_ca_code = volk_gnsssdr::vector<float>(static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS));
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Early, Prompt, and Late
d_correlator_outs.resize(d_n_correlator_taps, gr_complex(0.0, 0.0));
d_correlator_outs = volk_gnsssdr::vector<gr_complex>(d_n_correlator_taps, gr_complex(0.0, 0.0));
d_local_code_shift_chips = volk_gnsssdr::vector<float>(d_n_correlator_taps);
// Set TAPs delay values [chips]
@ -128,63 +154,24 @@ Gps_L1_Ca_Kf_Tracking_cc::Gps_L1_Ca_Kf_Tracking_cc(
multicorrelator_cpu.init(2 * d_current_prn_length_samples, d_n_correlator_taps);
// --- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_chips = GPS_L1_CA_CODE_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carr_phase_rad = 0.0;
// define residual carrier phase covariance
d_carr_phase_sigma2 = 0.0;
// sample synchronization
d_sample_counter = 0;
d_acq_sample_stamp = 0;
d_enable_tracking = false;
d_pull_in = false;
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = FLAGS_carrier_lock_th;
systemName["G"] = std::string("GPS");
systemName["S"] = std::string("SBAS");
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_doppler_hz = 0.0;
d_carrier_dopplerrate_hz2 = 0.0;
d_acc_carrier_phase_rad = 0.0;
d_code_phase_samples = 0.0;
d_rem_code_phase_chips = 0.0;
d_code_phase_step_chips = 0.0;
d_code_phase_rate_step_chips = 0.0;
d_carrier_phase_step_rad = 0.0;
code_error_chips = 0.0;
code_error_filt_chips = 0.0;
set_relative_rate(1.0 / static_cast<double>(d_vector_length));
// Kalman filter initialization (receiver initialization)
double CN_dB_Hz = 30;
double CN_lin = pow(10, CN_dB_Hz / 10.0);
const double CN_dB_Hz = 30;
const double CN_lin = pow(10, CN_dB_Hz / 10.0);
double sigma2_phase_detector_cycles2;
sigma2_phase_detector_cycles2 = (1.0 / (2.0 * CN_lin * GPS_L1_CA_CODE_PERIOD_S)) * (1.0 + 1.0 / (2.0 * CN_lin * GPS_L1_CA_CODE_PERIOD_S));
const double sigma2_phase_detector_cycles2 = (1.0 / (2.0 * CN_lin * GPS_L1_CA_CODE_PERIOD_S)) * (1.0 + 1.0 / (2.0 * CN_lin * GPS_L1_CA_CODE_PERIOD_S));
// covariances (static)
double sigma2_carrier_phase = TWO_PI / 4;
double sigma2_doppler = 450;
double sigma2_doppler_rate = pow(4.0 * TWO_PI, 2) / 12.0;
const double sigma2_carrier_phase = TWO_PI / 4;
const double sigma2_doppler = 450;
const double sigma2_doppler_rate = pow(4.0 * TWO_PI, 2) / 12.0;
kf_P_x_ini = arma::zeros(2, 2);
kf_P_x_ini(0, 0) = sigma2_carrier_phase;
@ -236,13 +223,6 @@ Gps_L1_Ca_Kf_Tracking_cc::Gps_L1_Ca_Kf_Tracking_cc(
}
// Bayesian covariance estimator initialization
kf_iter = 0;
bayes_run = bce_run;
bayes_ptrans = bce_ptrans;
bayes_strans = bce_strans;
bayes_kappa = bce_kappa;
bayes_nu = bce_nu;
kf_R_est = kf_R;
bayes_estimator.init(arma::zeros(1, 1), bayes_kappa, bayes_nu, (kf_H * kf_P_x_ini * kf_H.t() + kf_R) * (bayes_nu + 2));
@ -691,7 +671,7 @@ int Gps_L1_Ca_Kf_Tracking_cc::general_work(int noutput_items __attribute__((unus
// Kalman estimation (measurement update)
double sigma2_phase_detector_cycles2;
double CN_lin = pow(10, d_CN0_SNV_dB_Hz / 10.0);
const double CN_lin = pow(10, d_CN0_SNV_dB_Hz / 10.0);
sigma2_phase_detector_cycles2 = (1.0 / (2.0 * CN_lin * GPS_L1_CA_CODE_PERIOD_S)) * (1.0 + 1.0 / (2.0 * CN_lin * GPS_L1_CA_CODE_PERIOD_S));
kf_y(0) = d_carr_phase_error_rad; // measurement vector

17
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_kf_tracking_cc.h
View File

@ -55,8 +55,8 @@ using gps_l1_ca_kf_tracking_cc_sptr = gnss_shared_ptr<Gps_L1_Ca_Kf_Tracking_cc>;
gps_l1_ca_kf_tracking_cc_sptr
gps_l1_ca_kf_make_tracking_cc(uint32_t order,
int64_t if_freq,
int64_t fs_in, uint32_t vector_length,
int64_t fs_in,
uint32_t vector_length,
bool dump,
const std::string& dump_filename,
float dll_bw_hz,
@ -88,8 +88,8 @@ public:
private:
friend gps_l1_ca_kf_tracking_cc_sptr
gps_l1_ca_kf_make_tracking_cc(uint32_t order,
int64_t if_freq,
int64_t fs_in, uint32_t vector_length,
int64_t fs_in,
uint32_t vector_length,
bool dump,
const std::string& dump_filename,
float dll_bw_hz,
@ -101,8 +101,8 @@ private:
int32_t bce_kappa);
Gps_L1_Ca_Kf_Tracking_cc(uint32_t order,
int64_t if_freq,
int64_t fs_in, uint32_t vector_length,
int64_t fs_in,
uint32_t vector_length,
bool dump,
const std::string& dump_filename,
float dll_bw_hz,
@ -113,6 +113,8 @@ private:
int32_t bce_nu,
int32_t bce_kappa);
int32_t save_matfile();
// tracking configuration vars
uint32_t d_order;
uint32_t d_vector_length;
@ -121,7 +123,6 @@ private:
Gnss_Synchro* d_acquisition_gnss_synchro;
uint32_t d_channel;
int64_t d_if_freq;
int64_t d_fs_in;
double d_early_late_spc_chips;
@ -212,8 +213,6 @@ private:
std::map<std::string, std::string> systemName;
std::string sys;
int32_t save_matfile();
};

104
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.cc
View File

@ -69,39 +69,58 @@ Gps_L1_Ca_Tcp_Connector_Tracking_cc::Gps_L1_Ca_Tcp_Connector_Tracking_cc(
bool dump,
const std::string &dump_filename,
float early_late_space_chips,
size_t port_ch0) : gr::block("Gps_L1_Ca_Tcp_Connector_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
size_t port_ch0)
: gr::block("Gps_L1_Ca_Tcp_Connector_Tracking_cc", gr::io_signature::make(1, 1, sizeof(gr_complex)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro))),
d_acquisition_gnss_synchro(nullptr),
d_dump_filename(dump_filename),
d_early_late_spc_chips(early_late_space_chips),
d_code_phase_step_chips(0.0),
d_rem_code_phase_samples(0.0),
d_next_rem_code_phase_samples(0),
d_code_freq_hz(GPS_L1_CA_CODE_RATE_CPS),
d_carrier_doppler_hz(0.0),
d_acc_carrier_phase_rad(0.0),
d_code_phase_samples(0),
d_sample_counter_seconds(0),
d_fs_in(fs_in),
d_sample_counter(0ULL),
d_acq_sample_stamp(0ULL),
d_port_ch0(port_ch0),
d_port(0),
d_vector_length(vector_length),
d_channel(0),
d_correlation_length_samples(d_vector_length),
d_n_correlator_taps(3),
d_listen_connection(true),
d_current_prn_length_samples(static_cast<int32_t>(d_vector_length)),
d_next_prn_length_samples(0),
d_cn0_estimation_counter(0),
d_carrier_lock_fail_counter(0),
d_rem_carr_phase_rad(0.0),
d_acq_code_phase_samples(0.0),
d_acq_carrier_doppler_hz(0.0),
d_carrier_lock_test(1),
d_CN0_SNV_dB_Hz(0),
d_carrier_lock_threshold(static_cast<float>(FLAGS_carrier_lock_th)),
d_control_id(0),
d_enable_tracking(false),
d_pull_in(false),
d_dump(dump)
{
this->message_port_register_out(pmt::mp("events"));
this->message_port_register_in(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_fs_in = fs_in;
d_vector_length = vector_length;
d_dump_filename = dump_filename;
// -- DLL variables --------------------------------------------------------
d_early_late_spc_chips = early_late_space_chips; // Define early-late offset (in chips)
// -- TCP CONNECTOR variables --------------------------------------------------------
d_port_ch0 = port_ch0;
d_port = 0;
d_listen_connection = true;
d_control_id = 0;
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code.resize(GPS_L1_CA_CODE_LENGTH_CHIPS);
d_ca_code = volk_gnsssdr::vector<gr_complex>(GPS_L1_CA_CODE_LENGTH_CHIPS);
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Very-Early, Early, Prompt, Late, Very-Late
d_correlator_outs.resize(d_n_correlator_taps);
std::fill_n(d_correlator_outs.begin(), d_n_correlator_taps, gr_complex(0.0, 0.0));
d_correlator_outs = volk_gnsssdr::vector<gr_complex>(d_n_correlator_taps);
// map memory pointers of correlator outputs
d_Early = &d_correlator_outs[0];
d_Prompt = &d_correlator_outs[1];
d_Late = &d_correlator_outs[2];
d_Early = &d_correlator_outs[0]; // NOLINT(cppcoreguidelines-prefer-member-initializer)
d_Prompt = &d_correlator_outs[1]; // NOLINT(cppcoreguidelines-prefer-member-initializer)
d_Late = &d_correlator_outs[2]; // NOLINT(cppcoreguidelines-prefer-member-initializer)
d_local_code_shift_chips = volk_gnsssdr::vector<float>(d_n_correlator_taps);
// Set TAPs delay values [chips]
@ -109,52 +128,15 @@ Gps_L1_Ca_Tcp_Connector_Tracking_cc::Gps_L1_Ca_Tcp_Connector_Tracking_cc(
d_local_code_shift_chips[1] = 0.0;
d_local_code_shift_chips[2] = d_early_late_spc_chips;
d_correlation_length_samples = d_vector_length;
multicorrelator_cpu.init(2 * d_correlation_length_samples, d_n_correlator_taps);
// --- Perform initializations ------------------------------
// define initial code frequency basis of NCO
d_code_freq_hz = GPS_L1_CA_CODE_RATE_CPS;
// define residual code phase (in chips)
d_rem_code_phase_samples = 0.0;
// define residual carrier phase
d_rem_carr_phase_rad = 0.0;
// sample synchronization
d_sample_counter = 0ULL;
d_sample_counter_seconds = 0;
d_acq_sample_stamp = 0ULL;
d_enable_tracking = false;
d_pull_in = false;
d_current_prn_length_samples = static_cast<int32_t>(d_vector_length);
// CN0 estimation and lock detector buffers
d_cn0_estimation_counter = 0;
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(FLAGS_cn0_samples);
d_carrier_lock_test = 1;
d_CN0_SNV_dB_Hz = 0;
d_carrier_lock_fail_counter = 0;
d_carrier_lock_threshold = static_cast<float>(FLAGS_carrier_lock_th);
systemName["G"] = std::string("GPS");
systemName["R"] = std::string("GLONASS");
systemName["S"] = std::string("SBAS");
systemName["E"] = std::string("Galileo");
systemName["C"] = std::string("Compass");
d_acquisition_gnss_synchro = nullptr;
d_channel = 0;
d_next_rem_code_phase_samples = 0;
d_acq_code_phase_samples = 0.0;
d_acq_carrier_doppler_hz = 0.0;
d_carrier_doppler_hz = 0.0;
d_acc_carrier_phase_rad = 0.0;
d_code_phase_samples = 0;
d_next_prn_length_samples = 0;
d_code_phase_step_chips = 0.0;
}

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

@ -458,8 +458,8 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
d_n_correlator_taps = 3;
}
d_correlator_outs.reserve(d_n_correlator_taps);
d_local_code_shift_chips.reserve(d_n_correlator_taps);
d_correlator_outs = volk_gnsssdr::vector<gr_complex>(d_n_correlator_taps);
d_local_code_shift_chips = volk_gnsssdr::vector<float>(d_n_correlator_taps);
// map memory pointers of correlator outputs
if (d_veml)
{
@ -517,9 +517,9 @@ kf_vtl_tracking::kf_vtl_tracking(const Kf_Conf &conf_)
d_code_freq_kf_chips_s = d_code_chip_rate;
// CN0 estimation and lock detector buffers
d_Prompt_buffer.reserve(d_trk_parameters.cn0_samples);
d_Prompt_buffer = volk_gnsssdr::vector<gr_complex>(d_trk_parameters.cn0_samples);
d_Prompt_Data.reserve(1);
d_Prompt_Data = volk_gnsssdr::vector<gr_complex>(1);
d_cn0_smoother = Exponential_Smoother();
d_cn0_smoother.set_alpha(d_trk_parameters.cn0_smoother_alpha);

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

@ -21,6 +21,10 @@
#ifndef GNSS_SDR_KF_VTL_TRACKING_H
#define GNSS_SDR_KF_VTL_TRACKING_H
#if ARMA_NO_BOUND_CHECKING
#define ARMA_NO_DEBUG 1
#endif
#include "cpu_multicorrelator_real_codes.h"
#include "exponential_smoother.h"
#include "gnss_block_interface.h"
@ -46,12 +50,7 @@
class Gnss_Synchro;
class kf_vtl_tracking;
#if GNURADIO_USES_STD_POINTERS
using kf_vtl_tracking_sptr = std::shared_ptr<kf_vtl_tracking>;
#else
using kf_vtl_tracking_sptr = boost::shared_ptr<kf_vtl_tracking>;
#endif
using kf_vtl_tracking_sptr = gnss_shared_ptr<kf_vtl_tracking>;
kf_vtl_tracking_sptr kf_vtl_make_tracking(const Kf_Conf &conf_);

1
src/algorithms/tracking/libs/CMakeLists.txt
View File

@ -11,7 +11,6 @@ set(TRACKING_LIB_SOURCES
cpu_multicorrelator_16sc.cc
lock_detectors.cc
tcp_communication.cc
tcp_packet_data.cc
tracking_2nd_DLL_filter.cc
tracking_2nd_PLL_filter.cc
tracking_discriminators.cc

32
src/algorithms/tracking/libs/bayesian_estimation.cc
View File

@ -32,37 +32,37 @@
Bayesian_estimator::Bayesian_estimator()
: kappa_prior(0),
nu_prior(0)
{
int ny = 1;
mu_prior = arma::zeros(ny, 1);
kappa_prior = 0;
nu_prior = 0;
Psi_prior = arma::eye(ny, ny) * (nu_prior + ny + 1);
mu_prior = arma::zeros(1, 1);
mu_est = mu_prior;
Psi_prior = arma::eye(1, 1) * (nu_prior + 1 + 1);
Psi_est = Psi_prior;
}
Bayesian_estimator::Bayesian_estimator(int ny)
: kappa_prior(0),
nu_prior(0)
{
mu_prior = arma::zeros(ny, 1);
kappa_prior = 0;
nu_prior = 0;
Psi_prior = arma::eye(ny, ny) * (nu_prior + ny + 1);
mu_est = mu_prior;
Psi_prior = arma::eye(ny, ny) * (nu_prior + ny + 1);
Psi_est = Psi_prior;
}
Bayesian_estimator::Bayesian_estimator(const arma::vec& mu_prior_0, int kappa_prior_0, int nu_prior_0, const arma::mat& Psi_prior_0)
Bayesian_estimator::Bayesian_estimator(const arma::vec& mu_prior_0,
int kappa_prior_0,
int nu_prior_0,
const arma::mat& Psi_prior_0)
: mu_prior(mu_prior_0),
Psi_prior(Psi_prior_0),
kappa_prior(kappa_prior_0),
nu_prior(nu_prior_0)
{
mu_prior = mu_prior_0;
kappa_prior = kappa_prior_0;
nu_prior = nu_prior_0;
Psi_prior = Psi_prior_0;
mu_est = mu_prior;
Psi_est = Psi_prior;
}

56
src/algorithms/tracking/libs/nonlinear_tracking.cc
View File

@ -31,33 +31,29 @@
/***************** CUBATURE KALMAN FILTER *****************/
CubatureFilter::CubatureFilter()
: x_pred_out(arma::zeros(1, 1)),
P_x_pred_out(arma::eye(1, 1) * (1 + 1)),
x_est(x_pred_out),
P_x_est(P_x_pred_out)
{
int nx = 1;
x_pred_out = arma::zeros(nx, 1);
P_x_pred_out = arma::eye(nx, nx) * (nx + 1);
x_est = x_pred_out;
P_x_est = P_x_pred_out;
}
CubatureFilter::CubatureFilter(int nx)
: x_pred_out(arma::zeros(nx, 1)),
P_x_pred_out(arma::eye(nx, nx) * (nx + 1)),
x_est(x_pred_out),
P_x_est(P_x_pred_out)
{
x_pred_out = arma::zeros(nx, 1);
P_x_pred_out = arma::eye(nx, nx) * (nx + 1);
x_est = x_pred_out;
P_x_est = P_x_pred_out;
}
CubatureFilter::CubatureFilter(const arma::vec& x_pred_0, const arma::mat& P_x_pred_0)
: x_pred_out(x_pred_0),
P_x_pred_out(P_x_pred_0),
x_est(x_pred_out),
P_x_est(P_x_pred_out)
{
x_pred_out = x_pred_0;
P_x_pred_out = P_x_pred_0;
x_est = x_pred_out;
P_x_est = P_x_pred_out;
}
@ -189,33 +185,29 @@ arma::mat CubatureFilter::get_P_x_est() const
/***************** UNSCENTED KALMAN FILTER *****************/
UnscentedFilter::UnscentedFilter()
: x_pred_out(arma::zeros(1, 1)),
P_x_pred_out(arma::eye(1, 1) * (1 + 1)),
x_est(x_pred_out),
P_x_est(P_x_pred_out)
{
int nx = 1;
x_pred_out = arma::zeros(nx, 1);
P_x_pred_out = arma::eye(nx, nx) * (nx + 1);
x_est = x_pred_out;
P_x_est = P_x_pred_out;
}
UnscentedFilter::UnscentedFilter(int nx)
: x_pred_out(arma::zeros(nx, 1)),
P_x_pred_out(arma::eye(nx, nx) * (nx + 1)),
x_est(x_pred_out),
P_x_est(P_x_pred_out)
{
x_pred_out = arma::zeros(nx, 1);
P_x_pred_out = arma::eye(nx, nx) * (nx + 1);
x_est = x_pred_out;
P_x_est = P_x_pred_out;
}
UnscentedFilter::UnscentedFilter(const arma::vec& x_pred_0, const arma::mat& P_x_pred_0)
: x_pred_out(x_pred_0),
P_x_pred_out(P_x_pred_0),
x_est(x_pred_out),
P_x_est(P_x_pred_out)
{
x_pred_out = x_pred_0;
P_x_pred_out = P_x_pred_0;
x_est = x_pred_out;
P_x_est = P_x_pred_out;
}

24
src/algorithms/tracking/libs/tcp_packet_data.cc
View File

@ -1,24 +0,0 @@
/*!
* \file tcp_packet_data.cc
* \brief Interface of the TCP packet data class
* \author David Pubill, 2011. dpubill(at)cttc.es
*
*
* -----------------------------------------------------------------------------
*
* GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
* This file is part of GNSS-SDR.
*
* Copyright (C) 2010-2020 (see AUTHORS file for a list of contributors)
* SPDX-License-Identifier: GPL-3.0-or-later
*
* -----------------------------------------------------------------------------
*/
#include "tcp_packet_data.h"
Tcp_Packet_Data::Tcp_Packet_Data()
{
proc_pack_code_error = 0;
proc_pack_carr_error = 0;
proc_pack_carrier_doppler_hz = 0;
}

8
src/algorithms/tracking/libs/tcp_packet_data.h
View File

@ -30,11 +30,11 @@
class Tcp_Packet_Data
{
public:
Tcp_Packet_Data();
Tcp_Packet_Data() = default;
~Tcp_Packet_Data() = default;
float proc_pack_code_error;
float proc_pack_carr_error;
float proc_pack_carrier_doppler_hz;
float proc_pack_code_error = 0.0;
float proc_pack_carr_error = 0.0;
float proc_pack_carrier_doppler_hz = 0.0;
};