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