DBCParser.hpp

#pragma once
 
#include <cstdint>
#include <cstring>
#include <string>
#include <string_view>
#include <vector>
 
namespace Protocols::CAN
{
 
enum class ByteOrder
{
  BigEndian,
 
  LittleEndian
};
 
enum class ValueType
{
  Unsigned, 
  Signed,   
  Float32,  
  Double64  
};
 
struct ValueDescription
{
  int64_t value{};
  std::string name;
};
 
struct Attribute
{
  std::string name;
  std::string value;
};
 
struct AttributeSet
{
  std::vector<Attribute> attributes;
 
  const std::string* find(std::string_view name) const noexcept;
};
 
struct Signal
{
  std::string name;
  std::string unit;
  std::string comment;
  std::vector<std::string> receivers;
 
  int startBit{};
 
  int length{1};
 
  ByteOrder byteOrder{ByteOrder::LittleEndian};
  ValueType valueType{ValueType::Unsigned};
 
  double factor{1.};
  double offset{0.};
  double min{};
  double max{};
 
  bool hasRange{};
 
  bool isMultiplexer{};
 
  bool isMultiplexed{};
  int64_t multiplexValue{};
 
  std::vector<ValueDescription> valueTable;
 
  AttributeSet attributes;
};
 
struct Message
{
  uint32_t id{};
 
  bool extended{};
 
  std::string name;
  std::string comment;
  std::string transmitter;
 
  int size{};
 
  std::vector<Signal> signals;
 
  AttributeSet attributes;
 
  const Signal* findSignal(std::string_view name) const noexcept;
};
 
struct Database
{
  std::vector<Message> messages;
 
  std::string comment;
 
  std::string version;
 
  AttributeSet attributes;
 
  std::vector<std::string> warnings;
 
  const Message* findMessage(uint32_t id, bool extended) const noexcept;
};
 
inline constexpr const char* independentSignalMessage = "VECTOR__INDEPENDENT_SIG_MSG";
 
inline constexpr uint32_t dbcExtendedFlag = 0x80000000u;
inline constexpr uint32_t dbcIdentifierMask = 0x1FFFFFFFu;
 
Database parseDBC(std::string_view content);
 
Database parseDBCFile(const std::string& path);
 
constexpr int flipBitPos(int p) noexcept
{
  return (p & ~7) | (7 - (p & 7));
}
 
inline uint64_t extractRawBits(
    const uint8_t* data, int dataSize, int startBit, int length,
    ByteOrder order) noexcept
{
  if(length <= 0 || length > 64)
    return 0;
 
  const int frameBits = dataSize * 8;
  uint64_t out = 0;
 
  // Walk the value from its MSB down to its LSB, so that each step is a plain
  // shift-in. `k` is the significance of the bit being read.
  for(int k = length - 1; k >= 0; --k)
  {
    int pos;
    if(order == ByteOrder::LittleEndian)
    {
      // The start bit is the LSB and significance grows with the position.
      pos = startBit + k;
    }
    else
    {
      // The start bit is the MSB; significance grows *backwards* along the
      // flipped axis, on which the signal's bits are contiguous.
      pos = flipBitPos(flipBitPos(startBit) + (length - 1 - k));
    }
 
    out <<= 1;
    if(pos >= 0 && pos < frameBits)
      out |= uint64_t((data[pos >> 3] >> (pos & 7)) & 1u);
  }
 
  return out;
}
 
constexpr int64_t signExtend(uint64_t raw, int length) noexcept
{
  if(length <= 0 || length >= 64)
    return int64_t(raw);
 
  const uint64_t signBit = uint64_t(1) << (length - 1);
  if(raw & signBit)
    return int64_t(raw | ~((uint64_t(1) << length) - 1));
  return int64_t(raw);
}
 
inline double decodeSignal(const Signal& sig, const uint8_t* data, int dataSize) noexcept
{
  const uint64_t raw
      = extractRawBits(data, dataSize, sig.startBit, sig.length, sig.byteOrder);
 
  double physical{};
  switch(sig.valueType)
  {
    case ValueType::Float32: {
      const auto bits = uint32_t(raw);
      float f{};
      std::memcpy(&f, &bits, sizeof(f));
      physical = double(f);
      break;
    }
    case ValueType::Double64: {
      double d{};
      std::memcpy(&d, &raw, sizeof(d));
      physical = d;
      break;
    }
    case ValueType::Signed:
      physical = double(signExtend(raw, sig.length));
      break;
    case ValueType::Unsigned:
      physical = double(raw);
      break;
  }
 
  return physical * sig.factor + sig.offset;
}
 
inline uint64_t
rawSignalBits(const Signal& sig, const uint8_t* data, int dataSize) noexcept
{
  return extractRawBits(data, dataSize, sig.startBit, sig.length, sig.byteOrder);
}
 
void applyNodeIdOffset(Database& db, int32_t offset);
 
void applyFloat32Override(Database& db);
 
}