mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-14 04:00:34 +00:00
Code Issues Releases Wiki Activity

Make code more readable

Browse Source
This commit is contained in:
Carles Fernandez 2017-07-25 16:26:23 +02:00
parent 1dda344e46
commit 648956ea65
1 changed files with 172 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

502
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc.cc
View File

@ -76,8 +76,8 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::msg_handler_preamble_index(
pmt::pmt_t msg)
{
DLOG(INFO) << "Extended correlation enabled for Tracking CH "
<< d_channel << ": Satellite "
<< Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN);
<< d_channel << ": Satellite "
<< Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN);
if (d_enable_extended_integration == false) //avoid re-setting preamble indicator
{
d_preamble_timestamp_s = pmt::to_double(msg);
@ -127,34 +127,29 @@ gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::gps_l1_ca_dll_pll_c_aid_tracking_fpga_
// Initialization of local code replica
// Get space for a vector with the C/A code replica sampled 1x/chip
d_ca_code = static_cast<gr_complex*>(volk_gnsssdr_malloc(
static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS) * sizeof(gr_complex),
volk_gnsssdr_get_alignment()));
d_ca_code_16sc = static_cast<lv_16sc_t*>(volk_gnsssdr_malloc(
static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS) * sizeof(lv_16sc_t),
volk_gnsssdr_get_alignment()));
d_ca_code = static_cast<gr_complex*>(volk_gnsssdr_malloc(static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS) * sizeof(gr_complex), volk_gnsssdr_get_alignment()));
d_ca_code_16sc = static_cast<lv_16sc_t*>(volk_gnsssdr_malloc(static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS) * sizeof(lv_16sc_t), volk_gnsssdr_get_alignment()));
// correlator outputs (scalar)
d_n_correlator_taps = 3; // Early, Prompt, and Late
d_correlator_outs_16sc = static_cast<lv_16sc_t*>(volk_gnsssdr_malloc(
d_n_correlator_taps * sizeof(lv_16sc_t),
d_correlator_outs_16sc = static_cast<lv_16sc_t*>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(lv_16sc_t),
volk_gnsssdr_get_alignment()));
for (int n = 0; n < d_n_correlator_taps; n++)
{
d_correlator_outs_16sc[n] = lv_cmake(0, 0);
}
d_local_code_shift_chips = static_cast<float*>(volk_gnsssdr_malloc(
d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment()));
d_local_code_shift_chips = static_cast<float*>(volk_gnsssdr_malloc(d_n_correlator_taps * sizeof(float), volk_gnsssdr_get_alignment()));
// Set TAPs delay values [chips]
d_local_code_shift_chips[0] = -d_early_late_spc_chips;
d_local_code_shift_chips[1] = 0.0;
d_local_code_shift_chips[2] = d_early_late_spc_chips;
// create multicorrelator class
multicorrelator_fpga_8sc = std::make_shared < fpga_multicorrelator_8sc
> (d_n_correlator_taps, device_name, device_base);
multicorrelator_fpga_8sc = std::make_shared <fpga_multicorrelator_8sc>(d_n_correlator_taps, device_name, device_base);
//--- Perform initializations ------------------------------
// define initial code frequency basis of NCO
@ -217,55 +212,41 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::start_tracking()
long int acq_trk_diff_samples;
double acq_trk_diff_seconds;
acq_trk_diff_samples = static_cast<long int>(d_sample_counter)
- static_cast<long int>(d_acq_sample_stamp); //-d_vector_length;
DLOG(INFO) << "Number of samples between Acquisition and Tracking ="
<< acq_trk_diff_samples;
acq_trk_diff_seconds = static_cast<double>(acq_trk_diff_samples)
/ static_cast<double>(d_fs_in);
acq_trk_diff_samples = static_cast<long int>(d_sample_counter) - static_cast<long int>(d_acq_sample_stamp);
DLOG(INFO) << "Number of samples between Acquisition and Tracking =" << acq_trk_diff_samples;
acq_trk_diff_seconds = static_cast<double>(acq_trk_diff_samples) / static_cast<double>(d_fs_in);
// Doppler effect
// Fd=(C/(C+Vr))*F
double radial_velocity = (GPS_L1_FREQ_HZ + d_acq_carrier_doppler_hz)
/ GPS_L1_FREQ_HZ;
double radial_velocity = (GPS_L1_FREQ_HZ + d_acq_carrier_doppler_hz) / GPS_L1_FREQ_HZ;
// new chip and prn sequence periods based on acq Doppler
double T_chip_mod_seconds;
double T_prn_mod_seconds;
double T_prn_mod_samples;
d_code_freq_chips = radial_velocity * GPS_L1_CA_CODE_RATE_HZ;
d_code_phase_step_chips = static_cast<double>(d_code_freq_chips)
/ static_cast<double>(d_fs_in);
d_code_phase_step_chips = static_cast<double>(d_code_freq_chips) / static_cast<double>(d_fs_in);
T_chip_mod_seconds = 1.0 / d_code_freq_chips;
T_prn_mod_seconds = T_chip_mod_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS;
T_prn_mod_samples = T_prn_mod_seconds * static_cast<double>(d_fs_in);
d_correlation_length_samples = round(T_prn_mod_samples);
double T_prn_true_seconds = GPS_L1_CA_CODE_LENGTH_CHIPS
/ GPS_L1_CA_CODE_RATE_HZ;
double T_prn_true_samples = T_prn_true_seconds
* static_cast<double>(d_fs_in);
double T_prn_true_seconds = GPS_L1_CA_CODE_LENGTH_CHIPS / GPS_L1_CA_CODE_RATE_HZ;
double T_prn_true_samples = T_prn_true_seconds * static_cast<double>(d_fs_in);
double T_prn_diff_seconds = T_prn_true_seconds - T_prn_mod_seconds;
double N_prn_diff = acq_trk_diff_seconds / T_prn_true_seconds;
double corrected_acq_phase_samples, delay_correction_samples;
corrected_acq_phase_samples = fmod(
(d_acq_code_phase_samples
+ T_prn_diff_seconds * N_prn_diff
* static_cast<double>(d_fs_in)),
T_prn_true_samples);
corrected_acq_phase_samples = fmod((d_acq_code_phase_samples + T_prn_diff_seconds * N_prn_diff * static_cast<double>(d_fs_in)), T_prn_true_samples);
if (corrected_acq_phase_samples < 0)
{
corrected_acq_phase_samples = T_prn_mod_samples
+ corrected_acq_phase_samples;
corrected_acq_phase_samples = T_prn_mod_samples + corrected_acq_phase_samples;
}
delay_correction_samples = d_acq_code_phase_samples
- corrected_acq_phase_samples;
delay_correction_samples = d_acq_code_phase_samples - corrected_acq_phase_samples;
d_acq_code_phase_samples = corrected_acq_phase_samples;
d_carrier_doppler_hz = d_acq_carrier_doppler_hz;
d_carrier_phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz
/ static_cast<double>(d_fs_in);
d_carrier_phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz / static_cast<double>(d_fs_in);
// DLL/PLL filter initialization
d_carrier_loop_filter.initialize(d_acq_carrier_doppler_hz); // The carrier loop filter implements the Doppler accumulator
@ -273,12 +254,9 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::start_tracking()
// generate local reference ALWAYS starting at chip 1 (1 sample per chip)
gps_l1_ca_code_gen_complex(d_ca_code, d_acquisition_gnss_synchro->PRN, 0);
volk_gnsssdr_32fc_convert_16ic(d_ca_code_16sc, d_ca_code,
static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS));
volk_gnsssdr_32fc_convert_16ic(d_ca_code_16sc, d_ca_code, static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS));
multicorrelator_fpga_8sc->set_local_code_and_taps(
static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS), d_ca_code_16sc,
d_local_code_shift_chips);
multicorrelator_fpga_8sc->set_local_code_and_taps(static_cast<int>(GPS_L1_CA_CODE_LENGTH_CHIPS), d_ca_code_16sc, d_local_code_shift_chips);
for (int n = 0; n < d_n_correlator_taps; n++)
{
d_correlator_outs_16sc[n] = lv_16sc_t(0, 0);
@ -297,11 +275,11 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::start_tracking()
// DEBUG OUTPUT
std::cout << "Tracking start on channel " << d_channel << " for satellite "
<< Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
<< std::endl;
<< Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
<< std::endl;
LOG(INFO) << "Starting tracking of satellite "
<< Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
<< " on channel " << d_channel;
<< Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
<< " on channel " << d_channel;
// enable tracking
d_pull_in = true;
@ -313,22 +291,37 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::start_tracking()
multicorrelator_fpga_8sc->lock_channel();
LOG(INFO) << "PULL-IN Doppler [Hz]=" << d_carrier_doppler_hz
<< " Code Phase correction [samples]=" << delay_correction_samples
<< " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
<< " Code Phase correction [samples]=" << delay_correction_samples
<< " PULL-IN Code Phase [samples]=" << d_acq_code_phase_samples;
}
gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::~gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc()
{
d_dump_file.close();
volk_gnsssdr_free(d_local_code_shift_chips);
volk_gnsssdr_free(d_ca_code);
volk_gnsssdr_free(d_ca_code_16sc);
volk_gnsssdr_free(d_correlator_outs_16sc);
delete[] d_Prompt_buffer;
multicorrelator_fpga_8sc->free();
if (d_dump_file.is_open())
{
try
{
d_dump_file.close();
}
catch(const std::exception & ex)
{
LOG(WARNING)<< "Exception in destructor " << ex.what();
}
}
try
{
volk_gnsssdr_free(d_local_code_shift_chips);
volk_gnsssdr_free(d_ca_code);
volk_gnsssdr_free(d_ca_code_16sc);
volk_gnsssdr_free(d_correlator_outs_16sc);
delete[] d_Prompt_buffer;
multicorrelator_fpga_8sc->free();
}
catch(const std::exception & ex)
{
LOG(WARNING) << "Exception in destructor " << ex.what();
}
}
@ -360,39 +353,27 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
{
double acq_trk_shif_correction_samples;
int acq_to_trk_delay_samples;
acq_to_trk_delay_samples = d_sample_counter
- d_acq_sample_stamp;
acq_trk_shif_correction_samples =
d_correlation_length_samples
- fmod(
static_cast<double>(acq_to_trk_delay_samples),
static_cast<double>(d_correlation_length_samples));
samples_offset = round(
d_acq_code_phase_samples
+ acq_trk_shif_correction_samples);
current_synchro_data.Tracking_sample_counter =
d_sample_counter + samples_offset;
acq_to_trk_delay_samples = d_sample_counter - d_acq_sample_stamp;
acq_trk_shif_correction_samples = d_correlation_length_samples - fmod( static_cast<double>(acq_to_trk_delay_samples), static_cast<double>(d_correlation_length_samples));
samples_offset = round(d_acq_code_phase_samples + acq_trk_shif_correction_samples);
current_synchro_data.Tracking_sample_counter = d_sample_counter + samples_offset;
d_sample_counter += samples_offset; // count for the processed samples
d_pull_in = false;
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad
* samples_offset / GPS_TWO_PI;
current_synchro_data.Carrier_phase_rads =
d_acc_carrier_phase_cycles * GPS_TWO_PI;
current_synchro_data.Carrier_Doppler_hz =
d_carrier_doppler_hz;
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * samples_offset / GPS_TWO_PI;
current_synchro_data.Carrier_phase_rads = d_acc_carrier_phase_cycles * GPS_TWO_PI;
current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
current_synchro_data.fs = d_fs_in;
*out[0] = current_synchro_data;
//consume_each(samples_offset); // shift input to perform alignment with local replica
multicorrelator_fpga_8sc->set_initial_sample(
samples_offset);
multicorrelator_fpga_8sc->set_initial_sample(samples_offset);
return 1;
}
// ################# CARRIER WIPEOFF AND CORRELATORS ##############################
// perform carrier wipe-off and compute Early, Prompt and Late correlation
multicorrelator_fpga_8sc->set_output_vectors(
d_correlator_outs_16sc);
multicorrelator_fpga_8sc->set_output_vectors(d_correlator_outs_16sc);
multicorrelator_fpga_8sc->Carrier_wipeoff_multicorrelator_resampler(
d_rem_carrier_phase_rad, d_carrier_phase_step_rad,
d_rem_code_phase_chips, d_code_phase_step_chips,
@ -414,14 +395,8 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
bool enable_dll_pll;
if (d_enable_extended_integration == true)
{
long int symbol_diff = round(
1000.0
* ((static_cast<double>(d_sample_counter)
+ d_rem_code_phase_samples)
/ static_cast<double>(d_fs_in)
- d_preamble_timestamp_s));
if (symbol_diff > 0
and symbol_diff % d_extend_correlation_ms == 0)
long int symbol_diff = round(1000.0 * ((static_cast<double>(d_sample_counter) + d_rem_code_phase_samples) / static_cast<double>(d_fs_in) - d_preamble_timestamp_s));
if (symbol_diff > 0 and symbol_diff % d_extend_correlation_ms == 0)
{
// compute coherent integration and enable tracking loop
// perform coherent integration using correlator output history
@ -431,40 +406,32 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
d_correlator_outs_16sc[2] = lv_cmake(0, 0);
for (int n = 0; n < d_extend_correlation_ms; n++)
{
d_correlator_outs_16sc[0] += d_E_history.at(
n);
d_correlator_outs_16sc[1] += d_P_history.at(
n);
d_correlator_outs_16sc[2] += d_L_history.at(
n);
d_correlator_outs_16sc[0] += d_E_history.at(n);
d_correlator_outs_16sc[1] += d_P_history.at(n);
d_correlator_outs_16sc[2] += d_L_history.at(n);
}
if (d_preamble_synchronized == false)
{
d_code_loop_filter.set_DLL_BW(
d_dll_bw_narrow_hz);
d_carrier_loop_filter.set_params(10.0,
d_pll_bw_narrow_hz, 2);
d_code_loop_filter.set_DLL_BW(d_dll_bw_narrow_hz);
d_carrier_loop_filter.set_params(10.0, d_pll_bw_narrow_hz, 2);
d_preamble_synchronized = true;
std::cout << "Enabled "
<< d_extend_correlation_ms
<< " [ms] extended correlator for CH "
<< d_channel << " : Satellite "
<< Gnss_Satellite(systemName[sys],
d_acquisition_gnss_synchro->PRN)
<< " pll_bw = " << d_pll_bw_hz
<< " [Hz], pll_narrow_bw = "
<< d_pll_bw_narrow_hz << " [Hz]"
<< std::endl << " dll_bw = "
<< d_dll_bw_hz
<< " [Hz], dll_narrow_bw = "
<< d_dll_bw_narrow_hz << " [Hz]"
<< std::endl;
<< d_extend_correlation_ms
<< " [ms] extended correlator for CH "
<< d_channel << " : Satellite "
<< Gnss_Satellite(systemName[sys], d_acquisition_gnss_synchro->PRN)
<< " pll_bw = " << d_pll_bw_hz
<< " [Hz], pll_narrow_bw = "
<< d_pll_bw_narrow_hz << " [Hz]"
<< std::endl << " dll_bw = "
<< d_dll_bw_hz
<< " [Hz], dll_narrow_bw = "
<< d_dll_bw_narrow_hz << " [Hz]"
<< std::endl;
}
// UPDATE INTEGRATION TIME
CURRENT_INTEGRATION_TIME_S =
static_cast<double>(d_extend_correlation_ms)
* GPS_L1_CA_CODE_PERIOD;
CURRENT_INTEGRATION_TIME_S = static_cast<double>(d_extend_correlation_ms) * GPS_L1_CA_CODE_PERIOD;
enable_dll_pll = true;
}
else
@ -473,49 +440,25 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
{
// continue extended coherent correlation
// Compute the next buffer length based on the period of the PRN sequence and the code phase error estimation
double T_chip_seconds = 1.0
/ d_code_freq_chips;
double T_prn_seconds = T_chip_seconds
* GPS_L1_CA_CODE_LENGTH_CHIPS;
double T_prn_samples = T_prn_seconds
* static_cast<double>(d_fs_in);
double T_chip_seconds = 1.0 / d_code_freq_chips;
double T_prn_seconds = T_chip_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS;
double T_prn_samples = T_prn_seconds * static_cast<double>(d_fs_in);
int K_prn_samples = round(T_prn_samples);
double K_T_prn_error_samples = K_prn_samples
- T_prn_samples;
double K_T_prn_error_samples = K_prn_samples - T_prn_samples;
d_rem_code_phase_samples =
d_rem_code_phase_samples
- K_T_prn_error_samples;
d_rem_code_phase_integer_samples = round(
d_rem_code_phase_samples); // round to a discrete number of samples
d_correlation_length_samples = K_prn_samples
+ d_rem_code_phase_integer_samples;
d_rem_code_phase_samples =
d_rem_code_phase_samples
- d_rem_code_phase_integer_samples;
d_rem_code_phase_samples = d_rem_code_phase_samples - K_T_prn_error_samples;
d_rem_code_phase_integer_samples = round(d_rem_code_phase_samples); // round to a discrete number of samples
d_correlation_length_samples = K_prn_samples + d_rem_code_phase_integer_samples;
d_rem_code_phase_samples = d_rem_code_phase_samples - d_rem_code_phase_integer_samples;
// code phase step (Code resampler phase increment per sample) [chips/sample]
d_code_phase_step_chips = d_code_freq_chips
/ static_cast<double>(d_fs_in);
d_code_phase_step_chips = d_code_freq_chips / static_cast<double>(d_fs_in);
// remnant code phase [chips]
d_rem_code_phase_chips =
d_rem_code_phase_samples
* (d_code_freq_chips
/ static_cast<double>(d_fs_in));
d_rem_carrier_phase_rad =
fmod(
d_rem_carrier_phase_rad
+ d_carrier_phase_step_rad
* static_cast<double>(d_correlation_length_samples),
GPS_TWO_PI);
d_rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / static_cast<double>(d_fs_in));
d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + d_carrier_phase_step_rad * static_cast<double>(d_correlation_length_samples), GPS_TWO_PI);
// UPDATE ACCUMULATED CARRIER PHASE
CORRECTED_INTEGRATION_TIME_S =
(static_cast<double>(d_correlation_length_samples)
/ static_cast<double>(d_fs_in));
d_acc_carrier_phase_cycles -=
d_carrier_phase_step_rad
* d_correlation_length_samples
/ GPS_TWO_PI;
CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GPS_TWO_PI;
// disable tracking loop and inform telemetry decoder
enable_dll_pll = false;
@ -524,9 +467,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
{
// perform basic (1ms) correlation
// UPDATE INTEGRATION TIME
CURRENT_INTEGRATION_TIME_S =
static_cast<double>(d_correlation_length_samples)
/ static_cast<double>(d_fs_in);
CURRENT_INTEGRATION_TIME_S = static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in);
enable_dll_pll = true;
}
}
@ -534,9 +475,7 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
else
{
// UPDATE INTEGRATION TIME
CURRENT_INTEGRATION_TIME_S =
static_cast<double>(d_correlation_length_samples)
/ static_cast<double>(d_fs_in);
CURRENT_INTEGRATION_TIME_S = static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in);
enable_dll_pll = true;
}
@ -544,26 +483,16 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
{
// ################## PLL ##########################################################
// Update PLL discriminator [rads/Ti -> Secs/Ti]
d_carr_phase_error_secs_Ti = pll_cloop_two_quadrant_atan(
std::complex<float>(
d_correlator_outs_16sc[1].real(),
d_correlator_outs_16sc[1].imag()))
/ GPS_TWO_PI; //prompt output
d_carr_phase_error_secs_Ti = pll_cloop_two_quadrant_atan(std::complex<float>(d_correlator_outs_16sc[1].real(), d_correlator_outs_16sc[1].imag())) / GPS_TWO_PI; //prompt output
// Carrier discriminator filter
// NOTICE: The carrier loop filter includes the Carrier Doppler accumulator, as described in Kaplan
// Input [s/Ti] -> output [Hz]
d_carrier_doppler_hz =
d_carrier_loop_filter.get_carrier_error(0.0,
d_carr_phase_error_secs_Ti,
CURRENT_INTEGRATION_TIME_S);
d_carrier_doppler_hz = d_carrier_loop_filter.get_carrier_error(0.0, d_carr_phase_error_secs_Ti, CURRENT_INTEGRATION_TIME_S);
// PLL to DLL assistance [Secs/Ti]
d_pll_to_dll_assist_secs_Ti = (d_carrier_doppler_hz
* CURRENT_INTEGRATION_TIME_S) / GPS_L1_FREQ_HZ;
d_pll_to_dll_assist_secs_Ti = (d_carrier_doppler_hz * CURRENT_INTEGRATION_TIME_S) / GPS_L1_FREQ_HZ;
// code Doppler frequency update
d_code_freq_chips = GPS_L1_CA_CODE_RATE_HZ
+ ((d_carrier_doppler_hz * GPS_L1_CA_CODE_RATE_HZ)
/ GPS_L1_FREQ_HZ);
d_code_freq_chips = GPS_L1_CA_CODE_RATE_HZ + ((d_carrier_doppler_hz * GPS_L1_CA_CODE_RATE_HZ) / GPS_L1_FREQ_HZ);
// ################## DLL ##########################################################
// DLL discriminator
@ -575,70 +504,44 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
d_correlator_outs_16sc[2].real(),
d_correlator_outs_16sc[2].imag())); // [chips/Ti] //early and late
// Code discriminator filter
d_code_error_filt_chips_s = d_code_loop_filter.get_code_nco(
d_code_error_chips_Ti); // input [chips/Ti] -> output [chips/second]
d_code_error_filt_chips_Ti = d_code_error_filt_chips_s
* CURRENT_INTEGRATION_TIME_S;
code_error_filt_secs_Ti = d_code_error_filt_chips_Ti
/ d_code_freq_chips; // [s/Ti]
d_code_error_filt_chips_s = d_code_loop_filter.get_code_nco(d_code_error_chips_Ti); // input [chips/Ti] -> output [chips/second]
d_code_error_filt_chips_Ti = d_code_error_filt_chips_s * CURRENT_INTEGRATION_TIME_S;
code_error_filt_secs_Ti = d_code_error_filt_chips_Ti / d_code_freq_chips; // [s/Ti]
// ################## CARRIER AND CODE NCO BUFFER ALIGNEMENT #######################
// 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
double T_chip_seconds = 1.0 / d_code_freq_chips;
double T_prn_seconds = T_chip_seconds
* GPS_L1_CA_CODE_LENGTH_CHIPS;
double T_prn_samples = T_prn_seconds
* static_cast<double>(d_fs_in);
double T_prn_seconds = T_chip_seconds * GPS_L1_CA_CODE_LENGTH_CHIPS;
double T_prn_samples = T_prn_seconds * static_cast<double>(d_fs_in);
double K_prn_samples = round(T_prn_samples);
double K_T_prn_error_samples = K_prn_samples
- T_prn_samples;
double K_T_prn_error_samples = K_prn_samples - T_prn_samples;
d_rem_code_phase_samples = d_rem_code_phase_samples
- K_T_prn_error_samples
+ code_error_filt_secs_Ti
* static_cast<double>(d_fs_in); //(code_error_filt_secs_Ti + d_pll_to_dll_assist_secs_Ti) * static_cast<double>(d_fs_in);
d_rem_code_phase_integer_samples = round(
d_rem_code_phase_samples); // round to a discrete number of samples
d_correlation_length_samples = K_prn_samples
+ d_rem_code_phase_integer_samples;
d_rem_code_phase_samples = d_rem_code_phase_samples
- d_rem_code_phase_integer_samples;
d_rem_code_phase_samples = d_rem_code_phase_samples - K_T_prn_error_samples + code_error_filt_secs_Ti * static_cast<double>(d_fs_in); //(code_error_filt_secs_Ti + d_pll_to_dll_assist_secs_Ti) * static_cast<double>(d_fs_in);
d_rem_code_phase_integer_samples = round(d_rem_code_phase_samples); // round to a discrete number of samples
d_correlation_length_samples = K_prn_samples+ d_rem_code_phase_integer_samples;
d_rem_code_phase_samples = d_rem_code_phase_samples - d_rem_code_phase_integer_samples;
//################### PLL COMMANDS #################################################
//carrier phase step (NCO phase increment per sample) [rads/sample]
d_carrier_phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz
/ static_cast<double>(d_fs_in);
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad
* d_correlation_length_samples / GPS_TWO_PI;
d_carrier_phase_step_rad = GPS_TWO_PI * d_carrier_doppler_hz / static_cast<double>(d_fs_in);
d_acc_carrier_phase_cycles -= d_carrier_phase_step_rad * d_correlation_length_samples / GPS_TWO_PI;
// UPDATE ACCUMULATED CARRIER PHASE
CORRECTED_INTEGRATION_TIME_S =
(static_cast<double>(d_correlation_length_samples)
/ static_cast<double>(d_fs_in));
CORRECTED_INTEGRATION_TIME_S = (static_cast<double>(d_correlation_length_samples) / static_cast<double>(d_fs_in));
//remnant carrier phase [rad]
d_rem_carrier_phase_rad = fmod(
d_rem_carrier_phase_rad
+ GPS_TWO_PI * d_carrier_doppler_hz
* CORRECTED_INTEGRATION_TIME_S,
GPS_TWO_PI);
d_rem_carrier_phase_rad = fmod(d_rem_carrier_phase_rad + GPS_TWO_PI * d_carrier_doppler_hz * CORRECTED_INTEGRATION_TIME_S, GPS_TWO_PI);
//################### DLL COMMANDS #################################################
//code phase step (Code resampler phase increment per sample) [chips/sample]
d_code_phase_step_chips = d_code_freq_chips
/ static_cast<double>(d_fs_in);
d_code_phase_step_chips = d_code_freq_chips / static_cast<double>(d_fs_in);
//remnant code phase [chips]
d_rem_code_phase_chips =
d_rem_code_phase_samples
* (d_code_freq_chips
/ static_cast<double>(d_fs_in));
d_rem_code_phase_chips = d_rem_code_phase_samples * (d_code_freq_chips / static_cast<double>(d_fs_in));
// ####### CN0 ESTIMATION AND LOCK DETECTORS #######################################
if (d_cn0_estimation_counter < CN0_ESTIMATION_SAMPLES)
{
// fill buffer with prompt correlator output values
d_Prompt_buffer[d_cn0_estimation_counter] =
lv_cmake(
static_cast<float>(d_correlator_outs_16sc[1].real()),
d_Prompt_buffer[d_cn0_estimation_counter] = lv_cmake(static_cast<float>(d_correlator_outs_16sc[1].real()),
static_cast<float>(d_correlator_outs_16sc[1].imag())); // prompt
d_cn0_estimation_counter++;
}
@ -646,15 +549,11 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
{
d_cn0_estimation_counter = 0;
// Code lock indicator
d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer,
CN0_ESTIMATION_SAMPLES, d_fs_in,
GPS_L1_CA_CODE_LENGTH_CHIPS);
d_CN0_SNV_dB_Hz = cn0_svn_estimator(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES, d_fs_in, GPS_L1_CA_CODE_LENGTH_CHIPS);
// Carrier lock indicator
d_carrier_lock_test = carrier_lock_detector(
d_Prompt_buffer, CN0_ESTIMATION_SAMPLES);
d_carrier_lock_test = carrier_lock_detector(d_Prompt_buffer, CN0_ESTIMATION_SAMPLES);
// Loss of lock detection
if (d_carrier_lock_test
< d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < MINIMUM_VALID_CN0)
if (d_carrier_lock_test < d_carrier_lock_threshold or d_CN0_SNV_dB_Hz < MINIMUM_VALID_CN0)
{
d_carrier_lock_fail_counter++;
}
@ -665,39 +564,28 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
d_carrier_lock_fail_counter--;
}
}
if (d_carrier_lock_fail_counter
> MAXIMUM_LOCK_FAIL_COUNTER)
if (d_carrier_lock_fail_counter > MAXIMUM_LOCK_FAIL_COUNTER)
{
std::cout << "Loss of lock in channel "
<< d_channel << "!" << std::endl;
LOG(INFO) << "Loss of lock in channel "
<< d_channel << "!";
this->message_port_pub(pmt::mp("events"),
pmt::from_long(3)); //3 -> loss of lock
std::cout << "Loss of lock in channel " << d_channel << "!" << std::endl;
LOG(INFO) << "Loss of lock in channel " << d_channel << "!";
this->message_port_pub(pmt::mp("events"), pmt::from_long(3)); //3 -> loss of lock
d_carrier_lock_fail_counter = 0;
d_enable_tracking = false; // TODO: check if disabling tracking is consistent with the channel state machine
multicorrelator_fpga_8sc->unlock_channel();
}
}
// ########### Output the tracking data to navigation and PVT ##########
current_synchro_data.Prompt_I =
static_cast<double>((d_correlator_outs_16sc[1]).real());
current_synchro_data.Prompt_Q =
static_cast<double>((d_correlator_outs_16sc[1]).imag());
current_synchro_data.Tracking_sample_counter =
d_sample_counter + d_correlation_length_samples;
current_synchro_data.Code_phase_samples =
d_rem_code_phase_samples;
current_synchro_data.Carrier_phase_rads = GPS_TWO_PI
* d_acc_carrier_phase_cycles;
current_synchro_data.Carrier_Doppler_hz =
d_carrier_doppler_hz;
current_synchro_data.Prompt_I = static_cast<double>((d_correlator_outs_16sc[1]).real());
current_synchro_data.Prompt_Q = static_cast<double>((d_correlator_outs_16sc[1]).imag());
current_synchro_data.Tracking_sample_counter = d_sample_counter + d_correlation_length_samples;
current_synchro_data.Code_phase_samples = d_rem_code_phase_samples;
current_synchro_data.Carrier_phase_rads = GPS_TWO_PI * d_acc_carrier_phase_cycles;
current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz;
current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
current_synchro_data.Flag_valid_symbol_output = true;
if (d_preamble_synchronized == true)
{
current_synchro_data.correlation_length_ms =
d_extend_correlation_ms;
current_synchro_data.correlation_length_ms = d_extend_correlation_ms;
}
else
{
@ -706,18 +594,12 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
}
else
{
current_synchro_data.Prompt_I =
static_cast<double>((d_correlator_outs_16sc[1]).real());
current_synchro_data.Prompt_Q =
static_cast<double>((d_correlator_outs_16sc[1]).imag());
current_synchro_data.Tracking_sample_counter =
d_sample_counter + d_correlation_length_samples;
current_synchro_data.Code_phase_samples =
d_rem_code_phase_samples;
current_synchro_data.Carrier_phase_rads = GPS_TWO_PI
* d_acc_carrier_phase_cycles;
current_synchro_data.Carrier_Doppler_hz =
d_carrier_doppler_hz; // todo: project the carrier doppler
current_synchro_data.Prompt_I = static_cast<double>((d_correlator_outs_16sc[1]).real());
current_synchro_data.Prompt_Q = static_cast<double>((d_correlator_outs_16sc[1]).imag());
current_synchro_data.Tracking_sample_counter = d_sample_counter + d_correlation_length_samples;
current_synchro_data.Code_phase_samples = d_rem_code_phase_samples;
current_synchro_data.Carrier_phase_rads = GPS_TWO_PI * d_acc_carrier_phase_cycles;
current_synchro_data.Carrier_Doppler_hz = d_carrier_doppler_hz; // todo: project the carrier doppler
current_synchro_data.CN0_dB_hz = d_CN0_SNV_dB_Hz;
}
}
@ -728,13 +610,13 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
d_correlator_outs_16sc[n] = lv_cmake(0, 0);
}
current_synchro_data.System =
{ 'G'};
current_synchro_data.Tracking_sample_counter = d_sample_counter
+ d_correlation_length_samples;
current_synchro_data.System = {'G'};
current_synchro_data.Tracking_sample_counter = d_sample_counter + d_correlation_length_samples;
}
current_synchro_data.fs = d_fs_in;
*out[0] = current_synchro_data;
if (d_dump)
{
// MULTIPLEXED FILE RECORDING - Record results to file
@ -744,84 +626,49 @@ int gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::general_work(
double tmp_double;
prompt_I = d_correlator_outs_16sc[1].real();
prompt_Q = d_correlator_outs_16sc[1].imag();
tmp_E = std::abs<float>(
std::complex<float>(d_correlator_outs_16sc[0].real(),
d_correlator_outs_16sc[0].imag()));
tmp_P = std::abs<float>(
std::complex<float>(d_correlator_outs_16sc[1].real(),
d_correlator_outs_16sc[1].imag()));
tmp_L = std::abs<float>(
std::complex<float>(d_correlator_outs_16sc[2].real(),
d_correlator_outs_16sc[2].imag()));
tmp_E = std::abs<float>(std::complex<float>(d_correlator_outs_16sc[0].real(), d_correlator_outs_16sc[0].imag()));
tmp_P = std::abs<float>(std::complex<float>(d_correlator_outs_16sc[1].real(), d_correlator_outs_16sc[1].imag()));
tmp_L = std::abs<float>(std::complex<float>(d_correlator_outs_16sc[2].real(), d_correlator_outs_16sc[2].imag()));
try
{
// EPR
d_dump_file.write(reinterpret_cast<char*>(&tmp_E),
sizeof(float));
d_dump_file.write(reinterpret_cast<char*>(&tmp_P),
sizeof(float));
d_dump_file.write(reinterpret_cast<char*>(&tmp_L),
sizeof(float));
d_dump_file.write(reinterpret_cast<char*>(&tmp_E), sizeof(float));
d_dump_file.write(reinterpret_cast<char*>(&tmp_P), sizeof(float));
d_dump_file.write(reinterpret_cast<char*>(&tmp_L), sizeof(float));
// PROMPT I and Q (to analyze navigation symbols)
d_dump_file.write(reinterpret_cast<char*>(&prompt_I),
sizeof(float));
d_dump_file.write(reinterpret_cast<char*>(&prompt_Q),
sizeof(float));
d_dump_file.write(reinterpret_cast<char*>(&prompt_I), sizeof(float));
d_dump_file.write(reinterpret_cast<char*>(&prompt_Q), sizeof(float));
// PRN start sample stamp
//tmp_float=(float)d_sample_counter;
d_dump_file.write(
reinterpret_cast<char*>(&d_sample_counter),
sizeof(unsigned long int));
d_dump_file.write(reinterpret_cast<char*>(&d_sample_counter), sizeof(unsigned long int));
// accumulated carrier phase
d_dump_file.write(
reinterpret_cast<char*>(&d_acc_carrier_phase_cycles),
sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_acc_carrier_phase_cycles), sizeof(double));
// carrier and code frequency
d_dump_file.write(
reinterpret_cast<char*>(&d_carrier_doppler_hz),
sizeof(double));
d_dump_file.write(
reinterpret_cast<char*>(&d_code_freq_chips),
sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_code_freq_chips), sizeof(double));
//PLL commands
d_dump_file.write(
reinterpret_cast<char*>(&d_carr_phase_error_secs_Ti),
sizeof(double));
d_dump_file.write(
reinterpret_cast<char*>(&d_carrier_doppler_hz),
sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_carr_phase_error_secs_Ti), sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_carrier_doppler_hz), sizeof(double));
//DLL commands
d_dump_file.write(
reinterpret_cast<char*>(&d_code_error_chips_Ti),
sizeof(double));
d_dump_file.write(
reinterpret_cast<char*>(&d_code_error_filt_chips_Ti),
sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_code_error_chips_Ti), sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_code_error_filt_chips_Ti), sizeof(double));
// CN0 and carrier lock test
d_dump_file.write(reinterpret_cast<char*>(&d_CN0_SNV_dB_Hz),
sizeof(double));
d_dump_file.write(
reinterpret_cast<char*>(&d_carrier_lock_test),
sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_CN0_SNV_dB_Hz), sizeof(double));
d_dump_file.write(reinterpret_cast<char*>(&d_carrier_lock_test), sizeof(double));
// AUX vars (for debug purposes)
tmp_double = d_code_error_chips_Ti
* CURRENT_INTEGRATION_TIME_S;
d_dump_file.write(reinterpret_cast<char*>(&tmp_double),
sizeof(double));
tmp_double = static_cast<double>(d_sample_counter
+ d_correlation_length_samples);
d_dump_file.write(reinterpret_cast<char*>(&tmp_double),
sizeof(double));
tmp_double = d_code_error_chips_Ti * CURRENT_INTEGRATION_TIME_S;
d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
tmp_double = static_cast<double>(d_sample_counter + d_correlation_length_samples);
d_dump_file.write(reinterpret_cast<char*>(&tmp_double), sizeof(double));
}
catch (const std::ifstream::failure* e)
{
LOG(WARNING) << "Exception writing trk dump file "
<< e->what();
LOG(WARNING) << "Exception writing trk dump file " << e->what();
}
}
@ -844,24 +691,19 @@ void gps_l1_ca_dll_pll_c_aid_tracking_fpga_sc::set_channel(unsigned int channel)
{
try
{
d_dump_filename.append(
boost::lexical_cast<std::string>(
d_channel));
d_dump_filename.append(boost::lexical_cast<std::string>(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(
std::ifstream::failbit
| std::ifstream::badbit);
d_dump_file.open(d_dump_filename.c_str(),
std::ios::out | std::ios::binary);
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
d_dump_file.open(d_dump_filename.c_str(), std::ios::out | std::ios::binary);
LOG(INFO) << "Tracking dump enabled on channel "
<< d_channel << " Log file: "
<< d_dump_filename.c_str();
<< d_channel << " Log file: "
<< d_dump_filename.c_str();
}
catch (const std::ifstream::failure* e)
{
LOG(WARNING) << "channel " << d_channel
<< " Exception opening trk dump file "
<< e->what();
<< " Exception opening trk dump file "
<< e->what();
}
}
}