mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-10-31 23:26:22 +00:00
Code Issues Releases Wiki Activity

Improve value reading in navigation message decoding

Browse Source 
More concise code, less branching, fix some Wshorten-64-to-32 warnings
This commit is contained in:
Carles Fernandez 2024-01-13 12:07:06 +01:00
parent 5d5cbc05eb
commit 3697bc1dce
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
6 changed files with 61 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
src/core/system_parameters/beidou_dnav_navigation_message.cc
View File

@ -21,7 +21,7 @@
#include <cmath> // for cos, sin, fmod, sqrt, atan2, fabs, floor #include <cmath> // for cos, sin, fmod, sqrt, atan2, fabs, floor
#include <iostream> // for string, operator<<, cout, ostream #include <iostream> // for string, operator<<, cout, ostream
#include <limits> // for std::numeric_limits #include <limits> // for std::numeric_limits
#include <numeric> // for accumulate
Beidou_Dnav_Navigation_Message::Beidou_Dnav_Navigation_Message() Beidou_Dnav_Navigation_Message::Beidou_Dnav_Navigation_Message()
{ {
@ -30,9 +30,6 @@ Beidou_Dnav_Navigation_Message::Beidou_Dnav_Navigation_Message()
for (uint32_t i = 1; i < 64; i++) for (uint32_t i = 1; i < 64; i++)
{ {
satelliteBlock[i] = gnss_sat.what_block(_system, i); satelliteBlock[i] = gnss_sat.what_block(_system, i);
}
for (uint32_t i = 1; i < 64; i++)
{
almanacHealth[i] = 0; almanacHealth[i] = 0;
} }
} }
@ -48,16 +45,7 @@ bool Beidou_Dnav_Navigation_Message::read_navigation_bool(
const std::bitset<BEIDOU_DNAV_SUBFRAME_DATA_BITS>& bits, const std::bitset<BEIDOU_DNAV_SUBFRAME_DATA_BITS>& bits,
const std::vector<std::pair<int32_t, int32_t>>& parameter) const const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
bool value; bool value = bits[BEIDOU_DNAV_SUBFRAME_DATA_BITS - parameter[0].first];
if (bits[BEIDOU_DNAV_SUBFRAME_DATA_BITS - parameter[0].first] == 1)
{
value = true;
}
else
{
value = false;
}
return value; return value;
} }
@ -67,16 +55,11 @@ uint64_t Beidou_Dnav_Navigation_Message::read_navigation_unsigned(
const std::vector<std::pair<int32_t, int32_t>>& parameter) const const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
uint64_t value = 0ULL; uint64_t value = 0ULL;
const int32_t num_of_slices = parameter.size(); for (const auto& param : parameter)
for (int32_t i = 0; i < num_of_slices; i++)
{ {
for (int32_t j = 0; j < parameter[i].second; j++) for (int32_t j = 0; j < param.second; j++)
{ {
value <<= 1U; // shift left value = (value << 1U) | static_cast<uint64_t>(bits[BEIDOU_DNAV_SUBFRAME_DATA_BITS - param.first - j]);
if (bits[BEIDOU_DNAV_SUBFRAME_DATA_BITS - parameter[i].first - j] == 1)
{
value += 1U; // insert the bit
}
} }
} }
return value; return value;
@ -87,29 +70,12 @@ int64_t Beidou_Dnav_Navigation_Message::read_navigation_signed(
const std::bitset<BEIDOU_DNAV_SUBFRAME_DATA_BITS>& bits, const std::bitset<BEIDOU_DNAV_SUBFRAME_DATA_BITS>& bits,
const std::vector<std::pair<int32_t, int32_t>>& parameter) const const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
int64_t value = 0; int64_t value = bits[BEIDOU_DNAV_SUBFRAME_DATA_BITS - parameter[0].first] ? -1LL : 0LL;
const int32_t num_of_slices = parameter.size(); for (const auto& param : parameter)
// read the MSB and perform the sign extension
if (bits[BEIDOU_DNAV_SUBFRAME_DATA_BITS - parameter[0].first] == 1)
{ {
value ^= 0xFFFFFFFFFFFFFFFF; // 64 bits variable for (int32_t j = 0; j < param.second; j++)
}
else
{ {
value &= 0; value = (value << 1) | static_cast<int64_t>(bits[BEIDOU_DNAV_SUBFRAME_DATA_BITS - param.first - j]);
}
for (int32_t i = 0; i < num_of_slices; i++)
{
for (int32_t j = 0; j < parameter[i].second; j++)
{
value *= 2; // shift left the signed integer
value &= 0xFFFFFFFFFFFFFFFE; // reset the corresponding bit (for the 64 bits variable)
if (bits[BEIDOU_DNAV_SUBFRAME_DATA_BITS - parameter[i].first - j] == 1)
{
value += 1; // insert the bit
}
} }
} }
return value; return value;

35
src/core/system_parameters/galileo_fnav_message.cc
View File

@ -282,16 +282,12 @@ void Galileo_Fnav_Message::decode_page(const std::string& data)
uint64_t Galileo_Fnav_Message::read_navigation_unsigned(const std::bitset<GALILEO_FNAV_DATA_FRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const uint64_t Galileo_Fnav_Message::read_navigation_unsigned(const std::bitset<GALILEO_FNAV_DATA_FRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
uint64_t value = 0ULL; uint64_t value = 0ULL;
const int num_of_slices = parameter.size(); for (const auto& p : parameter)
for (int i = 0; i < num_of_slices; i++)
{ {
for (int j = 0; j < parameter[i].second; j++) for (int j = 0; j < p.second; j++)
{ {
value <<= 1U; // shift left value <<= 1U; // shift left
if (static_cast<int>(bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[i].first - j]) == 1) value |= static_cast<uint64_t>(bits[GALILEO_FNAV_DATA_FRAME_BITS - p.first - j]);
{
value += 1; // insert the bit
}
} }
} }
return value; return value;
@ -300,29 +296,12 @@ uint64_t Galileo_Fnav_Message::read_navigation_unsigned(const std::bitset<GALILE
int64_t Galileo_Fnav_Message::read_navigation_signed(const std::bitset<GALILEO_FNAV_DATA_FRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const int64_t Galileo_Fnav_Message::read_navigation_signed(const std::bitset<GALILEO_FNAV_DATA_FRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
int64_t value = 0LL; int64_t value = (bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[0].first] == 1) ? -1LL : 0LL;
const int num_of_slices = parameter.size(); for (const auto& p : parameter)
// read the MSB and perform the sign extension
if (static_cast<int>(bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[0].first]) == 1)
{ {
value ^= 0x0FFFFFFFFFFFFFFF; // 64 bits variable for (int32_t j = 0; j < p.second; j++)
}
else
{ {
value &= 0; value = (value << 1) | static_cast<int64_t>(bits[GALILEO_FNAV_DATA_FRAME_BITS - p.first - j]);
}
for (int i = 0; i < num_of_slices; i++)
{
for (int j = 0; j < parameter[i].second; j++)
{
value <<= 1; // shift left
value &= 0xFFFFFFFFFFFFFFFE; // reset the corresponding bit (for the 64 bits variable)
if (static_cast<int>(bits[GALILEO_FNAV_DATA_FRAME_BITS - parameter[i].first - j]) == 1)
{
value += 1; // insert the bit
}
} }
} }
return value; return value;

67
src/core/system_parameters/galileo_inav_message.cc
View File

@ -74,16 +74,12 @@ bool Galileo_Inav_Message::CRC_test(const std::bitset<GALILEO_DATA_FRAME_BITS>&
uint64_t Galileo_Inav_Message::read_navigation_unsigned(const std::bitset<GALILEO_DATA_JK_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const uint64_t Galileo_Inav_Message::read_navigation_unsigned(const std::bitset<GALILEO_DATA_JK_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
uint64_t value = 0ULL; uint64_t value = 0ULL;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
for (int32_t i = 0; i < num_of_slices; i++)
{ {
for (int32_t j = 0; j < parameter[i].second; j++) for (int j = 0; j < p.second; j++)
{ {
value <<= 1U; // shift left value <<= 1U; // shift left
if (static_cast<int>(bits[GALILEO_DATA_JK_BITS - parameter[i].first - j]) == 1) value |= static_cast<uint64_t>(bits[GALILEO_DATA_JK_BITS - p.first - j]);
{
value += 1; // insert the bit
}
} }
} }
return value; return value;
@ -93,16 +89,12 @@ uint64_t Galileo_Inav_Message::read_navigation_unsigned(const std::bitset<GALILE
uint8_t Galileo_Inav_Message::read_octet_unsigned(const std::bitset<GALILEO_DATA_JK_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const uint8_t Galileo_Inav_Message::read_octet_unsigned(const std::bitset<GALILEO_DATA_JK_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
uint8_t value = 0; uint8_t value = 0;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
for (int32_t i = 0; i < num_of_slices; i++)
{ {
for (int32_t j = 0; j < parameter[i].second; j++) for (int j = 0; j < p.second; j++)
{ {
value <<= 1; // shift left value <<= 1; // shift left
if (static_cast<int>(bits[GALILEO_DATA_JK_BITS - parameter[i].first - j]) == 1) value |= static_cast<uint8_t>(bits[GALILEO_DATA_JK_BITS - p.first - j]);
{
value += 1; // insert the bit
}
} }
} }
return value; return value;
@ -112,16 +104,12 @@ uint8_t Galileo_Inav_Message::read_octet_unsigned(const std::bitset<GALILEO_DATA
uint64_t Galileo_Inav_Message::read_page_type_unsigned(const std::bitset<GALILEO_PAGE_TYPE_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const uint64_t Galileo_Inav_Message::read_page_type_unsigned(const std::bitset<GALILEO_PAGE_TYPE_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
uint64_t value = 0ULL; uint64_t value = 0ULL;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
for (int32_t i = 0; i < num_of_slices; i++)
{ {
for (int32_t j = 0; j < parameter[i].second; j++) for (int j = 0; j < p.second; j++)
{ {
value <<= 1U; // shift left value <<= 1; // shift left
if (static_cast<int>(bits[GALILEO_PAGE_TYPE_BITS - parameter[i].first - j]) == 1) value |= static_cast<uint64_t>(bits[GALILEO_PAGE_TYPE_BITS - p.first - j]);
{
value += 1ULL; // insert the bit
}
} }
} }
return value; return value;
@ -130,29 +118,12 @@ uint64_t Galileo_Inav_Message::read_page_type_unsigned(const std::bitset<GALILEO
int64_t Galileo_Inav_Message::read_navigation_signed(const std::bitset<GALILEO_DATA_JK_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const int64_t Galileo_Inav_Message::read_navigation_signed(const std::bitset<GALILEO_DATA_JK_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
int64_t value = 0LL; int64_t value = (bits[GALILEO_DATA_JK_BITS - parameter[0].first] == 1) ? -1LL : 0LL;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
// read the MSB and perform the sign extension
if (static_cast<int>(bits[GALILEO_DATA_JK_BITS - parameter[0].first]) == 1)
{ {
value ^= 0xFFFFFFFFFFFFFFFFLL; // 64 bits variable for (int32_t j = 0; j < p.second; j++)
}
else
{ {
value &= 0LL; value = (value << 1) | static_cast<int64_t>(bits[GALILEO_DATA_JK_BITS - p.first - j]);
}
for (int32_t i = 0; i < num_of_slices; i++)
{
for (int32_t j = 0; j < parameter[i].second; j++)
{
value *= 2; // shift left the signed integer
value &= 0xFFFFFFFFFFFFFFFE; // reset the corresponding bit (for the 64 bits variable)
if (static_cast<int>(bits[GALILEO_DATA_JK_BITS - parameter[i].first - j]) == 1)
{
value += 1LL; // insert the bit
}
} }
} }
return value; return value;
@ -161,15 +132,7 @@ int64_t Galileo_Inav_Message::read_navigation_signed(const std::bitset<GALILEO_D
bool Galileo_Inav_Message::read_navigation_bool(const std::bitset<GALILEO_DATA_JK_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const bool Galileo_Inav_Message::read_navigation_bool(const std::bitset<GALILEO_DATA_JK_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
bool value; bool value = bits[GALILEO_DATA_JK_BITS - parameter[0].first];
if (static_cast<int>(bits[GALILEO_DATA_JK_BITS - parameter[0].first]) == 1)
{
value = true;
}
else
{
value = false;
}
return value; return value;
} }

46
src/core/system_parameters/glonass_gnav_navigation_message.cc
View File

@ -156,16 +156,7 @@ bool Glonass_Gnav_Navigation_Message::CRC_test(std::bitset<GLONASS_GNAV_STRING_B
bool Glonass_Gnav_Navigation_Message::read_navigation_bool(const std::bitset<GLONASS_GNAV_STRING_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const bool Glonass_Gnav_Navigation_Message::read_navigation_bool(const std::bitset<GLONASS_GNAV_STRING_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
bool value; bool value = bits[GLONASS_GNAV_STRING_BITS - parameter[0].first];
if (bits[GLONASS_GNAV_STRING_BITS - parameter[0].first] == 1)
{
value = true;
}
else
{
value = false;
}
return value; return value;
} }
@ -173,16 +164,11 @@ bool Glonass_Gnav_Navigation_Message::read_navigation_bool(const std::bitset<GLO
uint64_t Glonass_Gnav_Navigation_Message::read_navigation_unsigned(const std::bitset<GLONASS_GNAV_STRING_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const uint64_t Glonass_Gnav_Navigation_Message::read_navigation_unsigned(const std::bitset<GLONASS_GNAV_STRING_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
uint64_t value = 0ULL; uint64_t value = 0ULL;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
for (int32_t i = 0; i < num_of_slices; i++)
{ {
for (int32_t j = 0; j < parameter[i].second; j++) for (int32_t j = 0; j < p.second; j++)
{ {
value <<= 1ULL; // shift left value = (value << 1U) | static_cast<uint64_t>(bits[GLONASS_GNAV_STRING_BITS - p.first - j]);
if (bits[GLONASS_GNAV_STRING_BITS - parameter[i].first - j] == 1)
{
value += 1ULL; // insert the bit
}
} }
} }
return value; return value;
@ -192,26 +178,14 @@ uint64_t Glonass_Gnav_Navigation_Message::read_navigation_unsigned(const std::bi
int64_t Glonass_Gnav_Navigation_Message::read_navigation_signed(const std::bitset<GLONASS_GNAV_STRING_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const int64_t Glonass_Gnav_Navigation_Message::read_navigation_signed(const std::bitset<GLONASS_GNAV_STRING_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
int64_t value = 0LL; int64_t value = 0LL;
int64_t sign = 0LL; int64_t sign = (bits[GLONASS_GNAV_STRING_BITS - parameter[0].first] == 1) ? -1LL : 1LL;
const int32_t num_of_slices = parameter.size();
// read the MSB and perform the sign extension // const int32_t num_of_slices = parameter.size();
if (bits[GLONASS_GNAV_STRING_BITS - parameter[0].first] == 1) for (const auto& p : parameter)
{ {
sign = -1LL; for (int32_t j = 1; j < p.second; j++)
}
else
{ {
sign = 1LL; value = (value << 1) + bits[GLONASS_GNAV_STRING_BITS - p.first - j];
}
for (int32_t i = 0; i < num_of_slices; i++)
{
for (int32_t j = 1; j < parameter[i].second; j++)
{
value <<= 1; // shift left
if (bits[GLONASS_GNAV_STRING_BITS - parameter[i].first - j] == 1)
{
value += 1LL; // insert the bit
}
} }
} }
return (sign * value); return (sign * value);

47
src/core/system_parameters/gps_cnav_navigation_message.cc
View File

@ -36,16 +36,7 @@ Gps_CNAV_Navigation_Message::Gps_CNAV_Navigation_Message()
bool Gps_CNAV_Navigation_Message::read_navigation_bool(const std::bitset<GPS_CNAV_DATA_PAGE_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const bool Gps_CNAV_Navigation_Message::read_navigation_bool(const std::bitset<GPS_CNAV_DATA_PAGE_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
bool value; bool value = bits[GPS_CNAV_DATA_PAGE_BITS - parameter[0].first];
if (static_cast<int>(bits[GPS_CNAV_DATA_PAGE_BITS - parameter[0].first]) == 1)
{
value = true;
}
else
{
value = false;
}
return value; return value;
} }
@ -53,16 +44,11 @@ bool Gps_CNAV_Navigation_Message::read_navigation_bool(const std::bitset<GPS_CNA
uint64_t Gps_CNAV_Navigation_Message::read_navigation_unsigned(const std::bitset<GPS_CNAV_DATA_PAGE_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const uint64_t Gps_CNAV_Navigation_Message::read_navigation_unsigned(const std::bitset<GPS_CNAV_DATA_PAGE_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
uint64_t value = 0ULL; uint64_t value = 0ULL;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
for (int32_t i = 0; i < num_of_slices; i++)
{ {
for (int32_t j = 0; j < parameter[i].second; j++) for (int32_t j = 0; j < p.second; j++)
{ {
value <<= 1ULL; // shift left value = (value << 1) | static_cast<uint64_t>(bits[GPS_CNAV_DATA_PAGE_BITS - p.first - j]);
if (static_cast<int>(bits[GPS_CNAV_DATA_PAGE_BITS - parameter[i].first - j]) == 1)
{
value += 1ULL; // insert the bit
}
} }
} }
return value; return value;
@ -71,29 +57,12 @@ uint64_t Gps_CNAV_Navigation_Message::read_navigation_unsigned(const std::bitset
int64_t Gps_CNAV_Navigation_Message::read_navigation_signed(const std::bitset<GPS_CNAV_DATA_PAGE_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const int64_t Gps_CNAV_Navigation_Message::read_navigation_signed(const std::bitset<GPS_CNAV_DATA_PAGE_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
int64_t value = 0LL; int64_t value = (bits[GPS_CNAV_DATA_PAGE_BITS - parameter[0].first] == 1) ? -1LL : 0LL;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
// read the MSB and perform the sign extension
if (static_cast<int>(bits[GPS_CNAV_DATA_PAGE_BITS - parameter[0].first]) == 1)
{ {
value ^= 0xFFFFFFFFFFFFFFFFLL; // 64 bits variable for (int32_t j = 0; j < p.second; j++)
}
else
{ {
value &= 0LL; value = (value << 1) | static_cast<int64_t>(bits[GPS_CNAV_DATA_PAGE_BITS - p.first - j]);
}
for (int32_t i = 0; i < num_of_slices; i++)
{
for (int32_t j = 0; j < parameter[i].second; j++)
{
value *= 2; // shift left the signed integer
value &= 0xFFFFFFFFFFFFFFFELL; // reset the corresponding bit (for the 64 bits variable)
if (static_cast<int>(bits[GPS_CNAV_DATA_PAGE_BITS - parameter[i].first - j]) == 1)
{
value += 1LL; // insert the bit
}
} }
} }
return value; return value;

58
src/core/system_parameters/gps_navigation_message.cc
View File

@ -32,9 +32,6 @@ Gps_Navigation_Message::Gps_Navigation_Message()
for (uint32_t i = 1; i < 33; i++) for (uint32_t i = 1; i < 33; i++)
{ {
satelliteBlock[i] = gnss_sat.what_block(_system, i); satelliteBlock[i] = gnss_sat.what_block(_system, i);
}
for (int32_t i = 1; i < 33; i++)
{
almanacHealth[i] = 0; almanacHealth[i] = 0;
} }
} }
@ -46,66 +43,35 @@ void Gps_Navigation_Message::print_gps_word_bytes(uint32_t GPS_word) const
} }
bool Gps_Navigation_Message::read_navigation_bool(const std::bitset<GPS_SUBFRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t> /*unused*/>& parameter) const bool Gps_Navigation_Message::read_navigation_bool(const std::bitset<GPS_SUBFRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
bool value; bool value = bits[GPS_SUBFRAME_BITS - parameter[0].first];
if (static_cast<int>(bits[GPS_SUBFRAME_BITS - parameter[0].first]) == 1)
{
value = true;
}
else
{
value = false;
}
return value; return value;
} }
uint64_t Gps_Navigation_Message::read_navigation_unsigned(const std::bitset<GPS_SUBFRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t> /*unused*/>& parameter) const uint64_t Gps_Navigation_Message::read_navigation_unsigned(const std::bitset<GPS_SUBFRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
uint64_t value = 0ULL; uint64_t value = 0ULL;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
for (int32_t i = 0; i < num_of_slices; i++)
{ {
for (int32_t j = 0; j < parameter[i].second; j++) for (int32_t j = 0; j < p.second; ++j)
{ {
value <<= 1; // shift left value = (value << 1) | (bits.test(GPS_SUBFRAME_BITS - p.first - j) ? 1 : 0);
if (static_cast<int>(bits[GPS_SUBFRAME_BITS - parameter[i].first - j]) == 1)
{
value += 1ULL; // insert the bit
}
} }
} }
return value; return value;
} }
int64_t Gps_Navigation_Message::read_navigation_signed(const std::bitset<GPS_SUBFRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t> /*unused*/>& parameter) const int64_t Gps_Navigation_Message::read_navigation_signed(const std::bitset<GPS_SUBFRAME_BITS>& bits, const std::vector<std::pair<int32_t, int32_t>>& parameter) const
{ {
int64_t value = 0LL; int64_t value = (bits[GPS_SUBFRAME_BITS - parameter[0].first] == 1) ? -1LL : 0LL;
const int32_t num_of_slices = parameter.size(); for (const auto& p : parameter)
// read the MSB and perform the sign extension
if (static_cast<int>(bits[GPS_SUBFRAME_BITS - parameter[0].first]) == 1)
{ {
value ^= 0xFFFFFFFFFFFFFFFFLL; // 64 bits variable for (int32_t j = 0; j < p.second; j++)
}
else
{ {
value &= 0LL; value = (value << 1) | static_cast<int64_t>(bits[GPS_SUBFRAME_BITS - p.first - j]);
}
for (int32_t i = 0; i < num_of_slices; i++)
{
for (int32_t j = 0; j < parameter[i].second; j++)
{
value *= 2; // shift left the signed integer
value &= 0xFFFFFFFFFFFFFFFELL; // reset the corresponding bit (for the 64 bits variable)
if (static_cast<int>(bits[GPS_SUBFRAME_BITS - parameter[i].first - j]) == 1)
{
value += 1LL; // insert the bit
}
} }
} }
return value; return value;
@ -351,7 +317,7 @@ int32_t Gps_Navigation_Message::subframe_decoder(const char* subframe)
default: default:
break; break;
} // switch subframeID ... } // switch subframeID
return subframe_ID; return subframe_ID;
} }