IQ.Pilot Release Commit @ b6534c0

iqpilot/tools/cabana/dbc/dbc.cc

@@ -0,0 +1,231 @@
+#include "tools/cabana/dbc/dbc.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace {
+int numDecimals(double value) {
+  int decimals = 0;
+  while (decimals < 6 && std::fabs(value - std::round(value)) > 1e-9) {
+    value *= 10.0;
+    ++decimals;
+  }
+  return decimals;
+}
+}
+
+// cabana::Msg
+
+cabana::Msg::~Msg() {
+  for (auto s : sigs) {
+    delete s;
+  }
+}
+
+cabana::Signal *cabana::Msg::addSignal(const cabana::Signal &sig) {
+  auto s = sigs.emplace_back(new cabana::Signal(sig));
+  update();
+  return s;
+}
+
+cabana::Signal *cabana::Msg::updateSignal(const std::string &sig_name, const cabana::Signal &new_sig) {
+  auto s = sig(sig_name);
+  if (s) {
+    *s = new_sig;
+    update();
+  }
+  return s;
+}
+
+void cabana::Msg::removeSignal(const std::string &sig_name) {
+  auto it = std::find_if(sigs.begin(), sigs.end(), [&](auto &s) { return s->name == sig_name; });
+  if (it != sigs.end()) {
+    delete *it;
+    sigs.erase(it);
+    update();
+  }
+}
+
+cabana::Msg &cabana::Msg::operator=(const cabana::Msg &other) {
+  address = other.address;
+  name = other.name;
+  size = other.size;
+  comment = other.comment;
+  transmitter = other.transmitter;
+
+  for (auto s : sigs) delete s;
+  sigs.clear();
+  for (auto s : other.sigs) {
+    sigs.push_back(new cabana::Signal(*s));
+  }
+
+  update();
+  return *this;
+}
+
+cabana::Signal *cabana::Msg::sig(const std::string &sig_name) const {
+  auto it = std::find_if(sigs.begin(), sigs.end(), [&](auto &s) { return s->name == sig_name; });
+  return it != sigs.end() ? *it : nullptr;
+}
+
+int cabana::Msg::indexOf(const cabana::Signal *sig) const {
+  for (int i = 0; i < sigs.size(); ++i) {
+    if (sigs[i] == sig) return i;
+  }
+  return -1;
+}
+
+std::string cabana::Msg::newSignalName() {
+  std::string new_name;
+  for (int i = 1; /**/; ++i) {
+    new_name = "NEW_SIGNAL_" + std::to_string(i);
+    if (sig(new_name) == nullptr) break;
+  }
+  return new_name;
+}
+
+void cabana::Msg::update() {
+  if (transmitter.empty()) {
+    transmitter = DEFAULT_NODE_NAME;
+  }
+  mask.assign(size, 0x00);
+  multiplexor = nullptr;
+
+  // sort signals
+  std::sort(sigs.begin(), sigs.end(), [](auto l, auto r) {
+    return std::tie(r->type, l->multiplex_value, l->start_bit, l->name) <
+           std::tie(l->type, r->multiplex_value, r->start_bit, r->name);
+  });
+
+  for (auto sig : sigs) {
+    if (sig->type == cabana::Signal::Type::Multiplexor) {
+      multiplexor = sig;
+    }
+    sig->update();
+
+    // update mask
+    int i = sig->msb / 8;
+    int bits = sig->size;
+    while (i >= 0 && i < size && bits > 0) {
+      int lsb = (int)(sig->lsb / 8) == i ? sig->lsb : i * 8;
+      int msb = (int)(sig->msb / 8) == i ? sig->msb : (i + 1) * 8 - 1;
+
+      int sz = msb - lsb + 1;
+      int shift = (lsb - (i * 8));
+
+      mask[i] |= ((1ULL << sz) - 1) << shift;
+
+      bits -= sz;
+      i = sig->is_little_endian ? i - 1 : i + 1;
+    }
+  }
+
+  for (auto sig : sigs) {
+    sig->multiplexor = sig->type == cabana::Signal::Type::Multiplexed ? multiplexor : nullptr;
+    if (!sig->multiplexor) {
+      if (sig->type == cabana::Signal::Type::Multiplexed) {
+        sig->type = cabana::Signal::Type::Normal;
+      }
+      sig->multiplex_value = 0;
+    }
+  }
+}
+
+// cabana::Signal
+
+void cabana::Signal::update() {
+  updateMsbLsb(*this);
+  if (receiver_name.empty()) {
+    receiver_name = DEFAULT_NODE_NAME;
+  }
+
+  float h = 19 * (float)lsb / 64.0;
+  h = fmod(h, 1.0);
+  size_t hash = std::hash<std::string>{}(name);
+  float s = 0.25 + 0.25 * (float)(hash & 0xff) / 255.0;
+  float v = 0.75 + 0.25 * (float)((hash >> 8) & 0xff) / 255.0;
+
+  color = CabanaColor::fromHsv(h, s, v);
+  precision = std::max(numDecimals(factor), numDecimals(offset));
+}
+
+std::string cabana::Signal::formatValue(double value, bool with_unit) const {
+  // Show enum string
+  int64_t raw_value = round((value - offset) / factor);
+  for (const auto &[val, desc] : val_desc) {
+    if (std::abs(raw_value - val) < 1e-6) {
+      return desc;
+    }
+  }
+
+  char buf[64];
+  snprintf(buf, sizeof(buf), "%.*f", precision, value);
+  std::string val_str(buf);
+  if (with_unit && !unit.empty()) {
+    val_str += " " + unit;
+  }
+  return val_str;
+}
+
+bool cabana::Signal::getValue(const uint8_t *data, size_t data_size, double *val) const {
+  if (multiplexor && get_raw_value(data, data_size, *multiplexor) != multiplex_value) {
+    return false;
+  }
+  *val = get_raw_value(data, data_size, *this);
+  return true;
+}
+
+bool cabana::Signal::operator==(const cabana::Signal &other) const {
+  return name == other.name && size == other.size &&
+         start_bit == other.start_bit &&
+         msb == other.msb && lsb == other.lsb &&
+         is_signed == other.is_signed && is_little_endian == other.is_little_endian &&
+         factor == other.factor && offset == other.offset &&
+         min == other.min && max == other.max && comment == other.comment && unit == other.unit && val_desc == other.val_desc &&
+         multiplex_value == other.multiplex_value && type == other.type && receiver_name == other.receiver_name;
+}
+
+// helper functions
+
+double get_raw_value(const uint8_t *data, size_t data_size, const cabana::Signal &sig) {
+  const int msb_byte = sig.msb / 8;
+  if (msb_byte >= (int)data_size) return 0;
+
+  const int lsb_byte = sig.lsb / 8;
+  uint64_t val = 0;
+
+  // Fast path: signal fits in a single byte
+  if (msb_byte == lsb_byte) {
+    val = (data[msb_byte] >> (sig.lsb & 7)) & ((1ULL << sig.size) - 1);
+  } else {
+    // Multi-byte case: signal spans across multiple bytes
+    int bits = sig.size;
+    int i = msb_byte;
+    const int step = sig.is_little_endian ? -1 : 1;
+    while (i >= 0 && i < (int)data_size && bits > 0) {
+      const int msb = (i == msb_byte) ? sig.msb & 7 : 7;
+      const int lsb = (i == lsb_byte) ? sig.lsb & 7 : 0;
+      const int nbits = msb - lsb + 1;
+      val = (val << nbits) | ((data[i] >> lsb) & ((1ULL << nbits) - 1));
+      bits -= nbits;
+      i += step;
+    }
+  }
+
+  // Sign extension (if needed)
+  if (sig.is_signed && (val & (1ULL << (sig.size - 1)))) {
+    val |= ~((1ULL << sig.size) - 1);
+  }
+
+  return static_cast<int64_t>(val) * sig.factor + sig.offset;
+}
+
+void updateMsbLsb(cabana::Signal &s) {
+  if (s.is_little_endian) {
+    s.lsb = s.start_bit;
+    s.msb = s.start_bit + s.size - 1;
+  } else {
+    s.lsb = flipBitPos(flipBitPos(s.start_bit) + s.size - 1);
+    s.msb = s.start_bit;
+  }
+}

iqpilot/tools/cabana/dbc/dbc.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include <cstdio>
+#include <cstdlib>
+#include <functional>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "tools/cabana/core/color.h"
+#include "tools/cabana/core/message_id.h"
+
+const std::string UNTITLED = "untitled";
+const std::string DEFAULT_NODE_NAME = "XXX";
+constexpr int CAN_MAX_DATA_BYTES = 64;
+
+typedef std::vector<std::pair<double, std::string>> ValueDescription;
+
+namespace cabana {
+
+class Signal {
+public:
+  Signal() = default;
+  Signal(const Signal &other) = default;
+  void update();
+  bool getValue(const uint8_t *data, size_t data_size, double *val) const;
+  std::string formatValue(double value, bool with_unit = true) const;
+  bool operator==(const cabana::Signal &other) const;
+  inline bool operator!=(const cabana::Signal &other) const { return !(*this == other); }
+
+  enum class Type {
+    Normal = 0,
+    Multiplexed,
+    Multiplexor
+  };
+
+  Type type = Type::Normal;
+  std::string name;
+  int start_bit, msb, lsb, size;
+  double factor = 1.0;
+  double offset = 0;
+  bool is_signed;
+  bool is_little_endian;
+  double min, max;
+  std::string unit;
+  std::string comment;
+  std::string receiver_name;
+  ValueDescription val_desc;
+  int precision = 0;
+  CabanaColor color;
+
+  // Multiplexed
+  int multiplex_value = 0;
+  Signal *multiplexor = nullptr;
+};
+
+class Msg {
+public:
+  Msg() = default;
+  Msg(const Msg &other) { *this = other; }
+  ~Msg();
+  cabana::Signal *addSignal(const cabana::Signal &sig);
+  cabana::Signal *updateSignal(const std::string &sig_name, const cabana::Signal &sig);
+  void removeSignal(const std::string &sig_name);
+  Msg &operator=(const Msg &other);
+  int indexOf(const cabana::Signal *sig) const;
+  cabana::Signal *sig(const std::string &sig_name) const;
+  std::string newSignalName();
+  void update();
+  inline const std::vector<cabana::Signal *> &getSignals() const { return sigs; }
+
+  uint32_t address;
+  std::string name;
+  uint32_t size;
+  std::string comment;
+  std::string transmitter;
+  std::vector<cabana::Signal *> sigs;
+
+  std::vector<uint8_t> mask;
+  cabana::Signal *multiplexor = nullptr;
+};
+
+}  // namespace cabana
+
+// Helper functions
+double get_raw_value(const uint8_t *data, size_t data_size, const cabana::Signal &sig);
+void updateMsbLsb(cabana::Signal &s);
+inline int flipBitPos(int start_bit) { return 8 * (start_bit / 8) + 7 - start_bit % 8; }
+inline std::string doubleToString(double value) {
+  char buf[64];
+  snprintf(buf, sizeof(buf), "%.*g", std::numeric_limits<double>::digits10, value);
+  return buf;
+}

iqpilot/tools/cabana/dbc/dbcfile.cc

@@ -0,0 +1,271 @@
+#include "tools/cabana/dbc/dbcfile.h"
+
+#include <algorithm>
+#include <cassert>
+#include <filesystem>
+#include <fstream>
+#include <regex>
+#include <sstream>
+#include <stdexcept>
+
+namespace {
+
+std::string trim(const std::string &value) {
+  const auto first = value.find_first_not_of(" \t\r\n");
+  if (first == std::string::npos) return {};
+  return value.substr(first, value.find_last_not_of(" \t\r\n") - first + 1);
+}
+
+bool startsWith(const std::string &value, const char *prefix) {
+  return value.rfind(prefix, 0) == 0;
+}
+
+std::string unescapeComment(std::string value) {
+  for (size_t pos = 0; (pos = value.find("\\\"", pos)) != std::string::npos; ++pos) {
+    value.replace(pos, 2, "\"");
+  }
+  return trim(value);
+}
+
+bool commentComplete(const std::string &line) {
+  bool escaped = false;
+  for (size_t i = 0; i < line.size(); ++i) {
+    if (line[i] == '\\' && !escaped) {
+      escaped = true;
+      continue;
+    }
+    if (line[i] == '"' && !escaped) {
+      size_t next = line.find_first_not_of(" \t\r\n", i + 1);
+      if (next != std::string::npos && line[next] == ';') return true;
+    }
+    escaped = false;
+  }
+  return false;
+}
+
+}  // namespace
+
+DBCFile::DBCFile(const std::string &dbc_file_name) {
+  std::ifstream file(dbc_file_name, std::ios::binary);
+  if (!file) throw std::runtime_error("Failed to open file.");
+  filename = dbc_file_name;
+  name_ = std::filesystem::path(dbc_file_name).stem().string();
+  parse(std::string(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>()));
+}
+
+DBCFile::DBCFile(const std::string &name, const std::string &content) : name_(name) {
+  parse(content);
+}
+
+bool DBCFile::save() {
+  assert(!filename.empty());
+  return writeContents(filename);
+}
+
+bool DBCFile::saveAs(const std::string &new_filename) {
+  filename = new_filename;
+  return save();
+}
+
+bool DBCFile::writeContents(const std::string &fn) {
+  std::ofstream file(fn, std::ios::binary | std::ios::trunc);
+  if (!file) return false;
+  file << generateDBC();
+  return file.good();
+}
+
+void DBCFile::updateMsg(const MessageId &id, const std::string &name, uint32_t size,
+                        const std::string &node, const std::string &comment) {
+  auto &m = msgs[id.address];
+  m.address = id.address;
+  m.name = name;
+  m.size = size;
+  m.transmitter = node.empty() ? DEFAULT_NODE_NAME : node;
+  m.comment = comment;
+}
+
+cabana::Msg *DBCFile::msg(uint32_t address) {
+  auto it = msgs.find(address);
+  return it != msgs.end() ? &it->second : nullptr;
+}
+
+cabana::Msg *DBCFile::msg(const std::string &name) {
+  auto it = std::find_if(msgs.begin(), msgs.end(), [&name](auto &m) { return m.second.name == name; });
+  return it != msgs.end() ? &it->second : nullptr;
+}
+
+cabana::Signal *DBCFile::signal(uint32_t address, const std::string &name) {
+  auto m = msg(address);
+  return m ? m->sig(name) : nullptr;
+}
+
+void DBCFile::parse(const std::string &content) {
+  msgs.clear();
+  header.clear();
+  std::istringstream input(content);
+  std::string raw_line;
+  cabana::Msg *current_msg = nullptr;
+  int multiplexor_cnt = 0;
+  int line_num = 0;
+  bool seen_first = false;
+
+  while (std::getline(input, raw_line)) {
+    ++line_num;
+    const size_t first_nonspace = raw_line.find_first_not_of(" \t\r");
+    std::string line = first_nonspace == std::string::npos ? std::string() : raw_line.substr(first_nonspace);
+    const int statement_line = line_num;
+    if ((startsWith(line, "CM_ BO_") || startsWith(line, "CM_ SG_ ")) && !commentComplete(line)) {
+      std::string continuation;
+      while (std::getline(input, continuation)) {
+        ++line_num;
+        line += "\n" + continuation;
+        if (commentComplete(line)) break;
+      }
+    }
+
+    bool seen = true;
+    try {
+      if (startsWith(line, "BO_ ")) {
+        multiplexor_cnt = 0;
+        current_msg = parseBO(line);
+      } else if (startsWith(line, "SG_ ")) {
+        parseSG(line, current_msg, multiplexor_cnt);
+      } else if (startsWith(line, "VAL_ ")) {
+        parseVAL(line);
+      } else if (startsWith(line, "CM_ BO_")) {
+        parseCM_BO(line);
+      } else if (startsWith(line, "CM_ SG_ ")) {
+        parseCM_SG(line);
+      } else {
+        seen = false;
+      }
+    } catch (const std::exception &e) {
+      throw std::runtime_error("[" + filename + ":" + std::to_string(statement_line) + "]" + e.what() + ": " + line);
+    }
+    if (seen) seen_first = true;
+    else if (!seen_first) header += raw_line + "\n";
+  }
+  for (auto &[_, message] : msgs) message.update();
+}
+
+cabana::Msg *DBCFile::parseBO(const std::string &line) {
+  static const std::regex pattern(R"(^BO_ ([[:alnum:]_]+) ([[:alnum:]_]+) *: ([[:alnum:]_]+) ([[:alnum:]_]+))");
+  std::smatch match;
+  if (!std::regex_search(line, match, pattern)) throw std::runtime_error("Invalid BO_ line format");
+  const uint32_t address = std::stoul(match[1].str());
+  if (msgs.count(address)) throw std::runtime_error("Duplicate message address: " + std::to_string(address));
+  auto &message = msgs[address];
+  message.address = address;
+  message.name = match[2].str();
+  message.size = std::stoul(match[3].str());
+  message.transmitter = trim(match[4].str());
+  return &message;
+}
+
+void DBCFile::parseSG(const std::string &line, cabana::Msg *current_msg, int &multiplexor_cnt) {
+  static const std::regex pattern(R"dbc(^SG_ ([[:alnum:]_]+)(?: +([[:alnum:]_]+))? *: ([0-9]+)\|([0-9]+)@([0-9]+)([+-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] "(.*)" (.*))dbc");
+  if (!current_msg) throw std::runtime_error("No Message");
+  std::smatch match;
+  if (!std::regex_search(line, match, pattern)) throw std::runtime_error("Invalid SG_ line format");
+  if (current_msg->sig(match[1].str())) throw std::runtime_error("Duplicate signal name");
+
+  cabana::Signal signal{};
+  const std::string indicator = match[2].str();
+  if (!indicator.empty()) {
+    if (indicator == "M") {
+      if (++multiplexor_cnt >= 2) throw std::runtime_error("Multiple multiplexor");
+      signal.type = cabana::Signal::Type::Multiplexor;
+    } else {
+      signal.type = cabana::Signal::Type::Multiplexed;
+      signal.multiplex_value = indicator.size() > 1 ? std::stoi(indicator.substr(1)) : 0;
+    }
+  }
+  signal.name = match[1].str();
+  signal.start_bit = std::stoi(match[3].str());
+  signal.size = std::stoi(match[4].str());
+  signal.is_little_endian = match[5].str() == "1";
+  signal.is_signed = match[6].str() == "-";
+  signal.factor = std::stod(match[7].str());
+  signal.offset = std::stod(match[8].str());
+  signal.min = std::stod(match[9].str());
+  signal.max = std::stod(match[10].str());
+  signal.unit = match[11].str();
+  signal.receiver_name = trim(match[12].str());
+  current_msg->sigs.push_back(new cabana::Signal(signal));
+}
+
+void DBCFile::parseCM_BO(const std::string &line) {
+  std::istringstream prefix(line.substr(7));
+  uint32_t address = 0;
+  prefix >> address;
+  const size_t first_quote = line.find('"');
+  const size_t last_quote = line.rfind('"');
+  if (!prefix || first_quote == std::string::npos || last_quote <= first_quote) {
+    throw std::runtime_error("Invalid message comment format");
+  }
+  if (auto message = msg(address)) message->comment = unescapeComment(line.substr(first_quote + 1, last_quote - first_quote - 1));
+}
+
+void DBCFile::parseCM_SG(const std::string &line) {
+  std::istringstream prefix(line.substr(7));
+  uint32_t address = 0;
+  std::string name;
+  prefix >> address >> name;
+  const size_t first_quote = line.find('"');
+  const size_t last_quote = line.rfind('"');
+  if (!prefix || name.empty() || first_quote == std::string::npos || last_quote <= first_quote) {
+    throw std::runtime_error("Invalid CM_ SG_ line format");
+  }
+  if (auto sig = signal(address, name)) sig->comment = unescapeComment(line.substr(first_quote + 1, last_quote - first_quote - 1));
+}
+
+void DBCFile::parseVAL(const std::string &line) {
+  static const std::regex header_pattern(R"(^VAL_ ([[:alnum:]_]+) ([[:alnum:]_]+) (.*))");
+  static const std::regex entry_pattern(R"dbc(([+-]?[0-9]+(?:\.[0-9]+)?)\s+"([^"]*)")dbc");
+  std::smatch match;
+  if (!std::regex_search(line, match, header_pattern)) throw std::runtime_error("invalid VAL_ line format");
+  if (auto sig = signal(std::stoul(match[1].str()), match[2].str())) {
+    const std::string entries = match[3].str();
+    for (std::sregex_iterator it(entries.begin(), entries.end(), entry_pattern), end; it != end; ++it) {
+      sig->val_desc.emplace_back(std::stod((*it)[1].str()), trim((*it)[2].str()));
+    }
+  }
+}
+
+std::string DBCFile::generateDBC() {
+  std::string dbc_string, comment, val_desc;
+  for (const auto &[address, m] : msgs) {
+    const std::string &transmitter = m.transmitter.empty() ? DEFAULT_NODE_NAME : m.transmitter;
+    dbc_string += "BO_ " + std::to_string(address) + " " + m.name + ": " + std::to_string(m.size) + " " + transmitter + "\n";
+    if (!m.comment.empty()) {
+      std::string escaped = m.comment;
+      for (size_t pos = 0; (pos = escaped.find('"', pos)) != std::string::npos; pos += 2) escaped.replace(pos, 1, "\\\"");
+      comment += "CM_ BO_ " + std::to_string(address) + " \"" + escaped + "\";\n";
+    }
+    for (auto sig : m.getSignals()) {
+      std::string mux;
+      if (sig->type == cabana::Signal::Type::Multiplexor) mux = "M ";
+      else if (sig->type == cabana::Signal::Type::Multiplexed) mux = "m" + std::to_string(sig->multiplex_value) + " ";
+      const std::string &receiver = sig->receiver_name.empty() ? DEFAULT_NODE_NAME : sig->receiver_name;
+      dbc_string += " SG_ " + sig->name + " " + mux + ": " + std::to_string(sig->start_bit) + "|" + std::to_string(sig->size) + "@" +
+                    (sig->is_little_endian ? "1" : "0") + (sig->is_signed ? "-" : "+") +
+                    " (" + doubleToString(sig->factor) + "," + doubleToString(sig->offset) + ")" +
+                    " [" + doubleToString(sig->min) + "|" + doubleToString(sig->max) + "] \"" + sig->unit + "\" " + receiver + "\n";
+      if (!sig->comment.empty()) {
+        std::string escaped = sig->comment;
+        for (size_t pos = 0; (pos = escaped.find('"', pos)) != std::string::npos; pos += 2) escaped.replace(pos, 1, "\\\"");
+        comment += "CM_ SG_ " + std::to_string(address) + " " + sig->name + " \"" + escaped + "\";\n";
+      }
+      if (!sig->val_desc.empty()) {
+        std::string text;
+        for (const auto &[value, description] : sig->val_desc) {
+          if (!text.empty()) text += " ";
+          text += doubleToString(value) + " \"" + description + "\"";
+        }
+        val_desc += "VAL_ " + std::to_string(address) + " " + sig->name + " " + text + ";\n";
+      }
+    }
+    dbc_string += "\n";
+  }
+  return header + dbc_string + comment + val_desc;
+}

iqpilot/tools/cabana/dbc/dbcfile.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "tools/cabana/dbc/dbc.h"
+
+class DBCFile {
+public:
+  DBCFile(const std::string &dbc_file_name);
+  DBCFile(const std::string &name, const std::string &content);
+  ~DBCFile() {}
+
+  bool save();
+  bool saveAs(const std::string &new_filename);
+  bool writeContents(const std::string &fn);
+  std::string generateDBC();
+
+  void updateMsg(const MessageId &id, const std::string &name, uint32_t size, const std::string &node, const std::string &comment);
+  inline void removeMsg(const MessageId &id) { msgs.erase(id.address); }
+
+  inline const std::map<uint32_t, cabana::Msg> &getMessages() const { return msgs; }
+  cabana::Msg *msg(uint32_t address);
+  cabana::Msg *msg(const std::string &name);
+  inline cabana::Msg *msg(const MessageId &id) { return msg(id.address); }
+  cabana::Signal *signal(uint32_t address, const std::string &name);
+
+  inline std::string name() const { return name_.empty() ? "untitled" : name_; }
+  inline bool isEmpty() const { return msgs.empty() && name_.empty(); }
+
+  std::string filename;
+
+private:
+  void parse(const std::string &content);
+  cabana::Msg *parseBO(const std::string &line);
+  void parseSG(const std::string &line, cabana::Msg *current_msg, int &multiplexor_cnt);
+  void parseCM_BO(const std::string &line);
+  void parseCM_SG(const std::string &line);
+  void parseVAL(const std::string &line);
+
+  std::string header;
+  std::map<uint32_t, cabana::Msg> msgs;
+  std::string name_;
+};

iqpilot/tools/cabana/dbc/dbcmanager.cc

@@ -0,0 +1,182 @@
+#include "tools/cabana/dbc/dbcmanager.h"
+
+#include <algorithm>
+#include <cassert>
+#include <set>
+
+bool DBCManager::open(const SourceSet &sources, const std::string &dbc_file_name, std::string *error) {
+  try {
+    auto it = std::find_if(dbc_files.begin(), dbc_files.end(),
+                           [&](auto &f) { return f.second && f.second->filename == dbc_file_name; });
+    auto file = (it != dbc_files.end()) ? it->second : std::make_shared<DBCFile>(dbc_file_name);
+    for (auto s : sources) {
+      dbc_files[s] = file;
+    }
+  } catch (std::exception &e) {
+    if (error) *error = e.what();
+    return false;
+  }
+
+  if (callbacks_.file_changed) callbacks_.file_changed();
+  return true;
+}
+
+bool DBCManager::open(const SourceSet &sources, const std::string &name, const std::string &content, std::string *error) {
+  try {
+    auto file = std::make_shared<DBCFile>(name, content);
+    for (auto s : sources) {
+      dbc_files[s] = file;
+    }
+  } catch (std::exception &e) {
+    if (error) *error = e.what();
+    return false;
+  }
+
+  if (callbacks_.file_changed) callbacks_.file_changed();
+  return true;
+}
+
+void DBCManager::close(const SourceSet &sources) {
+  for (auto s : sources) {
+    dbc_files[s] = nullptr;
+  }
+  if (callbacks_.file_changed) callbacks_.file_changed();
+}
+
+void DBCManager::close(DBCFile *dbc_file) {
+  for (auto &[_, f] : dbc_files) {
+    if (f.get() == dbc_file) f = nullptr;
+  }
+  if (callbacks_.file_changed) callbacks_.file_changed();
+}
+
+void DBCManager::closeAll() {
+  dbc_files.clear();
+  if (callbacks_.file_changed) callbacks_.file_changed();
+}
+
+void DBCManager::addSignal(const MessageId &id, const cabana::Signal &sig) {
+  if (auto m = msg(id)) {
+    if (auto s = m->addSignal(sig)) {
+      if (callbacks_.signal_added) callbacks_.signal_added(id, s);
+      if (callbacks_.mask_updated) callbacks_.mask_updated();
+    }
+  }
+}
+
+void DBCManager::updateSignal(const MessageId &id, const std::string &sig_name, const cabana::Signal &sig) {
+  if (auto m = msg(id)) {
+    if (auto s = m->updateSignal(sig_name, sig)) {
+      if (callbacks_.signal_updated) callbacks_.signal_updated(s);
+      if (callbacks_.mask_updated) callbacks_.mask_updated();
+    }
+  }
+}
+
+void DBCManager::removeSignal(const MessageId &id, const std::string &sig_name) {
+  if (auto m = msg(id)) {
+    if (auto s = m->sig(sig_name)) {
+      if (callbacks_.signal_removed) callbacks_.signal_removed(s);
+      m->removeSignal(sig_name);
+      if (callbacks_.mask_updated) callbacks_.mask_updated();
+    }
+  }
+}
+
+void DBCManager::updateMsg(const MessageId &id, const std::string &name, uint32_t size, const std::string &node, const std::string &comment) {
+  auto dbc_file = findDBCFile(id);
+  assert(dbc_file);  // This should be impossible
+  dbc_file->updateMsg(id, name, size, node, comment);
+  if (callbacks_.msg_updated) callbacks_.msg_updated(id);
+}
+
+void DBCManager::removeMsg(const MessageId &id) {
+  auto dbc_file = findDBCFile(id);
+  assert(dbc_file);  // This should be impossible
+  dbc_file->removeMsg(id);
+  if (callbacks_.msg_removed) callbacks_.msg_removed(id);
+  if (callbacks_.mask_updated) callbacks_.mask_updated();
+}
+
+std::string DBCManager::newMsgName(const MessageId &id) {
+  char buf[64];
+  snprintf(buf, sizeof(buf), "NEW_MSG_%X", id.address);
+  return buf;
+}
+
+std::string DBCManager::newSignalName(const MessageId &id) {
+  auto m = msg(id);
+  return m ? m->newSignalName() : "";
+}
+
+const std::map<uint32_t, cabana::Msg> &DBCManager::getMessages(uint8_t source) {
+  static std::map<uint32_t, cabana::Msg> empty_msgs;
+  auto dbc_file = findDBCFile(source);
+  return dbc_file ? dbc_file->getMessages() : empty_msgs;
+}
+
+cabana::Msg *DBCManager::msg(const MessageId &id) {
+  auto dbc_file = findDBCFile(id);
+  return dbc_file ? dbc_file->msg(id) : nullptr;
+}
+
+cabana::Msg *DBCManager::msg(uint8_t source, const std::string &name) {
+  auto dbc_file = findDBCFile(source);
+  return dbc_file ? dbc_file->msg(name) : nullptr;
+}
+
+std::vector<std::string> DBCManager::signalNames() {
+  // Used for autocompletion
+  std::set<std::string> names;
+  for (auto &f : allDBCFiles()) {
+    for (auto &[_, m] : f->getMessages()) {
+      for (auto sig : m.getSignals()) {
+        names.insert(sig->name);
+      }
+    }
+  }
+  std::vector<std::string> ret(names.begin(), names.end());
+  std::sort(ret.begin(), ret.end());
+  return ret;
+}
+
+int DBCManager::nonEmptyDBCCount() {
+  auto files = allDBCFiles();
+  return std::count_if(files.cbegin(), files.cend(), [](auto &f) { return !f->isEmpty(); });
+}
+
+DBCFile *DBCManager::findDBCFile(const uint8_t source) {
+  // Find DBC file that matches id.source, fall back to SOURCE_ALL if no specific DBC is found
+  auto it = dbc_files.count(source) ? dbc_files.find(source) : dbc_files.find(-1);
+  return it != dbc_files.end() ? it->second.get() : nullptr;
+}
+
+std::set<DBCFile *> DBCManager::allDBCFiles() {
+  std::set<DBCFile *> files;
+  for (const auto &[_, f] : dbc_files) {
+    if (f) files.insert(f.get());
+  }
+  return files;
+}
+
+const SourceSet DBCManager::sources(const DBCFile *dbc_file) const {
+  SourceSet sources;
+  for (auto &[s, f] : dbc_files) {
+    if (f.get() == dbc_file) sources.insert(s);
+  }
+  return sources;
+}
+
+std::string toString(const SourceSet &ss) {
+  std::string result;
+  for (int source : ss) {
+    if (!result.empty()) result += ", ";
+    result += (source == -1) ? "all" : std::to_string(source);
+  }
+  return result;
+}
+
+DBCManager *dbc() {
+  static DBCManager dbc_manager;
+  return &dbc_manager;
+}

iqpilot/tools/cabana/dbc/dbcmanager.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "tools/cabana/dbc/dbcfile.h"
+
+typedef std::set<int> SourceSet;
+const SourceSet SOURCE_ALL = {-1};
+inline bool operator<(const std::shared_ptr<DBCFile> &l, const std::shared_ptr<DBCFile> &r) { return l.get() < r.get(); }
+
+class DBCManager {
+public:
+  struct Callbacks {
+    std::function<void(MessageId, const cabana::Signal *)> signal_added;
+    std::function<void(const cabana::Signal *)> signal_removed;
+    std::function<void(const cabana::Signal *)> signal_updated;
+    std::function<void(MessageId)> msg_updated;
+    std::function<void(MessageId)> msg_removed;
+    std::function<void()> file_changed;
+    std::function<void()> mask_updated;
+  };
+
+  DBCManager() = default;
+  bool open(const SourceSet &sources, const std::string &dbc_file_name, std::string *error = nullptr);
+  bool open(const SourceSet &sources, const std::string &name, const std::string &content, std::string *error = nullptr);
+  void close(const SourceSet &sources);
+  void close(DBCFile *dbc_file);
+  void closeAll();
+
+  void addSignal(const MessageId &id, const cabana::Signal &sig);
+  void updateSignal(const MessageId &id, const std::string &sig_name, const cabana::Signal &sig);
+  void removeSignal(const MessageId &id, const std::string &sig_name);
+
+  void updateMsg(const MessageId &id, const std::string &name, uint32_t size, const std::string &node, const std::string &comment);
+  void removeMsg(const MessageId &id);
+
+  std::string newMsgName(const MessageId &id);
+  std::string newSignalName(const MessageId &id);
+
+  const std::map<uint32_t, cabana::Msg> &getMessages(uint8_t source);
+  cabana::Msg *msg(const MessageId &id);
+  cabana::Msg* msg(uint8_t source, const std::string &name);
+
+  std::vector<std::string> signalNames();
+  inline int dbcCount() { return allDBCFiles().size(); }
+  int nonEmptyDBCCount();
+
+  const SourceSet sources(const DBCFile *dbc_file) const;
+  DBCFile *findDBCFile(const uint8_t source);
+  inline DBCFile *findDBCFile(const MessageId &id) { return findDBCFile(id.source); }
+  std::set<DBCFile *> allDBCFiles();
+  void setCallbacks(Callbacks callbacks) { callbacks_ = std::move(callbacks); }
+
+private:
+  std::map<int, std::shared_ptr<DBCFile>> dbc_files;
+  Callbacks callbacks_;
+};
+
+DBCManager *dbc();
+
+std::string toString(const SourceSet &ss);
+inline std::string msgName(const MessageId &id) {
+  auto msg = dbc()->msg(id);
+  return msg ? msg->name : UNTITLED;
+}

iqpilot/tools/cabana/dbc/dbcqt.cc

@@ -0,0 +1,18 @@
+#include "tools/cabana/dbc/dbcqt.h"
+
+QtDBCNotifier::QtDBCNotifier(QObject *parent) : QObject(parent) {
+  dbc()->setCallbacks({
+    .signal_added = [this](MessageId id, const cabana::Signal *sig) { emit signalAdded(id, sig); },
+    .signal_removed = [this](const cabana::Signal *sig) { emit signalRemoved(sig); },
+    .signal_updated = [this](const cabana::Signal *sig) { emit signalUpdated(sig); },
+    .msg_updated = [this](MessageId id) { emit msgUpdated(id); },
+    .msg_removed = [this](MessageId id) { emit msgRemoved(id); },
+    .file_changed = [this]() { emit DBCFileChanged(); },
+    .mask_updated = [this]() { emit maskUpdated(); },
+  });
+}
+
+QtDBCNotifier *dbcNotifier() {
+  static QtDBCNotifier notifier;
+  return &notifier;
+}

iqpilot/tools/cabana/dbc/dbcqt.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <QMetaType>
+#include <QObject>
+
+#include "tools/cabana/dbc/dbcmanager.h"
+
+Q_DECLARE_METATYPE(MessageId)
+Q_DECLARE_METATYPE(ValueDescription)
+
+class QtDBCNotifier : public QObject {
+  Q_OBJECT
+
+public:
+  explicit QtDBCNotifier(QObject *parent = nullptr);
+
+signals:
+  void signalAdded(MessageId id, const cabana::Signal *sig);
+  void signalRemoved(const cabana::Signal *sig);
+  void signalUpdated(const cabana::Signal *sig);
+  void msgUpdated(MessageId id);
+  void msgRemoved(MessageId id);
+  void DBCFileChanged();
+  void maskUpdated();
+};
+
+QtDBCNotifier *dbcNotifier();

iqpilot/tools/cabana/dbc/generate_dbc_json.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+import argparse
+import json
+from iqdbc.car import Bus
+from iqdbc.car.fingerprints import MIGRATION
+from iqdbc.car.values import PLATFORMS
+
+
+def generate_dbc_dict() -> dict[str, str]:
+  dbc_map = {}
+  for platform in PLATFORMS.values():
+    if platform != "MOCK":
+      if Bus.pt in platform.config.dbc_dict:
+        dbc_map[platform.name] = platform.config.dbc_dict[Bus.pt]
+      elif Bus.main in platform.config.dbc_dict:
+        dbc_map[platform.name] = platform.config.dbc_dict[Bus.main]
+      elif Bus.party in platform.config.dbc_dict:
+        dbc_map[platform.name] = platform.config.dbc_dict[Bus.party]
+      else:
+        raise ValueError("Unknown main type")
+
+  for m in MIGRATION:
+    if MIGRATION[m] in dbc_map:
+      dbc_map[m] = dbc_map[MIGRATION[m]]
+
+  return dbc_map
+
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser(description="Generate mapping for all car fingerprints to DBC names and outputs json file",
+                                   formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+
+  parser.add_argument("--out", required=True, help="Generated json filepath")
+  args = parser.parse_args()
+
+  with open(args.out, 'w') as f:
+    f.write(json.dumps(dict(sorted(generate_dbc_dict().items())), indent=2))
+  print(f"Generated and written to {args.out}")