From abd1032ca25e6b8d14534fc919fe8bc49df2ac85 Mon Sep 17 00:00:00 2001 From: Carles Fernandez Date: Tue, 29 Dec 2020 14:47:28 +0100 Subject: [PATCH] Avoid using reserved identifiers --- .../galileo_e1_pcps_ambiguous_acquisition.cc | 4 +- .../adapters/galileo_e6_pcps_acquisition.cc | 4 +- .../libs/beidou_b1i_signal_replica.cc | 88 ++--- .../libs/beidou_b1i_signal_replica.h | 15 +- .../libs/beidou_b3i_signal_replica.cc | 88 ++--- .../libs/beidou_b3i_signal_replica.h | 15 +- .../libs/galileo_e1_signal_replica.cc | 186 +++++----- .../libs/galileo_e1_signal_replica.h | 30 +- .../libs/galileo_e5_signal_replica.cc | 204 +++++------ .../libs/galileo_e5_signal_replica.h | 36 +- .../libs/galileo_e6_signal_replica.cc | 206 ++++++------ .../libs/galileo_e6_signal_replica.h | 42 +-- .../libs/glonass_l1_signal_replica.cc | 66 ++-- .../libs/glonass_l1_signal_replica.h | 11 +- .../libs/glonass_l2_signal_replica.cc | 66 ++-- .../libs/glonass_l2_signal_replica.h | 11 +- src/algorithms/libs/gnss_signal_replica.cc | 318 +++++++++--------- src/algorithms/libs/gnss_signal_replica.h | 20 +- src/algorithms/libs/gps_l2c_signal_replica.cc | 56 +-- src/algorithms/libs/gps_l2c_signal_replica.h | 8 +- src/algorithms/libs/gps_l5_signal_replica.cc | 104 +++--- src/algorithms/libs/gps_l5_signal_replica.h | 12 +- src/algorithms/libs/gps_sdr_signal_replica.cc | 86 ++--- src/algorithms/libs/gps_sdr_signal_replica.h | 15 +- .../libs/libswiftcnav/cnav_msg.c | 32 +- .../arithmetic/code_generation_test.cc | 16 +- 26 files changed, 864 insertions(+), 875 deletions(-) diff --git a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc index 40c2441ce..7eaed076d 100644 --- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc @@ -190,10 +190,10 @@ void GalileoE1PcpsAmbiguousAcquisition::set_local_code() } } - own::span code__span(code_.data(), vector_length_); + own::span code_span(code_.data(), vector_length_); for (unsigned int i = 0; i < sampled_ms_ / 4; i++) { - std::copy_n(code.data(), code_length_, code__span.subspan(i * code_length_, code_length_).data()); + std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data()); } acquisition_->set_local_code(code_.data()); diff --git a/src/algorithms/acquisition/adapters/galileo_e6_pcps_acquisition.cc b/src/algorithms/acquisition/adapters/galileo_e6_pcps_acquisition.cc index 18867183f..846653f70 100644 --- a/src/algorithms/acquisition/adapters/galileo_e6_pcps_acquisition.cc +++ b/src/algorithms/acquisition/adapters/galileo_e6_pcps_acquisition.cc @@ -163,10 +163,10 @@ void GalileoE6PcpsAcquisition::set_local_code() gnss_synchro_->PRN, fs_in_, 0); } - own::span code__span(code_.data(), vector_length_); + own::span code_span(code_.data(), vector_length_); for (unsigned int i = 0; i < sampled_ms_; i++) { - std::copy_n(code.data(), code_length_, code__span.subspan(i * code_length_, code_length_).data()); + std::copy_n(code.data(), code_length_, code_span.subspan(i * code_length_, code_length_).data()); } acquisition_->set_local_code(code_.data()); diff --git a/src/algorithms/libs/beidou_b1i_signal_replica.cc b/src/algorithms/libs/beidou_b1i_signal_replica.cc index 469bd4465..fd4d2e7c7 100644 --- a/src/algorithms/libs/beidou_b1i_signal_replica.cc +++ b/src/algorithms/libs/beidou_b1i_signal_replica.cc @@ -26,17 +26,17 @@ const auto AUX_CEIL = [](float x) { return static_cast(static_cast((x) + 1)); }; -void beidou_b1i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_shift) +void beidou_b1i_code_gen_int(own::span dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 2046; + constexpr uint32_t code_length = 2046; const std::array delays = {712 /*PRN1*/, 1581, 1414, 1550, 581, 771, 1311, 1043, 1549, 359, 710, 1579, 1548, 1103, 579, 769, 358, 709, 1411, 1547, 1102, 578, 357, 1577, 1410, 1546, 1101, 707, 1576, 1409, 1545, 354 /*PRN32*/, 705}; const std::array phase1 = {1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 8, 8, 8, 9, 9, 10}; const std::array phase2 = {3, 4, 5, 6, 8, 9, 10, 11, 7, 4, 5, 6, 8, 9, 10, 11, 5, 6, 8, 9, 10, 11, 6, 8, 9, 10, 11, 8, 9, 10, 11, 9, 10, 11, 10, 11, 11}; - std::bitset<_code_length> G1{}; - std::bitset<_code_length> G2{}; + std::bitset G1{}; + std::bitset G2{}; std::bitset<11> G1_register(std::string("01010101010")); std::bitset<11> G2_register(std::string("01010101010")); @@ -50,7 +50,7 @@ void beidou_b1i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _c int32_t prn_idx; // compute delay array index for given PRN number - prn_idx = _prn - 1; + prn_idx = prn - 1; // A simple error check if ((prn_idx < 0) || (prn_idx > 32)) @@ -59,7 +59,7 @@ void beidou_b1i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _c } // Generate G1 & G2 Register - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { G1[lcv] = G1_register[0]; G2[lcv] = G2_register[-(phase1[prn_idx] - 11)] xor G2_register[-(phase2[prn_idx] - 11)]; @@ -78,53 +78,53 @@ void beidou_b1i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _c } // Set the delay - delay = _code_length - delays[prn_idx] * 0; //********************************** - delay += _chip_shift; - delay %= _code_length; + delay = code_length - delays[prn_idx] * 0; //********************************** + delay += chip_shift; + delay %= code_length; // Generate PRN from G1 and G2 Registers - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { - aux = G1[(lcv + _chip_shift) % _code_length] xor G2[delay]; + aux = G1[(lcv + chip_shift) % code_length] xor G2[delay]; if (aux == true) { - _dest[lcv] = 1; + dest[lcv] = 1; } else { - _dest[lcv] = -1; + dest[lcv] = -1; } delay++; - delay %= _code_length; + delay %= code_length; } } -void beidou_b1i_code_gen_float(own::span _dest, int32_t _prn, uint32_t _chip_shift) +void beidou_b1i_code_gen_float(own::span dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 2046; - std::array b1i_code_int{}; + constexpr uint32_t code_length = 2046; + std::array b1i_code_int{}; - beidou_b1i_code_gen_int(own::span(b1i_code_int.data(), _code_length), _prn, _chip_shift); + beidou_b1i_code_gen_int(own::span(b1i_code_int.data(), code_length), prn, chip_shift); - for (uint32_t ii = 0; ii < _code_length; ++ii) + for (uint32_t ii = 0; ii < code_length; ++ii) { - _dest[ii] = static_cast(b1i_code_int[ii]); + dest[ii] = static_cast(b1i_code_int[ii]); } } -void beidou_b1i_code_gen_complex(own::span> _dest, int32_t _prn, uint32_t _chip_shift) +void beidou_b1i_code_gen_complex(own::span> dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 2046; - std::array b1i_code_int{}; + constexpr uint32_t code_length = 2046; + std::array b1i_code_int{}; - beidou_b1i_code_gen_int(own::span(b1i_code_int.data(), _code_length), _prn, _chip_shift); + beidou_b1i_code_gen_int(own::span(b1i_code_int.data(), code_length), prn, chip_shift); - for (uint32_t ii = 0; ii < _code_length; ++ii) + for (uint32_t ii = 0; ii < code_length; ++ii) { - _dest[ii] = std::complex(static_cast(b1i_code_int[ii]), 0.0F); + dest[ii] = std::complex(static_cast(b1i_code_int[ii]), 0.0F); } } @@ -132,22 +132,22 @@ void beidou_b1i_code_gen_complex(own::span> _dest, int32_t _ /* * Generates complex BeiDou B1I code for the desired SV ID and sampled to specific sampling frequency */ -void beidou_b1i_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs, uint32_t _chip_shift) +void beidou_b1i_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift) { - constexpr int32_t _codeFreqBasis = 2046000; // Hz - constexpr int32_t _codeLength = 2046; - constexpr float _tc = 1.0 / static_cast(_codeFreqBasis); // B1I chip period in sec + constexpr int32_t codeFreqBasis = 2046000; // chips per second + constexpr int32_t codeLength = 2046; + constexpr float tc = 1.0 / static_cast(codeFreqBasis); // B1I chip period in sec - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); - const float _ts = 1.0F / static_cast(_fs); // Sampling period in sec + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); + const float ts = 1.0F / static_cast(sampling_freq); // Sampling period in sec - std::array, 2046> _code{}; - int32_t _codeValueIndex; + std::array, 2046> code_aux{}; + int32_t codeValueIndex; float aux; - beidou_b1i_code_gen_complex(_code, _prn, _chip_shift); // generate B1I code 1 sample per chip + beidou_b1i_code_gen_complex(code_aux, prn, chip_shift); // generate B1I code 1 sample per chip - for (int32_t i = 0; i < _samplesPerCode; i++) + for (int32_t i = 0; i < samplesPerCode; i++) { // === Digitizing ================================================== @@ -156,20 +156,20 @@ void beidou_b1i_code_gen_complex_sampled(own::span> _dest, u // number of samples per millisecond (because one B1I code period is // one millisecond). - aux = (_ts * (static_cast(i) + 1)) / _tc; - _codeValueIndex = AUX_CEIL(aux) - 1; + aux = (ts * (static_cast(i) + 1)) / tc; + codeValueIndex = AUX_CEIL(aux) - 1; // --- Make the digitized version of the B1I code ------------------ - // The "upsampled" code is made by selecting values form the B1I code - // chip array (caCode) for the time instances of each sample. - if (i == _samplesPerCode - 1) + // The upsampled code is made by selecting values from the B1I code + // chip array for the time instances of each sample. + if (i == samplesPerCode - 1) { - // --- Correct the last index (due to number rounding issues) ----------- - _dest[i] = _code[_codeLength - 1]; + // Correct the last index (due to number rounding issues) + dest[i] = code_aux[codeLength - 1]; } else { - _dest[i] = _code[_codeValueIndex]; // repeat the chip -> upsample + dest[i] = code_aux[codeValueIndex]; // repeat the chip -> upsample } } } diff --git a/src/algorithms/libs/beidou_b1i_signal_replica.h b/src/algorithms/libs/beidou_b1i_signal_replica.h index d76f8d7e1..54ed402a4 100644 --- a/src/algorithms/libs/beidou_b1i_signal_replica.h +++ b/src/algorithms/libs/beidou_b1i_signal_replica.h @@ -41,19 +41,16 @@ namespace own = gsl; //! Generates int32_t GPS L1 C/A code for the desired SV ID and code shift -void beidou_b1i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_shift); +void beidou_b1i_code_gen_int(own::span dest, int32_t prn, uint32_t chip_shift); //! Generates float GPS L1 C/A code for the desired SV ID and code shift -void beidou_b1i_code_gen_float(own::span _dest, int32_t _prn, uint32_t _chip_shift); - -//! Generates complex GPS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency -void beidou_b1i_code_gen_complex(own::span> _dest, int32_t _prn, uint32_t _chip_shift); - -//! Generates N complex GPS L1 C/A codes for the desired SV ID and code shift -void beidou_b1i_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes); +void beidou_b1i_code_gen_float(own::span dest, int32_t prn, uint32_t chip_shift); //! Generates complex GPS L1 C/A code for the desired SV ID and code shift -void beidou_b1i_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs, uint32_t _chip_shift); +void beidou_b1i_code_gen_complex(own::span> dest, int32_t prn, uint32_t chip_shift); + +//! Generates complex GPS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency +void beidou_b1i_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift); /** \} */ diff --git a/src/algorithms/libs/beidou_b3i_signal_replica.cc b/src/algorithms/libs/beidou_b3i_signal_replica.cc index 7071a2e22..3e2a546ff 100644 --- a/src/algorithms/libs/beidou_b3i_signal_replica.cc +++ b/src/algorithms/libs/beidou_b3i_signal_replica.cc @@ -26,11 +26,11 @@ const auto AUX_CEIL = [](float x) { return static_cast(static_cast((x) + 1)); }; -void beidou_b3i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_shift) +void beidou_b3i_code_gen_int(own::span dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 10230; - std::bitset<_code_length> G1{}; - std::bitset<_code_length> G2{}; + constexpr uint32_t code_length = 10230; + std::bitset G1{}; + std::bitset G2{}; auto G1_register = std::bitset<13>{}.set(); // All true auto G2_register = std::bitset<13>{}.set(); // All true auto G1_register_reset = std::bitset<13>{}.set(); @@ -43,7 +43,7 @@ void beidou_b3i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_ uint32_t lcv; uint32_t lcv2; uint32_t delay; - int32_t prn_idx = _prn - 1; + int32_t prn_idx = prn - 1; const std::array, 63> G2_register_shifted = {std::bitset<13>(std::string("1010111111111")), @@ -120,7 +120,7 @@ void beidou_b3i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_ G2_register = G2_register_shifted[prn_idx]; // Generate G1 and G2 Register - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { G1[lcv] = G1_register[0]; G2[lcv] = G2_register[0]; @@ -145,74 +145,74 @@ void beidou_b3i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_ } } - delay = _code_length; - delay += _chip_shift; - delay %= _code_length; + delay = code_length; + delay += chip_shift; + delay %= code_length; // Generate PRN from G1 and G2 Registers - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { - aux = G1[(lcv + _chip_shift) % _code_length] xor G2[delay]; + aux = G1[(lcv + chip_shift) % code_length] xor G2[delay]; if (aux == true) { - _dest[lcv] = 1; + dest[lcv] = 1; } else { - _dest[lcv] = -1; + dest[lcv] = -1; } delay++; - delay %= _code_length; + delay %= code_length; } } -void beidou_b3i_code_gen_float(own::span _dest, int32_t _prn, uint32_t _chip_shift) +void beidou_b3i_code_gen_float(own::span dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 10230; - std::array b3i_code_int{}; + constexpr uint32_t code_length = 10230; + std::array b3i_code_int{}; - beidou_b3i_code_gen_int(b3i_code_int, _prn, _chip_shift); + beidou_b3i_code_gen_int(b3i_code_int, prn, chip_shift); - for (uint32_t ii = 0; ii < _code_length; ++ii) + for (uint32_t ii = 0; ii < code_length; ++ii) { - _dest[ii] = static_cast(b3i_code_int[ii]); + dest[ii] = static_cast(b3i_code_int[ii]); } } -void beidou_b3i_code_gen_complex(own::span> _dest, int32_t _prn, uint32_t _chip_shift) +void beidou_b3i_code_gen_complex(own::span> dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 10230; - std::array b3i_code_int{}; + constexpr uint32_t code_length = 10230; + std::array b3i_code_int{}; - beidou_b3i_code_gen_int(b3i_code_int, _prn, _chip_shift); + beidou_b3i_code_gen_int(b3i_code_int, prn, chip_shift); - for (uint32_t ii = 0; ii < _code_length; ++ii) + for (uint32_t ii = 0; ii < code_length; ++ii) { - _dest[ii] = std::complex(static_cast(b3i_code_int[ii]), 0.0F); + dest[ii] = std::complex(static_cast(b3i_code_int[ii]), 0.0F); } } -void beidou_b3i_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift) +void beidou_b3i_code_gen_complex_sampled(own::span> dest, uint32_t prn, int sampling_freq, uint32_t chip_shift) { - constexpr int32_t _codeFreqBasis = 10230000; // Hz - constexpr int32_t _codeLength = 10230; - constexpr float _tc = 1.0 / static_cast(_codeFreqBasis); // B3I chip period in sec + constexpr int32_t codeFreqBasis = 10230000; // chips per second + constexpr int32_t codeLength = 10230; + constexpr float tc = 1.0 / static_cast(codeFreqBasis); // B3I chip period in sec - const float _ts = 1.0F / static_cast(_fs); // Sampling period in secs - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); + const float ts = 1.0F / static_cast(sampling_freq); // Sampling period in secs + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); - std::array, 10230> _code{}; + std::array, 10230> code_aux{}; - int32_t _codeValueIndex; + int32_t codeValueIndex; float aux; - beidou_b3i_code_gen_complex(_code, _prn, _chip_shift); // generate B3I code 1 sample per chip + beidou_b3i_code_gen_complex(code_aux, prn, chip_shift); // generate B3I code 1 sample per chip - for (int32_t i = 0; i < _samplesPerCode; i++) + for (int32_t i = 0; i < samplesPerCode; i++) { // === Digitizing ================================================== @@ -221,20 +221,20 @@ void beidou_b3i_code_gen_complex_sampled(own::span> _dest, u // number of samples per millisecond (because one B3I code period is // one millisecond). - aux = (_ts * (static_cast(i) + 1)) / _tc; - _codeValueIndex = AUX_CEIL(aux) - 1; + aux = (ts * (static_cast(i) + 1)) / tc; + codeValueIndex = AUX_CEIL(aux) - 1; // --- Make the digitized version of the B3I code ------------------ - // The "upsampled" code is made by selecting values form the B3I code - // chip array (caCode) for the time instances of each sample. - if (i == _samplesPerCode - 1) + // The upsampled code is made by selecting values from the B3I code + // chip array for the time instances of each sample. + if (i == samplesPerCode - 1) { - // --- Correct the last index (due to number rounding issues) ----------- - _dest[i] = _code[_codeLength - 1]; + // Correct the last index (due to number rounding issues) + dest[i] = code_aux[codeLength - 1]; } else { - _dest[i] = _code[_codeValueIndex]; // repeat the chip -> upsample + dest[i] = code_aux[codeValueIndex]; // repeat the chip -> upsample } } } diff --git a/src/algorithms/libs/beidou_b3i_signal_replica.h b/src/algorithms/libs/beidou_b3i_signal_replica.h index 663b6780d..5edaafd0f 100644 --- a/src/algorithms/libs/beidou_b3i_signal_replica.h +++ b/src/algorithms/libs/beidou_b3i_signal_replica.h @@ -39,19 +39,16 @@ namespace own = gsl; //! Generates int BeiDou B3I code for the desired SV ID and code shift -void beidou_b3i_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_shift); +void beidou_b3i_code_gen_int(own::span dest, int32_t prn, uint32_t chip_shift); //! Generates float BeiDou B3I code for the desired SV ID and code shift -void beidou_b3i_code_gen_float(own::span _dest, int32_t _prn, uint32_t _chip_shift); - -//! Generates complex BeiDou B3I code for the desired SV ID and code shift, and sampled to specific sampling frequency -void beidou_b3i_code_gen_complex(own::span> _dest, int32_t _prn, uint32_t _chip_shift); - -//! Generates N complex BeiDou B3I codes for the desired SV ID and code shift -void beidou_b3i_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift, uint32_t _ncodes); +void beidou_b3i_code_gen_float(own::span dest, int32_t prn, uint32_t chip_shift); //! Generates complex BeiDou B3I code for the desired SV ID and code shift -void beidou_b3i_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int _fs, uint32_t _chip_shift); +void beidou_b3i_code_gen_complex(own::span> dest, int32_t prn, uint32_t chip_shift); + +//! Generates complex BeiDou B3I code for the desired SV ID and code shift, and sampled to specific sampling frequency +void beidou_b3i_code_gen_complex_sampled(own::span> dest, uint32_t prn, int sampling_freq, uint32_t chip_shift); /** \} */ diff --git a/src/algorithms/libs/galileo_e1_signal_replica.cc b/src/algorithms/libs/galileo_e1_signal_replica.cc index aa3750ced..38d716ae4 100644 --- a/src/algorithms/libs/galileo_e1_signal_replica.cc +++ b/src/algorithms/libs/galileo_e1_signal_replica.cc @@ -30,216 +30,216 @@ #include -void galileo_e1_code_gen_int(own::span _dest, const std::array& _Signal, int32_t _prn) +void galileo_e1_code_gen_int(own::span dest, const std::array& signal_id, int32_t prn) { - const std::string _galileo_signal = _Signal.data(); - const int32_t prn = _prn - 1; + const std::string galileo_signal = signal_id.data(); + const int32_t prn_ = prn - 1; int32_t index = 0; // A simple error check - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } - if (_galileo_signal.rfind("1B") != std::string::npos && _galileo_signal.length() >= 2) + if (galileo_signal.rfind("1B") != std::string::npos && galileo_signal.length() >= 2) { for (size_t i = 0; i < GALILEO_E1_B_PRIMARY_CODE_STR_LENGTH; i++) { - hex_to_binary_converter(_dest.subspan(index, 4), GALILEO_E1_B_PRIMARY_CODE[prn][i]); + hex_to_binary_converter(dest.subspan(index, 4), GALILEO_E1_B_PRIMARY_CODE[prn_][i]); index += 4; } } - else if (_galileo_signal.rfind("1C") != std::string::npos && _galileo_signal.length() >= 2) + else if (galileo_signal.rfind("1C") != std::string::npos && galileo_signal.length() >= 2) { for (size_t i = 0; i < GALILEO_E1_C_PRIMARY_CODE_STR_LENGTH; i++) { - hex_to_binary_converter(_dest.subspan(index, 4), GALILEO_E1_C_PRIMARY_CODE[prn][i]); + hex_to_binary_converter(dest.subspan(index, 4), GALILEO_E1_C_PRIMARY_CODE[prn_][i]); index += 4; } } } -void galileo_e1_sinboc_11_gen_int(own::span _dest, own::span _prn) +void galileo_e1_sinboc_11_gen_int(own::span dest, own::span prn) { - constexpr uint32_t _length_in = GALILEO_E1_B_CODE_LENGTH_CHIPS; - const auto _period = static_cast(_dest.size() / _length_in); - for (uint32_t i = 0; i < _length_in; i++) + constexpr uint32_t length_in = GALILEO_E1_B_CODE_LENGTH_CHIPS; + const auto period = static_cast(dest.size() / length_in); + for (uint32_t i = 0; i < length_in; i++) { - for (uint32_t j = 0; j < (_period / 2); j++) + for (uint32_t j = 0; j < (period / 2); j++) { - _dest[i * _period + j] = _prn[i]; + dest[i * period + j] = prn[i]; } - for (uint32_t j = (_period / 2); j < _period; j++) + for (uint32_t j = (period / 2); j < period; j++) { - _dest[i * _period + j] = -_prn[i]; + dest[i * period + j] = -prn[i]; } } } -void galileo_e1_sinboc_61_gen_int(own::span _dest, own::span _prn) +void galileo_e1_sinboc_61_gen_int(own::span dest, own::span prn) { - constexpr uint32_t _length_in = GALILEO_E1_B_CODE_LENGTH_CHIPS; - const auto _period = static_cast(_dest.size() / _length_in); + constexpr uint32_t length_in = GALILEO_E1_B_CODE_LENGTH_CHIPS; + const auto period = static_cast(dest.size() / length_in); - for (uint32_t i = 0; i < _length_in; i++) + for (uint32_t i = 0; i < length_in; i++) { - for (uint32_t j = 0; j < _period; j += 2) + for (uint32_t j = 0; j < period; j += 2) { - _dest[i * _period + j] = _prn[i]; + dest[i * period + j] = prn[i]; } - for (uint32_t j = 1; j < _period; j += 2) + for (uint32_t j = 1; j < period; j += 2) { - _dest[i * _period + j] = -_prn[i]; + dest[i * period + j] = -prn[i]; } } } -void galileo_e1_code_gen_sinboc11_float(own::span _dest, const std::array& _Signal, uint32_t _prn) +void galileo_e1_code_gen_sinboc11_float(own::span dest, const std::array& signal_id, uint32_t prn) { - const auto _codeLength = static_cast(GALILEO_E1_B_CODE_LENGTH_CHIPS); + const auto codeLength = static_cast(GALILEO_E1_B_CODE_LENGTH_CHIPS); std::array primary_code_E1_chips{}; - galileo_e1_code_gen_int(primary_code_E1_chips, _Signal, _prn); // generate Galileo E1 code, 1 sample per chip - for (uint32_t i = 0; i < _codeLength; i++) + galileo_e1_code_gen_int(primary_code_E1_chips, signal_id, prn); // generate Galileo E1 code, 1 sample per chip + for (uint32_t i = 0; i < codeLength; i++) { - _dest[2 * i] = static_cast(primary_code_E1_chips[i]); - _dest[2 * i + 1] = -_dest[2 * i]; + dest[2 * i] = static_cast(primary_code_E1_chips[i]); + dest[2 * i + 1] = -dest[2 * i]; } } -void galileo_e1_gen_float(own::span _dest, own::span _prn, const std::array& _Signal) +void galileo_e1_gen_float(own::span dest, own::span prn, const std::array& signal_id) { - const auto _codeLength = _dest.size(); + const auto codeLength = dest.size(); const float alpha = std::sqrt(10.0F / 11.0F); const float beta = std::sqrt(1.0F / 11.0F); - const std::string _galileo_signal = _Signal.data(); + const std::string galileo_signal = signal_id.data(); - std::vector sinboc_11(_codeLength); - std::vector sinboc_61(_codeLength); + std::vector sinboc_11(codeLength); + std::vector sinboc_61(codeLength); - galileo_e1_sinboc_11_gen_int(sinboc_11, _prn); // generate sinboc(1,1) 12 samples per chip - galileo_e1_sinboc_61_gen_int(sinboc_61, _prn); // generate sinboc(6,1) 12 samples per chip + galileo_e1_sinboc_11_gen_int(sinboc_11, prn); // generate sinboc(1,1) 12 samples per chip + galileo_e1_sinboc_61_gen_int(sinboc_61, prn); // generate sinboc(6,1) 12 samples per chip - if (_galileo_signal.rfind("1B") != std::string::npos && _galileo_signal.length() >= 2) + if (galileo_signal.rfind("1B") != std::string::npos && galileo_signal.length() >= 2) { - for (size_t i = 0; i < _codeLength; i++) + for (size_t i = 0; i < codeLength; i++) { - _dest[i] = alpha * static_cast(sinboc_11[i]) + - beta * static_cast(sinboc_61[i]); + dest[i] = alpha * static_cast(sinboc_11[i]) + + beta * static_cast(sinboc_61[i]); } } - else if (_galileo_signal.rfind("1C") != std::string::npos && _galileo_signal.length() >= 2) + else if (galileo_signal.rfind("1C") != std::string::npos && galileo_signal.length() >= 2) { - for (size_t i = 0; i < _codeLength; i++) + for (size_t i = 0; i < codeLength; i++) { - _dest[i] = alpha * static_cast(sinboc_11[i]) - - beta * static_cast(sinboc_61[i]); + dest[i] = alpha * static_cast(sinboc_11[i]) - + beta * static_cast(sinboc_61[i]); } } } -void galileo_e1_code_gen_float_sampled(own::span _dest, const std::array& _Signal, - bool _cboc, uint32_t _prn, int32_t _fs, uint32_t _chip_shift, - bool _secondary_flag) +void galileo_e1_code_gen_float_sampled(own::span dest, const std::array& signal_id, + bool cboc, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift, + bool secondary_flag) { - constexpr int32_t _codeFreqBasis = GALILEO_E1_CODE_CHIP_RATE_CPS; // Hz - const int32_t _samplesPerChip = (_cboc == true) ? 12 : 2; - const uint32_t _codeLength = _samplesPerChip * GALILEO_E1_B_CODE_LENGTH_CHIPS; - const std::string _galileo_signal = _Signal.data(); - auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / GALILEO_E1_B_CODE_LENGTH_CHIPS)); - const uint32_t delay = ((static_cast(GALILEO_E1_B_CODE_LENGTH_CHIPS) - _chip_shift) % static_cast(GALILEO_E1_B_CODE_LENGTH_CHIPS)) * _samplesPerCode / GALILEO_E1_B_CODE_LENGTH_CHIPS; + constexpr int32_t codeFreqBasis = GALILEO_E1_CODE_CHIP_RATE_CPS; // chips per second + const int32_t samplesPerChip = (cboc == true) ? 12 : 2; + const uint32_t codeLength = samplesPerChip * GALILEO_E1_B_CODE_LENGTH_CHIPS; + const std::string galileo_signal = signal_id.data(); + auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / GALILEO_E1_B_CODE_LENGTH_CHIPS)); + const uint32_t delay = ((static_cast(GALILEO_E1_B_CODE_LENGTH_CHIPS) - chip_shift) % static_cast(GALILEO_E1_B_CODE_LENGTH_CHIPS)) * samplesPerCode / GALILEO_E1_B_CODE_LENGTH_CHIPS; std::vector primary_code_E1_chips(static_cast(GALILEO_E1_B_CODE_LENGTH_CHIPS)); - galileo_e1_code_gen_int(primary_code_E1_chips, _Signal, _prn); // generate Galileo E1 code, 1 sample per chip + galileo_e1_code_gen_int(primary_code_E1_chips, signal_id, prn); // generate Galileo E1 code, 1 sample per chip - std::vector _signal_E1(_codeLength); + std::vector signal_E1(codeLength); - if (_cboc == true) + if (cboc == true) { - galileo_e1_gen_float(_signal_E1, primary_code_E1_chips, _Signal); // generate cboc 12 samples per chip + galileo_e1_gen_float(signal_E1, primary_code_E1_chips, signal_id); // generate cboc 12 samples per chip } else { - std::vector _signal_E1_int(static_cast(_codeLength)); - galileo_e1_sinboc_11_gen_int(_signal_E1_int, primary_code_E1_chips); // generate sinboc(1,1) 2 samples per chip + std::vector signal_E1_int(static_cast(codeLength)); + galileo_e1_sinboc_11_gen_int(signal_E1_int, primary_code_E1_chips); // generate sinboc(1,1) 2 samples per chip - for (uint32_t ii = 0; ii < _codeLength; ++ii) + for (uint32_t ii = 0; ii < codeLength; ++ii) { - _signal_E1[ii] = static_cast(_signal_E1_int[ii]); + signal_E1[ii] = static_cast(signal_E1_int[ii]); } } - if (_fs != _samplesPerChip * _codeFreqBasis) + if (sampling_freq != samplesPerChip * codeFreqBasis) { - std::vector _resampled_signal(_samplesPerCode); + std::vector resampled_signal(samplesPerCode); - resampler(_signal_E1, _resampled_signal, static_cast(_samplesPerChip * _codeFreqBasis), _fs); // resamples code to fs + resampler(signal_E1, resampled_signal, static_cast(samplesPerChip * codeFreqBasis), sampling_freq); // resamples code to fs - _signal_E1 = std::move(_resampled_signal); + signal_E1 = std::move(resampled_signal); } - if (_galileo_signal.rfind("1C") != std::string::npos && _galileo_signal.length() >= 2 && _secondary_flag) + if (galileo_signal.rfind("1C") != std::string::npos && galileo_signal.length() >= 2 && secondary_flag) { - std::vector _signal_E1C_secondary(static_cast(GALILEO_E1_C_SECONDARY_CODE_LENGTH) * _samplesPerCode); + std::vector signal_E1C_secondary(static_cast(GALILEO_E1_C_SECONDARY_CODE_LENGTH) * samplesPerCode); for (uint32_t i = 0; i < static_cast(GALILEO_E1_C_SECONDARY_CODE_LENGTH); i++) { - for (uint32_t k = 0; k < _samplesPerCode; k++) + for (uint32_t k = 0; k < samplesPerCode; k++) { - _signal_E1C_secondary[i * _samplesPerCode + k] = _signal_E1[k] * (GALILEO_E1_C_SECONDARY_CODE[i] == '0' ? 1.0F : -1.0F); + signal_E1C_secondary[i * samplesPerCode + k] = signal_E1[k] * (GALILEO_E1_C_SECONDARY_CODE[i] == '0' ? 1.0F : -1.0F); } } - _samplesPerCode *= static_cast(GALILEO_E1_C_SECONDARY_CODE_LENGTH); + samplesPerCode *= static_cast(GALILEO_E1_C_SECONDARY_CODE_LENGTH); - _signal_E1 = std::move(_signal_E1C_secondary); + signal_E1 = std::move(signal_E1C_secondary); } - for (uint32_t i = 0; i < _samplesPerCode; i++) + for (uint32_t i = 0; i < samplesPerCode; i++) { - _dest[(i + delay) % _samplesPerCode] = _signal_E1[i]; + dest[(i + delay) % samplesPerCode] = signal_E1[i]; } } -void galileo_e1_code_gen_complex_sampled(own::span> _dest, const std::array& _Signal, - bool _cboc, uint32_t _prn, int32_t _fs, uint32_t _chip_shift, - bool _secondary_flag) +void galileo_e1_code_gen_complex_sampled(own::span> dest, const std::array& signal_id, + bool cboc, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift, + bool secondary_flag) { - constexpr int32_t _codeFreqBasis = GALILEO_E1_CODE_CHIP_RATE_CPS; // Hz - const std::string _galileo_signal = _Signal.data(); - auto _samplesPerCode = static_cast(static_cast(_fs) / - (static_cast(_codeFreqBasis) / GALILEO_E1_B_CODE_LENGTH_CHIPS)); + constexpr int32_t codeFreqBasis = GALILEO_E1_CODE_CHIP_RATE_CPS; // Hz + const std::string galileo_signal = signal_id.data(); + auto samplesPerCode = static_cast(static_cast(sampling_freq) / + (static_cast(codeFreqBasis) / GALILEO_E1_B_CODE_LENGTH_CHIPS)); - if (_galileo_signal.rfind("1C") != std::string::npos && _galileo_signal.length() >= 2 && _secondary_flag) + if (galileo_signal.rfind("1C") != std::string::npos && galileo_signal.length() >= 2 && secondary_flag) { - _samplesPerCode *= static_cast(GALILEO_E1_C_SECONDARY_CODE_LENGTH); + samplesPerCode *= static_cast(GALILEO_E1_C_SECONDARY_CODE_LENGTH); } - std::vector real_code(_samplesPerCode); - galileo_e1_code_gen_float_sampled(real_code, _Signal, _cboc, _prn, _fs, _chip_shift, _secondary_flag); + std::vector real_code(samplesPerCode); + galileo_e1_code_gen_float_sampled(real_code, signal_id, cboc, prn, sampling_freq, chip_shift, secondary_flag); - for (uint32_t ii = 0; ii < _samplesPerCode; ++ii) + for (uint32_t ii = 0; ii < samplesPerCode; ++ii) { - _dest[ii] = std::complex(real_code[ii], 0.0F); + dest[ii] = std::complex(real_code[ii], 0.0F); } } -void galileo_e1_code_gen_float_sampled(own::span _dest, const std::array& _Signal, - bool _cboc, uint32_t _prn, int32_t _fs, uint32_t _chip_shift) +void galileo_e1_code_gen_float_sampled(own::span dest, const std::array& signal_id, + bool cboc, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift) { - galileo_e1_code_gen_float_sampled(_dest, _Signal, _cboc, _prn, _fs, _chip_shift, false); + galileo_e1_code_gen_float_sampled(dest, signal_id, cboc, prn, sampling_freq, chip_shift, false); } -void galileo_e1_code_gen_complex_sampled(own::span> _dest, const std::array& _Signal, - bool _cboc, uint32_t _prn, int32_t _fs, uint32_t _chip_shift) +void galileo_e1_code_gen_complex_sampled(own::span> dest, const std::array& signal_id, + bool cboc, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift) { - galileo_e1_code_gen_complex_sampled(_dest, _Signal, _cboc, _prn, _fs, _chip_shift, false); + galileo_e1_code_gen_complex_sampled(dest, signal_id, cboc, prn, sampling_freq, chip_shift, false); } diff --git a/src/algorithms/libs/galileo_e1_signal_replica.h b/src/algorithms/libs/galileo_e1_signal_replica.h index 3769bba6a..83ad4471b 100644 --- a/src/algorithms/libs/galileo_e1_signal_replica.h +++ b/src/algorithms/libs/galileo_e1_signal_replica.h @@ -43,39 +43,39 @@ namespace own = gsl; * \brief This function generates Galileo E1 code (can select E1B or E1C sinboc). * */ -void galileo_e1_code_gen_sinboc11_float(own::span _dest, const std::array& _Signal, uint32_t _prn); +void galileo_e1_code_gen_sinboc11_float(own::span dest, const std::array& signal_id, uint32_t prn); /*! * \brief This function generates Galileo E1 code (can select E1B or E1C, cboc or sinboc - * and the sample frequency _fs). + * and the sample frequency sampling_freq). * */ -void galileo_e1_code_gen_float_sampled(own::span _dest, const std::array& _Signal, - bool _cboc, uint32_t _prn, int32_t _fs, uint32_t _chip_shift, - bool _secondary_flag); +void galileo_e1_code_gen_float_sampled(own::span dest, const std::array& signal_id, + bool cboc, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift, + bool secondary_flag); /*! * \brief This function generates Galileo E1 code (can select E1B or E1C, cboc or sinboc - * and the sample frequency _fs). + * and the sample frequency sampling_freq). * */ -void galileo_e1_code_gen_float_sampled(own::span _dest, const std::array& _Signal, - bool _cboc, uint32_t _prn, int32_t _fs, uint32_t _chip_shift); +void galileo_e1_code_gen_float_sampled(own::span dest, const std::array& signal_id, + bool cboc, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift); /*! * \brief This function generates Galileo E1 code (can select E1B or E1C, cboc or sinboc - * and the sample frequency _fs). + * and the sample frequency sampling_freq). * */ -void galileo_e1_code_gen_complex_sampled(own::span> _dest, const std::array& _Signal, - bool _cboc, uint32_t _prn, int32_t _fs, uint32_t _chip_shift, - bool _secondary_flag); +void galileo_e1_code_gen_complex_sampled(own::span> dest, const std::array& signal_id, + bool cboc, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift, + bool secondary_flag); /*! - * \brief galileo_e1_code_gen_complex_sampled without _secondary_flag for backward compatibility. + * \brief galileo_e1_code_gen_complex_sampled without secondary_flag for backward compatibility. */ -void galileo_e1_code_gen_complex_sampled(own::span> _dest, const std::array& _Signal, - bool _cboc, uint32_t _prn, int32_t _fs, uint32_t _chip_shift); +void galileo_e1_code_gen_complex_sampled(own::span> dest, const std::array& signal_id, + bool cboc, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift); /** \} */ diff --git a/src/algorithms/libs/galileo_e5_signal_replica.cc b/src/algorithms/libs/galileo_e5_signal_replica.cc index 45c622fe9..cd7dbde73 100644 --- a/src/algorithms/libs/galileo_e5_signal_replica.cc +++ b/src/algorithms/libs/galileo_e5_signal_replica.cc @@ -31,189 +31,189 @@ #include -void galileo_e5_a_code_gen_complex_primary(own::span> _dest, - int32_t _prn, - const std::array& _Signal) +void galileo_e5_a_code_gen_complex_primary(own::span> dest, + int32_t prn, + const std::array& signal_id) { - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; std::array a{}; - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } - if (_Signal[0] == '5' && _Signal[1] == 'Q') + if (signal_id[0] == '5' && signal_id[1] == 'Q') { for (size_t i = 0; i < GALILEO_E5A_Q_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E5A_Q_PRIMARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); - _dest[index + 3] = std::complex(static_cast(a[3]), 0.0); + hex_to_binary_converter(a, GALILEO_E5A_Q_PRIMARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + dest[index + 3] = std::complex(static_cast(a[3]), 0.0); index = index + 4; } // last 2 bits are filled up zeros - hex_to_binary_converter(a, GALILEO_E5A_Q_PRIMARY_CODE[prn][GALILEO_E5A_Q_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + hex_to_binary_converter(a, GALILEO_E5A_Q_PRIMARY_CODE[prn_][GALILEO_E5A_Q_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); } - else if (_Signal[0] == '5' && _Signal[1] == 'I') + else if (signal_id[0] == '5' && signal_id[1] == 'I') { for (size_t i = 0; i < GALILEO_E5A_I_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E5A_I_PRIMARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); - _dest[index + 3] = std::complex(static_cast(a[3]), 0.0); + hex_to_binary_converter(a, GALILEO_E5A_I_PRIMARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + dest[index + 3] = std::complex(static_cast(a[3]), 0.0); index = index + 4; } // last 2 bits are filled up zeros - hex_to_binary_converter(a, GALILEO_E5A_I_PRIMARY_CODE[prn][GALILEO_E5A_I_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + hex_to_binary_converter(a, GALILEO_E5A_I_PRIMARY_CODE[prn_][GALILEO_E5A_I_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); } - else if (_Signal[0] == '5' && _Signal[1] == 'X') + else if (signal_id[0] == '5' && signal_id[1] == 'X') { std::array b{}; for (size_t i = 0; i < GALILEO_E5A_I_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E5A_I_PRIMARY_CODE[prn][i]); - hex_to_binary_converter(b, GALILEO_E5A_Q_PRIMARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), static_cast(b[0])); - _dest[index + 1] = std::complex(static_cast(a[1]), static_cast(b[1])); - _dest[index + 2] = std::complex(static_cast(a[2]), static_cast(b[2])); - _dest[index + 3] = std::complex(static_cast(a[3]), static_cast(b[3])); + hex_to_binary_converter(a, GALILEO_E5A_I_PRIMARY_CODE[prn_][i]); + hex_to_binary_converter(b, GALILEO_E5A_Q_PRIMARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), static_cast(b[0])); + dest[index + 1] = std::complex(static_cast(a[1]), static_cast(b[1])); + dest[index + 2] = std::complex(static_cast(a[2]), static_cast(b[2])); + dest[index + 3] = std::complex(static_cast(a[3]), static_cast(b[3])); index = index + 4; } // last 2 bits are filled up zeros - hex_to_binary_converter(a, GALILEO_E5A_I_PRIMARY_CODE[prn][GALILEO_E5A_I_PRIMARY_CODE_STR_LENGTH - 1]); - hex_to_binary_converter(b, GALILEO_E5A_Q_PRIMARY_CODE[prn][GALILEO_E5A_Q_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = std::complex(static_cast(a[0]), static_cast(b[0])); - _dest[index + 1] = std::complex(static_cast(a[1]), static_cast(b[1])); + hex_to_binary_converter(a, GALILEO_E5A_I_PRIMARY_CODE[prn_][GALILEO_E5A_I_PRIMARY_CODE_STR_LENGTH - 1]); + hex_to_binary_converter(b, GALILEO_E5A_Q_PRIMARY_CODE[prn_][GALILEO_E5A_Q_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = std::complex(static_cast(a[0]), static_cast(b[0])); + dest[index + 1] = std::complex(static_cast(a[1]), static_cast(b[1])); } } -void galileo_e5_a_code_gen_complex_sampled(own::span> _dest, - uint32_t _prn, - const std::array& _Signal, - int32_t _fs, - uint32_t _chip_shift) +void galileo_e5_a_code_gen_complex_sampled(own::span> dest, + uint32_t prn, + const std::array& signal_id, + int32_t sampling_freq, + uint32_t chip_shift) { - constexpr uint32_t _codeLength = GALILEO_E5A_CODE_LENGTH_CHIPS; - constexpr int32_t _codeFreqBasis = GALILEO_E5A_CODE_CHIP_RATE_CPS; + constexpr uint32_t codeLength = GALILEO_E5A_CODE_LENGTH_CHIPS; + constexpr int32_t codeFreqBasis = GALILEO_E5A_CODE_CHIP_RATE_CPS; - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); - const uint32_t delay = ((_codeLength - _chip_shift) % _codeLength) * _samplesPerCode / _codeLength; + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); + const uint32_t delay = ((codeLength - chip_shift) % codeLength) * samplesPerCode / codeLength; - std::vector> _code(_codeLength); - galileo_e5_a_code_gen_complex_primary(_code, _prn, _Signal); + std::vector> code_aux(codeLength); + galileo_e5_a_code_gen_complex_primary(code_aux, prn, signal_id); - if (_fs != _codeFreqBasis) + if (sampling_freq != codeFreqBasis) { - std::vector> _resampled_signal(_samplesPerCode); - resampler(_code, _resampled_signal, _codeFreqBasis, _fs); // resamples code to fs - _code = std::move(_resampled_signal); + std::vector> resampled_signal_aux(samplesPerCode); + resampler(code_aux, resampled_signal_aux, codeFreqBasis, sampling_freq); // resamples code to sampling_freq + code_aux = std::move(resampled_signal_aux); } - for (uint32_t i = 0; i < _samplesPerCode; i++) + for (uint32_t i = 0; i < samplesPerCode; i++) { - _dest[(i + delay) % _samplesPerCode] = _code[i]; + dest[(i + delay) % samplesPerCode] = code_aux[i]; } } -void galileo_e5_b_code_gen_complex_primary(own::span> _dest, - int32_t _prn, - const std::array& _Signal) +void galileo_e5_b_code_gen_complex_primary(own::span> dest, + int32_t prn, + const std::array& signal_id) { - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; std::array a{}; - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } - if (_Signal[0] == '7' && _Signal[1] == 'Q') + if (signal_id[0] == '7' && signal_id[1] == 'Q') { for (size_t i = 0; i < GALILEO_E5B_Q_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E5B_Q_PRIMARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); - _dest[index + 3] = std::complex(static_cast(a[3]), 0.0); + hex_to_binary_converter(a, GALILEO_E5B_Q_PRIMARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + dest[index + 3] = std::complex(static_cast(a[3]), 0.0); index = index + 4; } // last 2 bits are filled up zeros - hex_to_binary_converter(a, GALILEO_E5B_Q_PRIMARY_CODE[prn][GALILEO_E5B_Q_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + hex_to_binary_converter(a, GALILEO_E5B_Q_PRIMARY_CODE[prn_][GALILEO_E5B_Q_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); } - else if (_Signal[0] == '7' && _Signal[1] == 'I') + else if (signal_id[0] == '7' && signal_id[1] == 'I') { for (size_t i = 0; i < GALILEO_E5B_I_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E5B_I_PRIMARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); - _dest[index + 3] = std::complex(static_cast(a[3]), 0.0); + hex_to_binary_converter(a, GALILEO_E5B_I_PRIMARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + dest[index + 3] = std::complex(static_cast(a[3]), 0.0); index = index + 4; } // last 2 bits are filled up zeros - hex_to_binary_converter(a, GALILEO_E5B_I_PRIMARY_CODE[prn][GALILEO_E5B_I_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + hex_to_binary_converter(a, GALILEO_E5B_I_PRIMARY_CODE[prn_][GALILEO_E5B_I_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); } - else if (_Signal[0] == '7' && _Signal[1] == 'X') + else if (signal_id[0] == '7' && signal_id[1] == 'X') { std::array b{}; for (size_t i = 0; i < GALILEO_E5B_I_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E5B_I_PRIMARY_CODE[prn][i]); - hex_to_binary_converter(b, GALILEO_E5B_Q_PRIMARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), static_cast(b[0])); - _dest[index + 1] = std::complex(static_cast(a[1]), static_cast(b[1])); - _dest[index + 2] = std::complex(static_cast(a[2]), static_cast(b[2])); - _dest[index + 3] = std::complex(static_cast(a[3]), static_cast(b[3])); + hex_to_binary_converter(a, GALILEO_E5B_I_PRIMARY_CODE[prn_][i]); + hex_to_binary_converter(b, GALILEO_E5B_Q_PRIMARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), static_cast(b[0])); + dest[index + 1] = std::complex(static_cast(a[1]), static_cast(b[1])); + dest[index + 2] = std::complex(static_cast(a[2]), static_cast(b[2])); + dest[index + 3] = std::complex(static_cast(a[3]), static_cast(b[3])); index = index + 4; } // last 2 bits are filled up zeros - hex_to_binary_converter(a, GALILEO_E5B_I_PRIMARY_CODE[prn][GALILEO_E5B_I_PRIMARY_CODE_STR_LENGTH - 1]); - hex_to_binary_converter(b, GALILEO_E5B_Q_PRIMARY_CODE[prn][GALILEO_E5B_Q_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = std::complex(static_cast(a[0]), static_cast(b[0])); - _dest[index + 1] = std::complex(static_cast(a[1]), static_cast(b[1])); + hex_to_binary_converter(a, GALILEO_E5B_I_PRIMARY_CODE[prn_][GALILEO_E5B_I_PRIMARY_CODE_STR_LENGTH - 1]); + hex_to_binary_converter(b, GALILEO_E5B_Q_PRIMARY_CODE[prn_][GALILEO_E5B_Q_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = std::complex(static_cast(a[0]), static_cast(b[0])); + dest[index + 1] = std::complex(static_cast(a[1]), static_cast(b[1])); } } -void galileo_e5_b_code_gen_complex_sampled(own::span> _dest, - uint32_t _prn, - const std::array& _Signal, - int32_t _fs, - uint32_t _chip_shift) +void galileo_e5_b_code_gen_complex_sampled(own::span> dest, + uint32_t prn, + const std::array& signal_id, + int32_t sampling_freq, + uint32_t chip_shift) { - constexpr uint32_t _codeLength = GALILEO_E5B_CODE_LENGTH_CHIPS; - constexpr int32_t _codeFreqBasis = GALILEO_E5B_CODE_CHIP_RATE_CPS; + constexpr uint32_t codeLength = GALILEO_E5B_CODE_LENGTH_CHIPS; + constexpr int32_t codeFreqBasis = GALILEO_E5B_CODE_CHIP_RATE_CPS; - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); - const uint32_t delay = ((_codeLength - _chip_shift) % _codeLength) * _samplesPerCode / _codeLength; + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); + const uint32_t delay = ((codeLength - chip_shift) % codeLength) * samplesPerCode / codeLength; - std::vector> _code(_codeLength); - galileo_e5_b_code_gen_complex_primary(_code, _prn, _Signal); + std::vector> code_aux(codeLength); + galileo_e5_b_code_gen_complex_primary(code_aux, prn, signal_id); - if (_fs != _codeFreqBasis) + if (sampling_freq != codeFreqBasis) { - std::vector> _resampled_signal(_samplesPerCode); - resampler(_code, _resampled_signal, _codeFreqBasis, _fs); // resamples code to fs - _code = std::move(_resampled_signal); + std::vector> resampled_signal_aux(samplesPerCode); + resampler(code_aux, resampled_signal_aux, codeFreqBasis, sampling_freq); // resamples code to sampling_freq + code_aux = std::move(resampled_signal_aux); } - for (uint32_t i = 0; i < _samplesPerCode; i++) + for (uint32_t i = 0; i < samplesPerCode; i++) { - _dest[(i + delay) % _samplesPerCode] = _code[i]; + dest[(i + delay) % samplesPerCode] = code_aux[i]; } } diff --git a/src/algorithms/libs/galileo_e5_signal_replica.h b/src/algorithms/libs/galileo_e5_signal_replica.h index 5594e5524..3f2b6f698 100644 --- a/src/algorithms/libs/galileo_e5_signal_replica.h +++ b/src/algorithms/libs/galileo_e5_signal_replica.h @@ -44,39 +44,39 @@ namespace own = gsl; /*! * \brief Generates Galileo E5a code at 1 sample/chip */ -void galileo_e5_a_code_gen_complex_primary(own::span> _dest, - int32_t _prn, - const std::array& _Signal); +void galileo_e5_a_code_gen_complex_primary(own::span> dest, + int32_t prn, + const std::array& signal_id); /*! * \brief Generates Galileo E5a complex code, shifted to the desired chip and - * sampled at a frequency fs + * sampled at a frequency sampling_freq */ -void galileo_e5_a_code_gen_complex_sampled(own::span> _dest, - uint32_t _prn, - const std::array& _Signal, - int32_t _fs, - uint32_t _chip_shift); +void galileo_e5_a_code_gen_complex_sampled(own::span> dest, + uint32_t prn, + const std::array& signal_id, + int32_t sampling_freq, + uint32_t chip_shift); /*! * \brief Generates Galileo E5b code at 1 sample/chip */ -void galileo_e5_b_code_gen_complex_primary(own::span> _dest, - int32_t _prn, - const std::array& _Signal); +void galileo_e5_b_code_gen_complex_primary(own::span> dest, + int32_t prn, + const std::array& signal_id); /*! * \brief Generates Galileo E5b complex code, shifted to the desired chip and - * sampled at a frequency fs + * sampled at a frequency sampling_freq */ -void galileo_e5_b_code_gen_complex_sampled(own::span> _dest, - uint32_t _prn, - const std::array& _Signal, - int32_t _fs, - uint32_t _chip_shift); +void galileo_e5_b_code_gen_complex_sampled(own::span> dest, + uint32_t prn, + const std::array& signal_id, + int32_t sampling_freq, + uint32_t chip_shift); /** \} */ diff --git a/src/algorithms/libs/galileo_e6_signal_replica.cc b/src/algorithms/libs/galileo_e6_signal_replica.cc index a8b8423a6..2f394e3cd 100644 --- a/src/algorithms/libs/galileo_e6_signal_replica.cc +++ b/src/algorithms/libs/galileo_e6_signal_replica.cc @@ -26,222 +26,222 @@ #include #include -void galileo_e6_b_code_gen_complex_primary(own::span> _dest, - int32_t _prn) +void galileo_e6_b_code_gen_complex_primary(own::span> dest, + int32_t prn) { - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; std::array a{}; - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } for (size_t i = 0; i < GALILEO_E6_B_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E6_B_PRIMARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); - _dest[index + 3] = std::complex(static_cast(a[3]), 0.0); + hex_to_binary_converter(a, GALILEO_E6_B_PRIMARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + dest[index + 3] = std::complex(static_cast(a[3]), 0.0); index = index + 4; } // last bit is filled up with a zero - hex_to_binary_converter(a, GALILEO_E6_B_PRIMARY_CODE[prn][GALILEO_E6_B_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + hex_to_binary_converter(a, GALILEO_E6_B_PRIMARY_CODE[prn_][GALILEO_E6_B_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); } -void galileo_e6_b_code_gen_float_primary(own::span _dest, int32_t _prn) +void galileo_e6_b_code_gen_float_primary(own::span dest, int32_t prn) { - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; std::array a{}; - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } for (size_t i = 0; i < GALILEO_E6_B_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E6_B_PRIMARY_CODE[prn][i]); - _dest[index] = static_cast(a[0]); - _dest[index + 1] = static_cast(a[1]); - _dest[index + 2] = static_cast(a[2]); - _dest[index + 3] = static_cast(a[3]); + hex_to_binary_converter(a, GALILEO_E6_B_PRIMARY_CODE[prn_][i]); + dest[index] = static_cast(a[0]); + dest[index + 1] = static_cast(a[1]); + dest[index + 2] = static_cast(a[2]); + dest[index + 3] = static_cast(a[3]); index = index + 4; } // last bit is filled up with a zero - hex_to_binary_converter(a, GALILEO_E6_B_PRIMARY_CODE[prn][GALILEO_E6_B_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = static_cast(a[0]); - _dest[index + 1] = static_cast(a[1]); - _dest[index + 2] = static_cast(a[2]); + hex_to_binary_converter(a, GALILEO_E6_B_PRIMARY_CODE[prn_][GALILEO_E6_B_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = static_cast(a[0]); + dest[index + 1] = static_cast(a[1]); + dest[index + 2] = static_cast(a[2]); } -void galileo_e6_b_code_gen_complex_sampled(own::span> _dest, - uint32_t _prn, - int32_t _fs, - uint32_t _chip_shift) +void galileo_e6_b_code_gen_complex_sampled(own::span> dest, + uint32_t prn, + int32_t sampling_freq, + uint32_t chip_shift) { - constexpr uint32_t _codeLength = GALILEO_E6_B_CODE_LENGTH_CHIPS; - constexpr int32_t _codeFreqBasis = GALILEO_E6_B_CODE_CHIP_RATE_CPS; + constexpr uint32_t codeLength = GALILEO_E6_B_CODE_LENGTH_CHIPS; + constexpr int32_t codeFreqBasis = GALILEO_E6_B_CODE_CHIP_RATE_CPS; - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); - const uint32_t delay = ((_codeLength - _chip_shift) % _codeLength) * _samplesPerCode / _codeLength; + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); + const uint32_t delay = ((codeLength - chip_shift) % codeLength) * samplesPerCode / codeLength; - std::vector> _code(_codeLength); - galileo_e6_b_code_gen_complex_primary(_code, _prn); + std::vector> code_aux(codeLength); + galileo_e6_b_code_gen_complex_primary(code_aux, prn); - if (_fs != _codeFreqBasis) + if (sampling_freq != codeFreqBasis) { - std::vector> _resampled_signal(_samplesPerCode); - resampler(_code, _resampled_signal, _codeFreqBasis, _fs); // resamples code to fs - _code = std::move(_resampled_signal); + std::vector> resampled_signal_aux(samplesPerCode); + resampler(code_aux, resampled_signal_aux, codeFreqBasis, sampling_freq); // resamples code to sampling_freq + code_aux = std::move(resampled_signal_aux); } - for (uint32_t i = 0; i < _samplesPerCode; i++) + for (uint32_t i = 0; i < samplesPerCode; i++) { - _dest[(i + delay) % _samplesPerCode] = _code[i]; + dest[(i + delay) % samplesPerCode] = code_aux[i]; } } -void galileo_e6_c_code_gen_complex_primary(own::span> _dest, - int32_t _prn) +void galileo_e6_c_code_gen_complex_primary(own::span> dest, + int32_t prn) { - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; std::array a{}; - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } for (size_t i = 0; i < GALILEO_E6_C_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E6_C_PRIMARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); - _dest[index + 3] = std::complex(static_cast(a[3]), 0.0); + hex_to_binary_converter(a, GALILEO_E6_C_PRIMARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + dest[index + 3] = std::complex(static_cast(a[3]), 0.0); index = index + 4; } // last bit is filled up with a zero - hex_to_binary_converter(a, GALILEO_E6_C_PRIMARY_CODE[prn][GALILEO_E6_C_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + hex_to_binary_converter(a, GALILEO_E6_C_PRIMARY_CODE[prn_][GALILEO_E6_C_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); } -void galileo_e6_c_code_gen_float_primary(own::span _dest, int32_t _prn) +void galileo_e6_c_code_gen_float_primary(own::span dest, int32_t prn) { - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; std::array a{}; - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } for (size_t i = 0; i < GALILEO_E6_C_PRIMARY_CODE_STR_LENGTH - 1; i++) { - hex_to_binary_converter(a, GALILEO_E6_C_PRIMARY_CODE[prn][i]); - _dest[index] = static_cast(a[0]); - _dest[index + 1] = static_cast(a[1]); - _dest[index + 2] = static_cast(a[2]); - _dest[index + 3] = static_cast(a[3]); + hex_to_binary_converter(a, GALILEO_E6_C_PRIMARY_CODE[prn_][i]); + dest[index] = static_cast(a[0]); + dest[index + 1] = static_cast(a[1]); + dest[index + 2] = static_cast(a[2]); + dest[index + 3] = static_cast(a[3]); index = index + 4; } // last bit is filled up with a zero - hex_to_binary_converter(a, GALILEO_E6_C_PRIMARY_CODE[prn][GALILEO_E6_C_PRIMARY_CODE_STR_LENGTH - 1]); - _dest[index] = static_cast(a[0]); - _dest[index + 1] = static_cast(a[1]); - _dest[index + 2] = static_cast(a[2]); + hex_to_binary_converter(a, GALILEO_E6_C_PRIMARY_CODE[prn_][GALILEO_E6_C_PRIMARY_CODE_STR_LENGTH - 1]); + dest[index] = static_cast(a[0]); + dest[index + 1] = static_cast(a[1]); + dest[index + 2] = static_cast(a[2]); } -void galileo_e6_c_code_gen_complex_sampled(own::span> _dest, - uint32_t _prn, - int32_t _fs, - uint32_t _chip_shift) +void galileo_e6_c_code_gen_complex_sampled(own::span> dest, + uint32_t prn, + int32_t sampling_freq, + uint32_t chip_shift) { - constexpr uint32_t _codeLength = GALILEO_E6_C_CODE_LENGTH_CHIPS; - constexpr int32_t _codeFreqBasis = GALILEO_E6_C_CODE_CHIP_RATE_CPS; + constexpr uint32_t codeLength = GALILEO_E6_C_CODE_LENGTH_CHIPS; + constexpr int32_t codeFreqBasis = GALILEO_E6_C_CODE_CHIP_RATE_CPS; - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); - const uint32_t delay = ((_codeLength - _chip_shift) % _codeLength) * _samplesPerCode / _codeLength; + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); + const uint32_t delay = ((codeLength - chip_shift) % codeLength) * samplesPerCode / codeLength; - std::vector> _code(_codeLength); - galileo_e6_c_code_gen_complex_primary(_code, _prn); + std::vector> code_aux(codeLength); + galileo_e6_c_code_gen_complex_primary(code_aux, prn); - if (_fs != _codeFreqBasis) + if (sampling_freq != codeFreqBasis) { - std::vector> _resampled_signal(_samplesPerCode); - resampler(_code, _resampled_signal, _codeFreqBasis, _fs); // resamples code to fs - _code = std::move(_resampled_signal); + std::vector> resampled_signal_aux(samplesPerCode); + resampler(code_aux, resampled_signal_aux, codeFreqBasis, sampling_freq); // resamples code to sampling_freq + code_aux = std::move(resampled_signal_aux); } - for (uint32_t i = 0; i < _samplesPerCode; i++) + for (uint32_t i = 0; i < samplesPerCode; i++) { - _dest[(i + delay) % _samplesPerCode] = _code[i]; + dest[(i + delay) % samplesPerCode] = code_aux[i]; } } -void galileo_e6_c_secondary_code_gen_complex(own::span> _dest, - int32_t _prn) +void galileo_e6_c_secondary_code_gen_complex(own::span> dest, + int32_t prn) { - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; std::array a{}; - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } for (size_t i = 0; i < GALILEO_E6_C_SECONDARY_CODE_STR_LENGTH; i++) { - hex_to_binary_converter(a, GALILEO_E6_C_SECONDARY_CODE[prn][i]); - _dest[index] = std::complex(static_cast(a[0]), 0.0); - _dest[index + 1] = std::complex(static_cast(a[1]), 0.0); - _dest[index + 2] = std::complex(static_cast(a[2]), 0.0); - _dest[index + 3] = std::complex(static_cast(a[3]), 0.0); + hex_to_binary_converter(a, GALILEO_E6_C_SECONDARY_CODE[prn_][i]); + dest[index] = std::complex(static_cast(a[0]), 0.0); + dest[index + 1] = std::complex(static_cast(a[1]), 0.0); + dest[index + 2] = std::complex(static_cast(a[2]), 0.0); + dest[index + 3] = std::complex(static_cast(a[3]), 0.0); index = index + 4; } } -void galileo_e6_c_secondary_code_gen_float(own::span _dest, - int32_t _prn) +void galileo_e6_c_secondary_code_gen_float(own::span dest, + int32_t prn) { - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; std::array a{}; - if ((_prn < 1) || (_prn > 50)) + if ((prn < 1) || (prn > 50)) { return; } for (size_t i = 0; i < GALILEO_E6_C_SECONDARY_CODE_STR_LENGTH; i++) { - hex_to_binary_converter(a, GALILEO_E6_C_SECONDARY_CODE[prn][i]); - _dest[index] = static_cast(a[0]); - _dest[index + 1] = static_cast(a[1]); - _dest[index + 2] = static_cast(a[2]); - _dest[index + 3] = static_cast(a[3]); + hex_to_binary_converter(a, GALILEO_E6_C_SECONDARY_CODE[prn_][i]); + dest[index] = static_cast(a[0]); + dest[index + 1] = static_cast(a[1]); + dest[index + 2] = static_cast(a[2]); + dest[index + 3] = static_cast(a[3]); index = index + 4; } } -std::string galileo_e6_c_secondary_code(int32_t _prn) +std::string galileo_e6_c_secondary_code(int32_t prn) { std::string dest(static_cast(GALILEO_E6_C_SECONDARY_CODE_LENGTH_CHIPS), '0'); - const uint32_t prn = _prn - 1; + const uint32_t prn_ = prn - 1; uint32_t index = 0; for (size_t i = 0; i < GALILEO_E6_C_SECONDARY_CODE_STR_LENGTH; i++) { - std::string aux = hex_to_binary_string(GALILEO_E6_C_SECONDARY_CODE[prn][i]); + std::string aux = hex_to_binary_string(GALILEO_E6_C_SECONDARY_CODE[prn_][i]); dest[index] = aux[0]; dest[index + 1] = aux[1]; dest[index + 2] = aux[2]; diff --git a/src/algorithms/libs/galileo_e6_signal_replica.h b/src/algorithms/libs/galileo_e6_signal_replica.h index f40275c70..3191c57f2 100644 --- a/src/algorithms/libs/galileo_e6_signal_replica.h +++ b/src/algorithms/libs/galileo_e6_signal_replica.h @@ -43,67 +43,67 @@ namespace own = gsl; /*! * \brief Generates Galileo E6B code at 1 sample/chip */ -void galileo_e6_b_code_gen_complex_primary(own::span> _dest, - int32_t _prn); +void galileo_e6_b_code_gen_complex_primary(own::span> dest, + int32_t prn); /*! * \brief Generates Galileo E6B code at 1 sample/chip */ -void galileo_e6_b_code_gen_float_primary(own::span _dest, int32_t _prn); +void galileo_e6_b_code_gen_float_primary(own::span dest, int32_t prn); /*! * \brief Generates Galileo E6B complex code, shifted to the desired chip and - * sampled at a frequency fs + * sampled at a frequency sampling_freq */ -void galileo_e6_b_code_gen_complex_sampled(own::span> _dest, - uint32_t _prn, - int32_t _fs, - uint32_t _chip_shift); +void galileo_e6_b_code_gen_complex_sampled(own::span> dest, + uint32_t prn, + int32_t sampling_freq, + uint32_t chip_shift); /*! * \brief Generates Galileo E6C codes at 1 sample/chip */ -void galileo_e6_c_code_gen_complex_primary(own::span> _dest, - int32_t _prn); +void galileo_e6_c_code_gen_complex_primary(own::span> dest, + int32_t prn); /*! * \brief Generates Galileo E6C codes at 1 sample/chip */ -void galileo_e6_c_code_gen_float_primary(own::span _dest, int32_t _prn); +void galileo_e6_c_code_gen_float_primary(own::span dest, int32_t prn); /*! * \brief Generates Galileo E6C complex codes, shifted to the desired chip and - * sampled at a frequency fs + * sampled at a frequency sampling_freq */ -void galileo_e6_c_code_gen_complex_sampled(own::span> _dest, - uint32_t _prn, - int32_t _fs, - uint32_t _chip_shift); +void galileo_e6_c_code_gen_complex_sampled(own::span> dest, + uint32_t prn, + int32_t sampling_freq, + uint32_t chip_shift); /*! * \brief Generates Galileo E6C secondary codes at 1 sample/chip */ -void galileo_e6_c_secondary_code_gen_complex(own::span> _dest, - int32_t _prn); +void galileo_e6_c_secondary_code_gen_complex(own::span> dest, + int32_t prn); /*! * \brief Generates Galileo E6C secondary codes at 1 sample/chip */ -void galileo_e6_c_secondary_code_gen_float(own::span _dest, - int32_t _prn); +void galileo_e6_c_secondary_code_gen_float(own::span dest, + int32_t prn); /*! * \brief Generates a string with Galileo E6C secondary codes at 1 sample/chip */ -std::string galileo_e6_c_secondary_code(int32_t _prn); +std::string galileo_e6_c_secondary_code(int32_t prn); /** \} */ diff --git a/src/algorithms/libs/glonass_l1_signal_replica.cc b/src/algorithms/libs/glonass_l1_signal_replica.cc index 47feb5851..7233771dc 100644 --- a/src/algorithms/libs/glonass_l1_signal_replica.cc +++ b/src/algorithms/libs/glonass_l1_signal_replica.cc @@ -25,10 +25,10 @@ const auto AUX_CEIL = [](float x) { return static_cast(static_cast((x) + 1)); }; -void glonass_l1_ca_code_gen_complex(own::span> _dest, uint32_t _chip_shift) +void glonass_l1_ca_code_gen_complex(own::span> dest, uint32_t chip_shift) { - const uint32_t _code_length = 511; - std::bitset<_code_length> G1{}; + const uint32_t code_length = 511; + std::bitset G1{}; auto G1_register = std::bitset<9>{}.set(); // All true bool feedback1; bool aux; @@ -37,7 +37,7 @@ void glonass_l1_ca_code_gen_complex(own::span> _dest, uint32 uint32_t lcv2; /* Generate G1 Register */ - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { G1[lcv] = G1_register[2]; @@ -52,38 +52,38 @@ void glonass_l1_ca_code_gen_complex(own::span> _dest, uint32 } /* Generate PRN from G1 Register */ - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { aux = G1[lcv]; if (aux == true) { - _dest[lcv] = std::complex(1, 0); + dest[lcv] = std::complex(1, 0); } else { - _dest[lcv] = std::complex(-1, 0); + dest[lcv] = std::complex(-1, 0); } } /* Set the delay */ - delay = _code_length; - delay += _chip_shift; - delay %= _code_length; + delay = code_length; + delay += chip_shift; + delay %= code_length; /* Generate PRN from G1 and G2 Registers */ - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { - aux = G1[(lcv + _chip_shift) % _code_length]; + aux = G1[(lcv + chip_shift) % code_length]; if (aux == true) { - _dest[lcv] = std::complex(1, 0); + dest[lcv] = std::complex(1, 0); } else { - _dest[lcv] = std::complex(-1, 0); + dest[lcv] = std::complex(-1, 0); } delay++; - delay %= _code_length; + delay %= code_length; } } @@ -91,44 +91,44 @@ void glonass_l1_ca_code_gen_complex(own::span> _dest, uint32 /* * Generates complex GLONASS L1 C/A code for the desired SV ID and sampled to specific sampling frequency */ -void glonass_l1_ca_code_gen_complex_sampled(own::span> _dest, int32_t _fs, uint32_t _chip_shift) +void glonass_l1_ca_code_gen_complex_sampled(own::span> dest, int32_t sampling_freq, uint32_t chip_shift) { - constexpr int32_t _codeFreqBasis = 511000; // Hz - constexpr int32_t _codeLength = 511; - constexpr float _tc = 1.0 / static_cast(_codeFreqBasis); // C/A chip period in sec + constexpr int32_t codeFreqBasis = 511000; // chips per second + constexpr int32_t codeLength = 511; + constexpr float tc = 1.0 / static_cast(codeFreqBasis); // C/A chip period in sec - const float _ts = 1.0F / static_cast(_fs); // Sampling period in sec - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); + const float ts = 1.0F / static_cast(sampling_freq); // Sampling period in sec + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); - std::array, 511> _code{}; - int32_t _codeValueIndex; + std::array, 511> code_aux{}; + int32_t codeValueIndex; float aux; - glonass_l1_ca_code_gen_complex(_code, _chip_shift); // generate C/A code 1 sample per chip + glonass_l1_ca_code_gen_complex(code_aux, chip_shift); // generate C/A code 1 sample per chip - for (int32_t i = 0; i < _samplesPerCode; i++) + for (int32_t i = 0; i < samplesPerCode; i++) { // === Digitizing ================================================== // --- Make index array to read C/A code values -------------------- // The length of the index array depends on the sampling frequency - - // number of samples per millisecond (because one C/A code period is one - // millisecond). + // number of samples per millisecond (because one C/A code period is + // one millisecond). - aux = (_ts * (static_cast(i) + 1)) / _tc; - _codeValueIndex = AUX_CEIL(aux) - 1; + aux = (ts * (static_cast(i) + 1)) / tc; + codeValueIndex = AUX_CEIL(aux) - 1; // --- Make the digitized version of the C/A code ------------------ // The "upsampled" code is made by selecting values form the CA code // chip array (caCode) for the time instances of each sample. - if (i == _samplesPerCode - 1) + if (i == samplesPerCode - 1) { - // --- Correct the last index (due to number rounding issues) ----------- - _dest[i] = _code[_codeLength - 1]; + // Correct the last index (due to number rounding issues) + dest[i] = code_aux[codeLength - 1]; } else { - _dest[i] = _code[_codeValueIndex]; // repeat the chip -> upsample + dest[i] = code_aux[codeValueIndex]; // repeat the chip -> upsample } } } diff --git a/src/algorithms/libs/glonass_l1_signal_replica.h b/src/algorithms/libs/glonass_l1_signal_replica.h index a4afbc36b..1a8d71384 100644 --- a/src/algorithms/libs/glonass_l1_signal_replica.h +++ b/src/algorithms/libs/glonass_l1_signal_replica.h @@ -38,14 +38,11 @@ namespace own = gsl; * \{ */ -//! Generates complex GLONASS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency -void glonass_l1_ca_code_gen_complex(own::span> _dest, uint32_t _chip_shift); - -//! Generates N complex GLONASS L1 C/A codes for the desired SV ID and code shift -void glonass_l1_ca_code_gen_complex_sampled(own::span> _dest, int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes); - //! Generates complex GLONASS L1 C/A code for the desired SV ID and code shift -void glonass_l1_ca_code_gen_complex_sampled(own::span> _dest, int32_t _fs, uint32_t _chip_shift); +void glonass_l1_ca_code_gen_complex(own::span> dest, uint32_t chip_shift); + +//! Generates complex GLONASS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency +void glonass_l1_ca_code_gen_complex_sampled(own::span> dest, int32_t sampling_freq, uint32_t chip_shift); /** \} */ diff --git a/src/algorithms/libs/glonass_l2_signal_replica.cc b/src/algorithms/libs/glonass_l2_signal_replica.cc index f526295c8..dce249af3 100644 --- a/src/algorithms/libs/glonass_l2_signal_replica.cc +++ b/src/algorithms/libs/glonass_l2_signal_replica.cc @@ -25,10 +25,10 @@ const auto AUX_CEIL = [](float x) { return static_cast(static_cast((x) + 1)); }; -void glonass_l2_ca_code_gen_complex(own::span> _dest, uint32_t _chip_shift) +void glonass_l2_ca_code_gen_complex(own::span> dest, uint32_t chip_shift) { - const uint32_t _code_length = 511; - std::bitset<_code_length> G1{}; + const uint32_t code_length = 511; + std::bitset G1{}; auto G1_register = std::bitset<9>{}.set(); // All true bool feedback1; bool aux; @@ -37,7 +37,7 @@ void glonass_l2_ca_code_gen_complex(own::span> _dest, uint32 uint32_t lcv2; /* Generate G1 Register */ - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { G1[lcv] = G1_register[2]; @@ -52,38 +52,38 @@ void glonass_l2_ca_code_gen_complex(own::span> _dest, uint32 } /* Generate PRN from G1 Register */ - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { aux = G1[lcv]; if (aux == true) { - _dest[lcv] = std::complex(1, 0); + dest[lcv] = std::complex(1, 0); } else { - _dest[lcv] = std::complex(-1, 0); + dest[lcv] = std::complex(-1, 0); } } /* Set the delay */ - delay = _code_length; - delay += _chip_shift; - delay %= _code_length; + delay = code_length; + delay += chip_shift; + delay %= code_length; /* Generate PRN from G1 and G2 Registers */ - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { - aux = G1[(lcv + _chip_shift) % _code_length]; + aux = G1[(lcv + chip_shift) % code_length]; if (aux == true) { - _dest[lcv] = std::complex(1, 0); + dest[lcv] = std::complex(1, 0); } else { - _dest[lcv] = std::complex(-1, 0); + dest[lcv] = std::complex(-1, 0); } delay++; - delay %= _code_length; + delay %= code_length; } } @@ -91,44 +91,44 @@ void glonass_l2_ca_code_gen_complex(own::span> _dest, uint32 /* * Generates complex GLONASS L2 C/A code for the desired SV ID and sampled to specific sampling frequency */ -void glonass_l2_ca_code_gen_complex_sampled(own::span> _dest, int32_t _fs, uint32_t _chip_shift) +void glonass_l2_ca_code_gen_complex_sampled(own::span> dest, int32_t sampling_freq, uint32_t chip_shift) { - constexpr int32_t _codeFreqBasis = 511000; // Hz - constexpr int32_t _codeLength = 511; - constexpr float _tc = 1.0 / static_cast(_codeFreqBasis); // C/A chip period in sec + constexpr int32_t codeFreqBasis = 511000; // chips per second + constexpr int32_t codeLength = 511; + constexpr float tc = 1.0 / static_cast(codeFreqBasis); // C/A chip period in sec - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); - const float _ts = 1.0F / static_cast(_fs); // Sampling period in sec + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); + const float ts = 1.0F / static_cast(sampling_freq); // Sampling period in sec - std::array, 511> _code{}; - int32_t _codeValueIndex; + std::array, 511> code_aux{}; + int32_t codeValueIndex; float aux; - glonass_l2_ca_code_gen_complex(_code, _chip_shift); // generate C/A code 1 sample per chip + glonass_l2_ca_code_gen_complex(code_aux, chip_shift); // generate C/A code 1 sample per chip - for (int32_t i = 0; i < _samplesPerCode; i++) + for (int32_t i = 0; i < samplesPerCode; i++) { // === Digitizing ================================================== // --- Make index array to read C/A code values -------------------- // The length of the index array depends on the sampling frequency - - // number of samples per millisecond (because one C/A code period is one - // millisecond). + // number of samples per millisecond (because one C/A code period is + // one millisecond). - aux = (_ts * (static_cast(i) + 1)) / _tc; - _codeValueIndex = AUX_CEIL(aux) - 1; + aux = (ts * (static_cast(i) + 1)) / tc; + codeValueIndex = AUX_CEIL(aux) - 1; // --- Make the digitized version of the C/A code ------------------ // The "upsampled" code is made by selecting values form the CA code // chip array (caCode) for the time instances of each sample. - if (i == _samplesPerCode - 1) + if (i == samplesPerCode - 1) { - // --- Correct the last index (due to number rounding issues) ----------- - _dest[i] = _code[_codeLength - 1]; + // Correct the last index (due to number rounding issues) + dest[i] = code_aux[codeLength - 1]; } else { - _dest[i] = _code[_codeValueIndex]; // repeat the chip -> upsample + dest[i] = code_aux[codeValueIndex]; // repeat the chip -> upsample } } } diff --git a/src/algorithms/libs/glonass_l2_signal_replica.h b/src/algorithms/libs/glonass_l2_signal_replica.h index b87555ca1..4037b49ee 100644 --- a/src/algorithms/libs/glonass_l2_signal_replica.h +++ b/src/algorithms/libs/glonass_l2_signal_replica.h @@ -38,14 +38,11 @@ namespace own = gsl; * \{ */ -//! Generates complex GLONASS L2 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency -void glonass_l2_ca_code_gen_complex(own::span> _dest, uint32_t _chip_shift); - -//! Generates N complex GLONASS L2 C/A codes for the desired SV ID and code shift -void glonass_l2_ca_code_gen_complex_sampled(own::span> _dest, int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes); - //! Generates complex GLONASS L2 C/A code for the desired SV ID and code shift -void glonass_l2_ca_code_gen_complex_sampled(own::span> _dest, int32_t _fs, uint32_t _chip_shift); +void glonass_l2_ca_code_gen_complex(own::span> dest, uint32_t chip_shift); + +//! Generates complex GLONASS L2 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency +void glonass_l2_ca_code_gen_complex_sampled(own::span> dest, int32_t sampling_freq, uint32_t chip_shift); /** \} */ diff --git a/src/algorithms/libs/gnss_signal_replica.cc b/src/algorithms/libs/gnss_signal_replica.cc index 1edced77c..a7012b841 100644 --- a/src/algorithms/libs/gnss_signal_replica.cc +++ b/src/algorithms/libs/gnss_signal_replica.cc @@ -27,121 +27,121 @@ const auto AUX_CEIL2 = [](float x) { return static_cast(static_cast((x) + 1)); }; -void complex_exp_gen(own::span> _dest, double _f, double _fs) +void complex_exp_gen(own::span> dest, double freq, double sampling_freq) { gr::fxpt_nco d_nco; - d_nco.set_freq(static_cast((TWO_PI * _f) / _fs)); - d_nco.sincos(_dest.data(), _dest.size(), 1); + d_nco.set_freq(static_cast((TWO_PI * freq) / sampling_freq)); + d_nco.sincos(dest.data(), dest.size(), 1); } -void complex_exp_gen_conj(own::span> _dest, double _f, double _fs) +void complex_exp_gen_conj(own::span> dest, double freq, double sampling_freq) { gr::fxpt_nco d_nco; - d_nco.set_freq(-static_cast((TWO_PI * _f) / _fs)); - d_nco.sincos(_dest.data(), _dest.size(), 1); + d_nco.set_freq(-static_cast((TWO_PI * freq) / sampling_freq)); + d_nco.sincos(dest.data(), dest.size(), 1); } -void hex_to_binary_converter(own::span _dest, char _from) +void hex_to_binary_converter(own::span dest, char from) { - switch (_from) + switch (from) { case '0': - _dest[0] = 1; - _dest[1] = 1; - _dest[2] = 1; - _dest[3] = 1; + dest[0] = 1; + dest[1] = 1; + dest[2] = 1; + dest[3] = 1; break; case '1': - _dest[0] = 1; - _dest[1] = 1; - _dest[2] = 1; - _dest[3] = -1; + dest[0] = 1; + dest[1] = 1; + dest[2] = 1; + dest[3] = -1; break; case '2': - _dest[0] = 1; - _dest[1] = 1; - _dest[2] = -1; - _dest[3] = 1; + dest[0] = 1; + dest[1] = 1; + dest[2] = -1; + dest[3] = 1; break; case '3': - _dest[0] = 1; - _dest[1] = 1; - _dest[2] = -1; - _dest[3] = -1; + dest[0] = 1; + dest[1] = 1; + dest[2] = -1; + dest[3] = -1; break; case '4': - _dest[0] = 1; - _dest[1] = -1; - _dest[2] = 1; - _dest[3] = 1; + dest[0] = 1; + dest[1] = -1; + dest[2] = 1; + dest[3] = 1; break; case '5': - _dest[0] = 1; - _dest[1] = -1; - _dest[2] = 1; - _dest[3] = -1; + dest[0] = 1; + dest[1] = -1; + dest[2] = 1; + dest[3] = -1; break; case '6': - _dest[0] = 1; - _dest[1] = -1; - _dest[2] = -1; - _dest[3] = 1; + dest[0] = 1; + dest[1] = -1; + dest[2] = -1; + dest[3] = 1; break; case '7': - _dest[0] = 1; - _dest[1] = -1; - _dest[2] = -1; - _dest[3] = -1; + dest[0] = 1; + dest[1] = -1; + dest[2] = -1; + dest[3] = -1; break; case '8': - _dest[0] = -1; - _dest[1] = 1; - _dest[2] = 1; - _dest[3] = 1; + dest[0] = -1; + dest[1] = 1; + dest[2] = 1; + dest[3] = 1; break; case '9': - _dest[0] = -1; - _dest[1] = 1; - _dest[2] = 1; - _dest[3] = -1; + dest[0] = -1; + dest[1] = 1; + dest[2] = 1; + dest[3] = -1; break; case 'A': - _dest[0] = -1; - _dest[1] = 1; - _dest[2] = -1; - _dest[3] = 1; + dest[0] = -1; + dest[1] = 1; + dest[2] = -1; + dest[3] = 1; break; case 'B': - _dest[0] = -1; - _dest[1] = 1; - _dest[2] = -1; - _dest[3] = -1; + dest[0] = -1; + dest[1] = 1; + dest[2] = -1; + dest[3] = -1; break; case 'C': - _dest[0] = -1; - _dest[1] = -1; - _dest[2] = 1; - _dest[3] = 1; + dest[0] = -1; + dest[1] = -1; + dest[2] = 1; + dest[3] = 1; break; case 'D': - _dest[0] = -1; - _dest[1] = -1; - _dest[2] = 1; - _dest[3] = -1; + dest[0] = -1; + dest[1] = -1; + dest[2] = 1; + dest[3] = -1; break; case 'E': - _dest[0] = -1; - _dest[1] = -1; - _dest[2] = -1; - _dest[3] = 1; + dest[0] = -1; + dest[1] = -1; + dest[2] = -1; + dest[3] = 1; break; case 'F': - _dest[0] = -1; - _dest[1] = -1; - _dest[2] = -1; - _dest[3] = -1; + dest[0] = -1; + dest[1] = -1; + dest[2] = -1; + dest[3] = -1; break; default: break; @@ -149,143 +149,145 @@ void hex_to_binary_converter(own::span _dest, char _from) } -std::string hex_to_binary_string(char _from) +std::string hex_to_binary_string(char from) { - std::string _dest("0000"); - switch (_from) + std::string dest("0000"); + switch (from) { case '0': - _dest[0] = '0'; - _dest[1] = '0'; - _dest[2] = '0'; - _dest[3] = '0'; + dest[0] = '0'; + dest[1] = '0'; + dest[2] = '0'; + dest[3] = '0'; break; case '1': - _dest[0] = '0'; - _dest[1] = '0'; - _dest[2] = '0'; - _dest[3] = '1'; + dest[0] = '0'; + dest[1] = '0'; + dest[2] = '0'; + dest[3] = '1'; break; case '2': - _dest[0] = '0'; - _dest[1] = '0'; - _dest[2] = '1'; - _dest[3] = '0'; + dest[0] = '0'; + dest[1] = '0'; + dest[2] = '1'; + dest[3] = '0'; break; case '3': - _dest[0] = '0'; - _dest[1] = '0'; - _dest[2] = '1'; - _dest[3] = '1'; + dest[0] = '0'; + dest[1] = '0'; + dest[2] = '1'; + dest[3] = '1'; break; case '4': - _dest[0] = '0'; - _dest[1] = '1'; - _dest[2] = '0'; - _dest[3] = '0'; + dest[0] = '0'; + dest[1] = '1'; + dest[2] = '0'; + dest[3] = '0'; break; case '5': - _dest[0] = '0'; - _dest[1] = '1'; - _dest[2] = '0'; - _dest[3] = '1'; + dest[0] = '0'; + dest[1] = '1'; + dest[2] = '0'; + dest[3] = '1'; break; case '6': - _dest[0] = '0'; - _dest[1] = '1'; - _dest[2] = '1'; - _dest[3] = '0'; + dest[0] = '0'; + dest[1] = '1'; + dest[2] = '1'; + dest[3] = '0'; break; case '7': - _dest[0] = '0'; - _dest[1] = '1'; - _dest[2] = '1'; - _dest[3] = '1'; + dest[0] = '0'; + dest[1] = '1'; + dest[2] = '1'; + dest[3] = '1'; break; case '8': - _dest[0] = '1'; - _dest[1] = '0'; - _dest[2] = '0'; - _dest[3] = '0'; + dest[0] = '1'; + dest[1] = '0'; + dest[2] = '0'; + dest[3] = '0'; break; case '9': - _dest[0] = '1'; - _dest[1] = '0'; - _dest[2] = '0'; - _dest[3] = '1'; + dest[0] = '1'; + dest[1] = '0'; + dest[2] = '0'; + dest[3] = '1'; break; case 'A': - _dest[0] = '1'; - _dest[1] = '0'; - _dest[2] = '1'; - _dest[3] = '0'; + dest[0] = '1'; + dest[1] = '0'; + dest[2] = '1'; + dest[3] = '0'; break; case 'B': - _dest[0] = '1'; - _dest[1] = '0'; - _dest[2] = '1'; - _dest[3] = '1'; + dest[0] = '1'; + dest[1] = '0'; + dest[2] = '1'; + dest[3] = '1'; break; case 'C': - _dest[0] = '1'; - _dest[1] = '1'; - _dest[2] = '0'; - _dest[3] = '0'; + dest[0] = '1'; + dest[1] = '1'; + dest[2] = '0'; + dest[3] = '0'; break; case 'D': - _dest[0] = '1'; - _dest[1] = '1'; - _dest[2] = '0'; - _dest[3] = '1'; + dest[0] = '1'; + dest[1] = '1'; + dest[2] = '0'; + dest[3] = '1'; break; case 'E': - _dest[0] = '1'; - _dest[1] = '1'; - _dest[2] = '1'; - _dest[3] = '0'; + dest[0] = '1'; + dest[1] = '1'; + dest[2] = '1'; + dest[3] = '0'; break; case 'F': - _dest[0] = '1'; - _dest[1] = '1'; - _dest[2] = '1'; - _dest[3] = '1'; + dest[0] = '1'; + dest[1] = '1'; + dest[2] = '1'; + dest[3] = '1'; break; default: break; } - return _dest; + return dest; } -void resampler(const own::span _from, own::span _dest, float _fs_in, - float _fs_out) +void resampler(const own::span from, own::span dest, float fs_in, + float fs_out) { - uint32_t _codeValueIndex; + uint32_t codeValueIndex; float aux; - const float _t_out = 1.0F / _fs_out; // Output sampling period - for (size_t i = 0; i < _dest.size() - 1; i++) + const float t_out = 1.0F / fs_out; // Output sampling period + const size_t dest_size = dest.size(); + for (size_t i = 0; i < dest_size - 1; i++) { - aux = (_t_out * (static_cast(i) + 1.0F)) * _fs_in; - _codeValueIndex = AUX_CEIL2(aux) - 1; - _dest[i] = _from[_codeValueIndex]; + aux = (t_out * (static_cast(i) + 1.0F)) * fs_in; + codeValueIndex = AUX_CEIL2(aux) - 1; + dest[i] = from[codeValueIndex]; } // Correct the last index (due to number rounding issues) - _dest[_dest.size() - 1] = _from[_from.size() - 1]; + dest[dest_size - 1] = from[from.size() - 1]; } -void resampler(own::span> _from, own::span> _dest, float _fs_in, - float _fs_out) +void resampler(own::span> from, own::span> dest, float fs_in, + float fs_out) { - uint32_t _codeValueIndex; + uint32_t codeValueIndex; float aux; - const float _t_out = 1.0F / _fs_out; // Output sampling period - for (size_t i = 0; i < _dest.size() - 1; i++) + const float t_out = 1.0F / fs_out; // Output sampling period + const size_t dest_size = dest.size(); + for (size_t i = 0; i < dest_size - 1; i++) { - aux = (_t_out * (static_cast(i) + 1.0F)) * _fs_in; - _codeValueIndex = AUX_CEIL2(aux) - 1; - _dest[i] = _from[_codeValueIndex]; + aux = (t_out * (static_cast(i) + 1.0F)) * fs_in; + codeValueIndex = AUX_CEIL2(aux) - 1; + dest[i] = from[codeValueIndex]; } // Correct the last index (due to number rounding issues) - _dest[_dest.size() - 1] = _from[_from.size() - 1]; + dest[dest_size - 1] = from[from.size() - 1]; } diff --git a/src/algorithms/libs/gnss_signal_replica.h b/src/algorithms/libs/gnss_signal_replica.h index 70864187d..c7b0536b7 100644 --- a/src/algorithms/libs/gnss_signal_replica.h +++ b/src/algorithms/libs/gnss_signal_replica.h @@ -40,44 +40,44 @@ namespace own = gsl; /*! - * \brief This function generates a complex exponential in _dest. + * \brief This function generates a complex exponential in dest. * */ -void complex_exp_gen(own::span> _dest, double _f, double _fs); +void complex_exp_gen(own::span> dest, double freq, double sampling_freq); /*! - * \brief This function generates a conjugate complex exponential in _dest. + * \brief This function generates a conjugate complex exponential in dest. * */ -void complex_exp_gen_conj(own::span> _dest, double _f, double _fs); +void complex_exp_gen_conj(own::span> dest, double freq, double sampling_freq); /*! * \brief This function makes a conversion from hex (the input is a char) * to binary (the output are 4 ints with +1 or -1 values). * */ -void hex_to_binary_converter(own::span _dest, char _from); +void hex_to_binary_converter(own::span dest, char from); /*! * \brief This function makes a conversion from hex (the input is a char) * to binary (the output is a string of 4 char with 0 or 1 values). * */ -std::string hex_to_binary_string(char _from); +std::string hex_to_binary_string(char from); /*! * \brief This function resamples a sequence of float values. * */ -void resampler(const own::span _from, own::span _dest, - float _fs_in, float _fs_out); +void resampler(const own::span from, own::span dest, + float fs_in, float fs_out); /*! * \brief This function resamples a sequence of complex values. * */ -void resampler(own::span> _from, own::span> _dest, - float _fs_in, float _fs_out); +void resampler(own::span> from, own::span> dest, + float fs_in, float fs_out); /** \} */ diff --git a/src/algorithms/libs/gps_l2c_signal_replica.cc b/src/algorithms/libs/gps_l2c_signal_replica.cc index 5bf5e8f6d..fcaaf2a1f 100644 --- a/src/algorithms/libs/gps_l2c_signal_replica.cc +++ b/src/algorithms/libs/gps_l2c_signal_replica.cc @@ -31,43 +31,43 @@ uint32_t gps_l2c_m_shift(uint32_t x) } -void gps_l2c_m_code(own::span _dest, uint32_t _prn) +void gps_l2c_m_code(own::span dest, uint32_t prn) { - uint32_t x = GPS_L2C_M_INIT_REG[_prn - 1]; + uint32_t x = GPS_L2C_M_INIT_REG[prn - 1]; for (int32_t n = 0; n < GPS_L2_M_CODE_LENGTH_CHIPS; n++) { - _dest[n] = static_cast(x & 1U); + dest[n] = static_cast(x & 1U); x = gps_l2c_m_shift(x); } } -void gps_l2c_m_code_gen_complex(own::span> _dest, uint32_t _prn) +void gps_l2c_m_code_gen_complex(own::span> dest, uint32_t prn) { - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - gps_l2c_m_code(_code, _prn); + gps_l2c_m_code(code_aux, prn); } for (int32_t i = 0; i < GPS_L2_M_CODE_LENGTH_CHIPS; i++) { - _dest[i] = std::complex(0.0, 1.0F - 2.0F * _code[i]); + dest[i] = std::complex(0.0, 1.0F - 2.0F * code_aux[i]); } } -void gps_l2c_m_code_gen_float(own::span _dest, uint32_t _prn) +void gps_l2c_m_code_gen_float(own::span dest, uint32_t prn) { - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - gps_l2c_m_code(_code, _prn); + gps_l2c_m_code(code_aux, prn); } for (int32_t i = 0; i < GPS_L2_M_CODE_LENGTH_CHIPS; i++) { - _dest[i] = 1.0 - 2.0 * static_cast(_code[i]); + dest[i] = 1.0 - 2.0 * static_cast(code_aux[i]); } } @@ -75,37 +75,37 @@ void gps_l2c_m_code_gen_float(own::span _dest, uint32_t _prn) /* * Generates complex GPS L2C M code for the desired SV ID and sampled to specific sampling frequency */ -void gps_l2c_m_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs) +void gps_l2c_m_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq) { - constexpr int32_t _codeLength = GPS_L2_M_CODE_LENGTH_CHIPS; - constexpr float _tc = 1.0F / static_cast(GPS_L2_M_CODE_RATE_CPS); // L2C chip period in sec + constexpr int32_t codeLength = GPS_L2_M_CODE_LENGTH_CHIPS; + constexpr float tc = 1.0F / static_cast(GPS_L2_M_CODE_RATE_CPS); // L2C chip period in sec - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(GPS_L2_M_CODE_RATE_CPS) / static_cast(_codeLength))); - const float _ts = 1.0F / static_cast(_fs); // Sampling period in sec - int32_t _codeValueIndex; + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(GPS_L2_M_CODE_RATE_CPS) / static_cast(codeLength))); + const float ts = 1.0F / static_cast(sampling_freq); // Sampling period in sec + int32_t codeValueIndex; - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - gps_l2c_m_code(_code, _prn); + gps_l2c_m_code(code_aux, prn); } - for (int32_t i = 0; i < _samplesPerCode; i++) + for (int32_t i = 0; i < samplesPerCode; i++) { // === Digitizing ================================================== // --- Make index array to read L2C code values -------------------- - _codeValueIndex = std::ceil((_ts * (static_cast(i) + 1.0F)) / _tc) - 1; + codeValueIndex = std::ceil((ts * (static_cast(i) + 1.0F)) / tc) - 1; // --- Make the digitized version of the L2C code ------------------ - if (i == _samplesPerCode - 1) + if (i == samplesPerCode - 1) { - // --- Correct the last index (due to number rounding issues) ----------- - _dest[i] = std::complex(0.0, 1.0F - 2.0F * _code[_codeLength - 1]); + // Correct the last index (due to number rounding issues) + dest[i] = std::complex(0.0, 1.0F - 2.0F * code_aux[codeLength - 1]); } else { - _dest[i] = std::complex(0.0, 1.0F - 2.0F * _code[_codeValueIndex]); // repeat the chip -> upsample + dest[i] = std::complex(0.0, 1.0F - 2.0F * code_aux[codeValueIndex]); // repeat the chip -> upsample } } } diff --git a/src/algorithms/libs/gps_l2c_signal_replica.h b/src/algorithms/libs/gps_l2c_signal_replica.h index 6c0e65b69..e2fd9aa3b 100644 --- a/src/algorithms/libs/gps_l2c_signal_replica.h +++ b/src/algorithms/libs/gps_l2c_signal_replica.h @@ -38,11 +38,13 @@ namespace own = gsl; //! Generates complex GPS L2C M code for the desired SV ID -void gps_l2c_m_code_gen_complex(own::span> _dest, uint32_t _prn); -void gps_l2c_m_code_gen_float(own::span _dest, uint32_t _prn); +void gps_l2c_m_code_gen_complex(own::span> dest, uint32_t prn); + +//! Generates float GPS L2C M code for the desired SV ID +void gps_l2c_m_code_gen_float(own::span dest, uint32_t prn); //! Generates complex GPS L2C M code for the desired SV ID, and sampled to specific sampling frequency -void gps_l2c_m_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs); +void gps_l2c_m_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq); /** \} */ diff --git a/src/algorithms/libs/gps_l5_signal_replica.cc b/src/algorithms/libs/gps_l5_signal_replica.cc index 3a397750e..67fdcd020 100644 --- a/src/algorithms/libs/gps_l5_signal_replica.cc +++ b/src/algorithms/libs/gps_l5_signal_replica.cc @@ -120,7 +120,7 @@ std::deque make_l5q_xb() } -void make_l5i(own::span _dest, int32_t prn) +void make_l5i(own::span dest, int32_t prn) { const int32_t xb_offset = GPS_L5I_INIT_REG[prn]; @@ -135,12 +135,12 @@ void make_l5i(own::span _dest, int32_t prn) for (int32_t n = 0; n < GPS_L5I_CODE_LENGTH_CHIPS; n++) { - _dest[n] = xa[n] xor xb_shift[n]; + dest[n] = xa[n] xor xb_shift[n]; } } -void make_l5q(own::span _dest, int32_t prn) +void make_l5q(own::span dest, int32_t prn) { const int32_t xb_offset = GPS_L5Q_INIT_REG[prn]; @@ -155,37 +155,37 @@ void make_l5q(own::span _dest, int32_t prn) for (int32_t n = 0; n < GPS_L5Q_CODE_LENGTH_CHIPS; n++) { - _dest[n] = xa[n] xor xb_shift[n]; + dest[n] = xa[n] xor xb_shift[n]; } } -void gps_l5i_code_gen_complex(own::span> _dest, uint32_t _prn) +void gps_l5i_code_gen_complex(own::span> dest, uint32_t prn) { - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - make_l5i(_code, _prn - 1); + make_l5i(code_aux, prn - 1); } for (int32_t i = 0; i < GPS_L5I_CODE_LENGTH_CHIPS; i++) { - _dest[i] = std::complex(1.0F - 2.0F * static_cast(_code[i]), 0.0); + dest[i] = std::complex(1.0F - 2.0F * static_cast(code_aux[i]), 0.0); } } -void gps_l5i_code_gen_float(own::span _dest, uint32_t _prn) +void gps_l5i_code_gen_float(own::span dest, uint32_t prn) { - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - make_l5i(_code, _prn - 1); + make_l5i(code_aux, prn - 1); } for (int32_t i = 0; i < GPS_L5I_CODE_LENGTH_CHIPS; i++) { - _dest[i] = 1.0F - 2.0F * static_cast(_code[i]); + dest[i] = 1.0F - 2.0F * static_cast(code_aux[i]); } } @@ -193,68 +193,68 @@ void gps_l5i_code_gen_float(own::span _dest, uint32_t _prn) /* * Generates complex GPS L5i code for the desired SV ID and sampled to specific sampling frequency */ -void gps_l5i_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs) +void gps_l5i_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq) { - constexpr int32_t _codeLength = GPS_L5I_CODE_LENGTH_CHIPS; - constexpr float _tc = 1.0 / static_cast(GPS_L5I_CODE_RATE_CPS); // L5I primary chip period in sec + constexpr int32_t codeLength = GPS_L5I_CODE_LENGTH_CHIPS; + constexpr float tc = 1.0 / static_cast(GPS_L5I_CODE_RATE_CPS); // L5I primary chip period in sec - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(GPS_L5I_CODE_RATE_CPS) / static_cast(_codeLength))); - const float _ts = 1.0F / static_cast(_fs); // Sampling period in sec - int32_t _codeValueIndex; + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(GPS_L5I_CODE_RATE_CPS) / static_cast(codeLength))); + const float ts = 1.0F / static_cast(sampling_freq); // Sampling period in sec + int32_t codeValueIndex; - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - make_l5i(_code, _prn - 1); + make_l5i(code_aux, prn - 1); } - for (int32_t i = 0; i < _samplesPerCode; i++) + for (int32_t i = 0; i < samplesPerCode; i++) { // === Digitizing ================================================== // --- Make index array to read L5 code values --------------------- - _codeValueIndex = static_cast(std::ceil(_ts * static_cast(i + 1.0F) / _tc)) - 1; + codeValueIndex = static_cast(std::ceil(ts * static_cast(i + 1.0F) / tc)) - 1; // --- Make the digitized version of the L5I code ------------------ - if (i == _samplesPerCode - 1) + if (i == samplesPerCode - 1) { // --- Correct the last index (due to number rounding issues) ----------- - _dest[i] = std::complex(1.0F - 2.0F * _code[_codeLength - 1], 0.0); + dest[i] = std::complex(1.0F - 2.0F * code_aux[codeLength - 1], 0.0); } else { - _dest[i] = std::complex(1.0F - 2.0F * _code[_codeValueIndex], 0.0); // repeat the chip -> upsample + dest[i] = std::complex(1.0F - 2.0F * code_aux[codeValueIndex], 0.0); // repeat the chip -> upsample } } } -void gps_l5q_code_gen_complex(own::span> _dest, uint32_t _prn) +void gps_l5q_code_gen_complex(own::span> dest, uint32_t prn) { - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - make_l5q(_code, _prn - 1); + make_l5q(code_aux, prn - 1); } for (int32_t i = 0; i < GPS_L5Q_CODE_LENGTH_CHIPS; i++) { - _dest[i] = std::complex(0.0, 1.0F - 2.0F * static_cast(_code[i])); + dest[i] = std::complex(0.0, 1.0F - 2.0F * static_cast(code_aux[i])); } } -void gps_l5q_code_gen_float(own::span _dest, uint32_t _prn) +void gps_l5q_code_gen_float(own::span dest, uint32_t prn) { - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - make_l5q(_code, _prn - 1); + make_l5q(code_aux, prn - 1); } for (int32_t i = 0; i < GPS_L5Q_CODE_LENGTH_CHIPS; i++) { - _dest[i] = 1.0 - 2.0 * static_cast(_code[i]); + dest[i] = 1.0 - 2.0 * static_cast(code_aux[i]); } } @@ -262,40 +262,40 @@ void gps_l5q_code_gen_float(own::span _dest, uint32_t _prn) /* * Generates complex GPS L5Q code for the desired SV ID and sampled to specific sampling frequency */ -void gps_l5q_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs) +void gps_l5q_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq) { - std::array _code{}; - if (_prn > 0 and _prn < 51) + std::array code_aux{}; + if (prn > 0 and prn < 51) { - make_l5q(_code, _prn - 1); + make_l5q(code_aux, prn - 1); } - int32_t _codeValueIndex; - constexpr int32_t _codeLength = GPS_L5Q_CODE_LENGTH_CHIPS; + int32_t codeValueIndex; + constexpr int32_t codeLength = GPS_L5Q_CODE_LENGTH_CHIPS; // --- Find number of samples per spreading code --------------------------- - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(GPS_L5Q_CODE_RATE_CPS) / static_cast(_codeLength))); + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(GPS_L5Q_CODE_RATE_CPS) / static_cast(codeLength))); // --- Find time constants ------------------------------------------------- - const float _ts = 1.0F / static_cast(_fs); // Sampling period in sec - constexpr float _tc = 1.0F / static_cast(GPS_L5Q_CODE_RATE_CPS); // L5Q chip period in sec + const float ts = 1.0F / static_cast(sampling_freq); // Sampling period in sec + constexpr float tc = 1.0F / static_cast(GPS_L5Q_CODE_RATE_CPS); // L5Q chip period in sec - for (int32_t i = 0; i < _samplesPerCode; i++) + for (int32_t i = 0; i < samplesPerCode; i++) { // === Digitizing ================================================== // --- Make index array to read L5 code values --------------------- - _codeValueIndex = static_cast(std::ceil(_ts * static_cast(i + 1.0F) / _tc)) - 1; + codeValueIndex = static_cast(std::ceil(ts * static_cast(i + 1.0F) / tc)) - 1; // --- Make the digitized version of the L5Q code ------------------ - if (i == _samplesPerCode - 1) + if (i == samplesPerCode - 1) { // --- Correct the last index (due to number rounding issues) ----------- - _dest[i] = std::complex(0.0, 1.0F - 2.0F * _code[_codeLength - 1]); + dest[i] = std::complex(0.0, 1.0F - 2.0F * code_aux[codeLength - 1]); } else { - _dest[i] = std::complex(0.0, 1.0F - 2.0F * _code[_codeValueIndex]); // repeat the chip -> upsample + dest[i] = std::complex(0.0, 1.0F - 2.0F * code_aux[codeValueIndex]); // repeat the chip -> upsample } } } diff --git a/src/algorithms/libs/gps_l5_signal_replica.h b/src/algorithms/libs/gps_l5_signal_replica.h index ab0fa81e6..5220cbd66 100644 --- a/src/algorithms/libs/gps_l5_signal_replica.h +++ b/src/algorithms/libs/gps_l5_signal_replica.h @@ -38,22 +38,22 @@ namespace own = gsl; //! Generates complex GPS L5I code for the desired SV ID -void gps_l5i_code_gen_complex(own::span> _dest, uint32_t _prn); +void gps_l5i_code_gen_complex(own::span> dest, uint32_t prn); //! Generates real GPS L5I code for the desired SV ID -void gps_l5i_code_gen_float(own::span _dest, uint32_t _prn); +void gps_l5i_code_gen_float(own::span dest, uint32_t prn); //! Generates complex GPS L5Q code for the desired SV ID -void gps_l5q_code_gen_complex(own::span> _dest, uint32_t _prn); +void gps_l5q_code_gen_complex(own::span> dest, uint32_t prn); //! Generates real GPS L5Q code for the desired SV ID -void gps_l5q_code_gen_float(own::span _dest, uint32_t _prn); +void gps_l5q_code_gen_float(own::span dest, uint32_t prn); //! Generates complex GPS L5I code for the desired SV ID, and sampled to specific sampling frequency -void gps_l5i_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs); +void gps_l5i_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq); //! Generates complex GPS L5Q code for the desired SV ID, and sampled to specific sampling frequency -void gps_l5q_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs); +void gps_l5q_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq); /** \} */ diff --git a/src/algorithms/libs/gps_sdr_signal_replica.cc b/src/algorithms/libs/gps_sdr_signal_replica.cc index 5eb9e4150..6a78b79f7 100644 --- a/src/algorithms/libs/gps_sdr_signal_replica.cc +++ b/src/algorithms/libs/gps_sdr_signal_replica.cc @@ -25,11 +25,11 @@ const auto AUX_CEIL = [](float x) { return static_cast(static_cast((x) + 1)); }; -void gps_l1_ca_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_shift) +void gps_l1_ca_code_gen_int(own::span dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 1023; - std::bitset<_code_length> G1{}; - std::bitset<_code_length> G2{}; + constexpr uint32_t code_length = 1023; + std::bitset G1{}; + std::bitset G2{}; auto G1_register = std::bitset<10>{}.set(); // All true auto G2_register = std::bitset<10>{}.set(); // All true uint32_t lcv; @@ -47,13 +47,13 @@ void gps_l1_ca_code_gen_int(own::span _dest, int32_t _prn, uint32_t _ch 355, 1012, 176, 603, 130, 359, 595, 68, 386 /*PRN138*/}; // compute delay array index for given PRN number - if (120 <= _prn && _prn <= 138) + if (120 <= prn && prn <= 138) { - prn_idx = _prn - 88; // SBAS PRNs are at array indices 31 to 50 (offset: -120+33-1 =-88) + prn_idx = prn - 88; // SBAS PRNs are at array indices 31 to 50 (offset: -120+33-1 =-88) } else { - prn_idx = _prn - 1; + prn_idx = prn - 1; } // A simple error check @@ -63,7 +63,7 @@ void gps_l1_ca_code_gen_int(own::span _dest, int32_t _prn, uint32_t _ch } // Generate G1 & G2 Register - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { G1[lcv] = G1_register[0]; G2[lcv] = G2_register[0]; @@ -82,52 +82,52 @@ void gps_l1_ca_code_gen_int(own::span _dest, int32_t _prn, uint32_t _ch } // Set the delay - delay = _code_length - delays[prn_idx]; - delay += _chip_shift; - delay %= _code_length; + delay = code_length - delays[prn_idx]; + delay += chip_shift; + delay %= code_length; // Generate PRN from G1 and G2 Registers - for (lcv = 0; lcv < _code_length; lcv++) + for (lcv = 0; lcv < code_length; lcv++) { - aux = G1[(lcv + _chip_shift) % _code_length] xor G2[delay]; + aux = G1[(lcv + chip_shift) % code_length] xor G2[delay]; if (aux == true) { - _dest[lcv] = 1; + dest[lcv] = 1; } else { - _dest[lcv] = -1; + dest[lcv] = -1; } delay++; - delay %= _code_length; + delay %= code_length; } } -void gps_l1_ca_code_gen_float(own::span _dest, int32_t _prn, uint32_t _chip_shift) +void gps_l1_ca_code_gen_float(own::span dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 1023; - std::array ca_code_int{}; + constexpr uint32_t code_length = 1023; + std::array ca_code_int{}; - gps_l1_ca_code_gen_int(ca_code_int, _prn, _chip_shift); + gps_l1_ca_code_gen_int(ca_code_int, prn, chip_shift); - for (uint32_t ii = 0; ii < _code_length; ++ii) + for (uint32_t ii = 0; ii < code_length; ++ii) { - _dest[ii] = static_cast(ca_code_int[ii]); + dest[ii] = static_cast(ca_code_int[ii]); } } -void gps_l1_ca_code_gen_complex(own::span> _dest, int32_t _prn, uint32_t _chip_shift) +void gps_l1_ca_code_gen_complex(own::span> dest, int32_t prn, uint32_t chip_shift) { - constexpr uint32_t _code_length = 1023; - std::array ca_code_int{}; + constexpr uint32_t code_length = 1023; + std::array ca_code_int{}; - gps_l1_ca_code_gen_int(ca_code_int, _prn, _chip_shift); + gps_l1_ca_code_gen_int(ca_code_int, prn, chip_shift); - for (uint32_t ii = 0; ii < _code_length; ++ii) + for (uint32_t ii = 0; ii < code_length; ++ii) { - _dest[ii] = std::complex(0.0F, static_cast(ca_code_int[ii])); + dest[ii] = std::complex(0.0F, static_cast(ca_code_int[ii])); } } @@ -136,22 +136,22 @@ void gps_l1_ca_code_gen_complex(own::span> _dest, int32_t _p * Generates complex GPS L1 C/A code for the desired SV ID and sampled to specific sampling frequency * NOTICE: the number of samples is rounded towards zero (integer truncation) */ -void gps_l1_ca_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs, uint32_t _chip_shift) +void gps_l1_ca_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift) { // This function is based on the GNU software GPS for MATLAB in the Kay Borre book - constexpr int32_t _codeFreqBasis = 1023000; // Hz - constexpr int32_t _codeLength = 1023; - constexpr float _tc = 1.0F / static_cast(_codeFreqBasis); // C/A chip period in sec + constexpr int32_t codeFreqBasis = 1023000; // chips per second + constexpr int32_t codeLength = 1023; + constexpr float tc = 1.0F / static_cast(codeFreqBasis); // C/A chip period in sec - const auto _samplesPerCode = static_cast(static_cast(_fs) / (static_cast(_codeFreqBasis) / static_cast(_codeLength))); - const float _ts = 1.0F / static_cast(_fs); // Sampling period in sec - std::array, 1023> _code{}; - int32_t _codeValueIndex; + const auto samplesPerCode = static_cast(static_cast(sampling_freq) / (static_cast(codeFreqBasis) / static_cast(codeLength))); + const float ts = 1.0F / static_cast(sampling_freq); // Sampling period in sec + std::array, 1023> code_aux{}; + int32_t codeValueIndex; float aux; - gps_l1_ca_code_gen_complex(_code, _prn, _chip_shift); // generate C/A code 1 sample per chip + gps_l1_ca_code_gen_complex(code_aux, prn, chip_shift); // generate C/A code 1 sample per chip - for (int32_t i = 0; i < _samplesPerCode; i++) + for (int32_t i = 0; i < samplesPerCode; i++) { // === Digitizing ================================================== @@ -160,20 +160,20 @@ void gps_l1_ca_code_gen_complex_sampled(own::span> _dest, ui // number of samples per millisecond (because one C/A code period is one // millisecond). - aux = (_ts * (static_cast(i) + 1)) / _tc; - _codeValueIndex = AUX_CEIL(aux) - 1; + aux = (ts * (static_cast(i) + 1)) / tc; + codeValueIndex = AUX_CEIL(aux) - 1; // --- Make the digitized version of the C/A code ------------------- // The "upsampled" code is made by selecting values form the CA code // chip array (caCode) for the time instances of each sample. - if (i == _samplesPerCode - 1) + if (i == samplesPerCode - 1) { // --- Correct the last index (due to number rounding issues) - _dest[i] = _code[_codeLength - 1]; + dest[i] = code_aux[codeLength - 1]; } else { - _dest[i] = _code[_codeValueIndex]; // repeat the chip -> upsample + dest[i] = code_aux[codeValueIndex]; // repeat the chip -> upsample } } } diff --git a/src/algorithms/libs/gps_sdr_signal_replica.h b/src/algorithms/libs/gps_sdr_signal_replica.h index 652bfafe9..243d1ce07 100644 --- a/src/algorithms/libs/gps_sdr_signal_replica.h +++ b/src/algorithms/libs/gps_sdr_signal_replica.h @@ -39,19 +39,16 @@ namespace own = gsl; //! Generates int GPS L1 C/A code for the desired SV ID and code shift -void gps_l1_ca_code_gen_int(own::span _dest, int32_t _prn, uint32_t _chip_shift); +void gps_l1_ca_code_gen_int(own::span dest, int32_t prn, uint32_t chip_shift); //! Generates float GPS L1 C/A code for the desired SV ID and code shift -void gps_l1_ca_code_gen_float(own::span _dest, int32_t _prn, uint32_t _chip_shift); - -//! Generates complex GPS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency -void gps_l1_ca_code_gen_complex(own::span> _dest, int32_t _prn, uint32_t _chip_shift); - -//! Generates N complex GPS L1 C/A codes for the desired SV ID and code shift -void gps_l1_ca_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs, uint32_t _chip_shift, uint32_t _ncodes); +void gps_l1_ca_code_gen_float(own::span dest, int32_t prn, uint32_t chip_shift); //! Generates complex GPS L1 C/A code for the desired SV ID and code shift -void gps_l1_ca_code_gen_complex_sampled(own::span> _dest, uint32_t _prn, int32_t _fs, uint32_t _chip_shift); +void gps_l1_ca_code_gen_complex(own::span> dest, int32_t prn, uint32_t chip_shift); + +//! Generates complex GPS L1 C/A code for the desired SV ID and code shift, and sampled to specific sampling frequency +void gps_l1_ca_code_gen_complex_sampled(own::span> dest, uint32_t prn, int32_t sampling_freq, uint32_t chip_shift); /** \} */ diff --git a/src/algorithms/telemetry_decoder/libs/libswiftcnav/cnav_msg.c b/src/algorithms/telemetry_decoder/libs/libswiftcnav/cnav_msg.c index e19bcead8..33eade03f 100644 --- a/src/algorithms/telemetry_decoder/libs/libswiftcnav/cnav_msg.c +++ b/src/algorithms/telemetry_decoder/libs/libswiftcnav/cnav_msg.c @@ -71,7 +71,7 @@ const uint32_t GPS_CNAV_PREAMBLE2 = 0x74U; /* (0b01110100u) */ * * \private */ -static uint32_t _cnav_compute_crc(cnav_v27_part_t *part) +static uint32_t cnav_compute_crc_(cnav_v27_part_t *part) { uint32_t crc = crc24q_bits(0, part->decoded, GPS_CNAV_MSG_DATA_LENGTH, part->invert); @@ -90,7 +90,7 @@ static uint32_t _cnav_compute_crc(cnav_v27_part_t *part) * * \private */ -static uint32_t _cnav_extract_crc(const cnav_v27_part_t *part) +static uint32_t cnav_extract_crc_(const cnav_v27_part_t *part) { uint32_t crc = getbitu(part->decoded, GPS_CNAV_MSG_DATA_LENGTH, GPS_CNAV_MSG_CRC_LENGTH); @@ -116,7 +116,7 @@ static uint32_t _cnav_extract_crc(const cnav_v27_part_t *part) * * \private */ -static void _cnav_rescan_preamble(cnav_v27_part_t *part) +static void cnav_rescan_preamble_(cnav_v27_part_t *part) { part->preamble_seen = false; @@ -161,7 +161,7 @@ static void _cnav_rescan_preamble(cnav_v27_part_t *part) * * \private */ -static void _cnav_add_symbol(cnav_v27_part_t *part, uint8_t ch) +static void cnav_add_symbol_(cnav_v27_part_t *part, uint8_t ch) { part->symbols[part->n_symbols++] = ch; @@ -224,14 +224,14 @@ static void _cnav_add_symbol(cnav_v27_part_t *part, uint8_t ch) if (!part->preamble_seen) { /* Rescan for preamble if possible. The first bit is ignored. */ - _cnav_rescan_preamble(part); + cnav_rescan_preamble_(part); } if (part->preamble_seen && GPS_CNAV_MSG_LENGTH <= part->n_decoded) { /* We have collected 300 bits starting from message preamble. Now try * to compute CRC-24Q */ - const uint32_t crc = _cnav_compute_crc(part); - const uint32_t crc2 = _cnav_extract_crc(part); + const uint32_t crc = cnav_compute_crc_(part); + const uint32_t crc2 = cnav_extract_crc_(part); if (part->message_lock) { @@ -292,7 +292,7 @@ static void _cnav_add_symbol(cnav_v27_part_t *part, uint8_t ch) * * \return None */ -static void _cnav_msg_invert(cnav_v27_part_t *part) +static void cnav_msg_invert_(cnav_v27_part_t *part) { size_t i = 0; for (i = 0; i < sizeof(part->decoded); i++) @@ -322,7 +322,7 @@ static void _cnav_msg_invert(cnav_v27_part_t *part) * * \private */ -static bool _cnav_msg_decode(cnav_v27_part_t *part, cnav_msg_t *msg, uint32_t *delay) +static bool cnav_msg_decode_(cnav_v27_part_t *part, cnav_msg_t *msg, uint32_t *delay) { bool res = false; if (GPS_CNAV_MSG_LENGTH <= part->n_decoded) @@ -332,7 +332,7 @@ static bool _cnav_msg_decode(cnav_v27_part_t *part, cnav_msg_t *msg, uint32_t *d /* CRC is OK */ if (part->invert) { - _cnav_msg_invert(part); + cnav_msg_invert_(part); } msg->prn = getbitu(part->decoded, 8, 6); @@ -347,7 +347,7 @@ static bool _cnav_msg_decode(cnav_v27_part_t *part, cnav_msg_t *msg, uint32_t *d if (part->invert) { - _cnav_msg_invert(part); + cnav_msg_invert_(part); } res = true; } @@ -388,7 +388,7 @@ void cnav_msg_decoder_init(cnav_msg_decoder_t *dec) 0); dec->part1.init = true; dec->part2.init = true; - _cnav_add_symbol(&dec->part2, 0x80); + cnav_add_symbol_(&dec->part2, 0x80); } /** @@ -419,22 +419,22 @@ bool cnav_msg_decoder_add_symbol(cnav_msg_decoder_t *dec, cnav_msg_t *msg, uint32_t *pdelay) { - _cnav_add_symbol(&dec->part1, symbol); - _cnav_add_symbol(&dec->part2, symbol); + cnav_add_symbol_(&dec->part1, symbol); + cnav_add_symbol_(&dec->part2, symbol); if (dec->part1.message_lock) { /* Flush data in decoder. */ dec->part2.n_decoded = 0; dec->part2.n_symbols = 0; - return _cnav_msg_decode(&dec->part1, msg, pdelay); + return cnav_msg_decode_(&dec->part1, msg, pdelay); } if (dec->part2.message_lock) { /* Flush data in decoder. */ dec->part1.n_decoded = 0; dec->part1.n_symbols = 0; - return _cnav_msg_decode(&dec->part2, msg, pdelay); + return cnav_msg_decode_(&dec->part2, msg, pdelay); } return false; diff --git a/src/tests/unit-tests/arithmetic/code_generation_test.cc b/src/tests/unit-tests/arithmetic/code_generation_test.cc index 38d241dd9..8941bf612 100644 --- a/src/tests/unit-tests/arithmetic/code_generation_test.cc +++ b/src/tests/unit-tests/arithmetic/code_generation_test.cc @@ -56,10 +56,10 @@ TEST(CodeGenerationTest, CodeGenGPSL1SampledTest) signed int _prn = 1; unsigned int _chip_shift = 4; double _fs = 8000000.0; - const signed int _codeFreqBasis = 1023000; // Hz - const signed int _codeLength = 1023; - int _samplesPerCode = round(_fs / static_cast(_codeFreqBasis / _codeLength)); - std::vector> _dest(_samplesPerCode); + const signed int codeFreqBasis = 1023000; // Hz + const signed int codeLength = 1023; + int samplesPerCode = round(_fs / static_cast(codeFreqBasis / codeLength)); + std::vector> _dest(samplesPerCode); int iterations = 1000; @@ -83,10 +83,10 @@ TEST(CodeGenerationTest, ComplexConjugateTest) { double _fs = 8000000.0; double _f = 4000.0; - const signed int _codeFreqBasis = 1023000; // Hz - const signed int _codeLength = 1023; - int _samplesPerCode = round(_fs / static_cast(_codeFreqBasis / _codeLength)); - std::vector> _dest(_samplesPerCode); + const signed int codeFreqBasis = 1023000; // Hz + const signed int codeLength = 1023; + int samplesPerCode = round(_fs / static_cast(codeFreqBasis / codeLength)); + std::vector> _dest(samplesPerCode); int iterations = 1000;