mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-07-07 04:22:56 +00:00
Code Issues Releases Wiki Activity

removed some not used variables + code optimization

Browse Source
This commit is contained in:
Marc Majoral 2019-06-20 14:28:47 +02:00
parent b48a70b9dd
commit 0bb38ce38b
3 changed files with 133 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.cc
View File

@ -199,21 +199,21 @@ void pcps_acquisition_fpga::send_positive_acquisition()
<< ", input signal power " << d_input_power; << ", input signal power " << d_input_power;
std::cout << "positive acquisition" // std::cout << "positive acquisition"
<< ", satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN // << ", satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN
<< ", sample_stamp " << d_sample_counter // << ", sample_stamp " << d_sample_counter
<< ", test statistics value " << d_test_statistics // << ", test statistics value " << d_test_statistics
<< ", test statistics threshold " << d_threshold // << ", test statistics threshold " << d_threshold
<< ", code phase " << d_gnss_synchro->Acq_delay_samples // << ", code phase " << d_gnss_synchro->Acq_delay_samples
<< ", doppler " << d_gnss_synchro->Acq_doppler_hz // << ", doppler " << d_gnss_synchro->Acq_doppler_hz
<< ", magnitude " << d_mag // << ", magnitude " << d_mag
<< ", input signal power " << d_input_power // << ", input signal power " << d_input_power
<< ", d_gnss_synchro->Acq_samplestamp_samples " << d_gnss_synchro->Acq_samplestamp_samples // << ", d_gnss_synchro->Acq_samplestamp_samples " << d_gnss_synchro->Acq_samplestamp_samples
<< ", d_gnss_synchro->Flag_valid_word " << d_gnss_synchro->Flag_valid_word // << ", d_gnss_synchro->Flag_valid_word " << d_gnss_synchro->Flag_valid_word
<< ", Flag_valid_pseudorange " << d_gnss_synchro->Flag_valid_pseudorange // << ", Flag_valid_pseudorange " << d_gnss_synchro->Flag_valid_pseudorange
<< ", d_gnss_synchro->Flag_valid_symbol_output " << d_gnss_synchro->Flag_valid_symbol_output // << ", d_gnss_synchro->Flag_valid_symbol_output " << d_gnss_synchro->Flag_valid_symbol_output
<< ", d_gnss_synchro->Flag_valid_acquisition " << d_gnss_synchro->Flag_valid_acquisition // << ", d_gnss_synchro->Flag_valid_acquisition " << d_gnss_synchro->Flag_valid_acquisition
<< std::endl; // << std::endl;
//the channel FSM is set, so, notify it directly the positive acquisition to minimize delays //the channel FSM is set, so, notify it directly the positive acquisition to minimize delays
d_channel_fsm.lock()->Event_valid_acquisition(); d_channel_fsm.lock()->Event_valid_acquisition();

533
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.cc
View File

@ -128,7 +128,7 @@ dll_pll_veml_tracking_fpga::dll_pll_veml_tracking_fpga(const Dll_Pll_Conf_Fpga &
d_extended_correlation_in_fpga = trk_parameters.extended_correlation_in_fpga; d_extended_correlation_in_fpga = trk_parameters.extended_correlation_in_fpga;
printf("d_extended_correlation_in_fpga = %d\n", d_extended_correlation_in_fpga); //printf("d_extended_correlation_in_fpga = %d\n", d_extended_correlation_in_fpga);
d_sc_remodulate_enabled = false; // by default d_sc_remodulate_enabled = false; // by default
d_sc_demodulate_enabled = false; d_sc_demodulate_enabled = false;
@ -299,16 +299,6 @@ dll_pll_veml_tracking_fpga::dll_pll_veml_tracking_fpga(const Dll_Pll_Conf_Fpga &
d_symbols_per_bit = 20; d_symbols_per_bit = 20;
d_correlation_length_ms = 1; d_correlation_length_ms = 1;
// if (d_extended_correlation_in_fpga == true)
// {
// if (trk_parameters.extend_correlation_symbols > 1)
// {
// //printf("EXTENDED CORRELATION IN FPGA ENABLED => ENABLING SECONDARY CODE REMODULATION\n");
// d_sc_remodulate_enabled = true;
// }
// }
if (trk_parameters.track_pilot) if (trk_parameters.track_pilot)
{ {
@ -316,7 +306,6 @@ dll_pll_veml_tracking_fpga::dll_pll_veml_tracking_fpga(const Dll_Pll_Conf_Fpga &
{ {
if (trk_parameters.extend_correlation_symbols > 1) if (trk_parameters.extend_correlation_symbols > 1)
{ {
//printf("EXTENDED CORRELATION IN FPGA ENABLED => ENABLING SECONDARY CODE REMODULATION\n");
d_sc_demodulate_enabled = true; d_sc_demodulate_enabled = true;
d_sc_remodulate_enabled = true; d_sc_remodulate_enabled = true;
} }
@ -345,33 +334,12 @@ dll_pll_veml_tracking_fpga::dll_pll_veml_tracking_fpga(const Dll_Pll_Conf_Fpga &
{ {
//d_flag_printout = true;
//Do not acquire secondary code in data component. It is done in telemetry decoder //Do not acquire secondary code in data component. It is done in telemetry decoder
d_secondary = false; d_secondary = false;
signal_pretty_name = signal_pretty_name + "I"; signal_pretty_name = signal_pretty_name + "I";
interchange_iq = false; interchange_iq = false;
// the coherent integration in the fpga when using E5a without tracking the pilot cannot be done // the coherent integration in the fpga when using E5a without tracking the pilot is not enabled
// until the bug in the initialization variables related to the acquisition of the secondary code is
// solved in the SW
// printf("################# SET EXTENDED CORRELATION TO ZERO\n");
// d_extended_correlation_in_fpga == false;
// d_sc_demodulate_enabled = false;
// d_sc_remodulate_enabled = false;
// if (d_extended_correlation_in_fpga == true)
// {
// d_extended_correlation_in_fpga == false;
// }
// used by the FPGA
//d_secondary_code_length_data = static_cast<uint32_t>(GALILEO_E5A_I_SECONDARY_CODE_LENGTH);
//d_secondary_code_string_data = const_cast<std::string *>(&GALILEO_E5A_I_SECONDARY_CODE);
//d_secondary_code_string_post_apply = const_cast<std::string *>(&GALILEO_E5A_I_SECONDARY_CODE);
//d_secondary_code_post_apply_length = static_cast<uint32_t>(GALILEO_E5A_I_SECONDARY_CODE_LENGTH);
} }
@ -457,13 +425,13 @@ dll_pll_veml_tracking_fpga::dll_pll_veml_tracking_fpga(const Dll_Pll_Conf_Fpga &
if (trk_parameters.extend_correlation_symbols > 1) if (trk_parameters.extend_correlation_symbols > 1)
{ {
d_enable_extended_integration = true; d_enable_extended_integration = true;
printf("d_enable_extended_integration enabled\n"); //printf("d_enable_extended_integration enabled\n");
} }
else else
{ {
d_enable_extended_integration = false; d_enable_extended_integration = false;
trk_parameters.extend_correlation_symbols = 1; trk_parameters.extend_correlation_symbols = 1;
printf("d_enable_extended_integration disabled\n"); //printf("d_enable_extended_integration disabled\n");
} }
// --- Initializations --- // --- Initializations ---
@ -773,7 +741,6 @@ bool dll_pll_veml_tracking_fpga::cn0_and_tracking_lock_status(double coh_integra
} }
if (d_carrier_lock_fail_counter > trk_parameters.max_lock_fail) if (d_carrier_lock_fail_counter > trk_parameters.max_lock_fail)
{ {
printf("LOSS OF LOCK (TRACKING) --------------------------------------------x\n");
std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl; std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl;
LOG(INFO) << "Loss of lock in channel " << d_channel << "!"; LOG(INFO) << "Loss of lock in channel " << d_channel << "!";
this->message_port_pub(pmt::mp("events"), pmt::from_long(3)); // 3 -> loss of lock this->message_port_pub(pmt::mp("events"), pmt::from_long(3)); // 3 -> loss of lock
@ -897,32 +864,19 @@ void dll_pll_veml_tracking_fpga::clear_tracking_vars()
void dll_pll_veml_tracking_fpga::update_tracking_vars() void dll_pll_veml_tracking_fpga::update_tracking_vars()
{ {
// // debug -- remove when done !
// d_extended_integration_first_prn_length_samples = d_current_integration_length_samples - (trk_parameters.extend_correlation_symbols - 1)*static_cast<int32_t>(std::floor(T_prn_samples));
// d_extended_integration_next_prn_length_samples = static_cast<int32_t>(std::floor(T_prn_samples));
// // end of debug -- remove when done!
T_chip_seconds = 1.0 / d_code_freq_chips; // d_code_freq_chips updated in dll-pll T_chip_seconds = 1.0 / d_code_freq_chips; // d_code_freq_chips updated in dll-pll
T_prn_seconds = T_chip_seconds * static_cast<double>(d_code_length_chips); // d_code_freq_chips fixed permanently T_prn_seconds = T_chip_seconds * static_cast<double>(d_code_length_chips); // d_code_freq_chips fixed permanently
// ################## CARRIER AND CODE NCO BUFFER ALIGNMENT ####################### // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT #######################
// keep alignment parameters for the next input buffer // keep alignment parameters for the next input buffer
// Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation
//T_prn_samples_prev = T_prn_samples;
T_prn_samples_prev = T_prn_samples; T_prn_samples_prev = T_prn_samples;
T_prn_samples = T_prn_seconds * trk_parameters.fs_in; T_prn_samples = T_prn_seconds * trk_parameters.fs_in;
K_blk_samples_prev = K_blk_samples; K_blk_samples_prev = K_blk_samples;
K_blk_samples = T_prn_samples + d_rem_code_phase_samples; // initially d_rem_code_phase_samples is zero. It is updated at the end of this function K_blk_samples = T_prn_samples + d_rem_code_phase_samples; // initially d_rem_code_phase_samples is zero. It is updated at the end of this function
//d_next_prn_length_samples = static_cast<int32_t>(std::floor(K_blk_samples)); // round to a discrete number of samples
//d_next_prn_length_samples = static_cast<int32_t>(std::floor(K_blk_samples)); // round to a discrete number of samples
d_actual_blk_length = static_cast<int32_t>(std::floor(K_blk_samples)); d_actual_blk_length = static_cast<int32_t>(std::floor(K_blk_samples));
d_next_integration_length_samples = 2*d_actual_blk_length - d_current_integration_length_samples; d_next_integration_length_samples = 2*d_actual_blk_length - d_current_integration_length_samples;
//d_next_integration_length_samples = static_cast<int32_t>(std::floor(K_blk_samples));
//int32_t actual_prn_length_samples = static_cast<int32_t>(std::floor(K_blk_samples));
//d_next_prn_length_samples = actual_prn_length_samples + (actual_prn_length_samples - d_current_prn_length_samples);
//################### PLL COMMANDS ################################################# //################### PLL COMMANDS #################################################
// carrier phase step (NCO phase increment per sample) [rads/sample] // carrier phase step (NCO phase increment per sample) [rads/sample]
@ -947,8 +901,7 @@ void dll_pll_veml_tracking_fpga::update_tracking_vars()
d_carrier_phase_rate_step_rad = (tmp_cp2 - tmp_cp1) / tmp_samples; d_carrier_phase_rate_step_rad = (tmp_cp2 - tmp_cp1) / tmp_samples;
} }
} }
//std::cout << d_carrier_phase_rate_step_rad * trk_parameters.fs_in * trk_parameters.fs_in / PI_2 << std::endl; // remnant carrier phase
// remnant carrier phase to prevent overflow in the code NCO
d_rem_carr_phase_rad += static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_current_integration_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_integration_length_samples) * static_cast<double>(d_current_integration_length_samples)); d_rem_carr_phase_rad += static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_current_integration_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_integration_length_samples) * static_cast<double>(d_current_integration_length_samples));
// debug // debug
@ -957,9 +910,6 @@ void dll_pll_veml_tracking_fpga::update_tracking_vars()
d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, PI_2); d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, PI_2);
// carrier phase accumulator // carrier phase accumulator
//double a = d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples);
//double b = 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples);
//std::cout << fmod(b, PI_2) / fmod(a, PI_2) << std::endl;
d_acc_carrier_phase_rad -= (d_carrier_phase_step_rad * static_cast<double>(d_current_integration_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_integration_length_samples) * static_cast<double>(d_current_integration_length_samples)); d_acc_carrier_phase_rad -= (d_carrier_phase_step_rad * static_cast<double>(d_current_integration_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_integration_length_samples) * static_cast<double>(d_current_integration_length_samples));
//################### DLL COMMANDS ################################################# //################### DLL COMMANDS #################################################
@ -995,9 +945,6 @@ void dll_pll_veml_tracking_fpga::update_tracking_vars_extend_integration_in_FPGA
{ {
// first compute the long integration intermediate prn length values based on the current values (not the values that are compute here for the next iteration) // first compute the long integration intermediate prn length values based on the current values (not the values that are compute here for the next iteration)
// d_extended_integration_first_prn_length_samples = static_cast<int32_t>(std::floor(T_prn_samples + d_rem_code_phase_samples_prev));
// d_extended_integration_next_prn_length_samples = static_cast<int32_t>(std::floor(T_prn_samples));
d_extended_integration_first_prn_length_samples = d_current_integration_length_samples - (trk_parameters.extend_correlation_symbols - 1)*static_cast<int32_t>(std::floor(T_prn_samples)); d_extended_integration_first_prn_length_samples = d_current_integration_length_samples - (trk_parameters.extend_correlation_symbols - 1)*static_cast<int32_t>(std::floor(T_prn_samples));
d_extended_integration_next_prn_length_samples = static_cast<int32_t>(std::floor(T_prn_samples)); d_extended_integration_next_prn_length_samples = static_cast<int32_t>(std::floor(T_prn_samples));
@ -1007,21 +954,14 @@ void dll_pll_veml_tracking_fpga::update_tracking_vars_extend_integration_in_FPGA
// ################## CARRIER AND CODE NCO BUFFER ALIGNMENT ####################### // ################## CARRIER AND CODE NCO BUFFER ALIGNMENT #######################
// keep alignment parameters for the next input buffer // keep alignment parameters for the next input buffer
// Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation // Compute the next buffer length based in the new period of the PRN sequence and the code phase error estimation
//T_prn_samples_prev = T_prn_samples;
T_prn_samples_prev = T_prn_samples; T_prn_samples_prev = T_prn_samples;
T_prn_samples = T_prn_seconds * trk_parameters.fs_in; T_prn_samples = T_prn_seconds * trk_parameters.fs_in;
K_blk_samples_prev = K_blk_samples; K_blk_samples_prev = K_blk_samples;
K_blk_samples = T_prn_samples*trk_parameters.extend_correlation_symbols + d_rem_code_phase_samples; K_blk_samples = T_prn_samples*trk_parameters.extend_correlation_symbols + d_rem_code_phase_samples;
//d_next_integration_length_samples = static_cast<int32_t>(std::floor(K_blk_samples));
d_actual_blk_length = static_cast<int32_t>(std::floor(K_blk_samples)); d_actual_blk_length = static_cast<int32_t>(std::floor(K_blk_samples));
d_next_integration_length_samples = 2*d_actual_blk_length - d_current_integration_length_samples; d_next_integration_length_samples = 2*d_actual_blk_length - d_current_integration_length_samples;
//int32_t actual_prn_length_samples = static_cast<int32_t>(std::floor(K_blk_samples));
//d_next_prn_length_samples = actual_prn_length_samples + (actual_prn_length_samples - d_current_prn_length_samples);
//################### PLL COMMANDS ################################################# //################### PLL COMMANDS #################################################
// carrier phase step (NCO phase increment per sample) [rads/sample] // carrier phase step (NCO phase increment per sample) [rads/sample]
d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / trk_parameters.fs_in; d_carrier_phase_step_rad = PI_2 * d_carrier_doppler_hz / trk_parameters.fs_in;
@ -1045,13 +985,7 @@ void dll_pll_veml_tracking_fpga::update_tracking_vars_extend_integration_in_FPGA
d_carrier_phase_rate_step_rad = (tmp_cp2 - tmp_cp1) / tmp_samples; d_carrier_phase_rate_step_rad = (tmp_cp2 - tmp_cp1) / tmp_samples;
} }
} }
//std::cout << d_carrier_phase_rate_step_rad * trk_parameters.fs_in * trk_parameters.fs_in / PI_2 << std::endl; // remnant carrier phase
// remnant carrier phase to prevent overflow in the code NCO
// compute the long integration intermediate phase values
//d_extended_integration_first_rem_carr_phase_rad = d_rem_carr_phase_rad + static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_extended_integration_first_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_extended_integration_first_prn_length_samples) * static_cast<double>(d_extended_integration_first_prn_length_samples));
//d_extended_integration_next_rem_carr_phase_rad_step= static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_extended_integration_next_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_extended_integration_next_prn_length_samples) * static_cast<double>(d_extended_integration_next_prn_length_samples));;
d_rem_carr_phase_rad += static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_current_integration_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_integration_length_samples) * static_cast<double>(d_current_integration_length_samples)); d_rem_carr_phase_rad += static_cast<float>(d_carrier_phase_step_rad * static_cast<double>(d_current_integration_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_integration_length_samples) * static_cast<double>(d_current_integration_length_samples));
// debug // debug
@ -1059,14 +993,6 @@ void dll_pll_veml_tracking_fpga::update_tracking_vars_extend_integration_in_FPGA
d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, PI_2); d_rem_carr_phase_rad = fmod(d_rem_carr_phase_rad, PI_2);
// carrier phase accumulator
//double a = d_carrier_phase_step_rad * static_cast<double>(d_current_prn_length_samples);
//double b = 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_current_prn_length_samples) * static_cast<double>(d_current_prn_length_samples);
//std::cout << fmod(b, PI_2) / fmod(a, PI_2) << std::endl;
// compute the long integration intermediate phase values // compute the long integration intermediate phase values
d_extended_integration_first_acc_carrier_phase_rad = d_acc_carrier_phase_rad - (d_carrier_phase_step_rad * static_cast<double>(d_extended_integration_first_prn_length_samples) - 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_extended_integration_first_prn_length_samples) * static_cast<double>(d_extended_integration_first_prn_length_samples)); d_extended_integration_first_acc_carrier_phase_rad = d_acc_carrier_phase_rad - (d_carrier_phase_step_rad * static_cast<double>(d_extended_integration_first_prn_length_samples) - 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_extended_integration_first_prn_length_samples) * static_cast<double>(d_extended_integration_first_prn_length_samples));
d_extended_integration_next_acc_carrier_phase_rad_step = (d_carrier_phase_step_rad * static_cast<double>(d_extended_integration_next_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_extended_integration_next_prn_length_samples) * static_cast<double>(d_extended_integration_next_prn_length_samples)) d_extended_integration_next_acc_carrier_phase_rad_step = (d_carrier_phase_step_rad * static_cast<double>(d_extended_integration_next_prn_length_samples) + 0.5 * d_carrier_phase_rate_step_rad * static_cast<double>(d_extended_integration_next_prn_length_samples) * static_cast<double>(d_extended_integration_next_prn_length_samples))
@ -1098,8 +1024,6 @@ void dll_pll_veml_tracking_fpga::update_tracking_vars_extend_integration_in_FPGA
// remnant code phase [chips] // remnant code phase [chips]
d_rem_code_phase_samples_prev = d_rem_code_phase_samples; d_rem_code_phase_samples_prev = d_rem_code_phase_samples;
d_rem_code_phase_samples = K_blk_samples - static_cast<double>(d_current_integration_length_samples); // rounding error < 1 sample d_rem_code_phase_samples = K_blk_samples - static_cast<double>(d_current_integration_length_samples); // rounding error < 1 sample
// d_rem_code_phase_samples_first = K_blk_samples - static_cast<double>(d_extended_integration_first_prn_length_samples);
// d_rem_code_phase_samples_next = K_blk_samples - static_cast<double>(d_extended_integration_next_prn_length_samples);
d_rem_code_phase_chips = d_code_freq_chips * d_rem_code_phase_samples / trk_parameters.fs_in; d_rem_code_phase_chips = d_code_freq_chips * d_rem_code_phase_samples / trk_parameters.fs_in;
@ -1162,36 +1086,8 @@ void dll_pll_veml_tracking_fpga::save_correlation_results()
void dll_pll_veml_tracking_fpga::save_correlation_results_extended_integration_in_FPGA() void dll_pll_veml_tracking_fpga::save_correlation_results_extended_integration_in_FPGA()
{ {
// if (d_secondary) // no need to remove the secondary code. When extended coherent integration is enabled
// { // the secondary code is always removed in the FPGA
// if (d_secondary_code_string->at(d_current_symbol) == '0')
// {
// if (d_veml)
// {
// d_VE_accu += *d_Very_Early;
// d_VL_accu += *d_Very_Late;
// }
// d_E_accu += *d_Early;
// d_P_accu += *d_Prompt;
// d_L_accu += *d_Late;
// }
// else
// {
// if (d_veml)
// {
// d_VE_accu -= *d_Very_Early;
// d_VL_accu -= *d_Very_Late;
// }
// d_E_accu -= *d_Early;
// d_P_accu -= *d_Prompt;
// d_L_accu -= *d_Late;
// }
// d_current_symbol++;
// // secondary code roll-up
// d_current_symbol %= d_secondary_code_length;
// }
// else
// {
if (d_veml) if (d_veml)
{ {
d_VE_accu += *d_Very_Early; d_VE_accu += *d_Very_Early;
@ -1201,16 +1097,6 @@ void dll_pll_veml_tracking_fpga::save_correlation_results_extended_integration_i
d_P_accu += *d_Prompt; d_P_accu += *d_Prompt;
d_L_accu += *d_Late; d_L_accu += *d_Late;
// if (trk_parameters.track_pilot)
// {
// d_P_data_accu += *d_Prompt_data; // accumulate pilot result too
// }
// //d_current_symbol++;
// d_current_symbol = d_current_symbol + trk_parameters.extend_correlation_symbols;
// d_current_symbol %= d_symbols_per_bit;
//
// }
// If tracking pilot, disable Costas loop // If tracking pilot, disable Costas loop
if (trk_parameters.track_pilot) if (trk_parameters.track_pilot)
{ {
@ -1399,20 +1285,9 @@ void dll_pll_veml_tracking_fpga::log_data_extended_integration_in_FPGA(bool inte
tmp_E = std::abs<float>(d_E_accu); tmp_E = std::abs<float>(d_E_accu);
tmp_P = std::abs<float>(d_P_accu); tmp_P = std::abs<float>(d_P_accu);
tmp_L = std::abs<float>(d_L_accu); tmp_L = std::abs<float>(d_L_accu);
// if (integrating)
// { // no need to apply a scale factor. The
// //TODO: Improve this solution! // the signal is scaled up by the longer integration time in the FPGA
// // It compensates the amplitude difference while integrating
// if (d_extend_correlation_symbols_count > 0)
// {
// float scale_factor = static_cast<float>(trk_parameters.extend_correlation_symbols) / static_cast<float>(d_extend_correlation_symbols_count);
// tmp_VE *= scale_factor;
// tmp_E *= scale_factor;
// tmp_P *= scale_factor;
// tmp_L *= scale_factor;
// tmp_VL *= scale_factor;
// }
// }
for (uint32_t k=0;k<d_num_current_syncrho_repetitions;k++) for (uint32_t k=0;k<d_num_current_syncrho_repetitions;k++)
{ {
@ -1482,8 +1357,6 @@ void dll_pll_veml_tracking_fpga::log_data_extended_integration_in_FPGA(bool inte
// AUX vars (for debug purposes) // AUX vars (for debug purposes)
tmp_float = d_rem_code_phase_samples; tmp_float = d_rem_code_phase_samples;
d_dump_file.write(reinterpret_cast<char *>(&tmp_float), sizeof(float)); d_dump_file.write(reinterpret_cast<char *>(&tmp_float), sizeof(float));
//tmp_double = static_cast<double>(d_sample_counter + d_current_integration_length_samples);
if (!extended_correlation_in_fpga_enabled) if (!extended_correlation_in_fpga_enabled)
{ {
tmp_double = static_cast<double>(d_sample_counter_next); tmp_double = static_cast<double>(d_sample_counter_next);
@ -1492,7 +1365,6 @@ void dll_pll_veml_tracking_fpga::log_data_extended_integration_in_FPGA(bool inte
{ {
tmp_double = static_cast<double>(d_sample_counter + d_extended_integration_first_prn_length_samples*(k+1)); tmp_double = static_cast<double>(d_sample_counter + d_extended_integration_first_prn_length_samples*(k+1));
} }
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double)); d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
// PRN // PRN
uint32_t prn_ = d_acquisition_gnss_synchro->PRN; uint32_t prn_ = d_acquisition_gnss_synchro->PRN;
@ -1757,68 +1629,8 @@ void dll_pll_veml_tracking_fpga::set_channel(uint32_t channel)
{ {
d_channel = channel; d_channel = channel;
//debug
//if (d_channel != 1)
//{
// //d_extend_correlation_symbols = 1;
// d_sc_remodulate_enabled = 0;
// d_extended_correlation_in_fpga = 0;
//
// //d_enable_extended_integration = 0;
//
//}
multicorrelator_fpga->set_channel(d_channel); multicorrelator_fpga->set_channel(d_channel);
// if (d_enable_extended_integration == true)
// {
// if (d_extended_correlation_in_fpga == true)
// {
// // we can not write the secondary codes to the FPGA in the class constructors because the FPGA driver is not opened until the set_channel command is
// // sent to the FPGA multicorrelator (because the device name is linked to the channel number that is assigned to the current class).
// // Now we can write the secondary codes that do not depend on the PRN number
// if (trk_parameters.system == 'G')
// {
// if (signal_type == "L5")
// {
// if (trk_parameters.track_pilot)
// {
// multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_pilot, d_secondary_code_length_data);
// multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot);
// multicorrelator_fpga->initialize_secondary_code(1, d_secondary_code_string_data);
// }
// else
// {
// multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_data, 0);
// multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_data);
// }
// }
// }
// else if (trk_parameters.system == 'E')
// {
// if (signal_type == "5X")
// {
// if (trk_parameters.track_pilot)
// {
// multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_pilot, d_secondary_code_length_data);
// multicorrelator_fpga->initialize_secondary_code(1, d_secondary_code_string_data);
// }
// else
// {
// multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_data, 0);
// multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_data);
// }
// }
// }
// }
// }
// printf("================ now the secondary code stuff would be written ==================");
LOG(INFO) << "Tracking Channel set to " << d_channel; LOG(INFO) << "Tracking Channel set to " << d_channel;
// ############# ENABLE DATA FILE LOG ################# // ############# ENABLE DATA FILE LOG #################
if (d_dump) if (d_dump)
@ -1833,8 +1645,6 @@ void dll_pll_veml_tracking_fpga::set_channel(uint32_t channel)
{ {
try try
{ {
//trk_parameters.dump_filename.append(boost::lexical_cast<std::string>(d_channel));
//trk_parameters.dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
d_dump_file.open(dump_filename_.c_str(), std::ios::out | std::ios::binary); d_dump_file.open(dump_filename_.c_str(), std::ios::out | std::ios::binary);
LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << dump_filename_.c_str(); LOG(INFO) << "Tracking dump enabled on channel " << d_channel << " Log file: " << dump_filename_.c_str();
@ -1845,6 +1655,46 @@ void dll_pll_veml_tracking_fpga::set_channel(uint32_t channel)
} }
} }
} }
if (d_enable_extended_integration == true)
{
if (d_extended_correlation_in_fpga == true)
{
// Now we can write the secondary codes that do not depend on the PRN number
if (trk_parameters.system == 'G')
{
if (signal_type == "L5")
{
if (trk_parameters.track_pilot)
{
multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_pilot, d_secondary_code_length_data);
multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot);
multicorrelator_fpga->initialize_secondary_code(1, d_secondary_code_string_data);
}
else
{
multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_data, 0);
multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_data);
}
}
}
else if (trk_parameters.system == 'E')
{
if (signal_type == "5X")
{
// coherent integration in the FPGA is only enabled when tracking the pilot.
if (trk_parameters.track_pilot)
{
multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_pilot, d_secondary_code_length_data);
//multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot);
multicorrelator_fpga->initialize_secondary_code(1, d_secondary_code_string_data);
}
}
}
}
}
} }
@ -1853,20 +1703,17 @@ void dll_pll_veml_tracking_fpga::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro)
d_acquisition_gnss_synchro = p_gnss_synchro; d_acquisition_gnss_synchro = p_gnss_synchro;
if (p_gnss_synchro->PRN > 0) if (p_gnss_synchro->PRN > 0)
{ {
// When using the FPGA the SW only reads the sample counter during active tracking in order to spare CPU clock cycles. // A set_gnss_synchro command with a valid PRN is received when the system is going to run acquisition with that PRN.
// We can use this command to pre-initialize tracking parameters and variables before the actual acquisition process takes place.
// In this way we minimize the latency between acquisition and tracking once the acquisition has been made.
d_sample_counter = 0; d_sample_counter = 0;
d_sample_counter_next = 0; d_sample_counter_next = 0;
d_carrier_phase_rate_step_rad = 0.0; d_carrier_phase_rate_step_rad = 0.0;
d_code_ph_history.clear(); d_code_ph_history.clear();
d_carr_ph_history.clear(); d_carr_ph_history.clear();
if (systemName == "GPS" and signal_type == "L5") if (systemName == "GPS" and signal_type == "L5")
{ {
if (trk_parameters.track_pilot) if (trk_parameters.track_pilot)
@ -1886,15 +1733,23 @@ void dll_pll_veml_tracking_fpga::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro)
{ {
if (trk_parameters.track_pilot) if (trk_parameters.track_pilot)
{ {
d_secondary_code_string = const_cast<std::string *>(&GALILEO_E5A_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1]); d_secondary_code_string = const_cast<std::string *>(&GALILEO_E5A_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1]);
// used by the FPGA
d_secondary_code_string_pilot = const_cast<std::string *>(&GALILEO_E5A_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1]);
//multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot);
d_Prompt_Data[0] = gr_complex(0.0, 0.0); d_Prompt_Data[0] = gr_complex(0.0, 0.0);
if (d_enable_extended_integration == true)
{
if (d_extended_correlation_in_fpga == true)
{
// used by the FPGA
d_secondary_code_string_pilot = const_cast<std::string *>(&GALILEO_E5A_Q_SECONDARY_CODE[d_acquisition_gnss_synchro->PRN - 1]);
multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot);
}
}
} }
} }
@ -1942,8 +1797,6 @@ void dll_pll_veml_tracking_fpga::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro)
d_extended_integration_first_prn_length_samples = static_cast<int32_t>(trk_parameters.vector_length); d_extended_integration_first_prn_length_samples = static_cast<int32_t>(trk_parameters.vector_length);
d_extended_integration_next_prn_length_samples = d_extended_integration_first_prn_length_samples; d_extended_integration_next_prn_length_samples = d_extended_integration_first_prn_length_samples;
//d_extended_integration_first_rem_carr_phase_rad = 0.0;
//d_extended_integration_next_rem_carr_phase_rad_step = 0.0;
d_extended_integration_first_acc_carrier_phase_rad = 0.0; d_extended_integration_first_acc_carrier_phase_rad = 0.0;
d_extended_integration_next_acc_carrier_phase_rad_step = 0.0; d_extended_integration_next_acc_carrier_phase_rad_step = 0.0;
@ -1957,79 +1810,56 @@ void dll_pll_veml_tracking_fpga::set_gnss_synchro(Gnss_Synchro *p_gnss_synchro)
T_prn_samples_prev = T_prn_seconds * trk_parameters.fs_in; T_prn_samples_prev = T_prn_seconds * trk_parameters.fs_in;
K_blk_samples_prev = T_prn_samples_prev*trk_parameters.extend_correlation_symbols; K_blk_samples_prev = T_prn_samples_prev*trk_parameters.extend_correlation_symbols;
//multicorrelator_fpga->init_secondary_code_indices();
d_debug_counter = 0; d_debug_counter = 0;
enable_post_apply_secondary_code = 0; enable_post_apply_secondary_code = 0;
d_secondary_code_post_apply_counter = 0; d_secondary_code_post_apply_counter = 0;
d_secondary_code_debug_counter_whole_bits = -1; d_secondary_code_debug_counter_whole_bits = -1;
// re-establish nominal integration length (not extended integration by default) // re-establish nominal integration length (not extended integration by default)
d_current_integration_length_samples = static_cast<int32_t>(trk_parameters.vector_length); d_current_integration_length_samples = static_cast<int32_t>(trk_parameters.vector_length);
d_next_integration_length_samples = d_current_integration_length_samples; d_next_integration_length_samples = d_current_integration_length_samples;
multicorrelator_fpga->disable_secondary_codes(); // make sure the processing of the secondary codes is disabled by default multicorrelator_fpga->disable_secondary_codes(); // make sure the processing of the secondary codes is disabled by default
// debug
//debug_first_time = 1;
// updating the secondary code parameters is something that could be done only once during sw initialization. // if (d_enable_extended_integration == true)
// however, as the system works now, the SW resets the HW by launching a reset command from the acquisition class // {
// once for each channel during channel initialization. This erases the secondary length parameters that are already written // if (d_extended_correlation_in_fpga == true)
// to the hw during initialisation. That's why we need to do it here. // {
// in short a HW modification will be done in which the secondary code lengths nor the secondary codes are erased during reset // // Now we can write the secondary codes that do not depend on the PRN number
// in this way we will be able to program the secondary code parameters during initialisation and save some cpu cycles during // if (trk_parameters.system == 'G')
// real-time execution of gnss-sdr // {
if (d_enable_extended_integration == true) // if (signal_type == "L5")
{ // {
if (d_extended_correlation_in_fpga == true) // if (trk_parameters.track_pilot)
{ // {
// we can not write the secondary codes to the FPGA in the class constructors because the FPGA driver is not opened until the set_channel command is // multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_pilot, d_secondary_code_length_data);
// sent to the FPGA multicorrelator (because the device name is linked to the channel number that is assigned to the current class). // multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot);
// Now we can write the secondary codes that do not depend on the PRN number // multicorrelator_fpga->initialize_secondary_code(1, d_secondary_code_string_data);
if (trk_parameters.system == 'G') // }
{ // else
if (signal_type == "L5") // {
{ // multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_data, 0);
if (trk_parameters.track_pilot) // multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_data);
{ // }
multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_pilot, d_secondary_code_length_data); // }
multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot); // }
multicorrelator_fpga->initialize_secondary_code(1, d_secondary_code_string_data); // else if (trk_parameters.system == 'E')
} // {
else // if (signal_type == "5X")
{ // {
multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_data, 0); // // coherent integration in the FPGA is only enabled when tracking the pilot.
multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_data); // if (trk_parameters.track_pilot)
} // {
} // multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_pilot, d_secondary_code_length_data);
} // multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot);
else if (trk_parameters.system == 'E') // multicorrelator_fpga->initialize_secondary_code(1, d_secondary_code_string_data);
{ // }
if (signal_type == "5X") //
{ // }
if (trk_parameters.track_pilot) // }
{ // }
multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_pilot, d_secondary_code_length_data); // }
multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_pilot);
multicorrelator_fpga->initialize_secondary_code(1, d_secondary_code_string_data);
}
else
{
// the coherent integration in the fpga when using E5a without tracking the pilot cannot be done
// until the bug in the initialization variables related to the acquisition of the secondary code is
// solved in the SW
//multicorrelator_fpga->set_secondary_code_lengths(d_secondary_code_length_data, 0);
//multicorrelator_fpga->initialize_secondary_code(0, d_secondary_code_string_data);
}
}
}
}
}
} }
@ -2060,17 +1890,8 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
auto **out = reinterpret_cast<Gnss_Synchro **>(&output_items[0]); auto **out = reinterpret_cast<Gnss_Synchro **>(&output_items[0]);
Gnss_Synchro current_synchro_data = Gnss_Synchro(); Gnss_Synchro current_synchro_data = Gnss_Synchro();
//auto start = std::chrono::system_clock::now();
//d_current_prn_length_samples = d_next_prn_length_samples;
d_past_integration_length_samples = d_current_integration_length_samples;
d_current_integration_length_samples = d_next_integration_length_samples; d_current_integration_length_samples = d_next_integration_length_samples;
if (d_pull_in_transitory == true) if (d_pull_in_transitory == true)
{ {
if (d_sample_counter > 0) // do not execute this condition until the sample counter has ben read for the first time after start_tracking if (d_sample_counter > 0) // do not execute this condition until the sample counter has ben read for the first time after start_tracking
@ -2081,15 +1902,8 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
} }
} }
} }
//printf("entering general work");
//std::cout << "d_state = " << d_state << std::endl;
bool extended_correlation_in_fpga_enabled = false; bool extended_correlation_in_fpga_enabled = false;
//bool extended_correlation_in_sw_enabled = false;
//uint64_t reported_sample_counter;
//d_flag_printout = false;
switch (d_state) switch (d_state)
{ {
@ -2131,19 +1945,8 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
absolute_samples_offset = static_cast<uint64_t>(delta_trk_to_acq_prn_start_samples); absolute_samples_offset = static_cast<uint64_t>(delta_trk_to_acq_prn_start_samples);
} }
// debug L5
//absolute_samples_offset = 56615418;
//absolute_samples_offset = 399729106;
// if (d_channel == 0)
// {
//absolute_samples_offset = 96654773;
//absolute_samples_offset = 194417058;
// }
// debug E5a //std::cout << "TRACKING absolute_samples_offset = " << absolute_samples_offset << std::endl;
// absolute_samples_offset = 363577168;
std::cout << "TRACKING absolute_samples_offset = " << absolute_samples_offset << std::endl;
multicorrelator_fpga->set_initial_sample(absolute_samples_offset); multicorrelator_fpga->set_initial_sample(absolute_samples_offset);
d_absolute_samples_offset = absolute_samples_offset; d_absolute_samples_offset = absolute_samples_offset;
@ -2157,17 +1960,11 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
d_code_freq_chips = radial_velocity * d_code_chip_rate; d_code_freq_chips = radial_velocity * d_code_chip_rate;
d_code_phase_step_chips = d_code_freq_chips / trk_parameters.fs_in; d_code_phase_step_chips = d_code_freq_chips / trk_parameters.fs_in;
d_code_phase_rate_step_chips = 0.0; d_code_phase_rate_step_chips = 0.0;
//double T_chip_mod_seconds = 1.0 / d_code_freq_chips;
//double T_prn_mod_seconds = T_chip_mod_seconds * static_cast<double>(d_code_length_chips);
//double T_prn_mod_samples = T_prn_mod_seconds * trk_parameters.fs_in;
d_acq_code_phase_samples = absolute_samples_offset; d_acq_code_phase_samples = absolute_samples_offset;
//d_current_prn_length_samples = round(T_prn_mod_samples);
//d_current_prn_length_samples = trk_parameters.vector_length;
d_current_integration_length_samples = trk_parameters.vector_length; d_current_integration_length_samples = trk_parameters.vector_length;
//d_next_prn_length_samples = d_current_prn_length_samples;
d_next_integration_length_samples = d_current_integration_length_samples; d_next_integration_length_samples = d_current_integration_length_samples;
int32_t samples_offset = round(d_acq_code_phase_samples); int32_t samples_offset = round(d_acq_code_phase_samples);
@ -2184,10 +1981,6 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
DLOG(INFO) << "PULL-IN Doppler [Hz] = " << d_carrier_doppler_hz DLOG(INFO) << "PULL-IN Doppler [Hz] = " << d_carrier_doppler_hz
<< ". PULL-IN Code Phase [samples] = " << d_acq_code_phase_samples; << ". PULL-IN Code Phase [samples] = " << d_acq_code_phase_samples;
*out[0] = *d_acquisition_gnss_synchro; *out[0] = *d_acquisition_gnss_synchro;
return 1; return 1;
} }
@ -2221,18 +2014,17 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
else else
{ {
bool next_state = false; bool next_state = false;
// Perform DLL/PLL tracking loop computations. Costas Loop enabled
// Perform DLL/PLL tracking loop computations. Costas Loop enabled
run_dll_pll(); run_dll_pll();
update_tracking_vars(); update_tracking_vars();
// enable write dump file this cycle (valid DLL/PLL cycle)
d_num_current_syncrho_repetitions = 1; d_num_current_syncrho_repetitions = 1;
// enable write dump file this cycle (valid DLL/PLL cycle)
log_data(false); log_data(false);
//printf("aa\n");
if (d_secondary) if (d_secondary)
{ {
// ####### SECONDARY CODE LOCK ##### // ####### SECONDARY CODE LOCK #####
@ -2330,7 +2122,6 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
} }
} }
//printf("ff\n");
current_synchro_data.Tracking_sample_counter = d_sample_counter_next; current_synchro_data.Tracking_sample_counter = d_sample_counter_next;
current_synchro_data.Code_phase_samples = d_rem_code_phase_samples; current_synchro_data.Code_phase_samples = d_rem_code_phase_samples;
current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad; current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_rad;
@ -2351,67 +2142,23 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
if (d_enable_extended_integration) if (d_enable_extended_integration)
{ {
printf("EXTENDED INTEGRATION ENABLED\n"); // update integration time
//printf("in state 3");
//std::cout << "d_current_prn_length_samples = " << d_current_prn_length_samples << std::endl;
// UPDATE INTEGRATION TIME
d_extend_correlation_symbols_count = 0; d_extend_correlation_symbols_count = 0;
d_current_correlation_time_s = static_cast<float>(trk_parameters.extend_correlation_symbols) * static_cast<float>(d_code_period); d_current_correlation_time_s = static_cast<float>(trk_parameters.extend_correlation_symbols) * static_cast<float>(d_code_period);
if (d_extended_correlation_in_fpga) if (d_extended_correlation_in_fpga)
{ {
// if (trk_parameters.track_pilot)
// {
// d_P_data_accu = gr_complex(0.0, 0.0);
// }
//d_flag_printout = true;
// std::cout << "state 2 d_current_integration_length_samples = " << d_current_integration_length_samples << std::endl;
// std::cout << "state 2 d_sample_counter = " << d_sample_counter_tmp << std::endl;
// std::cout << "state 2 d_sample_counter_next = " << d_sample_counter_next_tmp << std::endl;
// // recompute current_integration_length as if it was a long integration
// double K_blk_samples_tmp = T_prn_samples_prev*trk_parameters.extend_correlation_symbols + d_rem_code_phase_samples_prev;
//
// //d_next_integration_length_samples = static_cast<int32_t>(std::floor(K_blk_samples));
// int32_t d_actual_blk_length_tmp = static_cast<int32_t>(std::floor(K_blk_samples_tmp));
// std::cout << "d_actual_blk_length_tmp = " << d_actual_blk_length_tmp << std::endl;
// std::cout << "d_past_integration_length_samples = " << d_past_integration_length_samples << std::endl;
// int32_t d_current_integration_length_samples_tmp = 2*d_actual_blk_length_tmp - d_past_integration_length_samples;
// std::cout << "d_current_integration_length_samples_tmp = " << d_current_integration_length_samples_tmp << std::endl;
// std::cout << "d_current_integration_length_samples = " << d_current_integration_length_samples << std::endl;
//d_next_prn_length_samples = d_current_prn_length_samples*trk_parameters.extend_correlation_symbols;
// correction on already computed parameters // correction on already computed parameters
//d_next_integration_length_samples = d_current_integration_length_samples*trk_parameters.extend_correlation_symbols;
K_blk_samples = T_prn_samples*trk_parameters.extend_correlation_symbols + d_rem_code_phase_samples_prev; K_blk_samples = T_prn_samples*trk_parameters.extend_correlation_symbols + d_rem_code_phase_samples_prev;
d_next_integration_length_samples = static_cast<int32_t>(std::floor(K_blk_samples)); d_next_integration_length_samples = static_cast<int32_t>(std::floor(K_blk_samples));
// std::cout << "state 2 modifying d_next_integration_length_samples = " << d_next_integration_length_samples << std::endl;
//d_actual_blk_length = static_cast<int32_t>(std::floor(K_blk_samples));
//d_next_integration_length_samples = 2*d_actual_blk_length - d_current_integration_length_samples_tmp;
// if (trk_parameters.extend_correlation_symbols == d_symbols_per_bit)
// {
// d_state = 6;
// }
// else
// {
// d_state = 5;
// }
if (d_sc_demodulate_enabled) if (d_sc_demodulate_enabled)
{ {
multicorrelator_fpga->enable_secondary_codes(); multicorrelator_fpga->enable_secondary_codes();
} }
d_state = 6; d_state = 5;
//d_state = 7;
} }
else else
@ -2428,7 +2175,7 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
// Set narrow taps delay values [chips] // Set narrow taps delay values [chips]
d_code_loop_filter.set_update_interval(d_current_correlation_time_s); d_code_loop_filter.set_update_interval(d_current_correlation_time_s);
d_code_loop_filter.set_noise_bandwidth(trk_parameters.dll_bw_narrow_hz); d_code_loop_filter.set_noise_bandwidth(trk_parameters.dll_bw_narrow_hz);
std::cout << " pll_bw_narrow_hz << " << trk_parameters.pll_bw_narrow_hz << " fll_bw_hz " << trk_parameters.fll_bw_hz << std::endl; //std::cout << " pll_bw_narrow_hz << " << trk_parameters.pll_bw_narrow_hz << " fll_bw_hz " << trk_parameters.fll_bw_hz << std::endl;
d_carrier_loop_filter.set_params(trk_parameters.fll_bw_hz, trk_parameters.pll_bw_narrow_hz, trk_parameters.pll_filter_order); d_carrier_loop_filter.set_params(trk_parameters.fll_bw_hz, trk_parameters.pll_bw_narrow_hz, trk_parameters.pll_filter_order);
if (d_veml) if (d_veml)
{ {
@ -2588,22 +2335,12 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
} }
case 6: // narrow tracking IN THE FPGA case 5: // narrow tracking IN THE FPGA
{ {
//printf("in state 6");
//std::cout << "d_current_prn_length_samples = " << d_current_prn_length_samples;
d_sample_counter = d_sample_counter_next; d_sample_counter = d_sample_counter_next;
d_sample_counter_next = d_sample_counter + static_cast<uint64_t>(d_current_integration_length_samples); d_sample_counter_next = d_sample_counter + static_cast<uint64_t>(d_current_integration_length_samples);
//d_flag_printout = true;
// std::cout << "state 6 d_current_integration_length_samples = " << d_current_integration_length_samples << std::endl;
// std::cout << "state 6 d_sample_counter = " << d_sample_counter << std::endl;
// std::cout << "state 6 d_sample_counter_next = " << d_sample_counter_next << std::endl;
// Fill the acquisition data // Fill the acquisition data
current_synchro_data = *d_acquisition_gnss_synchro; current_synchro_data = *d_acquisition_gnss_synchro;
@ -2615,25 +2352,13 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
d_first_length_secondary_code = d_current_integration_length_samples - (trk_parameters.extend_correlation_symbols - 1)*static_cast<int32_t>(std::floor(T_prn_samples)); d_first_length_secondary_code = d_current_integration_length_samples - (trk_parameters.extend_correlation_symbols - 1)*static_cast<int32_t>(std::floor(T_prn_samples));
d_next_length_secondary_code = static_cast<int32_t>(std::floor(T_prn_samples)); d_next_length_secondary_code = static_cast<int32_t>(std::floor(T_prn_samples));
// debug
// std::cout << "d_first_length_secondary_code = " << d_first_length_secondary_code << std::endl;
// std::cout << "d_next_length_secondary_code = " << d_next_length_secondary_code << std::endl;
multicorrelator_fpga->update_secondary_code_length(d_first_length_secondary_code, d_next_length_secondary_code); multicorrelator_fpga->update_secondary_code_length(d_first_length_secondary_code, d_next_length_secondary_code);
} }
// perform a correlation step // perform a correlation step
//std::cout << "going to do trk : d_current_integration_length_samples = " << d_current_integration_length_samples << std::endl;
do_correlation_step(); do_correlation_step();
// for (uint32_t k = 0;k<d_n_correlator_taps;k++)
// {
// //std::cout << "d_correlator_outs[" << k << "] = " << d_correlator_outs[k] << std::endl;
// d_correlator_outs[k] = d_correlator_outs[k]*(std::complex<float>(0.5,0));
// //std::cout << "d_correlator_outs[" << k << "] = " << d_correlator_outs[k] << std::endl;
// }
save_correlation_results_extended_integration_in_FPGA(); save_correlation_results_extended_integration_in_FPGA();
// check lock status // check lock status
@ -2647,10 +2372,6 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
run_dll_pll(); run_dll_pll();
update_tracking_vars_extend_integration_in_FPGA(); update_tracking_vars_extend_integration_in_FPGA();
// debug
// std::cout << "d_extended_integration_first_prn_length_samples = " << d_extended_integration_first_prn_length_samples << std::endl;
// std::cout << "d_extended_integration_next_prn_length_samples = " << d_extended_integration_next_prn_length_samples << std::endl;
// ########### Output the tracking results to Telemetry block ########## // ########### Output the tracking results to Telemetry block ##########
if (interchange_iq) if (interchange_iq)
{ {
@ -2720,11 +2441,9 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
{ {
current_synchro_data.fs = static_cast<int64_t>(trk_parameters.fs_in); current_synchro_data.fs = static_cast<int64_t>(trk_parameters.fs_in);
// debug // debug
d_sc_prompt_changed = false; d_sc_prompt_changed = false;
if (d_state == 3 || d_state == 4 | d_state ==6) if (d_state == 3 || d_state == 4 | d_state ==5)
{ {
// debug - remodulate secondary code // debug - remodulate secondary code
if (d_sc_remodulate_enabled == true) if (d_sc_remodulate_enabled == true)
@ -2761,12 +2480,10 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
if (current_synchro_data.Prompt_I < 0) if (current_synchro_data.Prompt_I < 0)
{ {
//outfile << "1" << std::endl;
outfile << "1 " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << std::endl; outfile << "1 " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << std::endl;
} }
else else
{ {
//outfile << "0" << std::endl;
outfile << "0 " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << std::endl; outfile << "0 " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << std::endl;
} }
@ -2776,11 +2493,6 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
d_secondary_code_debug_counter_whole_bits = 0; d_secondary_code_debug_counter_whole_bits = 0;
outfile << "--" << std::endl; outfile << "--" << std::endl;
} }
// if (debug_first_time == 1)
// {
// outfile << "-- " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << " --" << std::endl;
// debug_first_time = 0;
// }
outfile.close(); outfile.close();
d_debug_counter++; d_debug_counter++;
} }
@ -2806,9 +2518,8 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
d_extended_integration_first_acc_carrier_phase_rad -= d_extended_integration_next_acc_carrier_phase_rad_step; d_extended_integration_first_acc_carrier_phase_rad -= d_extended_integration_next_acc_carrier_phase_rad_step;
current_synchro_data.Carrier_phase_rads = d_extended_integration_first_acc_carrier_phase_rad; current_synchro_data.Carrier_phase_rads = d_extended_integration_first_acc_carrier_phase_rad;
// debug
d_sc_prompt_changed = false; d_sc_prompt_changed = false;
if (d_state == 3 || d_state == 4 | d_state ==6) if (d_state == 3 || d_state == 4 | d_state ==5)
{ {
if (d_sc_remodulate_enabled == true) if (d_sc_remodulate_enabled == true)
@ -2830,18 +2541,13 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
if (d_flag_printout == true) if (d_flag_printout == true)
{ {
outfile.open("trk_out.txt", std::ios_base::app); outfile.open("trk_out.txt", std::ios_base::app);
//outfile << "d_num_current_syncrho_repetitions = " << d_num_current_syncrho_repetitions << " d_debug_counter = " << d_debug_counter << std::endl;
outfile << d_debug_counter << " "; outfile << d_debug_counter << " ";
//outfile << current_synchro_data.Prompt_I << " "; // << std::endl;
//outfile << current_synchro_data.Prompt_Q << " "; //<< std::endl;
if (current_synchro_data.Prompt_I < 0) if (current_synchro_data.Prompt_I < 0)
{ {
//outfile << "1" << std::endl;
outfile << "1 " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << std::endl; outfile << "1 " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << std::endl;
} }
else else
{ {
//outfile << "0" << std::endl;
outfile << "0 " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << std::endl; outfile << "0 " << debug_d_rem_carr_phase_rad << " " << d_rem_carr_phase_rad << std::endl;
} }
@ -2870,13 +2576,6 @@ int dll_pll_veml_tracking_fpga::general_work(int noutput_items __attribute__((un
return d_num_current_syncrho_repetitions; return d_num_current_syncrho_repetitions;
// if (current_synchro_data.Flag_valid_symbol_output)
// {
// current_synchro_data.fs = static_cast<int64_t>(trk_parameters.fs_in);
// //current_synchro_data.Tracking_sample_counter = d_sample_counter_next;
// *out[0] = current_synchro_data;
// return 1;
} }
return 0; return 0;
} }

10
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.h
View File

@ -195,11 +195,9 @@ private:
double K_blk_samples; double K_blk_samples;
double K_blk_samples_prev; double K_blk_samples_prev;
// PRN period in samples
// REPLACED BY d_correlation_length_samples, d_next_integration_length_samples
//int32_t d_current_prn_length_samples;
int32_t d_current_integration_length_samples; int32_t d_current_integration_length_samples;
int32_t d_past_integration_length_samples;
// processing samples counters // processing samples counters
uint64_t d_sample_counter; uint64_t d_sample_counter;
uint64_t d_acq_sample_stamp; uint64_t d_acq_sample_stamp;
@ -229,7 +227,6 @@ private:
// extra // extra
int32_t d_correlation_length_samples; int32_t d_correlation_length_samples;
//int32_t d_next_prn_length_samples;
int32_t d_next_integration_length_samples; int32_t d_next_integration_length_samples;
int32_t d_extended_integration_first_prn_length_samples; int32_t d_extended_integration_first_prn_length_samples;
@ -238,9 +235,6 @@ private:
double d_extended_integration_first_acc_carrier_phase_rad; double d_extended_integration_first_acc_carrier_phase_rad;
double d_extended_integration_next_acc_carrier_phase_rad_step; double d_extended_integration_next_acc_carrier_phase_rad_step;
//float d_extended_integration_first_rem_carr_phase_rad;
//float d_extended_integration_next_rem_carr_phase_rad_step;
uint64_t d_sample_counter_next; uint64_t d_sample_counter_next;
// DEBUG STUFF // DEBUG STUFF