IQ.Pilot Release Commit @ e46d557

2026-08-07 00:13:39 -05:00
parent 03c3158b81
commit 824bb9ddfd
216 changed files with 7457 additions and 3151 deletions
--- a/tools/cabana/streams/abstractstream.cc
+++ b/tools/cabana/streams/abstractstream.cc
@@ -1,4 +1,5 @@
 #include "tools/cabana/streams/abstractstream.h"
+#include "tools/cabana/dbc/dbcqt.h"

 #include <limits>
 #include <utility>
@@ -18,8 +19,8 @@ AbstractStream::AbstractStream(QObject *parent) : QObject(parent) {
  QObject::connect(this, &AbstractStream::privateUpdateLastMsgsSignal, this, &AbstractStream::updateLastMessages, Qt::QueuedConnection);
  QObject::connect(this, &AbstractStream::seekedTo, this, &AbstractStream::updateLastMsgsTo);
  QObject::connect(this, &AbstractStream::seeking, this, [this](double sec) { current_sec_ = sec; });
-  QObject::connect(dbc(), &DBCManager::DBCFileChanged, this, &AbstractStream::updateMasks);
-  QObject::connect(dbc(), &DBCManager::maskUpdated, this, &AbstractStream::updateMasks);
+  QObject::connect(dbcNotifier(), &QtDBCNotifier::DBCFileChanged, this, &AbstractStream::updateMasks);
+  QObject::connect(dbcNotifier(), &QtDBCNotifier::maskUpdated, this, &AbstractStream::updateMasks);
 }

 void AbstractStream::updateMasks() {
@@ -233,18 +234,18 @@ std::pair<CanEventIter, CanEventIter> AbstractStream::eventsInRange(const Messag
 namespace {

 enum Color { GREYISH_BLUE, CYAN, RED};
-QColor getColor(int c) {
+CabanaColor getColor(int c) {
  constexpr int start_alpha = 128;
-  static const QColor colors[] = {
-      [GREYISH_BLUE] = QColor(102, 86, 169, start_alpha / 2),
-      [CYAN] = QColor(0, 187, 255, start_alpha),
-      [RED] = QColor(255, 0, 0, start_alpha),
+  static const CabanaColor colors[] = {
+      [GREYISH_BLUE] = CabanaColor(102, 86, 169, start_alpha / 2),
+      [CYAN] = CabanaColor(0, 187, 255, start_alpha),
+      [RED] = CabanaColor(255, 0, 0, start_alpha),
  };
  return settings.theme == LIGHT_THEME ? colors[c] : colors[c].lighter(135);
 }

-inline QColor blend(const QColor &a, const QColor &b) {
-  return QColor((a.red() + b.red()) / 2, (a.green() + b.green()) / 2, (a.blue() + b.blue()) / 2, (a.alpha() + b.alpha()) / 2);
+inline CabanaColor blend(const CabanaColor &a, const CabanaColor &b) {
+  return CabanaColor((a.red() + b.red()) / 2, (a.green() + b.green()) / 2, (a.blue() + b.blue()) / 2, (a.alpha() + b.alpha()) / 2);
 }

 // Calculate the frequency from the past one minute data
@@ -271,7 +272,7 @@ void CanData::compute(const MessageId &msg_id, const uint8_t *can_data, const in

  if (dat.size() != size) {
    dat.assign(can_data, can_data + size);
-    colors.assign(size, QColor(0, 0, 0, 0));
+    colors.assign(size, CabanaColor(0, 0, 0, 0));
    last_changes.resize(size);
    bit_flip_counts.resize(size);
    std::for_each(last_changes.begin(), last_changes.end(), [current_sec](auto &c) { c.ts = current_sec; });
@@ -317,7 +318,7 @@ void CanData::compute(const MessageId &msg_id, const uint8_t *can_data, const in
        last_change.delta = delta;
      } else {
        // Fade out
-        colors[i].setAlphaF(std::max(0.0, colors[i].alphaF() - alpha_delta));
+        colors[i].setAlphaF(std::max(0.0f, colors[i].alphaF() - alpha_delta));
      }
    }
  }
--- a/tools/cabana/streams/abstractstream.h
+++ b/tools/cabana/streams/abstractstream.h
@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <array>
 #include <condition_variable>
+#include <chrono>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -11,51 +12,12 @@
 #include <utility>
 #include <vector>

-#include <QColor>
-#include <QDateTime>
-
 #include "cereal/messaging/messaging.h"
+#include "tools/cabana/core/can_data.h"
 #include "tools/cabana/dbc/dbcmanager.h"
 #include "tools/cabana/utils/util.h"
 #include "tools/replay/util.h"

-struct CanData {
-  void compute(const MessageId &msg_id, const uint8_t *dat, const int size, double current_sec,
-               double playback_speed, const std::vector<uint8_t> &mask, double in_freq = 0);
-
-  double ts = 0.;
-  uint32_t count = 0;
-  double freq = 0;
-  std::vector<uint8_t> dat;
-  std::vector<QColor> colors;
-
-  struct ByteLastChange {
-    double ts = 0;
-    int delta = 0;
-    int same_delta_counter = 0;
-    bool suppressed = false;
-  };
-  std::vector<ByteLastChange> last_changes;
-  std::vector<std::array<uint32_t, 8>> bit_flip_counts;
-  double last_freq_update_ts = 0;
-};
-
-struct CanEvent {
-  uint8_t src;
-  uint32_t address;
-  uint64_t mono_time;
-  uint8_t size;
-  uint8_t dat[];
-};
-
-struct CompareCanEvent {
-  constexpr bool operator()(const CanEvent *const e, uint64_t ts) const { return e->mono_time < ts; }
-  constexpr bool operator()(uint64_t ts, const CanEvent *const e) const { return ts < e->mono_time; }
-};
-
-typedef std::unordered_map<MessageId, std::vector<const CanEvent *>> MessageEventsMap;
-using CanEventIter = std::vector<const CanEvent *>::const_iterator;
-
 class AbstractStream : public QObject {
  Q_OBJECT

@@ -65,9 +27,9 @@ public:
  virtual void start() = 0;
  virtual bool liveStreaming() const { return true; }
  virtual void seekTo(double ts) {}
-  virtual QString routeName() const = 0;
-  virtual QString carFingerprint() const { return ""; }
-  virtual QDateTime beginDateTime() const { return {}; }
+  virtual std::string routeName() const = 0;
+  virtual std::string carFingerprint() const { return ""; }
+  virtual std::chrono::system_clock::time_point beginDateTime() const { return {}; }
  virtual uint64_t beginMonoTime() const { return 0; }
  virtual double minSeconds() const { return 0; }
  virtual double maxSeconds() const { return 0; }
@@ -113,12 +75,12 @@ protected:
  const CanEvent *newEvent(uint64_t mono_time, const cereal::CanData::Reader &c);
  void updateEvent(const MessageId &id, double sec, const uint8_t *data, uint8_t size);
  void waitForSeekFinshed();
+  virtual void updateLastMessages();
  std::vector<const CanEvent *> all_events_;
  double current_sec_ = 0;
  std::optional<std::pair<double, double>> time_range_;

 private:
-  void updateLastMessages();
  void updateLastMsgsTo(double sec);
  void updateMasks();

@@ -149,7 +111,7 @@ class DummyStream : public AbstractStream {
  Q_OBJECT
 public:
  DummyStream(QObject *parent) : AbstractStream(parent) {}
-  QString routeName() const override { return tr("No Stream"); }
+  std::string routeName() const override { return "No Stream"; }
  void start() override {}
 };

--- a/tools/cabana/streams/devicestream.cc
+++ b/tools/cabana/streams/devicestream.cc
@@ -1,34 +1,123 @@
 #include "tools/cabana/streams/devicestream.h"

+#include <cerrno>
+#include <chrono>
+#include <csignal>
+#include <cstring>
+#include <fcntl.h>
+#include <filesystem>
 #include <memory>
 #include <string>
+#include <thread>
+#include <unistd.h>
+#include <sys/wait.h>

 #include "cereal/services.h"

 #include <QButtonGroup>
 #include <QFormLayout>
+#include <QMessageBox>
 #include <QRadioButton>
-#include <QRegularExpression>
-#include <QRegularExpressionValidator>
-#include <QThread>
+
+#include "tools/cabana/utils/util.h"

 // DeviceStream

-DeviceStream::DeviceStream(QObject *parent, QString address) : zmq_address(address), LiveStream(parent) {
+DeviceStream::DeviceStream(QObject *parent, Mode mode, QString address)
+    : mode_(mode), address_(address.isEmpty() ? "127.0.0.1" : address), LiveStream(parent) {
+}
+
+DeviceStream::~DeviceStream() {
+  stop();
+  stopBridge();
+}
+
+void DeviceStream::stopBridge() {
+  if (bridge_pid <= 0) return;
+
+  ::kill(bridge_pid, SIGTERM);
+  for (int i = 0; i < 30; ++i) {
+    int status = 0;
+    pid_t r = ::waitpid(bridge_pid, &status, WNOHANG);
+    if (r == bridge_pid || (r < 0 && errno == ECHILD)) {
+      bridge_pid = -1;
+      return;
+    }
+    usleep(100000);  // 100ms, up to ~3s
+  }
+  ::kill(bridge_pid, SIGKILL);
+  ::waitpid(bridge_pid, nullptr, 0);
+  bridge_pid = -1;
+}
+
+void DeviceStream::start() {
+  if (mode_ == Mode::Bridge) {
+    stopBridge();
+    const std::string path = (std::filesystem::path(QCoreApplication::applicationDirPath().toStdString()) /
+                              "../../cereal/messaging/bridge").lexically_normal().string();
+    const std::string addr = address_.toStdString();
+    const char *can_filter = "/\"can/\"";
+
+    // Self-pipe: write end is CLOEXEC so it closes on successful exec. If exec
+    // fails, the child writes errno and the parent aborts stream start.
+    int err_pipe[2] = {-1, -1};
+    if (::pipe(err_pipe) != 0) {
+      QMessageBox::warning(nullptr, tr("Error"),
+                           tr("Failed to start bridge: %1").arg(QString::fromLocal8Bit(strerror(errno))));
+      return;
+    }
+
+    pid_t pid = ::fork();
+    if (pid == 0) {
+      ::close(err_pipe[0]);
+      ::fcntl(err_pipe[1], F_SETFD, FD_CLOEXEC);
+      execl(path.c_str(), path.c_str(), addr.c_str(), can_filter, static_cast<char *>(nullptr));
+      const int err = errno;
+      (void)!::write(err_pipe[1], &err, sizeof(err));
+      _exit(127);
+    }
+
+    ::close(err_pipe[1]);
+    if (pid < 0) {
+      ::close(err_pipe[0]);
+      QMessageBox::warning(nullptr, tr("Error"),
+                           tr("Failed to start bridge: %1").arg(QString::fromLocal8Bit(strerror(errno))));
+      return;
+    }
+
+    int exec_errno = 0;
+    const ssize_t n = ::read(err_pipe[0], &exec_errno, sizeof(exec_errno));
+    ::close(err_pipe[0]);
+    if (n == static_cast<ssize_t>(sizeof(exec_errno))) {
+      // Child failed to exec; reap and surface the error.
+      int status = 0;
+      ::waitpid(pid, &status, 0);
+      QMessageBox::warning(nullptr, tr("Error"),
+                           tr("Failed to start bridge: %1").arg(QString::fromLocal8Bit(strerror(exec_errno))));
+      return;
+    }
+
+    bridge_pid = pid;
+  }
+
+  LiveStream::start();
 }

 void DeviceStream::streamThread() {
-  zmq_address.isEmpty() ? unsetenv("ZMQ") : setenv("ZMQ", "1", 1);
+  // Bridge mode republishes into local msgq, so only the direct Zmq mode talks ZMQ.
+  // (Upstream sets ZMQ=1 for its bridge path too, which reads nothing — the bridge
+  // publishes to msgq.)
+  mode_ == Mode::Zmq ? setenv("ZMQ", "1", 1) : unsetenv("ZMQ");
+  const std::string address = mode_ == Mode::Zmq ? address_.toStdString() : "127.0.0.1";

  std::unique_ptr<Context> context(Context::create());
-  std::string address = zmq_address.isEmpty() ? "127.0.0.1" : zmq_address.toStdString();
  std::unique_ptr<SubSocket> sock(SubSocket::create(context.get(), "can", address, false, true, services.at("can").queue_size));
  assert(sock != NULL);
  // run as fast as messages come in
-  while (!QThread::currentThread()->isInterruptionRequested()) {
+  while (!exit_) {
    std::unique_ptr<Message> msg(sock->receive(true));
    if (!msg) {
-      QThread::msleep(50);
+      std::this_thread::sleep_for(std::chrono::milliseconds(50));
      continue;
    }
    handleEvent(kj::ArrayPtr<capnp::word>((capnp::word*)msg->getData(), msg->getSize() / sizeof(capnp::word)));
@@ -40,28 +129,30 @@ void DeviceStream::streamThread() {
 OpenDeviceWidget::OpenDeviceWidget(QWidget *parent) : AbstractOpenStreamWidget(parent) {
  QRadioButton *msgq = new QRadioButton(tr("MSGQ"));
  QRadioButton *zmq = new QRadioButton(tr("ZMQ"));
+  QRadioButton *bridge = new QRadioButton(tr("Bridge"));
+  zmq->setToolTip(tr("Subscribe directly to a ZMQ 'can' publisher: a device running "
+                     "cereal/messaging/bridge, or konn3kt_canproxy.py on 127.0.0.1."));
+  bridge->setToolTip(tr("Run cereal/messaging/bridge locally against the device and read msgq."));
  ip_address = new QLineEdit(this);
  ip_address->setPlaceholderText(tr("Enter device Ip Address"));
-  QString ip_range = "(?:[0-1]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])";
-  QString pattern("^" + ip_range + "\\." + ip_range + "\\." + ip_range + "\\." + ip_range + "$");
-  QRegularExpression re(pattern);
-  ip_address->setValidator(new QRegularExpressionValidator(re, this));
+  ip_address->setValidator(new IpAddressValidator(this));

  group = new QButtonGroup(this);
-  group->addButton(msgq, 0);
-  group->addButton(zmq, 1);
+  group->addButton(msgq, static_cast<int>(DeviceStream::Mode::Msgq));
+  group->addButton(zmq, static_cast<int>(DeviceStream::Mode::Zmq));
+  group->addButton(bridge, static_cast<int>(DeviceStream::Mode::Bridge));

  QFormLayout *form_layout = new QFormLayout(this);
  form_layout->addRow(msgq);
  form_layout->addRow(zmq, ip_address);
+  form_layout->addRow(bridge);
  QObject::connect(group, qOverload<QAbstractButton *, bool>(&QButtonGroup::buttonToggled), [=](QAbstractButton *button, bool checked) {
-    ip_address->setEnabled(button == zmq && checked);
+    if (checked) ip_address->setEnabled(button != msgq);
  });
  zmq->setChecked(true);
 }

 AbstractStream *OpenDeviceWidget::open() {
-  QString ip = ip_address->text().isEmpty() ? "127.0.0.1" : ip_address->text();
-  bool msgq = group->checkedId() == 0;
-  return new DeviceStream(qApp, msgq ? "" : ip);
+  auto mode = static_cast<DeviceStream::Mode>(group->checkedId());
+  return new DeviceStream(qApp, mode, mode == DeviceStream::Mode::Msgq ? "" : ip_address->text());
 }
--- a/tools/cabana/streams/devicestream.h
+++ b/tools/cabana/streams/devicestream.h
@@ -2,17 +2,37 @@

 #include "tools/cabana/streams/livestream.h"

+#include <sys/types.h>
+
+// IQ.Pilot patch: upstream (#38484) folded the ZMQ path into "fork a local bridge and
+// read msgq". iqpilot needs the direct ZMQ attach kept as a first-class mode, because
+// tools/cabana/konn3kt_canproxy.py publishes a remote device's CAN onto a LOCAL ZMQ
+// "can" socket and Cabana attaches to it — see that script's header for the topology.
+// So the mode is explicit rather than inferred from whether an address was entered:
+//
+//   Msgq   - local msgq, no address                     (cabana running on the device)
+//   Zmq    - ZMQ subscribe straight to <address>        (konn3kt_canproxy, or `bridge` on the device)
+//   Bridge - fork cereal/messaging/bridge <address>,    (upstream's convenience path)
+//            which ZMQ-subscribes there and republishes
+//            to local msgq, then read msgq
 class DeviceStream : public LiveStream {
  Q_OBJECT
 public:
-  DeviceStream(QObject *parent, QString address = {});
-  inline QString routeName() const override {
-    return QString("Live Streaming From %1").arg(zmq_address.isEmpty() ? "127.0.0.1" : zmq_address);
+  enum class Mode { Msgq, Zmq, Bridge };
+
+  DeviceStream(QObject *parent, Mode mode = Mode::Msgq, QString address = {});
+  ~DeviceStream();
+  inline std::string routeName() const override {
+    return "Live Streaming From " + address_.toStdString();
  }

 protected:
+  void start() override;
  void streamThread() override;
-  const QString zmq_address;
+  void stopBridge();
+  pid_t bridge_pid = -1;
+  const Mode mode_;
+  const QString address_;
 };

 class OpenDeviceWidget : public AbstractOpenStreamWidget {
--- a/tools/cabana/streams/livestream.cc
+++ b/tools/cabana/streams/livestream.cc
@@ -1,9 +1,11 @@
 #include "tools/cabana/streams/livestream.h"

-#include <QThread>
 #include <algorithm>
+#include <chrono>
 #include <fstream>
+#include <iomanip>
 #include <memory>
+#include <sstream>

 #include "common/timing.h"
 #include "common/util.h"
@@ -14,9 +16,14 @@ struct LiveStream::Logger {
  void write(kj::ArrayPtr<capnp::word> data) {
    int n = (seconds_since_epoch() - start_ts) / 60.0;
    if (std::exchange(segment_num, n) != segment_num) {
+      const time_t start_time = start_ts;
+      std::tm local_time = {};
+      localtime_r(&start_time, &local_time);
+      std::ostringstream date;
+      date << std::put_time(&local_time, "%Y-%m-%d--%H-%M-%S");
      QString dir = QString("%1/%2--%3")
-                        .arg(settings.log_path)
-                        .arg(QDateTime::fromSecsSinceEpoch(start_ts).toString("yyyy-MM-dd--hh-mm-ss"))
+                        .arg(QString::fromStdString(settings.log_path))
+                        .arg(QString::fromStdString(date.str()))
                        .arg(n);
      util::create_directories(dir.toStdString(), 0755);
      fs.reset(new std::ofstream((dir + "/rlog").toStdString(), std::ios::binary | std::ios::out));
@@ -35,37 +42,34 @@ LiveStream::LiveStream(QObject *parent) : AbstractStream(parent) {
  if (settings.log_livestream) {
    logger = std::make_unique<Logger>();
  }
-  stream_thread = new QThread(this);
-
-  QObject::connect(&settings, &Settings::changed, this, &LiveStream::startUpdateTimer);
-  QObject::connect(stream_thread, &QThread::started, [=]() { streamThread(); });
-  QObject::connect(stream_thread, &QThread::finished, stream_thread, &QThread::deleteLater);
 }

 LiveStream::~LiveStream() {
  stop();
 }

-void LiveStream::startUpdateTimer() {
-  update_timer.stop();
-  update_timer.start(1000.0 / settings.fps, this);
-  timer_id = update_timer.timerId();
-}
-
 void LiveStream::start() {
-  stream_thread->start();
-  startUpdateTimer();
-  begin_date_time = QDateTime::currentDateTime();
+  begin_date_time = std::chrono::system_clock::now();
+  fps_ = settings.fps;
+  exit_ = false;
+  stream_thread = std::thread(&LiveStream::streamThread, this);
+  update_thread = std::thread(&LiveStream::updateThread, this);
 }

 void LiveStream::stop() {
-  if (!stream_thread) return;
+  exit_ = true;
+  if (stream_thread.joinable()) stream_thread.join();
+  if (update_thread.joinable()) update_thread.join();
+}

-  update_timer.stop();
-  stream_thread->requestInterruption();
-  stream_thread->quit();
-  stream_thread->wait();
-  stream_thread = nullptr;
+void LiveStream::updateThread() {
+  while (!exit_) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1000 / fps_));
+    // coalesce: skip the emit if the main thread hasn't processed the previous one yet.
+    if (!update_pending_.exchange(true)) {
+      emit privateUpdateLastMsgsSignal();
+    }
+  }
 }

 // called in streamThread
@@ -85,23 +89,22 @@ void LiveStream::handleEvent(kj::ArrayPtr<capnp::word> data) {
  }
 }

-void LiveStream::timerEvent(QTimerEvent *event) {
-  if (event->timerId() == timer_id) {
-    {
-      // merge events received from live stream thread.
-      std::lock_guard lk(lock);
-      mergeEvents(received_events_);
-      uint64_t last_received_ts = !received_events_.empty() ? received_events_.back()->mono_time : 0;
-      lastest_event_ts = std::max(lastest_event_ts, last_received_ts);
-      received_events_.clear();
-    }
-    if (!all_events_.empty()) {
-      begin_event_ts = all_events_.front()->mono_time;
-      updateEvents();
-      return;
-    }
+// called on the main thread by the queued privateUpdateLastMsgsSignal connection
+void LiveStream::updateLastMessages() {
+  update_pending_ = false;
+  fps_ = settings.fps;
+  {
+    // merge events received from live stream thread.
+    std::lock_guard lk(lock);
+    mergeEvents(received_events_);
+    uint64_t last_received_ts = !received_events_.empty() ? received_events_.back()->mono_time : 0;
+    lastest_event_ts = std::max(lastest_event_ts, last_received_ts);
+    received_events_.clear();
+  }
+  if (!all_events_.empty()) {
+    begin_event_ts = all_events_.front()->mono_time;
+    updateEvents();
  }
-  QObject::timerEvent(event);
 }

 void LiveStream::updateEvents() {
@@ -131,7 +134,7 @@ void LiveStream::updateEvents() {
    updateEvent(id, (e->mono_time - begin_event_ts) / 1e9, e->dat, e->size);
    current_event_ts = e->mono_time;
  }
-  emit privateUpdateLastMsgsSignal();
+  AbstractStream::updateLastMessages();
 }

 void LiveStream::seekTo(double sec) {
--- a/tools/cabana/streams/livestream.h
+++ b/tools/cabana/streams/livestream.h
@@ -1,11 +1,11 @@
 #pragma once

 #include <algorithm>
+#include <atomic>
 #include <memory>
+#include <thread>
 #include <vector>

-#include <QBasicTimer>
-
 #include "tools/cabana/streams/abstractstream.h"

 class LiveStream : public AbstractStream {
@@ -16,7 +16,7 @@ public:
  virtual ~LiveStream();
  void start() override;
  void stop();
-  inline QDateTime beginDateTime() const { return begin_date_time; }
+  inline std::chrono::system_clock::time_point beginDateTime() const override { return begin_date_time; }
  inline uint64_t beginMonoTime() const override { return begin_event_ts; }
  double maxSeconds() const override { return std::max(1.0, (lastest_event_ts - begin_event_ts) / 1e9); }
  void setSpeed(float speed) override { speed_ = speed; }
@@ -29,19 +29,20 @@ protected:
  virtual void streamThread() = 0;
  void handleEvent(kj::ArrayPtr<capnp::word> event);

+  std::atomic<bool> exit_ = false;
+
 private:
-  void startUpdateTimer();
-  void timerEvent(QTimerEvent *event) override;
+  void updateThread();
+  void updateLastMessages() override;
  void updateEvents();

  std::mutex lock;
-  QThread *stream_thread;
+  std::thread stream_thread, update_thread;
+  std::atomic<bool> update_pending_ = false;
+  std::atomic<int> fps_ = 10;
  std::vector<const CanEvent *> received_events_;

-  int timer_id;
-  QBasicTimer update_timer;
-
-  QDateTime begin_date_time;
+  std::chrono::system_clock::time_point begin_date_time;
  uint64_t begin_event_ts = 0;
  uint64_t lastest_event_ts = 0;
  uint64_t current_event_ts = 0;
--- a/tools/cabana/streams/pandastream.cc
+++ b/tools/cabana/streams/pandastream.cc
@@ -1,11 +1,13 @@
 #include "tools/cabana/streams/pandastream.h"

-#include <QDebug>
+#include <chrono>
+#include <cstdio>
+#include <thread>
+
 #include <QCheckBox>
 #include <QLabel>
 #include <QMessageBox>
 #include <QPushButton>
-#include <QThread>
 #include <QTimer>

 PandaStream::PandaStream(QObject *parent, PandaStreamConfig config_) : config(config_), LiveStream(parent) {
@@ -16,34 +18,48 @@ PandaStream::PandaStream(QObject *parent, PandaStreamConfig config_) : config(co

 bool PandaStream::connect() {
  try {
-    qDebug() << "Connecting to panda " << config.serial;
-    panda.reset(new Panda(config.serial.toStdString(), 0, true));
+    fprintf(stderr, "Connecting to panda %s\n", config.serial.c_str());
+    panda.reset(new Panda(config.serial));
    config.bus_config.resize(3);
-    qDebug() << "Connected";
+    fprintf(stderr, "Connected\n");
  } catch (const std::exception& e) {
    return false;
  }

+  panda->set_safety_model(cereal::CarParams::SafetyModel::NO_OUTPUT);
+  for (int bus = 0; bus < config.bus_config.size(); bus++) {
+    panda->set_can_speed_kbps(bus, config.bus_config[bus].can_speed_kbps);
+
+    // CAN-FD
+    if (panda->hw_type == cereal::PandaState::PandaType::RED_PANDA || panda->hw_type == cereal::PandaState::PandaType::RED_PANDA_V2) {
+      if (config.bus_config[bus].can_fd) {
+        panda->set_data_speed_kbps(bus, config.bus_config[bus].data_speed_kbps);
+      } else {
+        // Hack to disable can-fd by setting data speed to a low value
+        panda->set_data_speed_kbps(bus, 10);
+      }
+    }
+  }
  return true;
 }

 void PandaStream::streamThread() {
  std::vector<can_frame> raw_can_data;

-  while (!QThread::currentThread()->isInterruptionRequested()) {
-    QThread::msleep(1);
+  while (!exit_) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));

    if (!panda->connected()) {
-      qDebug() << "Connection to panda lost. Attempting reconnect.";
+      fprintf(stderr, "Connection to panda lost. Attempting reconnect.\n");
      if (!connect()){
-        QThread::msleep(1000);
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        continue;
      }
    }

    raw_can_data.clear();
    if (!panda->can_receive(raw_can_data)) {
-      qDebug() << "failed to receive";
+      fprintf(stderr, "failed to receive\n");
      continue;
    }

@@ -58,6 +74,7 @@ void PandaStream::streamThread() {

    handleEvent(capnp::messageToFlatArray(msg));

+    panda->send_heartbeat(false);
  }
 }

@@ -66,7 +83,7 @@ void PandaStream::streamThread() {
 OpenPandaWidget::OpenPandaWidget(QWidget *parent) : AbstractOpenStreamWidget(parent) {
  form_layout = new QFormLayout(this);
  if (can && dynamic_cast<PandaStream *>(can) != nullptr) {
-    form_layout->addWidget(new QLabel(tr("Already connected to %1.").arg(can->routeName())));
+    form_layout->addWidget(new QLabel(tr("Already connected to %1.").arg(QString::fromStdString(can->routeName()))));
    form_layout->addWidget(new QLabel("Close the current connection via [File menu -> Close Stream] before connecting to another Panda."));
    QTimer::singleShot(0, [this]() { emit enableOpenButton(false); });
    return;
@@ -105,16 +122,16 @@ void OpenPandaWidget::buildConfigForm() {
  bool has_panda = !serial.isEmpty();
  if (has_panda) {
    try {
-      Panda panda(serial.toStdString(), 0, true);
+      Panda panda(serial.toStdString());
      has_fd = (panda.hw_type == cereal::PandaState::PandaType::RED_PANDA) || (panda.hw_type == cereal::PandaState::PandaType::RED_PANDA_V2);
    } catch (const std::exception& e) {
-      qDebug() << "failed to open panda" << serial;
+      fprintf(stderr, "failed to open panda %s\n", serial.toUtf8().constData());
      has_panda = false;
    }
  }

  if (has_panda) {
-    config.serial = serial;
+    config.serial = serial.toStdString();
    config.bus_config.resize(3);
    for (int i = 0; i < config.bus_config.size(); i++) {
      QHBoxLayout *bus_layout = new QHBoxLayout;
--- a/tools/cabana/streams/pandastream.h
+++ b/tools/cabana/streams/pandastream.h
@@ -19,7 +19,7 @@ struct BusConfig {
 };

 struct PandaStreamConfig {
-  QString serial = "";
+  std::string serial = "";
  std::vector<BusConfig> bus_config;
 };

@@ -28,8 +28,8 @@ class PandaStream : public LiveStream {
 public:
  PandaStream(QObject *parent, PandaStreamConfig config_ = {});
  ~PandaStream() { stop(); }
-  inline QString routeName() const override {
-    return QString("Panda: %1").arg(config.serial);
+  inline std::string routeName() const override {
+    return "Panda: " + config.serial;
  }

 protected:
--- a/tools/cabana/streams/replaystream.cc
+++ b/tools/cabana/streams/replaystream.cc
@@ -1,5 +1,7 @@
 #include "tools/cabana/streams/replaystream.h"

+#include <filesystem>
+
 #include <QLabel>
 #include <QFileDialog>
 #include <QGridLayout>
@@ -14,10 +16,7 @@ ReplayStream::ReplayStream(QObject *parent) : AbstractStream(parent) {
  unsetenv("ZMQ");
  setenv("COMMA_CACHE", "/tmp/comma_download_cache", 1);

-  // TODO: Remove when OpenpilotPrefix supports ZMQ
-#ifndef __APPLE__
  op_prefix = std::make_unique<OpenpilotPrefix>();
-#endif

  QObject::connect(&settings, &Settings::changed, this, [this]() {
    if (replay) replay->setSegmentCacheLimit(settings.max_cached_minutes);
@@ -46,9 +45,9 @@ void ReplayStream::mergeSegments() {
  }
 }

-bool ReplayStream::loadRoute(const QString &route, const QString &data_dir, uint32_t replay_flags, bool auto_source) {
-  replay.reset(new Replay(route.toStdString(), {"can", "roadEncodeIdx", "driverEncodeIdx", "wideRoadEncodeIdx", "carParams"},
-                          {}, nullptr, replay_flags, data_dir.toStdString(), auto_source));
+bool ReplayStream::loadRoute(const std::string &route, const std::string &data_dir, uint32_t replay_flags, bool auto_source) {
+  replay.reset(new Replay(route, {"can", "roadEncodeIdx", "driverEncodeIdx", "wideRoadEncodeIdx", "carParams"},
+                          {}, nullptr, replay_flags, data_dir, auto_source));
  replay->setSegmentCacheLimit(settings.max_cached_minutes);
  replay->installEventFilter([this](const Event *event) { return eventFilter(event); });

@@ -68,21 +67,21 @@ bool ReplayStream::loadRoute(const QString &route, const QString &data_dir, uint
      QString message;
      if (auth_content.empty()) {
        message = "Authentication Required. Please run the following command to authenticate:\n\n"
-                  "python3 tools/lib/auth.py\n\n"
+                  "python3 openpilot/tools/lib/auth.py\n\n"
                  "This will grant access to routes from your comma account.";
      } else {
        message = tr("Access Denied. You do not have permission to access route:\n\n%1\n\n"
-                     "This is likely a private route.").arg(route);
+                     "This is likely a private route.").arg(QString::fromStdString(route));
      }
      QMessageBox::warning(nullptr, tr("Access Denied"), message);
    } else if (replay->lastRouteError() == RouteLoadError::NetworkError) {
      QMessageBox::warning(nullptr, tr("Network Error"),
-                          tr("Unable to load the route:\n\n %1.\n\nPlease check your network connection and try again.").arg(route));
+                          tr("Unable to load the route:\n\n %1.\n\nPlease check your network connection and try again.").arg(QString::fromStdString(route)));
    } else if (replay->lastRouteError() == RouteLoadError::FileNotFound) {
      QMessageBox::warning(nullptr, tr("Route Not Found"),
-                           tr("The specified route could not be found:\n\n %1.\n\nPlease check the route name and try again.").arg(route));
+                           tr("The specified route could not be found:\n\n %1.\n\nPlease check the route name and try again.").arg(QString::fromStdString(route)));
    } else {
-      QMessageBox::warning(nullptr, tr("Route Load Failed"), tr("Failed to load route: '%1'").arg(route));
+      QMessageBox::warning(nullptr, tr("Route Load Failed"), tr("Failed to load route: '%1'").arg(QString::fromStdString(route)));
    }
  }
  return success;
@@ -136,10 +135,10 @@ OpenReplayWidget::OpenReplayWidget(QWidget *parent) : AbstractOpenStreamWidget(p

  setMinimumWidth(550);
  QObject::connect(browse_local_btn, &QPushButton::clicked, [=]() {
-    QString dir = QFileDialog::getExistingDirectory(this, tr("Open Local Route"), settings.last_route_dir);
+    QString dir = QFileDialog::getExistingDirectory(this, tr("Open Local Route"), QString::fromStdString(settings.last_route_dir));
    if (!dir.isEmpty()) {
      route_edit->setText(dir);
-      settings.last_route_dir = QFileInfo(dir).absolutePath();
+      settings.last_route_dir = std::filesystem::absolute(dir.toStdString()).parent_path().string();
    }
  });
  QObject::connect(browse_remote_btn, &QPushButton::clicked, [this]() {
@@ -168,7 +167,7 @@ AbstractStream *OpenReplayWidget::open() {
    if (cameras[2]->isChecked()) flags |= REPLAY_FLAG_ECAM;
    if (flags == REPLAY_FLAG_NONE && !cameras[0]->isChecked()) flags = REPLAY_FLAG_NO_VIPC;

-    if (replay_stream->loadRoute(route, data_dir, flags)) {
+    if (replay_stream->loadRoute(route.toStdString(), data_dir.toStdString(), flags)) {
      return replay_stream.release();
    }
  }
--- a/tools/cabana/streams/replaystream.h
+++ b/tools/cabana/streams/replaystream.h
@@ -18,15 +18,17 @@ class ReplayStream : public AbstractStream {
 public:
  ReplayStream(QObject *parent);
  void start() override { replay->start(); }
-  bool loadRoute(const QString &route, const QString &data_dir, uint32_t replay_flags = REPLAY_FLAG_NONE, bool auto_source = false);
+  bool loadRoute(const std::string &route, const std::string &data_dir, uint32_t replay_flags = REPLAY_FLAG_NONE, bool auto_source = false);
  bool eventFilter(const Event *event);
  void seekTo(double ts) override { replay->seekTo(std::max(double(0), ts), false); }
  bool liveStreaming() const override { return false; }
-  inline QString routeName() const override { return QString::fromStdString(replay->route().name()); }
-  inline QString carFingerprint() const override { return replay->carFingerprint().c_str(); }
+  inline std::string routeName() const override { return replay->route().name(); }
+  inline std::string carFingerprint() const override { return replay->carFingerprint(); }
  double minSeconds() const override { return replay->minSeconds(); }
  double maxSeconds() const { return replay->maxSeconds(); }
-  inline QDateTime beginDateTime() const { return QDateTime::fromSecsSinceEpoch(replay->routeDateTime()); }
+  inline std::chrono::system_clock::time_point beginDateTime() const override {
+    return std::chrono::system_clock::from_time_t(replay->routeDateTime());
+  }
  inline uint64_t beginMonoTime() const override { return replay->routeStartNanos(); }
  inline void setSpeed(float speed) override { replay->setSpeed(speed); }
  inline float getSpeed() const { return replay->getSpeed(); }
--- a/tools/cabana/streams/routes.cc
+++ b/tools/cabana/streams/routes.cc
@@ -1,27 +1,77 @@
 #include "tools/cabana/streams/routes.h"

-#include <QDateTime>
+#include <chrono>
+#include <ctime>
+#include <string>
+#include <thread>
+#include <utility>
+
+#include <QApplication>
 #include <QDialogButtonBox>
 #include <QFormLayout>
-#include <QJsonArray>
-#include <QJsonDocument>
 #include <QListWidget>
 #include <QMessageBox>
 #include <QPainter>

-class OneShotHttpRequest : public HttpRequest {
-public:
-  OneShotHttpRequest(QObject *parent) : HttpRequest(parent, false) {}
-  void send(const QString &url) {
-    if (reply) {
-      reply->disconnect();
-      reply->abort();
-      reply->deleteLater();
-      reply = nullptr;
-    }
-    sendRequest(url);
+#include "third_party/json11/json11.hpp"
+// IQ.Pilot patch: iqpilot's tools/replay has no py_downloader — device and route
+// listing come from the konn3kt API over libcurl. CommaApi2 returns the same JSON
+// shapes and the same {"error": ...} envelope upstream's PyDownloader produces, so
+// only the call sites change.
+#include "tools/replay/api.h"
+
+namespace {
+
+// Parse a konn3kt API JSON response into (success, error_code).
+std::pair<bool, int> checkApiResponse(const std::string &result) {
+  if (result.empty()) return {false, 500};
+  std::string err;
+  auto doc = json11::Json::parse(result, err);
+  if (!err.empty()) return {false, 500};
+  if (doc.is_object() && doc["error"].is_string()) {
+    return {false, doc["error"].string_value() == "unauthorized" ? 401 : 500};
  }
-};
+  return {true, 0};
+}
+
+int64_t nowUnixMs() {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(
+             std::chrono::system_clock::now().time_since_epoch())
+      .count();
+}
+
+// Parse ISO-8601 (with optional fractional seconds / Z) to unix ms. Returns 0 on failure.
+int64_t parseIsoToUnixMs(const std::string &s) {
+  std::string bytes = s;
+  if (!bytes.empty() && (bytes.back() == 'Z' || bytes.back() == 'z')) bytes.pop_back();
+  int millis = 0;
+  auto dot = bytes.find('.');
+  if (dot != std::string::npos) {
+    std::string frac = bytes.substr(dot + 1);
+    bytes = bytes.substr(0, dot);
+    while (frac.size() < 3) frac.push_back('0');
+    millis = std::atoi(frac.substr(0, 3).c_str());
+  }
+  std::tm tm{};
+  const char *ret = strptime(bytes.c_str(), "%Y-%m-%dT%H:%M:%S", &tm);
+  if (!ret) ret = strptime(bytes.c_str(), "%Y-%m-%d %H:%M:%S", &tm);
+  if (!ret) return 0;
+  tm.tm_isdst = -1;
+  time_t secs = timegm(&tm);
+  if (secs == static_cast<time_t>(-1)) return 0;
+  return static_cast<int64_t>(secs) * 1000 + millis;
+}
+
+QString formatUnixMs(int64_t ms) {
+  time_t secs = static_cast<time_t>(ms / 1000);
+  std::tm tm{};
+  localtime_r(&secs, &tm);
+  char buf[64];
+  std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
+  return QString::fromUtf8(buf);
+}
+
+}  // namespace

 // The RouteListWidget class extends QListWidget to display a custom message when empty
 class RouteListWidget : public QListWidget {
@@ -41,7 +91,7 @@ public:
  QString empty_text_ = tr("No items");
 };

-RoutesDialog::RoutesDialog(QWidget *parent) : QDialog(parent), route_requester_(new OneShotHttpRequest(this)) {
+RoutesDialog::RoutesDialog(QWidget *parent) : QDialog(parent) {
  setWindowTitle(tr("Remote routes"));

  QFormLayout *layout = new QFormLayout(this);
@@ -52,41 +102,42 @@ RoutesDialog::RoutesDialog(QWidget *parent) : QDialog(parent), route_requester_(
  layout->addRow(button_box);

  device_list_->addItem(tr("Loading..."));
-  // Populate period selector with predefined durations
  period_selector_->addItem(tr("Last week"), 7);
  period_selector_->addItem(tr("Last 2 weeks"), 14);
  period_selector_->addItem(tr("Last month"), 30);
  period_selector_->addItem(tr("Last 6 months"), 180);
  period_selector_->addItem(tr("Preserved"), -1);

-  // Connect signals and slots
-  QObject::connect(route_requester_, &HttpRequest::requestDone, this, &RoutesDialog::parseRouteList);
  connect(device_list_, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RoutesDialog::fetchRoutes);
  connect(period_selector_, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &RoutesDialog::fetchRoutes);
  connect(route_list_, &QListWidget::itemDoubleClicked, this, &QDialog::accept);
-  QObject::connect(button_box, &QDialogButtonBox::accepted, this, &QDialog::accept);
-  QObject::connect(button_box, &QDialogButtonBox::rejected, this, &QDialog::reject);
+  connect(button_box, &QDialogButtonBox::accepted, this, &QDialog::accept);
+  connect(button_box, &QDialogButtonBox::rejected, this, &QDialog::reject);

-  // Send request to fetch devices
-  HttpRequest *http = new HttpRequest(this, false);
-  QObject::connect(http, &HttpRequest::requestDone, this, &RoutesDialog::parseDeviceList);
-  http->sendRequest(CommaApi::BASE_URL + "/v1/me/devices/");
+  // Fetch devices
+  std::thread([this, alive = std::weak_ptr<bool>(alive_)]() {
+    std::string result = CommaApi2::getDevices();
+    QMetaObject::invokeMethod(qApp, [this, alive, r = QString::fromStdString(result), response = checkApiResponse(result)]() {
+      if (!alive.expired()) parseDeviceList(r, response.first, response.second);
+    }, Qt::QueuedConnection);
+  }).detach();
 }

-void RoutesDialog::parseDeviceList(const QString &json, bool success, QNetworkReply::NetworkError err) {
+void RoutesDialog::parseDeviceList(const QString &json, bool success, int error_code) {
  if (success) {
    device_list_->clear();
-    auto devices = QJsonDocument::fromJson(json.toUtf8()).array();
-    for (const QJsonValue &device : devices) {
-      QString dongle_id = device["dongle_id"].toString();
-      device_list_->addItem(dongle_id, dongle_id);
+    std::string err;
+    auto doc = json11::Json::parse(json.toStdString(), err);
+    if (err.empty() && doc.is_array()) {
+      for (const auto &device : doc.array_items()) {
+        QString dongle_id = QString::fromStdString(device["dongle_id"].string_value());
+        device_list_->addItem(dongle_id, dongle_id);
+      }
    }
  } else {
-    bool unauthorized = (err == QNetworkReply::ContentAccessDenied || err == QNetworkReply::AuthenticationRequiredError);
-    QMessageBox::warning(this, tr("Error"), unauthorized ? tr("Unauthorized, Authenticate with tools/lib/auth.py") : tr("Network error"));
+    QMessageBox::warning(this, tr("Error"), error_code == 401 ? tr("Unauthorized. Authenticate with tools/lib/auth.py") : tr("Network error"));
    reject();
  }
-  sender()->deleteLater();
 }

 void RoutesDialog::fetchRoutes() {
@@ -95,34 +146,45 @@ void RoutesDialog::fetchRoutes() {

  route_list_->clear();
  route_list_->setEmptyText(tr("Loading..."));
-  // Construct URL with selected device and date range
-  QString url = QString("%1/v1/devices/%2").arg(CommaApi::BASE_URL, device_list_->currentText());
+
+  std::string did = device_list_->currentText().toStdString();
  int period = period_selector_->currentData().toInt();
-  if (period == -1) {
-    url += "/routes/preserved";
-  } else {
-    QDateTime now = QDateTime::currentDateTime();
-    url += QString("/routes_segments?start=%1&end=%2")
-               .arg(now.addDays(-period).toMSecsSinceEpoch())
-               .arg(now.toMSecsSinceEpoch());
+
+  bool preserved = (period == -1);
+  int64_t start_ms = 0, end_ms = 0;
+  if (!preserved) {
+    end_ms = nowUnixMs();
+    start_ms = end_ms - static_cast<int64_t>(period) * 24LL * 60LL * 60LL * 1000LL;
  }
-  route_requester_->send(url);
+
+  int request_id = ++fetch_id_;
+  std::thread([this, alive = std::weak_ptr<bool>(alive_), did, start_ms, end_ms, preserved, request_id]() {
+    std::string result = CommaApi2::getDeviceRoutes(did, start_ms, end_ms, preserved);
+    QMetaObject::invokeMethod(qApp, [this, alive, r = QString::fromStdString(result), response = checkApiResponse(result), request_id]() {
+      if (!alive.expired() && fetch_id_ == request_id) parseRouteList(r, response.first, response.second);
+    }, Qt::QueuedConnection);
+  }).detach();
 }

-void RoutesDialog::parseRouteList(const QString &json, bool success, QNetworkReply::NetworkError err) {
+void RoutesDialog::parseRouteList(const QString &json, bool success, int error_code) {
  if (success) {
-    for (const QJsonValue &route : QJsonDocument::fromJson(json.toUtf8()).array()) {
-      QDateTime from, to;
-      if (period_selector_->currentData().toInt() == -1) {
-        from = QDateTime::fromString(route["start_time"].toString(), Qt::ISODateWithMs);
-        to = QDateTime::fromString(route["end_time"].toString(), Qt::ISODateWithMs);
-      } else {
-        from = QDateTime::fromMSecsSinceEpoch(route["start_time_utc_millis"].toDouble());
-        to = QDateTime::fromMSecsSinceEpoch(route["end_time_utc_millis"].toDouble());
+    std::string err;
+    auto doc = json11::Json::parse(json.toStdString(), err);
+    if (err.empty() && doc.is_array()) {
+      for (const auto &route : doc.array_items()) {
+        int64_t from_ms = 0, to_ms = 0;
+        if (period_selector_->currentData().toInt() == -1) {
+          from_ms = parseIsoToUnixMs(route["start_time"].string_value());
+          to_ms = parseIsoToUnixMs(route["end_time"].string_value());
+        } else {
+          from_ms = static_cast<int64_t>(route["start_time_utc_millis"].number_value());
+          to_ms = static_cast<int64_t>(route["end_time_utc_millis"].number_value());
+        }
+        const int mins = static_cast<int>((to_ms - from_ms) / 60000);
+        auto item = new QListWidgetItem(QString("%1    %2min").arg(formatUnixMs(from_ms)).arg(mins));
+        item->setData(Qt::UserRole, QString::fromStdString(route["fullname"].string_value()));
+        route_list_->addItem(item);
      }
-      auto item = new QListWidgetItem(QString("%1    %2min").arg(from.toString()).arg(from.secsTo(to) / 60));
-      item->setData(Qt::UserRole, route["fullname"].toString());
-      route_list_->addItem(item);
    }
    if (route_list_->count() > 0) route_list_->setCurrentRow(0);
  } else {
--- a/tools/cabana/streams/routes.h
+++ b/tools/cabana/streams/routes.h
@@ -1,11 +1,12 @@
 #pragma once

+#include <atomic>
+#include <memory>
+
 #include <QComboBox>
 #include <QDialog>
-#include "tools/cabana/utils/api.h"

 class RouteListWidget;
-class OneShotHttpRequest;

 class RoutesDialog : public QDialog {
  Q_OBJECT
@@ -14,12 +15,14 @@ public:
  QString route();

 protected:
-  void parseDeviceList(const QString &json, bool success, QNetworkReply::NetworkError err);
-  void parseRouteList(const QString &json, bool success, QNetworkReply::NetworkError err);
+  void parseDeviceList(const QString &json, bool success, int error_code);
+  void parseRouteList(const QString &json, bool success, int error_code);
  void fetchRoutes();

  QComboBox *device_list_;
  QComboBox *period_selector_;
  RouteListWidget *route_list_;
-  OneShotHttpRequest *route_requester_;
+  std::atomic<int> fetch_id_{0};
+  // expires on destruction; guards main-thread callbacks from detached worker threads
+  std::shared_ptr<bool> alive_ = std::make_shared<bool>(true);
 };
--- a/tools/cabana/streams/socketcanstream.cc
+++ b/tools/cabana/streams/socketcanstream.cc
@@ -1,67 +1,99 @@
 #include "tools/cabana/streams/socketcanstream.h"

-#include <QDebug>
+#include <linux/can.h>
+#include <linux/can/raw.h>
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+
 #include <QFormLayout>
 #include <QHBoxLayout>
 #include <QMessageBox>
 #include <QPushButton>
-#include <QThread>

 SocketCanStream::SocketCanStream(QObject *parent, SocketCanStreamConfig config_) : config(config_), LiveStream(parent) {
  if (!available()) {
-    throw std::runtime_error("SocketCAN plugin not available");
+    throw std::runtime_error("SocketCAN not available");
  }

-  qDebug() << "Connecting to SocketCAN device" << config.device;
+  fprintf(stderr, "Connecting to SocketCAN device %s\n", config.device.c_str());
  if (!connect()) {
    throw std::runtime_error("Failed to connect to SocketCAN device");
  }
 }

+SocketCanStream::~SocketCanStream() {
+  stop();
+  if (sock_fd >= 0) {
+    ::close(sock_fd);
+    sock_fd = -1;
+  }
+}
+
 bool SocketCanStream::available() {
-  return QCanBus::instance()->plugins().contains("socketcan");
+  int fd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+  if (fd < 0) return false;
+  ::close(fd);
+  return true;
 }

 bool SocketCanStream::connect() {
-  // Connecting might generate some warnings about missing socketcan/libsocketcan libraries
-  // These are expected and can be ignored, we don't need the advanced features of libsocketcan
-  QString errorString;
-  device.reset(QCanBus::instance()->createDevice("socketcan", config.device, &errorString));
-  device->setConfigurationParameter(QCanBusDevice::CanFdKey, true);
-
-  if (!device) {
-    qDebug() << "Failed to create SocketCAN device" << errorString;
+  sock_fd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+  if (sock_fd < 0) {
+    fprintf(stderr, "Failed to create CAN socket\n");
    return false;
  }

-  if (!device->connectDevice()) {
-    qDebug() << "Failed to connect to device";
+  // Enable CAN-FD
+  int fd_enable = 1;
+  setsockopt(sock_fd, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &fd_enable, sizeof(fd_enable));
+
+  struct ifreq ifr = {};
+  strncpy(ifr.ifr_name, config.device.c_str(), IFNAMSIZ - 1);
+  if (ioctl(sock_fd, SIOCGIFINDEX, &ifr) < 0) {
+    fprintf(stderr, "Failed to get interface index for %s\n", config.device.c_str());
+    ::close(sock_fd);
+    sock_fd = -1;
    return false;
  }

+  struct sockaddr_can addr = {};
+  addr.can_family = AF_CAN;
+  addr.can_ifindex = ifr.ifr_ifindex;
+  if (bind(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+    fprintf(stderr, "Failed to bind CAN socket\n");
+    ::close(sock_fd);
+    sock_fd = -1;
+    return false;
+  }
+
+  // Set read timeout so the thread can check for interruption
+  struct timeval tv = {.tv_sec = 0, .tv_usec = 100000};  // 100ms
+  setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+
  return true;
 }

 void SocketCanStream::streamThread() {
-  while (!QThread::currentThread()->isInterruptionRequested()) {
-    QThread::msleep(1);
+  struct canfd_frame frame;

-    auto frames = device->readAllFrames();
-    if (frames.size() == 0) continue;
+  while (!exit_) {
+    ssize_t nbytes = read(sock_fd, &frame, sizeof(frame));
+    if (nbytes <= 0) continue;
+
+    uint8_t len = (nbytes == CAN_MTU) ? frame.len : frame.len;  // works for both CAN and CAN-FD

    MessageBuilder msg;
    auto evt = msg.initEvent();
-    auto canData = evt.initCan(frames.size());
-
-    for (uint i = 0; i < frames.size(); i++) {
-      if (!frames[i].isValid()) continue;
-
-      canData[i].setAddress(frames[i].frameId());
-      canData[i].setSrc(0);
-
-      auto payload = frames[i].payload();
-      canData[i].setDat(kj::arrayPtr((uint8_t*)payload.data(), payload.size()));
-    }
+    auto canData = evt.initCan(1);
+    canData[0].setAddress(frame.can_id & CAN_EFF_MASK);
+    canData[0].setSrc(0);
+    canData[0].setDat(kj::arrayPtr(frame.data, len));

    handleEvent(capnp::messageToFlatArray(msg));
  }
@@ -87,7 +119,7 @@ OpenSocketCanWidget::OpenSocketCanWidget(QWidget *parent) : AbstractOpenStreamWi
  main_layout->addStretch(1);

  QObject::connect(refresh, &QPushButton::clicked, this, &OpenSocketCanWidget::refreshDevices);
-  QObject::connect(device_edit, &QComboBox::currentTextChanged, this, [=]{ config.device = device_edit->currentText(); });
+  QObject::connect(device_edit, &QComboBox::currentTextChanged, this, [=]{ config.device = device_edit->currentText().toStdString(); });

  // Populate devices
  refreshDevices();
@@ -95,12 +127,17 @@ OpenSocketCanWidget::OpenSocketCanWidget(QWidget *parent) : AbstractOpenStreamWi

 void OpenSocketCanWidget::refreshDevices() {
  device_edit->clear();
-  for (auto device : QCanBus::instance()->availableDevices(QStringLiteral("socketcan"))) {
-    device_edit->addItem(device.name());
+  // Scan /sys/class/net/ for CAN interfaces (type 280 = ARPHRD_CAN)
+  std::error_code ec;
+  for (const auto &entry : std::filesystem::directory_iterator("/sys/class/net", ec)) {
+    std::ifstream type_file(entry.path() / "type");
+    int type = 0;
+    if (type_file >> type && type == 280) {
+      device_edit->addItem(QString::fromStdString(entry.path().filename().string()));
+    }
  }
 }

-
 AbstractStream *OpenSocketCanWidget::open() {
  try {
    return new SocketCanStream(qApp, config);
--- a/tools/cabana/streams/socketcanstream.h
+++ b/tools/cabana/streams/socketcanstream.h
@@ -1,27 +1,22 @@
 #pragma once

-#include <memory>
-
-#include <QtSerialBus/QCanBus>
-#include <QtSerialBus/QCanBusDevice>
-#include <QtSerialBus/QCanBusDeviceInfo>
 #include <QComboBox>

 #include "tools/cabana/streams/livestream.h"

 struct SocketCanStreamConfig {
-  QString device = ""; // TODO: support multiple devices/buses at once
+  std::string device = ""; // TODO: support multiple devices/buses at once
 };

 class SocketCanStream : public LiveStream {
  Q_OBJECT
 public:
  SocketCanStream(QObject *parent, SocketCanStreamConfig config_ = {});
-  ~SocketCanStream() { stop(); }
+  ~SocketCanStream();
  static bool available();

-  inline QString routeName() const override {
-    return QString("Live Streaming From Socket CAN %1").arg(config.device);
+  inline std::string routeName() const override {
+    return "Live Streaming From Socket CAN " + config.device;
  }

 protected:
@@ -29,7 +24,7 @@ protected:
  bool connect();

  SocketCanStreamConfig config = {};
-  std::unique_ptr<QCanBusDevice> device;
+  int sock_fd = -1;
 };

 class OpenSocketCanWidget : public AbstractOpenStreamWidget {