CAN ID (11 bit) = (node_id << 6) | msg_id

<CAN_ID hex> <RTR 0|1> <payload hex>\n

// Fault codes (excerpt)
enum Fault : uint8_t {
  FAULT_NONE = 0, FAULT_ENCODER = 1, FAULT_NO_PROGRESS = 2,
  FAULT_HOMING_TIMEOUT = 3,
  FAULT_DRIVER_OT = 4,       // TMC over-temperature shutdown (OT)
  FAULT_DRIVER_SHORT = 5,    // TMC short-to-GND or low-side short
};

// Cached last TMC DRV_STATUS / GSTAT snapshot for diagnostics + fault latch.
static uint16_t tmcStallGuard = 0;
static uint8_t  tmcFlagsA = 0;
static uint8_t  tmcFlagsB = 0;
static uint8_t  tmcGstat = 0;
static uint8_t  tmcCsActual = 0;
static uint16_t tmcInterstep = 0;
static bool     tmcOtLatched = false;
static bool     tmcShortLatched = false;
static uint32_t tmcPollMs = 0;

// Refresh TMC UART registers. Safe to call from telemetry / loop (not ISR).
static void tmcPollStatus() {
  bool uartOk = tmc.isSetupAndCommunicating();
  tmcFlagsA = uartOk ? 0x01 : 0x00;
  tmcFlagsB = 0;
  tmcGstat = 0;
  tmcCsActual = 0;
  tmcInterstep = 0;
  tmcStallGuard = 0;
  if (!uartOk) return;

  tmcStallGuard = (uint16_t)tmc.getStallGuardResult();
  TMC2209::Status st = tmc.getStatus();
  TMC2209::GlobalStatus gs = tmc.getGlobalStatus();
  uint32_t tstep = tmc.getInterstepDuration();
  tmcInterstep = (uint16_t)(tstep > 0xFFFFu ? 0xFFFFu : tstep);
  tmcCsActual = (uint8_t)(st.current_scaling & 0x1F);

  if (st.over_temperature_warning)  tmcFlagsA |= (1u << 1);
  if (st.over_temperature_shutdown) tmcFlagsA |= (1u << 2);
  if (st.short_to_ground_a)         tmcFlagsA |= (1u << 3);
  if (st.short_to_ground_b)         tmcFlagsA |= (1u << 4);
  if (st.low_side_short_a)          tmcFlagsA |= (1u << 5);
  if (st.low_side_short_b)          tmcFlagsA |= (1u << 6);
  if (st.open_load_a)               tmcFlagsA |= (1u << 7);
  if (st.open_load_b)               tmcFlagsB |= (1u << 0);
  if (st.over_temperature_120c)     tmcFlagsB |= (1u << 1);
  if (st.over_temperature_143c)     tmcFlagsB |= (1u << 2);
  if (st.over_temperature_150c)     tmcFlagsB |= (1u << 3);
  if (st.over_temperature_157c)     tmcFlagsB |= (1u << 4);
  if (st.stealth_chop_mode)         tmcFlagsB |= (1u << 5);
  if (st.standstill)                tmcFlagsB |= (1u << 6);

  if (gs.reset)  tmcGstat |= (1u << 0);
  if (gs.drv_err) tmcGstat |= (1u << 1);
  if (gs.uv_cp)  tmcGstat |= (1u << 2);

  if (st.over_temperature_shutdown) tmcOtLatched = true;
  if (st.short_to_ground_a || st.short_to_ground_b ||
      st.low_side_short_a || st.low_side_short_b) {
    tmcShortLatched = true;
  }
}

static void sendDriver() {
  tmcPollStatus();
  uint8_t p[8] = {0};
  memcpy(p, &tmcStallGuard, 2);
  p[2] = tmcFlagsA;
  p[3] = tmcFlagsB;
  p[4] = tmcGstat;
  p[5] = tmcCsActual;
  memcpy(p + 6, &tmcInterstep, 2);
  canSend(TEL_DRIVER, p, 8);
}

// Periodic TMC health: raise FAULT_DRIVER_OT / FAULT_DRIVER_SHORT and stop motion.
static void tmcDriverService() {
  uint32_t now = millis();
  if ((uint32_t)(now - tmcPollMs) < 100) return;
  tmcPollMs = now;
  if (!driverEnabled) return;

  tmcPollStatus();
  bool ot = (tmcFlagsA & (1u << 2)) != 0;
  bool shorted = (tmcFlagsA & ((1u << 3) | (1u << 4) | (1u << 5) | (1u << 6))) != 0;

  if (ot && fault != FAULT_DRIVER_OT) {
    stopImmediate();
    pidState = 3;
    fault = FAULT_DRIVER_OT;
    sendEvent(EVT_FAULT, FAULT_DRIVER_OT, (float)temperatureRead());
    Serial.println("# FAULT: TMC over-temperature shutdown (OT)");
  } else if (shorted && fault != FAULT_DRIVER_SHORT && fault != FAULT_DRIVER_OT) {
    stopImmediate();
    pidState = 3;
    fault = FAULT_DRIVER_SHORT;
    sendEvent(EVT_FAULT, FAULT_DRIVER_SHORT, (float)tmcFlagsA);
    Serial.println("# FAULT: TMC short detected (S2G/S2VS)");
  }

  // OTPW alone: log once per edge via serial (do not stop — warning only).
  static bool otpwPrev = false;
  bool otpw = (tmcFlagsA & (1u << 1)) != 0;
  if (otpw && !otpwPrev) {
    Serial.println("# WARN: TMC over-temperature pre-warning (OTPW)");
  }
  otpwPrev = otpw;
}

// Inside setDriverEnabled(true) — clears sticky thermal / GSTAT latches:
//   tmc.clearDriveError();
//   tmc.clearReset();
//   tmcOtLatched = false;
//   tmcShortLatched = false;
//   if (fault == FAULT_DRIVER_OT || fault == FAULT_DRIVER_SHORT) {
//     fault = FAULT_NONE;
//     pidState = 0;
//   }

// Inside loop():
//   canHealthService();
//   tmcDriverService();
//   ...
// Slow telemetry also calls sendDriver() at slow_rate_hz.

follower = local_ref + (leader − leader_ref) × ratio × (invert ? −1 : 1)