sunnypilot v2026.002.000

version: sunnypilot v2026.002.000 (staging)
date: 2026-07-21T07:44:02
master commit: 2c334ede443d7391d27575af8c854a095ba702a8

openpilot/tools/cabana/dbc/dbc.cc

@@ -0,0 +1,221 @@
+#include "tools/cabana/dbc/dbc.h"
+
+#include <algorithm>
+
+#include "tools/cabana/utils/util.h"
+
+// 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 = QColor::fromHsvF(h, s, v);
+  precision = std::max(num_decimals(factor), num_decimals(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;
+  }
+}

openpilot/tools/cabana/dbc/dbc.h

@@ -0,0 +1,138 @@
+#pragma once
+
+#include <cstdio>
+#include <cstdlib>
+#include <functional>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <QColor>
+#include <QMetaType>
+
+const std::string UNTITLED = "untitled";
+const std::string DEFAULT_NODE_NAME = "XXX";
+constexpr int CAN_MAX_DATA_BYTES = 64;
+
+struct MessageId {
+  uint8_t source = 0;
+  uint32_t address = 0;
+
+  std::string toString() const {
+    char buf[64];
+    snprintf(buf, sizeof(buf), "%u:%X", source, address);
+    return buf;
+  }
+
+  inline static MessageId fromString(const std::string &str) {
+    auto pos = str.find(':');
+    if (pos == std::string::npos) return {};
+    return MessageId{.source = uint8_t(std::stoul(str.substr(0, pos))),
+                     .address = uint32_t(std::stoul(str.substr(pos + 1), nullptr, 16))};
+  }
+
+  bool operator==(const MessageId &other) const {
+    return source == other.source && address == other.address;
+  }
+
+  bool operator!=(const MessageId &other) const {
+    return !(*this == other);
+  }
+
+  bool operator<(const MessageId &other) const {
+    return std::tie(source, address) < std::tie(other.source, other.address);
+  }
+
+  bool operator>(const MessageId &other) const {
+    return std::tie(source, address) > std::tie(other.source, other.address);
+  }
+};
+
+Q_DECLARE_METATYPE(MessageId);
+
+template <>
+struct std::hash<MessageId> {
+  std::size_t operator()(const MessageId &k) const noexcept {
+    return std::hash<uint8_t>{}(k.source) ^ (std::hash<uint32_t>{}(k.address) << 1);
+  }
+};
+
+typedef std::vector<std::pair<double, std::string>> ValueDescription;
+Q_DECLARE_METATYPE(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;
+  QColor 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;
+}

openpilot/tools/cabana/dbc/dbcfile.cc

@@ -0,0 +1,281 @@
+#include "tools/cabana/dbc/dbcfile.h"
+
+#include <QFile>
+#include <QFileInfo>
+#include <QRegularExpression>
+#include <QString>
+
+DBCFile::DBCFile(const std::string &dbc_file_name) {
+  QFile file(QString::fromStdString(dbc_file_name));
+  if (file.open(QIODevice::ReadOnly)) {
+    name_ = QFileInfo(QString::fromStdString(dbc_file_name)).baseName().toStdString();
+    filename = dbc_file_name;
+    parse(file.readAll());
+  } else {
+    throw std::runtime_error("Failed to open file.");
+  }
+}
+
+DBCFile::DBCFile(const std::string &name, const std::string &content) : name_(name), filename("") {
+  parse(QString::fromStdString(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) {
+  QFile file(QString::fromStdString(fn));
+  if (file.open(QIODevice::WriteOnly)) {
+    std::string content = generateDBC();
+    return file.write(content.c_str(), content.size()) >= 0;
+  }
+  return false;
+}
+
+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 ? (cabana::Signal *)m->sig(name) : nullptr;
+}
+
+void DBCFile::parse(const QString &content) {
+  msgs.clear();
+
+  int line_num = 0;
+  QString line;
+  cabana::Msg *current_msg = nullptr;
+  int multiplexor_cnt = 0;
+  bool seen_first = false;
+  QTextStream stream((QString *)&content);
+
+  while (!stream.atEnd()) {
+    ++line_num;
+    QString raw_line = stream.readLine();
+    line = raw_line.trimmed();
+
+    bool seen = true;
+    try {
+      if (line.startsWith("BO_ ")) {
+        multiplexor_cnt = 0;
+        current_msg = parseBO(line);
+      } else if (line.startsWith("SG_ ")) {
+        parseSG(line, current_msg, multiplexor_cnt);
+      } else if (line.startsWith("VAL_ ")) {
+        parseVAL(line);
+      } else if (line.startsWith("CM_ BO_")) {
+        parseCM_BO(line, content, raw_line, stream);
+      } else if (line.startsWith("CM_ SG_ ")) {
+        parseCM_SG(line, content, raw_line, stream);
+      } else {
+        seen = false;
+      }
+    } catch (std::exception &e) {
+      throw std::runtime_error(QString("[%1:%2]%3: %4").arg(QString::fromStdString(filename)).arg(line_num).arg(e.what()).arg(line).toStdString());
+    }
+
+    if (seen) {
+      seen_first = true;
+    } else if (!seen_first) {
+      header += raw_line.toStdString() + "\n";
+    }
+  }
+
+  for (auto &[_, m] : msgs) {
+    m.update();
+  }
+}
+
+cabana::Msg *DBCFile::parseBO(const QString &line) {
+  static QRegularExpression bo_regexp(R"(^BO_ (?<address>\w+) (?<name>\w+) *: (?<size>\w+) (?<transmitter>\w+))");
+
+  QRegularExpressionMatch match = bo_regexp.match(line);
+  if (!match.hasMatch())
+    throw std::runtime_error("Invalid BO_ line format");
+
+  uint32_t address = match.captured("address").toUInt();
+  if (msgs.count(address) > 0)
+    throw std::runtime_error(QString("Duplicate message address: %1").arg(address).toStdString());
+
+  // Create a new message object
+  cabana::Msg *msg = &msgs[address];
+  msg->address = address;
+  msg->name = match.captured("name").toStdString();
+  msg->size = match.captured("size").toULong();
+  msg->transmitter = match.captured("transmitter").trimmed().toStdString();
+  return msg;
+}
+
+void DBCFile::parseCM_BO(const QString &line, const QString &content, const QString &raw_line, const QTextStream &stream) {
+  static QRegularExpression msg_comment_regexp(R"(^CM_ BO_ *(?<address>\w+) *\"(?<comment>(?:[^"\\]|\\.)*)\"\s*;)");
+
+  QString parse_line = line;
+  if (!parse_line.endsWith("\";")) {
+    int pos = stream.pos() - raw_line.length() - 1;
+    parse_line = content.mid(pos, content.indexOf("\";", pos));
+  }
+  auto match = msg_comment_regexp.match(parse_line);
+  if (!match.hasMatch())
+    throw std::runtime_error("Invalid message comment format");
+
+  if (auto m = (cabana::Msg *)msg(match.captured("address").toUInt()))
+    m->comment = match.captured("comment").trimmed().replace("\\\"", "\"").toStdString();
+}
+
+void DBCFile::parseSG(const QString &line, cabana::Msg *current_msg, int &multiplexor_cnt) {
+  static QRegularExpression sg_regexp(R"(^SG_ (\w+) *: (\d+)\|(\d+)@(\d+)([\+|\-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] \"(.*)\" (.*))");
+  static QRegularExpression sgm_regexp(R"(^SG_ (\w+) (\w+) *: (\d+)\|(\d+)@(\d+)([\+|\-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] \"(.*)\" (.*))");
+
+  if (!current_msg)
+    throw std::runtime_error("No Message");
+
+  int offset = 0;
+  auto match = sg_regexp.match(line);
+  if (!match.hasMatch()) {
+    match = sgm_regexp.match(line);
+    offset = 1;
+  }
+  if (!match.hasMatch())
+    throw std::runtime_error("Invalid SG_ line format");
+
+  std::string name = match.captured(1).toStdString();
+  if (current_msg->sig(name) != nullptr)
+    throw std::runtime_error("Duplicate signal name");
+
+  cabana::Signal s{};
+  if (offset == 1) {
+    auto indicator = match.captured(2);
+    if (indicator == "M") {
+      ++multiplexor_cnt;
+      // Only one signal within a single message can be the multiplexer switch.
+      if (multiplexor_cnt >= 2)
+        throw std::runtime_error("Multiple multiplexor");
+
+      s.type = cabana::Signal::Type::Multiplexor;
+    } else {
+      s.type = cabana::Signal::Type::Multiplexed;
+      s.multiplex_value = indicator.mid(1).toInt();
+    }
+  }
+  s.name = name;
+  s.start_bit = match.captured(offset + 2).toInt();
+  s.size = match.captured(offset + 3).toInt();
+  s.is_little_endian = match.captured(offset + 4).toInt() == 1;
+  s.is_signed = match.captured(offset + 5) == "-";
+  s.factor = match.captured(offset + 6).toDouble();
+  s.offset = match.captured(offset + 7).toDouble();
+  s.min = match.captured(8 + offset).toDouble();
+  s.max = match.captured(9 + offset).toDouble();
+  s.unit = match.captured(10 + offset).toStdString();
+  s.receiver_name = match.captured(11 + offset).trimmed().toStdString();
+  current_msg->sigs.push_back(new cabana::Signal(s));
+}
+
+void DBCFile::parseCM_SG(const QString &line, const QString &content, const QString &raw_line, const QTextStream &stream) {
+  static QRegularExpression sg_comment_regexp(R"(^CM_ SG_ *(\w+) *(\w+) *\"((?:[^"\\]|\\.)*)\"\s*;)");
+
+  QString parse_line = line;
+  if (!parse_line.endsWith("\";")) {
+    int pos = stream.pos() - raw_line.length() - 1;
+    parse_line = content.mid(pos, content.indexOf("\";", pos));
+  }
+  auto match = sg_comment_regexp.match(parse_line);
+  if (!match.hasMatch())
+    throw std::runtime_error("Invalid CM_ SG_ line format");
+
+  if (auto s = signal(match.captured(1).toUInt(), match.captured(2).toStdString())) {
+    s->comment = match.captured(3).trimmed().replace("\\\"", "\"").toStdString();
+  }
+}
+
+void DBCFile::parseVAL(const QString &line) {
+  static QRegularExpression val_regexp(R"(VAL_ (\w+) (\w+) (\s*[-+]?[0-9]+\s+\".+?\"[^;]*))");
+
+  auto match = val_regexp.match(line);
+  if (!match.hasMatch())
+    throw std::runtime_error("invalid VAL_ line format");
+
+  if (auto s = signal(match.captured(1).toUInt(), match.captured(2).toStdString())) {
+    QStringList desc_list = match.captured(3).trimmed().split('"');
+    for (int i = 0; i < desc_list.size(); i += 2) {
+      auto val = desc_list[i].trimmed();
+      if (!val.isEmpty() && (i + 1) < desc_list.size()) {
+        auto desc = desc_list[i + 1].trimmed();
+        s->val_desc.push_back({val.toDouble(), desc.toStdString()});
+      }
+    }
+  }
+}
+
+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_comment = m.comment;
+      // Replace " with \"
+      for (size_t pos = 0; (pos = escaped_comment.find('"', pos)) != std::string::npos; pos += 2)
+        escaped_comment.replace(pos, 1, "\\\"");
+      comment += "CM_ BO_ " + std::to_string(address) + " \"" + escaped_comment + "\";\n";
+    }
+    for (auto sig : m.getSignals()) {
+      std::string multiplexer_indicator;
+      if (sig->type == cabana::Signal::Type::Multiplexor) {
+        multiplexer_indicator = "M ";
+      } else if (sig->type == cabana::Signal::Type::Multiplexed) {
+        multiplexer_indicator = "m" + std::to_string(sig->multiplex_value) + " ";
+      }
+      const std::string &recv = sig->receiver_name.empty() ? DEFAULT_NODE_NAME : sig->receiver_name;
+      dbc_string += " SG_ " + sig->name + " " + multiplexer_indicator + ": " +
+                    std::to_string(sig->start_bit) + "|" + std::to_string(sig->size) + "@" +
+                    std::string(1, sig->is_little_endian ? '1' : '0') +
+                    std::string(1, sig->is_signed ? '-' : '+') +
+                    " (" + doubleToString(sig->factor) + "," + doubleToString(sig->offset) + ")" +
+                    " [" + doubleToString(sig->min) + "|" + doubleToString(sig->max) + "]" +
+                    " \"" + sig->unit + "\" " + recv + "\n";
+      if (!sig->comment.empty()) {
+        std::string escaped_comment = sig->comment;
+        for (size_t pos = 0; (pos = escaped_comment.find('"', pos)) != std::string::npos; pos += 2)
+          escaped_comment.replace(pos, 1, "\\\"");
+        comment += "CM_ SG_ " + std::to_string(address) + " " + sig->name + " \"" + escaped_comment + "\";\n";
+      }
+      if (!sig->val_desc.empty()) {
+        std::string text;
+        for (auto &[val, desc] : sig->val_desc) {
+          if (!text.empty()) text += " ";
+          char val_buf[64];
+          snprintf(val_buf, sizeof(val_buf), "%g", val);
+          text += std::string(val_buf) + " \"" + desc + "\"";
+        }
+        val_desc += "VAL_ " + std::to_string(address) + " " + sig->name + " " + text + ";\n";
+      }
+    }
+    dbc_string += "\n";
+  }
+  return header + dbc_string + comment + val_desc;
+}

openpilot/tools/cabana/dbc/dbcfile.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <QTextStream>
+
+#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 QString &content);
+  cabana::Msg *parseBO(const QString &line);
+  void parseSG(const QString &line, cabana::Msg *current_msg, int &multiplexor_cnt);
+  void parseCM_BO(const QString &line, const QString &content, const QString &raw_line, const QTextStream &stream);
+  void parseCM_SG(const QString &line, const QString &content, const QString &raw_line, const QTextStream &stream);
+  void parseVAL(const QString &line);
+
+  std::string header;
+  std::map<uint32_t, cabana::Msg> msgs;
+  std::string name_;
+};

openpilot/tools/cabana/dbc/dbcmanager.cc

@@ -0,0 +1,181 @@
+#include "tools/cabana/dbc/dbcmanager.h"
+
+#include <algorithm>
+#include <set>
+
+bool DBCManager::open(const SourceSet &sources, const std::string &dbc_file_name, QString *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;
+  }
+
+  emit DBCFileChanged();
+  return true;
+}
+
+bool DBCManager::open(const SourceSet &sources, const std::string &name, const std::string &content, QString *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;
+  }
+
+  emit DBCFileChanged();
+  return true;
+}
+
+void DBCManager::close(const SourceSet &sources) {
+  for (auto s : sources) {
+    dbc_files[s] = nullptr;
+  }
+  emit DBCFileChanged();
+}
+
+void DBCManager::close(DBCFile *dbc_file) {
+  for (auto &[_, f] : dbc_files) {
+    if (f.get() == dbc_file) f = nullptr;
+  }
+  emit DBCFileChanged();
+}
+
+void DBCManager::closeAll() {
+  dbc_files.clear();
+  emit DBCFileChanged();
+}
+
+void DBCManager::addSignal(const MessageId &id, const cabana::Signal &sig) {
+  if (auto m = msg(id)) {
+    if (auto s = m->addSignal(sig)) {
+      emit signalAdded(id, s);
+      emit maskUpdated();
+    }
+  }
+}
+
+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)) {
+      emit signalUpdated(s);
+      emit maskUpdated();
+    }
+  }
+}
+
+void DBCManager::removeSignal(const MessageId &id, const std::string &sig_name) {
+  if (auto m = msg(id)) {
+    if (auto s = m->sig(sig_name)) {
+      emit signalRemoved(s);
+      m->removeSignal(sig_name);
+      emit maskUpdated();
+    }
+  }
+}
+
+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);
+  emit msgUpdated(id);
+}
+
+void DBCManager::removeMsg(const MessageId &id) {
+  auto dbc_file = findDBCFile(id);
+  assert(dbc_file);  // This should be impossible
+  dbc_file->removeMsg(id);
+  emit msgRemoved(id);
+  emit maskUpdated();
+}
+
+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(nullptr);
+  return &dbc_manager;
+}

openpilot/tools/cabana/dbc/dbcmanager.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <QObject>
+#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};
+const int INVALID_SOURCE = 0xff;
+inline bool operator<(const std::shared_ptr<DBCFile> &l, const std::shared_ptr<DBCFile> &r) { return l.get() < r.get(); }
+
+class DBCManager : public QObject {
+  Q_OBJECT
+
+public:
+  DBCManager(QObject *parent) : QObject(parent) {}
+  ~DBCManager() {}
+  bool open(const SourceSet &sources, const std::string &dbc_file_name, QString *error = nullptr);
+  bool open(const SourceSet &sources, const std::string &name, const std::string &content, QString *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();
+
+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();
+
+private:
+  std::map<int, std::shared_ptr<DBCFile>> dbc_files;
+};
+
+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;
+}

openpilot/tools/cabana/dbc/generate_dbc_json.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+import argparse
+import json
+from opendbc.car import Bus
+from opendbc.car.fingerprints import MIGRATION
+from opendbc.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}")