Merge pull request 'feat: systemd auto-start for ROS2 + dashboard on Orin boot (bd-1hyn)' (#732) from sl-perception/bd-1hyn-orin-autostart into main

Extends the bd-66hx serial protocol with two new Orin→ESP32 commands:
  CMD_OTA_CHECK  (0x10): triggers gitea_ota_check_now(), responds with
    TELEM_VERSION_INFO (0x84) for Balance and IO (current + available ver).
  CMD_OTA_UPDATE (0x11): uint8 target (0=balance, 1=io, 2=both) — triggers
    uart_ota_trigger() for IO or ota_self_trigger() for Balance.
    NACK with ERR_OTA_BUSY or ERR_OTA_NO_UPDATE on failure.
New telemetry: TELEM_OTA_STATUS (0x83, target+state+progress+err),
  TELEM_VERSION_INFO (0x84, target+current[16]+available[16]).
Wires OTA stack into app_main: ota_self_health_check on boot,
  gitea_ota_init + ota_display_init after peripherals ready.
CMakeLists updated with all OTA component dependencies.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitea/workflows/ota-release.yml

@@ -0,0 +1,162 @@
+# .gitea/workflows/ota-release.yml
+# Gitea Actions — ESP32 OTA firmware build & release (bd-9kod)
+#
+# Triggers on signed release tags:
+#   esp32-balance/vX.Y.Z  →  builds esp32s3/balance/   (ESP32-S3 Balance board)
+#   esp32-io/vX.Y.Z       →  builds esp32s3-io/         (ESP32-S3 IO board)
+#
+# Uses the official espressif/idf Docker image for reproducible builds.
+# Attaches <app>_<version>.bin + <app>_<version>.sha256 to the Gitea release.
+# The ESP32 Balance OTA system fetches the .bin from the release asset URL.
+
+name: OTA release — build & attach firmware
+
+on:
+  push:
+    tags:
+      - "esp32-balance/v*"
+      - "esp32-io/v*"
+
+permissions:
+  contents: write
+
+jobs:
+  build-and-release:
+    name: Build ${{ github.ref_name }}
+    runs-on: ubuntu-latest
+    container:
+      image: espressif/idf:v5.2.2
+      options: --user root
+
+    steps:
+      # ── 1. Checkout ───────────────────────────────────────────────────────────
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      # ── 2. Resolve build target from tag ─────────────────────────────────────
+      # Tag format:  esp32-balance/v1.2.3  or  esp32-io/v1.2.3
+      - name: Resolve project from tag
+        id: proj
+        shell: bash
+        run: |
+          TAG="${GITHUB_REF_NAME}"
+          case "$TAG" in
+            esp32-balance/*)
+              DIR="esp32s3/balance"
+              APP="esp32s3_balance"
+              ;;
+            esp32-io/*)
+              DIR="esp32s3-io"
+              APP="esp32s3_io"
+              ;;
+            *)
+              echo "::error::Unrecognised tag prefix: ${TAG}"
+              exit 1
+              ;;
+          esac
+          VERSION="${TAG#*/}"
+          echo "dir=${DIR}"         >> "$GITHUB_OUTPUT"
+          echo "app=${APP}"         >> "$GITHUB_OUTPUT"
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+          echo "tag=${TAG}"         >> "$GITHUB_OUTPUT"
+          echo "Build: ${APP} ${VERSION} from ${DIR}"
+
+      # ── 3. Build with ESP-IDF ─────────────────────────────────────────────────
+      - name: Build firmware (idf.py build)
+        shell: bash
+        run: |
+          . "${IDF_PATH}/export.sh"
+          cd "${{ steps.proj.outputs.dir }}"
+          idf.py build
+
+      # ── 4. Collect binary & generate checksum ────────────────────────────────
+      - name: Collect artifacts
+        id: art
+        shell: bash
+        run: |
+          APP="${{ steps.proj.outputs.app }}"
+          VER="${{ steps.proj.outputs.version }}"
+          BIN_SRC="${{ steps.proj.outputs.dir }}/build/${APP}.bin"
+          BIN_OUT="${APP}_${VER}.bin"
+          SHA_OUT="${APP}_${VER}.sha256"
+
+          cp "$BIN_SRC" "$BIN_OUT"
+          sha256sum "$BIN_OUT" > "$SHA_OUT"
+
+          echo "bin=${BIN_OUT}" >> "$GITHUB_OUTPUT"
+          echo "sha=${SHA_OUT}" >> "$GITHUB_OUTPUT"
+
+          echo "Binary:   ${BIN_OUT} ($(wc -c < "$BIN_OUT") bytes)"
+          echo "Checksum: $(cat "$SHA_OUT")"
+
+      # ── 5. Archive artifacts in CI workspace ─────────────────────────────────
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: firmware-${{ steps.proj.outputs.app }}-${{ steps.proj.outputs.version }}
+          path: |
+            ${{ steps.art.outputs.bin }}
+            ${{ steps.art.outputs.sha }}
+
+      # ── 6. Create Gitea release (if needed) & upload assets ──────────────────
+      # Uses GITHUB_TOKEN (auto-provided, contents:write from permissions block).
+      # URL-encodes the tag to handle the slash in esp32-balance/vX.Y.Z.
+      - name: Publish assets to Gitea release
+        shell: bash
+        env:
+          GITEA_URL: https://gitea.vayrette.com
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REPO: ${{ github.repository }}
+          TAG: ${{ steps.proj.outputs.tag }}
+          BIN: ${{ steps.art.outputs.bin }}
+          SHA: ${{ steps.art.outputs.sha }}
+        run: |
+          API="${GITEA_URL}/api/v1/repos/${REPO}"
+
+          # URL-encode the tag (slash in esp32-balance/vX.Y.Z must be escaped)
+          TAG_ENC=$(python3 -c "
+          import urllib.parse, sys
+          print(urllib.parse.quote(sys.argv[1], safe=''))
+          " "$TAG")
+
+          # Try to fetch an existing release for this tag
+          RELEASE=$(curl -sf \
+            -H "Authorization: token ${TOKEN}" \
+            "${API}/releases/tags/${TAG_ENC}") || true
+
+          # If no release yet, create it
+          if [ -z "$RELEASE" ]; then
+            echo "Creating release for tag: ${TAG}"
+            RELEASE=$(curl -sf \
+              -X POST \
+              -H "Authorization: token ${TOKEN}" \
+              -H "Content-Type: application/json" \
+              -d "$(python3 -c "
+          import json, sys
+          print(json.dumps({
+              'tag_name': sys.argv[1],
+              'name':     sys.argv[1],
+              'draft':    False,
+              'prerelease': False,
+          }))
+          " "$TAG")" \
+              "${API}/releases")
+          fi
+
+          RELEASE_ID=$(echo "$RELEASE" | python3 -c "
+          import sys, json; print(json.load(sys.stdin)['id'])
+          ")
+          echo "Release ID: ${RELEASE_ID}"
+
+          # Upload binary and checksum
+          for FILE in "$BIN" "$SHA"; do
+            FNAME=$(basename "$FILE")
+            echo "Uploading: ${FNAME}"
+            curl -sf \
+              -X POST \
+              -H "Authorization: token ${TOKEN}" \
+              -F "attachment=@${FILE}" \
+              "${API}/releases/${RELEASE_ID}/assets?name=${FNAME}"
+          done
+
+          echo "Published: ${BIN} + ${SHA} → release ${TAG}"

AUTONOMOUS_ARMING.md

@@ -7,7 +7,11 @@ The robot can now be armed and operated autonomously from the Jetson without req
 
 ### Jetson Autonomous Arming
 - Command: `A\n` (single byte 'A' followed by newline)
-- Sent via USB CDC to the STM32 firmware
+<<<<<<< HEAD
+- Sent via USB CDC to the ESP32 BALANCE firmware
+=======
+- Sent via USB Serial (CH343) to the ESP32-S3 firmware
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 - Robot arms after ARMING_HOLD_MS (~500ms) safety hold period
 - Works even when RC is not connected or not armed
 
@@ -42,7 +46,11 @@ The robot can now be armed and operated autonomously from the Jetson without req
 
 ## Command Protocol
 
-### From Jetson to STM32 (USB CDC)
+<<<<<<< HEAD
+### From Jetson to ESP32 BALANCE (USB CDC)
+=======
+### From Jetson to ESP32-S3 (USB Serial (CH343))
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 ```
 A           — Request arm (triggers safety hold, then motors enable)
 D           — Request disarm (immediate motor stop)
@@ -52,7 +60,11 @@ H           — Heartbeat (refresh timeout timer, every 500ms)
 C<spd>,<str> — Drive command: speed, steer (also refreshes heartbeat)
 ```
 
-### From STM32 to Jetson (USB CDC)
+<<<<<<< HEAD
+### From ESP32 BALANCE to Jetson (USB CDC)
+=======
+### From ESP32-S3 to Jetson (USB Serial (CH343))
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 Motor commands are gated by `bal.state == BALANCE_ARMED`:
 - When ARMED: Motor commands sent every 20ms (50 Hz)
 - When DISARMED: Zero sent every 20ms (prevents ESC timeout)

CLAUDE.md

@@ -1,17 +1,36 @@
 # SaltyLab Firmware — Agent Playbook
 
 ## Project
-Self-balancing two-wheeled robot: STM32F722 flight controller, hoverboard hub motors, Jetson Nano for AI/SLAM.
+<<<<<<< HEAD
+**SAUL-TEE** — 4-wheel wagon (870×510×550 mm, 23 kg).
+Two ESP32-S3 boards + Jetson Orin via CAN. Full spec: `docs/SAUL-TEE-SYSTEM-REFERENCE.md`
+
+| Board | Role |
+|-------|------|
+| **ESP32-S3 BALANCE** | QMI8658 IMU, PID balance, CAN→VESC (L:68 / R:56), GC9A01 LCD (Waveshare Touch LCD 1.28) |
+| **ESP32-S3 IO** | TBS Crossfire RC, ELRS failover, BTS7960 motors, NFC/baro/ToF, WS2812 |
+| **Jetson Orin** | AI/SLAM, CANable2 USB→CAN, cmds 0x300–0x303, telemetry 0x400–0x401 |
+
+> **Legacy:** `src/` and `include/` = archived STM32 HAL — do not extend. New firmware in `esp32/`.
+=======
+Self-balancing two-wheeled robot: ESP32-S3 ESP32-S3 BALANCE, hoverboard hub motors, Jetson Orin Nano Super for AI/SLAM.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ## Team
 | Agent | Role | Focus |
 |-------|------|-------|
-| **sl-firmware** | Embedded Firmware Lead | STM32 HAL, USB CDC debugging, SPI/UART, PlatformIO, DFU bootloader |
+<<<<<<< HEAD
+| **sl-firmware** | Embedded Firmware Lead | ESP32-S3, ESP-IDF, QMI8658, CAN/UART protocol, BTS7960 |
+| **sl-controls** | Control Systems Engineer | PID tuning, IMU fusion, balance loop, safety |
+| **sl-perception** | Perception / SLAM Engineer | Jetson Orin, RealSense D435i, RPLIDAR, ROS2, Nav2 |
+=======
+| **sl-firmware** | Embedded Firmware Lead | ESP-IDF, USB Serial (CH343) debugging, SPI/UART, PlatformIO, DFU bootloader |
 | **sl-controls** | Control Systems Engineer | PID tuning, IMU sensor fusion, real-time control loops, safety systems |
-| **sl-perception** | Perception / SLAM Engineer | Jetson Nano, RealSense D435i, RPLIDAR, ROS2, Nav2 |
+| **sl-perception** | Perception / SLAM Engineer | Jetson Orin Nano Super, RealSense D435i, RPLIDAR, ROS2, Nav2 |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ## Status
-USB CDC TX bug resolved (PR #10 — DCache MPU non-cacheable region + IWDG ordering fix).
+USB Serial (CH343) TX bug resolved (PR #10 — DCache MPU non-cacheable region + IWDG ordering fix).
 
 ## Repo Structure
 - `projects/saltybot/SALTYLAB.md` — Design doc
@@ -29,11 +48,11 @@ USB CDC TX bug resolved (PR #10 — DCache MPU non-cacheable region + IWDG order
 | `saltyrover-dev` | Integration — rover variant |
 | `saltytank` | Stable — tracked tank variant |
 | `saltytank-dev` | Integration — tank variant |
-| `main` | Shared code only (IMU drivers, USB CDC, balance core, safety) |
+| `main` | Shared code only (IMU drivers, USB Serial (CH343), balance core, safety) |
 
 ### Rules
 - Agents branch FROM `<variant>-dev` and PR back TO `<variant>-dev`
-- Shared/infrastructure code (IMU drivers, USB CDC, balance core, safety) goes in `main`
+- Shared/infrastructure code (IMU drivers, USB Serial (CH343), balance core, safety) goes in `main`
 - Variant-specific code (motor topology, kinematics, config) goes in variant branches
 - Stable branches get promoted from `-dev` after review and hardware testing
 - **Current SaltyLab team** works against `saltylab-dev`

TEAM.md

@@ -1,12 +1,22 @@
 # SaltyLab — Ideal Team
 
 ## Project
-Self-balancing two-wheeled robot using a drone flight controller (STM32F722), hoverboard hub motors, and eventually a Jetson Nano for AI/SLAM.
+<<<<<<< HEAD
+**SAUL-TEE** — 4-wheel wagon (870×510×550 mm, 23 kg).
+Two ESP32-S3 boards (BALANCE + IO) + Jetson Orin. See `docs/SAUL-TEE-SYSTEM-REFERENCE.md`.
+
+## Current Status
+- **Hardware:** ESP32-S3 BALANCE (Waveshare Touch LCD 1.28, CH343 USB) + ESP32-S3 IO (bare devkit, JTAG USB)
+- **Firmware:** ESP-IDF/PlatformIO target; legacy `src/` STM32 HAL archived
+- **Comms:** UART 460800 baud inter-board; CANable2 USB→CAN for Orin; CAN 500 kbps to VESCs (L:68 / R:56)
+=======
+Self-balancing two-wheeled robot using a drone ESP32-S3 BALANCE (ESP32-S3), hoverboard hub motors, and eventually a Jetson Orin Nano Super for AI/SLAM.
 
 ## Current Status
 - **Hardware:** Assembled — FC, motors, ESC, IMU, battery, RC all on hand
-- **Firmware:** Balance PID + hoverboard ESC protocol written, but blocked by USB CDC bug
-- **Blocker:** USB CDC TX stops working when peripheral inits (SPI/UART/GPIO) are added alongside USB OTG FS — see `USB_CDC_BUG.md`
+- **Firmware:** Balance PID + hoverboard ESC protocol written, but blocked by USB Serial (CH343) bug
+- **Blocker:** USB Serial (CH343) TX stops working when peripheral inits (SPI/UART/GPIO) are added alongside USB on ESP32-S3 — see `legacy/stm32/USB_CDC_BUG.md` for historical context
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ---
 
@@ -14,18 +24,30 @@ Self-balancing two-wheeled robot using a drone flight controller (STM32F722), ho
 
 ### 1. Embedded Firmware Engineer (Lead)
 **Must-have:**
-- Deep STM32 HAL experience (F7 series specifically)
+<<<<<<< HEAD
+- Deep ESP32 (Arduino/ESP-IDF) or STM32 HAL experience
 - USB OTG FS / CDC ACM debugging (TxState, endpoint management, DMA conflicts)
-- SPI + UART + USB coexistence on STM32
-- PlatformIO or bare-metal STM32 toolchain
+- SPI + UART + USB coexistence on ESP32
+- PlatformIO or bare-metal ESP32 toolchain
 - DFU bootloader implementation
+=======
+- Deep ESP-IDF experience (ESP32-S3 specifically)
+- USB Serial (CH343) / UART debugging on ESP32-S3
+- SPI + UART + USB coexistence on ESP32-S3
+- ESP-IDF / Arduino-ESP32 toolchain
+- OTA firmware update implementation
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 **Nice-to-have:**
-- Betaflight/iNav/ArduPilot codebase familiarity
+- ESP32-S3 peripheral coexistence (SPI + UART + USB)
 - PID control loop tuning for balance robots
 - FOC motor control (hoverboard ESC protocol)
 
-**Why:** The immediate blocker is a USB peripheral conflict. Need someone who's debugged STM32 USB issues before — this is not a software logic bug, it's a hardware peripheral interaction issue.
+<<<<<<< HEAD
+**Why:** The immediate blocker is a USB peripheral conflict. Need someone who's debugged STM32 USB issues before — ESP32 firmware for the balance loop and I/O needs to be written from scratch.
+=======
+**Why:** The immediate blocker is a USB peripheral conflict on ESP32-S3. Need someone who's debugged ESP32-S3 USB Serial (CH343) issues before — this is not a software logic bug, it's a hardware peripheral interaction issue.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ### 2. Control Systems / Robotics Engineer
 **Must-have:**
@@ -43,7 +65,7 @@ Self-balancing two-wheeled robot using a drone flight controller (STM32F722), ho
 
 ### 3. Perception / SLAM Engineer (Phase 2)
 **Must-have:**
-- Jetson Nano / NVIDIA Jetson platform
+- Jetson Orin Nano Super / NVIDIA Jetson platform
 - Intel RealSense D435i depth camera
 - RPLIDAR integration
 - SLAM (ORB-SLAM3, RTAB-Map, or similar)
@@ -54,19 +76,23 @@ Self-balancing two-wheeled robot using a drone flight controller (STM32F722), ho
 - Obstacle avoidance
 - Nav2 stack
 
-**Why:** Phase 2 goal is autonomous navigation. Jetson Nano with RealSense + RPLIDAR for indoor mapping and person following.
+**Why:** Phase 2 goal is autonomous navigation. Jetson Orin Nano Super with RealSense + RPLIDAR for indoor mapping and person following.
 
 ---
 
 ## Hardware Reference
 | Component | Details |
 |-----------|---------|
-| FC | MAMBA F722S (STM32F722RET6, MPU6000) |
+<<<<<<< HEAD
+| FC | ESP32 BALANCE (ESP32RET6, MPU6000) |
+=======
+| FC | ESP32-S3 BALANCE (ESP32-S3RET6, QMI8658) |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | Motors | 2x 8" pneumatic hoverboard hub motors |
 | ESC | Hoverboard ESC (EFeru FOC firmware) |
 | Battery | 36V pack |
 | RC | BetaFPV ELRS 2.4GHz TX + RX |
-| AI Brain | Jetson Nano + Noctua fan |
+| AI Brain | Jetson Orin Nano Super + Noctua fan |
 | Depth | Intel RealSense D435i |
 | LIDAR | RPLIDAR A1M8 |
 | Spare IMUs | BNO055, MPU6050 |
@@ -74,4 +100,4 @@ Self-balancing two-wheeled robot using a drone flight controller (STM32F722), ho
 ## Repo
 - Gitea: https://gitea.vayrette.com/seb/saltylab-firmware
 - Design doc: `projects/saltybot/SALTYLAB.md`
-- Bug doc: `USB_CDC_BUG.md`
+- Bug doc: `legacy/stm32/USB_CDC_BUG.md` (archived — STM32 era)

android/build.gradle

@@ -0,0 +1,46 @@
+plugins {
+    id 'com.android.application'
+    id 'kotlin-android'
+}
+
+android {
+    compileSdk 34
+    namespace 'com.saltylab.uwbtag'
+
+    defaultConfig {
+        applicationId "com.saltylab.uwbtag"
+        minSdk 26
+        targetSdk 34
+        versionCode 1
+        versionName "1.0"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    buildFeatures {
+        viewBinding true
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+}
+
+dependencies {
+    implementation 'androidx.core:core-ktx:1.12.0'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'com.google.android.material:material:1.11.0'
+    implementation 'androidx.recyclerview:recyclerview:1.3.2'
+    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.7.0'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+    implementation 'com.google.code.gson:gson:2.10.1'
+}

android/src/main/AndroidManifest.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- BLE permissions (API 31+) -->
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN"
+        android:usesPermissionFlags="neverForLocation" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
+
+    <!-- Legacy BLE (API < 31) -->
+    <uses-permission android:name="android.permission.BLUETOOTH"
+        android:maxSdkVersion="30" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"
+        android:maxSdkVersion="30" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"
+        android:maxSdkVersion="30" />
+
+    <uses-feature android:name="android.hardware.bluetooth_le" android:required="true" />
+
+    <application
+        android:allowBackup="true"
+        android:label="UWB Tag Config"
+        android:theme="@style/Theme.MaterialComponents.DayNight.DarkActionBar">
+
+        <activity
+            android:name=".UwbTagBleActivity"
+            android:exported="true"
+            android:launchMode="singleTop">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+
+    </application>
+
+</manifest>

android/src/main/kotlin/com/saltylab/uwbtag/UwbTagBleActivity.kt

@@ -0,0 +1,444 @@
+package com.saltylab.uwbtag
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.bluetooth.*
+import android.bluetooth.le.*
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.TextView
+import android.widget.Toast
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import com.google.android.material.card.MaterialCardView
+import com.google.android.material.switchmaterial.SwitchMaterial
+import com.google.android.material.textfield.TextInputEditText
+import com.google.gson.Gson
+import com.saltylab.uwbtag.databinding.ActivityUwbTagBleBinding
+import java.util.UUID
+
+// ---------------------------------------------------------------------------
+// GATT service / characteristic UUIDs
+// ---------------------------------------------------------------------------
+private val SERVICE_UUID     = UUID.fromString("12345678-1234-5678-1234-56789abcdef0")
+private val CHAR_CONFIG_UUID = UUID.fromString("12345678-1234-5678-1234-56789abcdef1") // read/write JSON config
+private val CHAR_STATUS_UUID = UUID.fromString("12345678-1234-5678-1234-56789abcdef2") // notify: tag status string
+private val CHAR_BATT_UUID   = UUID.fromString("12345678-1234-5678-1234-56789abcdef3") // notify: battery %
+private val CCCD_UUID        = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")
+
+// BLE scan timeout
+private const val SCAN_TIMEOUT_MS = 15_000L
+
+// Permissions request code
+private const val REQ_PERMISSIONS = 1001
+
+// ---------------------------------------------------------------------------
+// Data model
+// ---------------------------------------------------------------------------
+data class TagConfig(
+    val tag_name: String = "UWB_TAG_0001",
+    val sleep_timeout_s: Int = 300,
+    val display_brightness: Int = 50,
+    val uwb_channel: Int = 9,
+    val ranging_interval_ms: Int = 100,
+    val battery_report: Boolean = true
+)
+
+data class ScannedDevice(
+    val name: String,
+    val address: String,
+    var rssi: Int,
+    val device: BluetoothDevice
+)
+
+// ---------------------------------------------------------------------------
+// RecyclerView adapter for scanned devices
+// ---------------------------------------------------------------------------
+class DeviceAdapter(
+    private val onConnect: (ScannedDevice) -> Unit
+) : RecyclerView.Adapter<DeviceAdapter.VH>() {
+
+    private val items = mutableListOf<ScannedDevice>()
+
+    fun update(device: ScannedDevice) {
+        val idx = items.indexOfFirst { it.address == device.address }
+        if (idx >= 0) {
+            items[idx] = device
+            notifyItemChanged(idx)
+        } else {
+            items.add(device)
+            notifyItemInserted(items.size - 1)
+        }
+    }
+
+    fun clear() {
+        items.clear()
+        notifyDataSetChanged()
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
+        val view = LayoutInflater.from(parent.context)
+            .inflate(R.layout.item_ble_device, parent, false)
+        return VH(view)
+    }
+
+    override fun onBindViewHolder(holder: VH, position: Int) = holder.bind(items[position])
+    override fun getItemCount() = items.size
+
+    inner class VH(view: View) : RecyclerView.ViewHolder(view) {
+        private val tvName    = view.findViewById<TextView>(R.id.tvDeviceName)
+        private val tvAddress = view.findViewById<TextView>(R.id.tvDeviceAddress)
+        private val tvRssi    = view.findViewById<TextView>(R.id.tvRssi)
+        private val btnConn   = view.findViewById<Button>(R.id.btnConnect)
+
+        fun bind(item: ScannedDevice) {
+            tvName.text    = item.name
+            tvAddress.text = item.address
+            tvRssi.text    = "${item.rssi} dBm"
+            btnConn.setOnClickListener { onConnect(item) }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Activity
+// ---------------------------------------------------------------------------
+@SuppressLint("MissingPermission") // permissions checked at runtime before any BLE call
+class UwbTagBleActivity : AppCompatActivity() {
+
+    private lateinit var binding: ActivityUwbTagBleBinding
+    private val gson = Gson()
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    // BLE
+    private val btManager by lazy { getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager }
+    private val btAdapter by lazy { btManager.adapter }
+    private var bleScanner: BluetoothLeScanner? = null
+    private var gatt: BluetoothGatt? = null
+    private var configChar: BluetoothGattCharacteristic? = null
+    private var statusChar: BluetoothGattCharacteristic? = null
+    private var battChar: BluetoothGattCharacteristic? = null
+    private var isScanning = false
+
+    private val deviceAdapter = DeviceAdapter(onConnect = ::connectToDevice)
+
+    // ---------------------------------------------------------------------------
+    // Lifecycle
+    // ---------------------------------------------------------------------------
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivityUwbTagBleBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+        setSupportActionBar(binding.toolbar)
+
+        binding.rvDevices.layoutManager = LinearLayoutManager(this)
+        binding.rvDevices.adapter = deviceAdapter
+
+        binding.btnScan.setOnClickListener {
+            if (isScanning) stopScan() else startScanIfPermitted()
+        }
+        binding.btnDisconnect.setOnClickListener { disconnectGatt() }
+        binding.btnReadConfig.setOnClickListener { readConfig() }
+        binding.btnWriteConfig.setOnClickListener { writeConfig() }
+
+        requestBlePermissions()
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        stopScan()
+        disconnectGatt()
+    }
+
+    // ---------------------------------------------------------------------------
+    // Permissions
+    // ---------------------------------------------------------------------------
+    private fun requestBlePermissions() {
+        val needed = mutableListOf<String>()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            if (!hasPermission(Manifest.permission.BLUETOOTH_SCAN))
+                needed += Manifest.permission.BLUETOOTH_SCAN
+            if (!hasPermission(Manifest.permission.BLUETOOTH_CONNECT))
+                needed += Manifest.permission.BLUETOOTH_CONNECT
+        } else {
+            if (!hasPermission(Manifest.permission.ACCESS_FINE_LOCATION))
+                needed += Manifest.permission.ACCESS_FINE_LOCATION
+        }
+        if (needed.isNotEmpty()) {
+            ActivityCompat.requestPermissions(this, needed.toTypedArray(), REQ_PERMISSIONS)
+        }
+    }
+
+    private fun hasPermission(perm: String) =
+        ContextCompat.checkSelfPermission(this, perm) == PackageManager.PERMISSION_GRANTED
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int, permissions: Array<out String>, grantResults: IntArray
+    ) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        if (requestCode == REQ_PERMISSIONS &&
+            grantResults.any { it != PackageManager.PERMISSION_GRANTED }) {
+            toast("BLE permissions required")
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // BLE Scan
+    // ---------------------------------------------------------------------------
+    private fun startScanIfPermitted() {
+        if (btAdapter?.isEnabled != true) { toast("Bluetooth is off"); return }
+        bleScanner = btAdapter.bluetoothLeScanner
+        val filter = ScanFilter.Builder()
+            .setDeviceNamePattern("UWB_TAG_.*".toRegex().toPattern())
+            .build()
+        val settings = ScanSettings.Builder()
+            .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+            .build()
+        deviceAdapter.clear()
+        bleScanner?.startScan(listOf(filter), settings, scanCallback)
+        isScanning = true
+        binding.btnScan.text = "Stop"
+        binding.tvScanStatus.text = "Scanning…"
+        mainHandler.postDelayed({ stopScan() }, SCAN_TIMEOUT_MS)
+    }
+
+    private fun stopScan() {
+        bleScanner?.stopScan(scanCallback)
+        isScanning = false
+        binding.btnScan.text = "Scan"
+        binding.tvScanStatus.text = "Scan stopped"
+    }
+
+    private val scanCallback = object : ScanCallback() {
+        override fun onScanResult(callbackType: Int, result: ScanResult) {
+            val name = result.device.name ?: return
+            if (!name.startsWith("UWB_TAG_")) return
+            val dev = ScannedDevice(
+                name    = name,
+                address = result.device.address,
+                rssi    = result.rssi,
+                device  = result.device
+            )
+            mainHandler.post { deviceAdapter.update(dev) }
+        }
+
+        override fun onScanFailed(errorCode: Int) {
+            mainHandler.post {
+                binding.tvScanStatus.text = "Scan failed (code $errorCode)"
+                isScanning = false
+                binding.btnScan.text = "Scan"
+            }
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // GATT Connection
+    // ---------------------------------------------------------------------------
+    private fun connectToDevice(scanned: ScannedDevice) {
+        stopScan()
+        binding.tvScanStatus.text = "Connecting to ${scanned.name}…"
+        gatt = scanned.device.connectGatt(this, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
+    }
+
+    private fun disconnectGatt() {
+        gatt?.disconnect()
+        gatt?.close()
+        gatt = null
+        configChar = null
+        statusChar = null
+        battChar = null
+        mainHandler.post {
+            binding.cardConfig.visibility = View.GONE
+            binding.tvScanStatus.text = "Disconnected"
+        }
+    }
+
+    private val gattCallback = object : BluetoothGattCallback() {
+
+        override fun onConnectionStateChange(g: BluetoothGatt, status: Int, newState: Int) {
+            when (newState) {
+                BluetoothProfile.STATE_CONNECTED -> {
+                    mainHandler.post { binding.tvScanStatus.text = "Connected — discovering services…" }
+                    g.discoverServices()
+                }
+                BluetoothProfile.STATE_DISCONNECTED -> {
+                    mainHandler.post {
+                        binding.cardConfig.visibility = View.GONE
+                        binding.tvScanStatus.text = "Disconnected"
+                        toast("Tag disconnected")
+                    }
+                    gatt?.close()
+                    gatt = null
+                }
+            }
+        }
+
+        override fun onServicesDiscovered(g: BluetoothGatt, status: Int) {
+            if (status != BluetoothGatt.GATT_SUCCESS) {
+                mainHandler.post { toast("Service discovery failed") }
+                return
+            }
+            val service = g.getService(SERVICE_UUID)
+            if (service == null) {
+                mainHandler.post { toast("UWB config service not found on tag") }
+                return
+            }
+            configChar = service.getCharacteristic(CHAR_CONFIG_UUID)
+            statusChar = service.getCharacteristic(CHAR_STATUS_UUID)
+            battChar   = service.getCharacteristic(CHAR_BATT_UUID)
+
+            // Subscribe to status notifications
+            statusChar?.let { enableNotifications(g, it) }
+            battChar?.let   { enableNotifications(g, it) }
+
+            // Initial config read
+            configChar?.let { g.readCharacteristic(it) }
+
+            mainHandler.post {
+                val devName = g.device.name ?: g.device.address
+                binding.tvConnectedName.text = "Connected: $devName"
+                binding.cardConfig.visibility = View.VISIBLE
+                binding.tvScanStatus.text = "Connected to $devName"
+            }
+        }
+
+        override fun onCharacteristicRead(
+            g: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+            status: Int
+        ) {
+            if (status != BluetoothGatt.GATT_SUCCESS) return
+            if (characteristic.uuid == CHAR_CONFIG_UUID) {
+                val json = characteristic.value?.toString(Charsets.UTF_8) ?: return
+                val cfg = runCatching { gson.fromJson(json, TagConfig::class.java) }.getOrNull() ?: return
+                mainHandler.post { populateFields(cfg) }
+            }
+        }
+
+        // API 33+ callback
+        override fun onCharacteristicRead(
+            g: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+            value: ByteArray,
+            status: Int
+        ) {
+            if (status != BluetoothGatt.GATT_SUCCESS) return
+            if (characteristic.uuid == CHAR_CONFIG_UUID) {
+                val json = value.toString(Charsets.UTF_8)
+                val cfg = runCatching { gson.fromJson(json, TagConfig::class.java) }.getOrNull() ?: return
+                mainHandler.post { populateFields(cfg) }
+            }
+        }
+
+        override fun onCharacteristicWrite(
+            g: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+            status: Int
+        ) {
+            val msg = if (status == BluetoothGatt.GATT_SUCCESS) "Config written" else "Write failed ($status)"
+            mainHandler.post { toast(msg) }
+        }
+
+        override fun onCharacteristicChanged(
+            g: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic
+        ) {
+            val value = characteristic.value ?: return
+            handleNotification(characteristic.uuid, value)
+        }
+
+        // API 33+ callback
+        override fun onCharacteristicChanged(
+            g: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+            value: ByteArray
+        ) {
+            handleNotification(characteristic.uuid, value)
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // Notification helpers
+    // ---------------------------------------------------------------------------
+    private fun enableNotifications(g: BluetoothGatt, char: BluetoothGattCharacteristic) {
+        g.setCharacteristicNotification(char, true)
+        val descriptor = char.getDescriptor(CCCD_UUID) ?: return
+        descriptor.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+        g.writeDescriptor(descriptor)
+    }
+
+    private fun handleNotification(uuid: UUID, value: ByteArray) {
+        val text = value.toString(Charsets.UTF_8)
+        mainHandler.post {
+            when (uuid) {
+                CHAR_STATUS_UUID -> binding.tvTagStatus.text = "Status: $text"
+                CHAR_BATT_UUID   -> {
+                    val pct = text.toIntOrNull() ?: return@post
+                    binding.tvTagStatus.text = binding.tvTagStatus.text.toString()
+                        .replace(Regex("\\| Batt:.*"), "")
+                        .trimEnd() + " | Batt: $pct%"
+                }
+            }
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // Config read / write
+    // ---------------------------------------------------------------------------
+    private fun readConfig() {
+        val g = gatt ?: run { toast("Not connected"); return }
+        val c = configChar ?: run { toast("Config char not found"); return }
+        g.readCharacteristic(c)
+    }
+
+    private fun writeConfig() {
+        val g = gatt ?: run { toast("Not connected"); return }
+        val c = configChar ?: run { toast("Config char not found"); return }
+        val cfg = buildConfigFromFields()
+        val json = gson.toJson(cfg)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            g.writeCharacteristic(c, json.toByteArray(Charsets.UTF_8),
+                BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT)
+        } else {
+            @Suppress("DEPRECATION")
+            c.value = json.toByteArray(Charsets.UTF_8)
+            @Suppress("DEPRECATION")
+            g.writeCharacteristic(c)
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // UI helpers
+    // ---------------------------------------------------------------------------
+    private fun populateFields(cfg: TagConfig) {
+        binding.etTagName.setText(cfg.tag_name)
+        binding.etSleepTimeout.setText(cfg.sleep_timeout_s.toString())
+        binding.etBrightness.setText(cfg.display_brightness.toString())
+        binding.etUwbChannel.setText(cfg.uwb_channel.toString())
+        binding.etRangingInterval.setText(cfg.ranging_interval_ms.toString())
+        binding.switchBatteryReport.isChecked = cfg.battery_report
+    }
+
+    private fun buildConfigFromFields() = TagConfig(
+        tag_name           = binding.etTagName.text?.toString() ?: "UWB_TAG_0001",
+        sleep_timeout_s    = binding.etSleepTimeout.text?.toString()?.toIntOrNull() ?: 300,
+        display_brightness = binding.etBrightness.text?.toString()?.toIntOrNull() ?: 50,
+        uwb_channel        = binding.etUwbChannel.text?.toString()?.toIntOrNull() ?: 9,
+        ranging_interval_ms = binding.etRangingInterval.text?.toString()?.toIntOrNull() ?: 100,
+        battery_report     = binding.switchBatteryReport.isChecked
+    )
+
+    private fun toast(msg: String) =
+        Toast.makeText(this, msg, Toast.LENGTH_SHORT).show()
+}

android/src/main/res/layout/activity_uwb_tag_ble.xml

@@ -0,0 +1,238 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <androidx.appcompat.widget.Toolbar
+        android:id="@+id/toolbar"
+        android:layout_width="match_parent"
+        android:layout_height="?attr/actionBarSize"
+        android:background="?attr/colorPrimary"
+        android:elevation="4dp"
+        android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"
+        app:title="UWB Tag BLE Config" />
+
+    <!-- Scan controls -->
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:padding="12dp"
+        android:gravity="center_vertical">
+
+        <Button
+            android:id="@+id/btnScan"
+            style="@style/Widget.MaterialComponents.Button"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Scan" />
+
+        <TextView
+            android:id="@+id/tvScanStatus"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:layout_marginStart="12dp"
+            android:text="Tap Scan to find UWB tags"
+            android:textAppearance="@style/TextAppearance.MaterialComponents.Body2" />
+
+    </LinearLayout>
+
+    <!-- Scan results list -->
+    <TextView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:paddingHorizontal="12dp"
+        android:text="Nearby Tags"
+        android:textAppearance="@style/TextAppearance.MaterialComponents.Subtitle1"
+        android:textStyle="bold" />
+
+    <androidx.recyclerview.widget.RecyclerView
+        android:id="@+id/rvDevices"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:padding="8dp"
+        android:clipToPadding="false" />
+
+    <!-- Connected device config panel -->
+    <com.google.android.material.card.MaterialCardView
+        android:id="@+id/cardConfig"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_margin="8dp"
+        android:visibility="gone"
+        app:cardElevation="4dp">
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:padding="12dp">
+
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:gravity="center_vertical">
+
+                <TextView
+                    android:id="@+id/tvConnectedName"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:text="Connected: —"
+                    android:textAppearance="@style/TextAppearance.MaterialComponents.Subtitle1"
+                    android:textStyle="bold" />
+
+                <Button
+                    android:id="@+id/btnDisconnect"
+                    style="@style/Widget.MaterialComponents.Button.OutlinedButton"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:text="Disconnect" />
+
+            </LinearLayout>
+
+            <!-- tag_name -->
+            <com.google.android.material.textfield.TextInputLayout
+                style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.Dense"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="8dp"
+                android:hint="Tag Name">
+                <com.google.android.material.textfield.TextInputEditText
+                    android:id="@+id/etTagName"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:inputType="text" />
+            </com.google.android.material.textfield.TextInputLayout>
+
+            <!-- sleep_timeout_s and uwb_channel (row) -->
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:layout_marginTop="4dp">
+
+                <com.google.android.material.textfield.TextInputLayout
+                    style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.Dense"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:layout_marginEnd="4dp"
+                    android:hint="Sleep Timeout (s)">
+                    <com.google.android.material.textfield.TextInputEditText
+                        android:id="@+id/etSleepTimeout"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:inputType="number" />
+                </com.google.android.material.textfield.TextInputLayout>
+
+                <com.google.android.material.textfield.TextInputLayout
+                    style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.Dense"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:layout_marginStart="4dp"
+                    android:hint="UWB Channel">
+                    <com.google.android.material.textfield.TextInputEditText
+                        android:id="@+id/etUwbChannel"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:inputType="number" />
+                </com.google.android.material.textfield.TextInputLayout>
+
+            </LinearLayout>
+
+            <!-- display_brightness and ranging_interval_ms (row) -->
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:layout_marginTop="4dp">
+
+                <com.google.android.material.textfield.TextInputLayout
+                    style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.Dense"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:layout_marginEnd="4dp"
+                    android:hint="Brightness (0-100)">
+                    <com.google.android.material.textfield.TextInputEditText
+                        android:id="@+id/etBrightness"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:inputType="number" />
+                </com.google.android.material.textfield.TextInputLayout>
+
+                <com.google.android.material.textfield.TextInputLayout
+                    style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox.Dense"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:layout_marginStart="4dp"
+                    android:hint="Ranging Interval (ms)">
+                    <com.google.android.material.textfield.TextInputEditText
+                        android:id="@+id/etRangingInterval"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:inputType="number" />
+                </com.google.android.material.textfield.TextInputLayout>
+
+            </LinearLayout>
+
+            <!-- battery_report toggle -->
+            <com.google.android.material.switchmaterial.SwitchMaterial
+                android:id="@+id/switchBatteryReport"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="8dp"
+                android:text="Battery Reporting" />
+
+            <!-- Action buttons -->
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal"
+                android:layout_marginTop="8dp">
+
+                <Button
+                    android:id="@+id/btnReadConfig"
+                    style="@style/Widget.MaterialComponents.Button.OutlinedButton"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:layout_marginEnd="4dp"
+                    android:text="Read" />
+
+                <Button
+                    android:id="@+id/btnWriteConfig"
+                    style="@style/Widget.MaterialComponents.Button"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:layout_marginStart="4dp"
+                    android:text="Write" />
+
+            </LinearLayout>
+
+            <!-- Status notifications from tag -->
+            <TextView
+                android:id="@+id/tvTagStatus"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="8dp"
+                android:background="#1A000000"
+                android:fontFamily="monospace"
+                android:padding="8dp"
+                android:text="Tag status: —"
+                android:textAppearance="@style/TextAppearance.MaterialComponents.Caption" />
+
+        </LinearLayout>
+
+    </com.google.android.material.card.MaterialCardView>
+
+</LinearLayout>

android/src/main/res/layout/item_ble_device.xml

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<com.google.android.material.card.MaterialCardView
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:layout_margin="4dp"
+    app:cardElevation="2dp"
+    android:clickable="true"
+    android:focusable="true">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:padding="12dp"
+        android:gravity="center_vertical">
+
+        <LinearLayout
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:orientation="vertical">
+
+            <TextView
+                android:id="@+id/tvDeviceName"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="UWB_TAG_XXXX"
+                android:textAppearance="@style/TextAppearance.MaterialComponents.Subtitle2"
+                android:textStyle="bold" />
+
+            <TextView
+                android:id="@+id/tvDeviceAddress"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="XX:XX:XX:XX:XX:XX"
+                android:textAppearance="@style/TextAppearance.MaterialComponents.Caption" />
+
+        </LinearLayout>
+
+        <TextView
+            android:id="@+id/tvRssi"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="-70 dBm"
+            android:textAppearance="@style/TextAppearance.MaterialComponents.Caption"
+            android:textColor="?attr/colorSecondary" />
+
+        <Button
+            android:id="@+id/btnConnect"
+            style="@style/Widget.MaterialComponents.Button.OutlinedButton"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="8dp"
+            android:text="Connect" />
+
+    </LinearLayout>
+
+</com.google.android.material.card.MaterialCardView>

cad/assembly.scad

@@ -60,7 +60,7 @@ color("Purple", 0.9)
     translate([0, 0, h_fc])
         cube([36, 36, 5], center=true);
 
-// Jetson Nano
+// Jetson Orin Nano Super
 color("LimeGreen", 0.7)
     translate([0, 0, h_jetson])
         cube([100, 80, 29], center=true);

cad/dimensions.scad

@@ -20,7 +20,7 @@ fc_hole_dia = 3.2;      // M3 clearance
 fc_board_size = 36;      // Typical FC PCB
 fc_standoff_h = 5;       // Rubber standoff height
 
-// --- Jetson Nano ---
+// --- Jetson Orin Nano Super ---
 jetson_w = 100;
 jetson_d = 80;
 jetson_h = 29;           // With heatsink

cad/jetson_shelf.scad

@@ -1,7 +1,7 @@
 // ============================================
-// SaltyLab — Jetson Nano Shelf
+// SaltyLab — Jetson Orin Nano Super Shelf
 // 120×100×15mm PETG
-// Mounts Jetson Nano to 2020 extrusion
+// Mounts Jetson Orin Nano Super to 2020 extrusion
 // ============================================
 include <dimensions.scad>
 

chassis/ASSEMBLY.md

@@ -56,15 +56,24 @@
 3. Fasten 4× M4×12 SHCS. Torque 2.5 N·m.
 4. Insert battery pack; route Velcro straps through slots and cinch.
 
-### 7  FC mount (MAMBA F722S)
-1. Place silicone anti-vibration grommets onto nylon M3 standoffs.
-2. Lower FC onto standoffs; secure with M3×6 BHCS. Snug only — do not over-torque.
-3. Orient USB-C port toward front of robot for cable access.
+<<<<<<< HEAD
+### 7  MCU mount (ESP32 BALANCE + ESP32 IO)
 
-### 8  Jetson Nano mount plate
+> ⚠️ **ARCHITECTURE CHANGE (2026-04-03):** ESP32 BALANCE retired. Two ESP32 boards replace it.
+> Board dimensions and hole patterns TBD — await spec from max before machining mount plate.
+
+=======
+### 7  FC mount (ESP32-S3 BALANCE)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
+1. Place silicone anti-vibration grommets onto nylon M3 standoffs.
+2. Lower ESP32 BALANCE board onto standoffs; secure with M3×6 BHCS. Snug only.
+3. Mount ESP32 IO board adjacent — exact placement TBD pending board dimensions.
+4. Orient USB connectors toward front of robot for cable access.
+
+### 8  Jetson Orin Nano Super mount plate
 1. Press or thread M3 nylon standoffs (8mm) into plate holes.
 2. Bolt plate to deck: 4× M3×10 SHCS at deck corners.
-3. Set Jetson Nano B01 carrier onto plate standoffs; fasten M3×6 BHCS.
+3. Set Jetson Orin Nano Super B01 carrier onto plate standoffs; fasten M3×6 BHCS.
 
 ### 9  Bumper brackets
 1. Slide 22mm EMT conduit through saddle clamp openings.
@@ -86,7 +95,8 @@
 | Wheelbase (axle C/L to C/L) | 600 mm | ±1 mm |
 | Motor fork slot width | 24 mm | +0.5 / 0 |
 | Motor fork dropout depth | 60 mm | ±0.5 mm |
-| FC hole pattern | 30.5 × 30.5 mm | ±0.2 mm |
+| ESP32 BALANCE hole pattern | TBD — await spec from max | ±0.2 mm |
+| ESP32 IO hole pattern | TBD — await spec from max | ±0.2 mm |
 | Jetson hole pattern | 58 × 58 mm | ±0.2 mm |
 | Battery tray inner | 185 × 72 × 52 mm | +2 / 0 mm |
 

chassis/BOM.md

@@ -41,7 +41,11 @@ PR #7 (`chassis_frame.scad`) used placeholder values. The table below records th
 | 3 | Dropout clamp — upper | 2 | 8mm 6061-T6 Al | 90×70mm blank | D-cut bore; `RENDER="clamp_upper_2d"` |
 | 4 | Stem flange ring | 2 | 6mm Al or acrylic | Ø82mm disc | One above + one below plate; `RENDER="stem_flange_2d"` |
 | 5 | Vertical stem tube | 1 | 38.1mm OD × 1.5mm wall 6061-T6 Al | 1050mm length | 1.5" EMT conduit is a drop-in alternative |
-| 6 | FC standoff M3×6mm nylon | 4 | Nylon | — | MAMBA F722S vibration isolation |
+<<<<<<< HEAD
+| 6 | MCU standoff M3×6mm nylon | 4 | Nylon | — | ESP32 BALANCE / IO board isolation (dimensions TBD) |
+=======
+| 6 | FC standoff M3×6mm nylon | 4 | Nylon | — | ESP32-S3 BALANCE vibration isolation |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | 7 | Ø4mm × 16mm alignment pin | 8 | Steel dowel | — | Dropout clamp-to-plate alignment |
 
 ### Battery Stem Clamp (`stem_battery_clamp.scad`) — Part B
@@ -70,7 +74,7 @@ PR #7 (`chassis_frame.scad`) used placeholder values. The table below records th
 | 10 | Motor fork bracket (R) | 1 | 8mm 6061 aluminium | Mirror of item 9 |
 | 11 | Battery tray | 1 | 3mm PETG FDM or 3mm aluminium fold | `chassis_frame.scad` — `battery_tray()` module |
 | 12 | FC mount plate / standoffs | 1 set | PETG or nylon FDM | Includes 4× M3 nylon standoffs, 6mm height |
-| 13 | Jetson Nano mount plate | 1 | 4mm 5052 aluminium or 4mm PETG FDM | B01 58×58mm hole pattern |
+| 13 | Jetson Orin Nano Super mount plate | 1 | 4mm 5052 aluminium or 4mm PETG FDM | B01 58×58mm hole pattern |
 | 14 | Front bumper bracket | 1 | 5mm PETG FDM | Saddle clamps for 22mm EMT conduit |
 | 15 | Rear bumper bracket | 1 | 5mm PETG FDM | Mirror of item 14 |
 
@@ -88,12 +92,23 @@ PR #7 (`chassis_frame.scad`) used placeholder values. The table below records th
 
 ## Electronics Mounts
 
+> ⚠️ **ARCHITECTURE CHANGE (2026-04-03):** ESP32 BALANCE (ESP32) is retired.
+> Replaced by **ESP32 BALANCE** + **ESP32 IO**. Board dimensions and hole patterns TBD — await spec from max.
+
 | # | Part | Qty | Spec | Notes |
 |---|------|-----|------|-------|
-| 13 | STM32 MAMBA F722S FC | 1 | 36×36mm PCB, 30.5×30.5mm M3 mount | Oriented USB-C port toward front |
+<<<<<<< HEAD
+| 13 | ESP32 BALANCE board | 1 | TBD — mount pattern TBD | PID balance loop; replaces ESP32 BALANCE |
+| 13b | ESP32 IO board | 1 | TBD — mount pattern TBD | Motor/sensor/comms I/O |
+| 14 | Nylon M3 standoff 6mm | 4 | F/F nylon | ESP32 board isolation |
+| 15 | Anti-vibration grommet M3 | 4 | Ø6mm silicone | Under ESP32 mount pads |
+| 16 | Jetson Orin module | 1 | 69.6×45mm module + carrier | 58×58mm M3 carrier hole pattern |
+=======
+| 13 | ESP32-S3 ESP32-S3 BALANCE FC | 1 | 36×36mm PCB, 30.5×30.5mm M3 mount | Oriented USB-C port toward front |
 | 14 | Nylon M3 standoff 6mm | 4 | F/F nylon | FC vibration isolation |
 | 15 | Anti-vibration grommet M3 | 4 | Ø6mm silicone | Under FC mount pads |
-| 16 | Jetson Nano B01 module | 1 | 69.6×45mm module + carrier | 58×58mm M3 carrier hole pattern |
+| 16 | Jetson Orin Nano Super B01 module | 1 | 69.6×45mm module + carrier | 58×58mm M3 carrier hole pattern |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | 17 | Nylon M3 standoff 8mm | 4 | F/F nylon | Jetson board standoffs |
 
 ---
@@ -144,8 +159,8 @@ Slide entire carousel up/down the stem with M6 collar bolts loosened. Tighten at
 | 26 | M6×60 SHCS  | 4  | ISO 4762, SS | Collar clamping bolts |
 | 27 | M6 hex nut  | 4  | ISO 4032, SS | Captured in collar pockets |
 | 28 | M6×12 set screw | 2 | ISO 4026, SS cup-point | Stem height lock (1 per collar half) |
-| 29 | M3×10 SHCS | 12 | ISO 4762, SS | FC mount + miscellaneous |
-| 30 | M3×6 BHCS  | 4  | ISO 4762, SS | FC board bolts |
+| 29 | M3×10 SHCS | 12 | ISO 4762, SS | ESP32 mount + miscellaneous |
+| 30 | M3×6 BHCS  | 4  | ISO 4762, SS | ESP32 board bolts (qty TBD pending board spec) |
 | 31 | Axle lock nut (match axle tip thread) | 4 | Flanged, confirm thread | 2 per motor |
 | 32 | Flat washer M5 | 32 | SS | |
 | 33 | Flat washer M4 | 32 | SS | |

chassis/chassis_frame.scad

@@ -8,9 +8,9 @@
 // Requirements:
 //   - 600mm wheelbase
 //   - 2x hoverboard hub motors (170mm OD)
-//   - STM32 MAMBA F722S FC mount (30.5x30.5mm pattern)
+//   - ESP32-S3 ESP32-S3 BALANCE FC mount (30.5x30.5mm pattern)
 //   - Battery tray (24V 4Ah — ~180x70x50mm pack)
-//   - Jetson Nano B01 mount plate (100x80mm, M3 holes)
+//   - Jetson Orin Nano Super B01 mount plate (100x80mm, M3 holes)
 //   - Front/rear bumper brackets
 // =============================================================================
 
@@ -37,7 +37,7 @@ MOTOR_FORK_H       = 80;    // mm, total height of motor fork bracket
 MOTOR_FORK_T       = 8;     // mm, fork plate thickness
 AXLE_HEIGHT        = 310;   // mm, axle CL above ground (motor radius + clearance)
 
-// ── FC mount (MAMBA F722S — 30.5 × 30.5 mm M3 pattern) ──────────────────────
+// ── FC mount (ESP32-S3 BALANCE — 30.5 × 30.5 mm M3 pattern) ──────────────────────
 FC_MOUNT_SPACING   = 30.5;  // mm, hole pattern pitch
 FC_MOUNT_HOLE_D    = 3.2;   // mm, M3 clearance
 FC_STANDOFF_H      = 6;     // mm, standoff height
@@ -52,7 +52,7 @@ BATT_FLOOR         = 4;     // mm, tray floor thickness
 BATT_STRAP_W       = 20;    // mm, Velcro strap slot width
 BATT_STRAP_T       = 2;     // mm, strap slot depth
 
-// ── Jetson Nano B01 mount plate ──────────────────────────────────────────────
+// ── Jetson Orin Nano Super B01 mount plate ──────────────────────────────────────────────
 // B01 carrier board hole pattern: 58 x 58 mm M3 (inner) + corner pass-throughs
 JETSON_HOLE_PITCH  = 58;    // mm, M3 mounting hole pattern
 JETSON_HOLE_D      = 3.2;   // mm
@@ -210,7 +210,7 @@ module battery_tray() {
 
 // ─── FC mount holes helper ────────────────────────────────────────────────────
 module fc_mount_holes(z_offset=0, depth=10) {
-    // MAMBA F722S: 30.5×30.5 mm M3 pattern, centred at origin
+    // ESP32-S3 BALANCE: 30.5×30.5 mm M3 pattern, centred at origin
     for (x = [-FC_MOUNT_SPACING/2, FC_MOUNT_SPACING/2])
     for (y = [-FC_MOUNT_SPACING/2, FC_MOUNT_SPACING/2])
         translate([x, y, z_offset])
@@ -247,7 +247,7 @@ module fc_mount_plate() {
     }
 }
 
-// ─── Jetson Nano B01 mount plate ─────────────────────────────────────────────
+// ─── Jetson Orin Nano Super B01 mount plate ─────────────────────────────────────────────
 // Positioned rear of deck, elevated on standoffs
 module jetson_mount_plate() {
     jet_x =  60;   // offset toward rear

chassis/ip54_BOM.md

@@ -104,7 +104,11 @@ IP54-rated enclosures and sensor housings for all-weather outdoor robot operatio
 | Component | Thermal strategy | Max junction | Enclosure budget |
 |-----------|-----------------|-------------|-----------------|
 | Jetson Orin NX | Al pad → lid → fan forced convection | 95 °C Tj | Target ≤ 60 °C case |
-| FC (MAMBA F722S) | Passive; FC has own EMI shield | 85 °C | <60 °C ambient OK |
+<<<<<<< HEAD
+| FC (ESP32 BALANCE) | Passive; FC has own EMI shield | 85 °C | <60 °C ambient OK |
+=======
+| FC (ESP32-S3 BALANCE) | Passive; FC has own EMI shield | 85 °C | <60 °C ambient OK |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | ESC × 2 | Al pad → lid | 100 °C Tj | Target ≤ 60 °C |
 | D435i | Passive; housing vent gap on rear cap | 45 °C surface | — |
 

chassis/prototype_baseplate.scad

@@ -65,7 +65,7 @@ CLAMP_ALIGN_D   =   4.1;   // Ø4 pin
 // D-cut bore clearance
 DCUT_CL         =  0.3;
 
-// FC mount — MAMBA F722S 30.5 × 30.5 mm M3
+// FC mount — ESP32-S3 BALANCE 30.5 × 30.5 mm M3
 FC_PITCH        = 30.5;
 FC_HOLE_D       =  3.2;
 // FC is offset toward front of plate (away from stem)
@@ -202,7 +202,7 @@ module base_plate() {
                 translate([STEM_FLANGE_BC/2, 0, -1])
                     cylinder(d=M5, h=PLATE_THICK + 2);
 
-        // ── FC mount (MAMBA F722S 30.5 × 30.5 M3) ────────────────────────
+        // ── FC mount (ESP32-S3 BALANCE 30.5 × 30.5 M3) ────────────────────────
         for (x = [FC_X_OFFSET - FC_PITCH/2, FC_X_OFFSET + FC_PITCH/2])
         for (y = [-FC_PITCH/2, FC_PITCH/2])
             translate([x, y, -1])

chassis/rover_electronics_bay.scad

@@ -11,7 +11,7 @@
 //          • Ventilation slots      — all 4 walls + lid
 //
 // Shared mounting patterns (swappable with SaltyLab):
-//   FC    : 30.5 × 30.5 mm M3 (MAMBA F722S / Pixhawk)
+//   FC    : 30.5 × 30.5 mm M3 (ESP32-S3 BALANCE / Pixhawk)
 //   Jetson: 58 × 49 mm M3    (Orin NX / Nano Devkit carrier)
 //
 // Coordinate: bay centred at origin; Z=0 = deck top face.

chassis/saltyrover_chassis_r2.scad

@@ -17,7 +17,7 @@
 //   • Weight target: <2 kg frame (excl. motors/electronics)
 //
 // Shared SaltyLab patterns (swappable electronics):
-//   FC  : 30.5 × 30.5 mm M3  (MAMBA F722S / Pixhawk)
+//   FC  : 30.5 × 30.5 mm M3  (ESP32-S3 BALANCE / Pixhawk)
 //   Jetson: 58 × 49 mm M3    (Orin NX / Nano carrier board)
 //   Stem  : Ø25 mm bore      (sensor head unchanged)
 //
@@ -87,7 +87,7 @@ STEM_COLLAR_OD = 50.0;
 STEM_COLLAR_H  = 20.0;   // raised boss height above deck top
 STEM_FLANGE_BC = 40.0;   // 4× M4 bolt circle for stem adapter
 
-// ── FC mount — MAMBA F722S / Pixhawk (30.5 × 30.5 mm M3) ────────────────────
+// ── FC mount — ESP32-S3 BALANCE / Pixhawk (30.5 × 30.5 mm M3) ────────────────────
 // Shared with SaltyLab — swappable electronics
 FC_PITCH    = 30.5;
 FC_HOLE_D   =  3.2;

chassis/vesc_mount.scad

@@ -0,0 +1,296 @@
+// ============================================================
+// vesc_mount.scad — FSESC 6.7 Pro Mini Dual ESC Mount Cradle
+// Issue #699 / sl-mechanical  2026-03-17
+// ============================================================
+// Open-top tray for Flipsky FSESC 6.7 Pro Mini Dual (~100 × 68 × 28 mm).
+// Attaches to 2020 aluminium T-slot rail via 4× M5 T-nuts
+// (2× per rail, two parallel rails, 60 mm bolt spacing in X,
+//  20 mm bolt spacing in Y matching 2020 slot pitch).
+//
+// Connector access:
+//   XT60 battery inputs    — X− end wall cutouts (2 connectors, side-by-side)
+//   XT30 motor outputs     — Y+ and Y− side wall cutouts (2 per side wall)
+//   CAN/UART terminal      — X+ end wall cutout (screw terminal, wire exit)
+//
+// Ventilation:
+//   Open top face          — heatsink fins fully exposed
+//   Floor grille slots     — under-board airflow
+//   Side vent louvres      — 4 slots on each Y± wall at heatsink height
+//
+// Retention: 4× M3 heat-set insert boss in floor — board screws down through
+// ESC mounting holes via M3×8 FHCS. Board sits on 4 mm raised posts for
+// under-board airflow.
+//
+// ⚠  VERIFY WITH CALIPERS BEFORE PRINTING:
+//    PCB_L, PCB_W                   board outline
+//    XT60_W, XT60_H                 XT60 shell at X− edge
+//    XT30_W, XT30_H                 XT30 shells at Y± edges
+//    TERM_W, TERM_H                 CAN screw terminal at X+ edge
+//    MOUNT_X1/X2, MOUNT_Y1/Y2      ESC board mounting hole pattern
+//
+// Print settings (PETG):
+//   3 perimeters, 40 % gyroid infill, no supports, 0.2 mm layer
+//   Print orientation: open face UP (as modelled)
+//
+// BOM:
+//   4 × M5×10 BHCS  +  4 × M5 slide-in T-nut  (2020 rail)
+//   4 × M3 heat-set insert (Voron-style, OD 4.5 mm × 4 mm deep)
+//   4 × M3×8 FHCS  (board retention)
+//
+// Export commands:
+//   openscad -D 'RENDER="mount"'    -o vesc_mount.stl    vesc_mount.scad
+//   openscad -D 'RENDER="assembly"' -o vesc_assembly.png vesc_mount.scad
+// ============================================================
+
+RENDER = "assembly"; // mount | assembly
+
+$fn = 48;
+EPS = 0.01;
+
+// ── ⚠ Verify before printing ─────────────────────────────────
+// FSESC 6.7 Pro Mini Dual PCB
+PCB_L    = 100.0;  // board length (X: XT60 end → CAN terminal end)
+PCB_W    =  68.0;  // board width  (Y)
+PCB_T    =  2.0;   // board thickness (incl. bottom-side components)
+COMP_H   =  26.0;  // tallest component above board top face (heatsink ~26 mm)
+
+// XT60 battery connectors at X− end (2 connectors, side-by-side)
+XT60_W   =  16.0;  // each XT60 shell width (Y)
+XT60_H   =  16.0;  // each XT60 shell height (Z) above board surface
+XT60_Z0  =   0.0;  // connector bottom offset above board surface
+// Y centres of each XT60 measured from PCB Y− edge
+XT60_Y1  =  16.0;
+XT60_Y2  =  52.0;
+
+// XT30 motor output connectors at Y± sides (2 per side)
+XT30_W   =  10.5;  // each XT30 shell width (X span)
+XT30_H   =  12.0;  // each XT30 shell height (Z) above board surface
+XT30_Z0  =   0.5;  // connector bottom offset above board surface
+// X centres measured from PCB X− edge (same layout both Y− and Y+ sides)
+XT30_X1  =  22.0;
+XT30_X2  =  78.0;
+
+// CAN / UART screw terminal block at X+ end (3-pos 3.5 mm pitch)
+TERM_W   =  14.0;  // terminal block Y span
+TERM_H   =  10.0;  // terminal block height above board surface
+TERM_Z0  =   0.5;  // terminal bottom offset above board surface
+TERM_Y_CTR = PCB_W / 2;
+
+// ── ESC board mounting hole pattern ──────────────────────────
+// 4 corner holes, 4 mm inset from each PCB edge
+MOUNT_INSET  =  4.0;
+MOUNT_X1     = MOUNT_INSET;
+MOUNT_X2     = PCB_L - MOUNT_INSET;
+MOUNT_Y1     = MOUNT_INSET;
+MOUNT_Y2     = PCB_W - MOUNT_INSET;
+
+M3_INSERT_OD =  4.6;   // Voron M3 heat-set insert press-fit OD
+M3_INSERT_H  =  4.0;   // insert depth
+M3_CLEAR_D   =  3.4;   // M3 clearance bore below insert
+
+// ── Cradle geometry ──────────────────────────────────────────
+WALL_T   =  2.8;   // side / end wall thickness
+FLOOR_T  =  4.5;   // floor plate thickness (fits M5 BHCS head pocket)
+POST_H   =  4.0;   // standoff post height (board lifts off floor for airflow)
+CL_SIDE  =  0.35;  // Y clearance per side
+CL_END   =  0.40;  // X clearance per end
+
+INN_W    = PCB_W + 2*CL_SIDE;
+INN_L    = PCB_L + 2*CL_END;
+INN_H    = POST_H + PCB_T + COMP_H + 1.5;
+
+OTR_W    = INN_W  + 2*WALL_T;
+OTR_L    = INN_L  + 2*WALL_T;
+OTR_H    = FLOOR_T + INN_H;
+
+PCB_X0   = WALL_T + CL_END;
+PCB_Y0   = WALL_T + CL_SIDE;
+PCB_Z0   = FLOOR_T + POST_H;
+
+// ── M5 T-nut mount (2020 rail) ────────────────────────────────
+// 4 bolts: 2 columns (X) × 2 rows (Y), centred on body
+M5_D       =  5.3;
+M5_HEAD_D  =  9.5;
+M5_HEAD_H  =  3.0;
+M5_SPAC_X  = 60.0;   // X bolt spacing
+M5_SPAC_Y  = 20.0;   // Y bolt spacing (2020 T-slot pitch)
+
+// ── Floor ventilation grille ──────────────────────────────────
+GRILLE_SLOT_W =  4.0;
+GRILLE_SLOT_T = FLOOR_T - 1.5;
+GRILLE_PITCH  = 10.0;
+GRILLE_X0     = WALL_T + 14;
+GRILLE_X_LEN  = OTR_L - 2*WALL_T - 28;
+GRILLE_N      = floor((INN_W - 10) / GRILLE_PITCH);
+
+// ── Side vent louvres on Y± walls ────────────────────────────
+LOUV_H     =  5.0;
+LOUV_W     = 12.0;
+LOUV_Z     = FLOOR_T + POST_H + PCB_T + 4.0;  // mid-heatsink height
+LOUV_N     =  4;
+LOUV_PITCH = (OTR_L - 2*WALL_T - 20) / max(LOUV_N - 1, 1);
+
+// ── CAN wire strain relief bosses (X+ end) ───────────────────
+SR_BOSS_OD =  7.0;
+SR_BOSS_H  =  6.0;
+SR_SLOT_W  =  3.5;
+SR_SLOT_T  =  2.2;
+SR_Y1      = WALL_T + INN_W * 0.25;
+SR_Y2      = WALL_T + INN_W * 0.75;
+SR_X       = OTR_L - WALL_T - SR_BOSS_OD/2 - 2.5;
+
+// ─────────────────────────────────────────────────────────────
+module m3_insert_boss() {
+    // Solid post with heat-set insert bore from top
+    post_h = FLOOR_T + POST_H;
+    difference() {
+        cylinder(d = M3_INSERT_OD + 3.2, h = post_h);
+        // Insert bore from top
+        translate([0, 0, post_h - M3_INSERT_H])
+            cylinder(d = M3_INSERT_OD, h = M3_INSERT_H + EPS);
+        // Clearance bore from bottom
+        translate([0, 0, -EPS])
+            cylinder(d = M3_CLEAR_D, h = post_h - M3_INSERT_H + EPS);
+    }
+}
+
+module vesc_mount() {
+    difference() {
+        union() {
+            // Main body
+            cube([OTR_L, OTR_W, OTR_H]);
+
+            // M3 insert bosses at board mounting corners
+            for (mx = [MOUNT_X1, MOUNT_X2])
+            for (my = [MOUNT_Y1, MOUNT_Y2])
+                translate([PCB_X0 + mx, PCB_Y0 + my, 0])
+                    m3_insert_boss();
+
+            // CAN strain relief bosses on X+ end
+            for (sy = [SR_Y1, SR_Y2])
+                translate([SR_X, sy, 0])
+                    cylinder(d = SR_BOSS_OD, h = SR_BOSS_H);
+        }
+
+        // ── Interior cavity (open top) ─────────────────────────
+        translate([WALL_T, WALL_T, FLOOR_T])
+            cube([INN_L, INN_W, INN_H + EPS]);
+
+        // ── XT60 cutouts at X− end (2 connectors) ──────────────
+        for (yc = [XT60_Y1, XT60_Y2])
+            translate([-EPS,
+                       PCB_Y0 + yc - (XT60_W + 2.0)/2,
+                       PCB_Z0 + XT60_Z0 - 0.5])
+                cube([WALL_T + 2*EPS, XT60_W + 2.0, XT60_H + 3.0]);
+
+        // ── XT30 cutouts at Y− side (2 connectors) ─────────────
+        for (xc = [XT30_X1, XT30_X2])
+            translate([PCB_X0 + xc - (XT30_W + 2.0)/2,
+                       -EPS,
+                       PCB_Z0 + XT30_Z0 - 0.5])
+                cube([XT30_W + 2.0, WALL_T + 2*EPS, XT30_H + 3.0]);
+
+        // ── XT30 cutouts at Y+ side (2 connectors) ─────────────
+        for (xc = [XT30_X1, XT30_X2])
+            translate([PCB_X0 + xc - (XT30_W + 2.0)/2,
+                       OTR_W - WALL_T - EPS,
+                       PCB_Z0 + XT30_Z0 - 0.5])
+                cube([XT30_W + 2.0, WALL_T + 2*EPS, XT30_H + 3.0]);
+
+        // ── CAN terminal cutout at X+ end ──────────────────────
+        translate([OTR_L - WALL_T - EPS,
+                   PCB_Y0 + TERM_Y_CTR - (TERM_W + 3.0)/2,
+                   PCB_Z0 + TERM_Z0 - 0.5])
+            cube([WALL_T + 2*EPS, TERM_W + 3.0, TERM_H + 5.0]);
+
+        // ── Floor ventilation grille ───────────────────────────
+        for (i = [0 : GRILLE_N - 1]) {
+            sy = WALL_T + 5 + i * GRILLE_PITCH;
+            translate([GRILLE_X0, sy, -EPS])
+                cube([GRILLE_X_LEN, GRILLE_SLOT_W, GRILLE_SLOT_T + EPS]);
+        }
+
+        // ── Side vent louvres — Y− wall ────────────────────────
+        for (i = [0 : LOUV_N - 1]) {
+            lx = WALL_T + 10 + i * LOUV_PITCH;
+            translate([lx, -EPS, LOUV_Z])
+                cube([LOUV_W, WALL_T + 2*EPS, LOUV_H]);
+        }
+
+        // ── Side vent louvres — Y+ wall ────────────────────────
+        for (i = [0 : LOUV_N - 1]) {
+            lx = WALL_T + 10 + i * LOUV_PITCH;
+            translate([lx, OTR_W - WALL_T - EPS, LOUV_Z])
+                cube([LOUV_W, WALL_T + 2*EPS, LOUV_H]);
+        }
+
+        // ── M5 BHCS head pockets (4 bolts, bottom face) ────────
+        for (mx = [OTR_L/2 - M5_SPAC_X/2, OTR_L/2 + M5_SPAC_X/2])
+        for (my = [OTR_W/2 - M5_SPAC_Y/2, OTR_W/2 + M5_SPAC_Y/2])
+            translate([mx, my, -EPS]) {
+                cylinder(d = M5_D,      h = FLOOR_T + 2*EPS);
+                cylinder(d = M5_HEAD_D, h = M5_HEAD_H + EPS);
+            }
+
+        // ── Zip-tie slots through CAN strain relief bosses ─────
+        for (sy = [SR_Y1, SR_Y2])
+            translate([SR_X, sy, SR_BOSS_H/2 - SR_SLOT_T/2])
+                rotate([0, 90, 0])
+                    cube([SR_SLOT_T, SR_SLOT_W, SR_BOSS_OD + 2*EPS],
+                         center = true);
+
+        // ── Weight-relief pocket in floor underside ─────────────
+        translate([WALL_T + 16, WALL_T + 6, -EPS])
+            cube([OTR_L - 2*WALL_T - 32, OTR_W - 2*WALL_T - 12,
+                  FLOOR_T - 2.0 + EPS]);
+    }
+}
+
+// ── Assembly preview ─────────────────────────────────────────
+if (RENDER == "assembly") {
+    color("DimGray", 0.93) vesc_mount();
+
+    // Phantom PCB
+    color("ForestGreen", 0.30)
+        translate([PCB_X0, PCB_Y0, PCB_Z0])
+            cube([PCB_L, PCB_W, PCB_T]);
+
+    // Phantom heatsink / component block
+    color("SlateGray", 0.22)
+        translate([PCB_X0, PCB_Y0, PCB_Z0 + PCB_T])
+            cube([PCB_L, PCB_W, COMP_H]);
+
+    // XT60 connector highlights (X− end)
+    for (yc = [XT60_Y1, XT60_Y2])
+        color("Gold", 0.85)
+            translate([-2,
+                       PCB_Y0 + yc - XT60_W/2,
+                       PCB_Z0 + XT60_Z0])
+                cube([WALL_T + 3, XT60_W, XT60_H]);
+
+    // XT30 connector highlights — Y− side
+    for (xc = [XT30_X1, XT30_X2])
+        color("OrangeRed", 0.80)
+            translate([PCB_X0 + xc - XT30_W/2,
+                       -2,
+                       PCB_Z0 + XT30_Z0])
+                cube([XT30_W, WALL_T + 3, XT30_H]);
+
+    // XT30 connector highlights — Y+ side
+    for (xc = [XT30_X1, XT30_X2])
+        color("OrangeRed", 0.80)
+            translate([PCB_X0 + xc - XT30_W/2,
+                       OTR_W - WALL_T - 1,
+                       PCB_Z0 + XT30_Z0])
+                cube([XT30_W, WALL_T + 3, XT30_H]);
+
+    // CAN terminal highlight
+    color("Tomato", 0.75)
+        translate([OTR_L - WALL_T - 1,
+                   PCB_Y0 + TERM_Y_CTR - TERM_W/2,
+                   PCB_Z0 + TERM_Z0])
+            cube([WALL_T + 3, TERM_W, TERM_H]);
+
+} else {
+    vesc_mount();
+}

docs/AGENTS.md

@@ -2,22 +2,44 @@
 
 You're working on **SaltyLab**, a self-balancing two-wheeled indoor robot. Read this entire file before touching anything.
 
-## Project Overview
+## ⚠️ ARCHITECTURE — SAUL-TEE (finalised 2026-04-04)
 
+<<<<<<< HEAD
+Full hardware spec: `docs/SAUL-TEE-SYSTEM-REFERENCE.md` — **read it before writing firmware.**
+
+| Board | Role |
+|-------|------|
+| **ESP32-S3 BALANCE** | Waveshare Touch LCD 1.28 (CH343 USB). QMI8658 IMU, PID loop, CAN→VESC L(68)/R(56), GC9A01 LCD |
+| **ESP32-S3 IO** | Bare devkit (JTAG USB). TBS Crossfire RC (UART0), ELRS failover (UART2), BTS7960 motors, NFC/baro/ToF, WS2812, buzzer/horn/headlight/fan |
+| **Jetson Orin** | CANable2 USB→CAN. Cmds on 0x300–0x303, telemetry on 0x400–0x401 |
+
+```
+Jetson Orin ──CANable2──► CAN 500kbps ◄───────────────────────┐
+                                │                               │
+                         ESP32-S3 BALANCE ←─UART 460800─► ESP32-S3 IO
+                         (QMI8658, PID loop)              (BTS7960, RC, sensors)
+                                │ CAN 500kbps
+                      ┌─────────┴──────────┐
+                 VESC Left (ID 68)    VESC Right (ID 56)
+=======
 A hoverboard-based balancing robot with two compute layers:
-1. **FC (Flight Controller)** — MAMBA F722S (STM32F722RET6 + MPU6000 IMU). Runs a lean C balance loop at up to 8kHz. Talks UART to the hoverboard ESC. This is the safety-critical layer.
-2. **Jetson Nano** — AI brain. ROS2, SLAM, person tracking. Sends velocity commands to FC via UART. Not safety-critical — FC operates independently.
+1. **ESP32-S3 BALANCE** — ESP32-S3 BALANCE (ESP32-S3RET6 + MPU6000 IMU). Runs a lean C balance loop at up to 8kHz. Talks UART to the hoverboard ESC. This is the safety-critical layer.
+2. **Jetson Orin Nano Super** — AI brain. ROS2, SLAM, person tracking. Sends velocity commands to FC via UART. Not safety-critical — FC operates independently.
 
 ```
 Jetson (speed+steer via UART1)  ←→  ELRS RC (UART3, kill switch)
          │
          ▼
-   MAMBA F722S (MPU6000 IMU, PID balance)
+   ESP32-S3 BALANCE (MPU6000 IMU, PID balance)
          │
          ▼ UART2
    Hoverboard ESC (FOC) → 2× 8" hub motors
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 ```
 
+Frame: `[0xAA][LEN][TYPE][PAYLOAD][CRC8]`  
+Legacy `src/` STM32 HAL code is **archived — do not extend.**
+
 ## ⚠️ SAFETY — READ THIS OR PEOPLE GET HURT
 
 This is not a toy. 8" hub motors + 36V battery can crush fingers, break toes, and launch the frame. Every firmware change must preserve these invariants:
@@ -35,10 +57,14 @@ This is not a toy. 8" hub motors + 36V battery can crush fingers, break toes, an
 ## Repository Layout
 
 ```
-firmware/              # STM32 HAL firmware (PlatformIO)
+<<<<<<< HEAD
+firmware/              # Legacy ESP32/STM32 HAL firmware (PlatformIO, archived)
+=======
+firmware/              # ESP-IDF firmware (PlatformIO)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 ├── src/
 │   ├── main.c         # Entry point, clock config, main loop
-│   ├── icm42688.c     # ICM-42688-P SPI driver (backup IMU — currently broken)
+│   ├── icm42688.c     # QMI8658-P SPI driver (backup IMU — currently broken)
 │   ├── bmp280.c       # Barometer driver (disabled)
 │   └── status.c       # LED + buzzer status patterns
 ├── include/
@@ -49,7 +75,7 @@ firmware/              # STM32 HAL firmware (PlatformIO)
 │   ├── crsf.h         # ELRS CRSF protocol
 │   ├── bmp280.h
 │   └── status.h
-├── lib/USB_CDC/       # USB CDC stack (serial over USB)
+├── lib/USB_CDC/       # USB Serial (CH343) stack (serial over USB)
 │   ├── src/           # CDC implementation, USB descriptors, PCD config
 │   └── include/
 └── platformio.ini     # Build config
@@ -82,16 +108,24 @@ PLATFORM.md            # Hardware platform reference
 
 ## Hardware Quick Reference
 
-### MAMBA F722S Flight Controller
+<<<<<<< HEAD
+### ESP32 BALANCE Flight Controller
 
 | Spec | Value |
 |------|-------|
-| MCU | STM32F722RET6 (Cortex-M7, 216MHz, 512KB flash, 256KB RAM) |
+| MCU | ESP32RET6 (Cortex-M7, 216MHz, 512KB flash, 256KB RAM) |
+=======
+### ESP32-S3 BALANCE Flight Controller
+
+| Spec | Value |
+|------|-------|
+| MCU | ESP32-S3RET6 (Cortex-M7, 216MHz, 512KB flash, 256KB RAM) |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | Primary IMU | MPU6000 (WHO_AM_I = 0x68) |
 | IMU Bus | SPI1: PA5=SCK, PA6=MISO, PA7=MOSI, CS=PA4 |
 | IMU EXTI | PC4 (data ready interrupt) |
 | IMU Orientation | CW270 (Betaflight convention) |
-| Secondary IMU | ICM-42688-P (on same SPI1, CS unknown — currently non-functional) |
+| Secondary IMU | QMI8658-P (on same SPI1, CS unknown — currently non-functional) |
 | Betaflight Target | DIAT-MAMBAF722_2022B |
 | USB | OTG FS (PA11/PA12), enumerates as /dev/cu.usbmodemSALTY0011 |
 | VID/PID | 0x0483/0x5740 |
@@ -104,7 +138,7 @@ PLATFORM.md            # Hardware platform reference
 
 | UART | Pins | Connected To | Baud |
 |------|------|-------------|------|
-| USART1 | PA9/PA10 | Jetson Nano | 115200 |
+| USART1 | PA9/PA10 | Jetson Orin Nano Super | 115200 |
 | USART2 | PA2/PA3 | Hoverboard ESC | 115200 |
 | USART3 | PB10/PB11 | ELRS Receiver | 420000 (CRSF) |
 | UART4 | — | Spare | — |
@@ -125,7 +159,7 @@ PLATFORM.md            # Hardware platform reference
 | FC board size | ~36mm square |
 | Hub motor body | Ø200mm (~8") |
 | Motor axle | Ø12mm, 45mm long |
-| Jetson Nano | 100×80×29mm, M2.5 holes at 86×58mm |
+| Jetson Orin Nano Super | 100×80×29mm, M2.5 holes at 86×58mm |
 | RealSense D435i | 90×25×25mm, 1/4-20 tripod mount |
 | RPLIDAR A1 | Ø70×41mm, 4× M2.5 on Ø67mm circle |
 | Kill switch hole | Ø22mm panel mount |
@@ -160,19 +194,27 @@ PLATFORM.md            # Hardware platform reference
 ### Critical Lessons Learned (DON'T REPEAT THESE)
 
 1. **SysTick_Handler with HAL_IncTick() is MANDATORY** — without it, HAL_Delay() and every HAL timeout hangs forever. This bricked us multiple times.
-2. **DCache breaks SPI on STM32F7** — disable DCache or use cache-aligned DMA buffers with clean/invalidate. We disable it.
+<<<<<<< HEAD
+2. **DCache breaks SPI on ESP32** — disable DCache or use cache-aligned DMA buffers with clean/invalidate. We disable it.
+=======
+2. **DCache breaks SPI on ESP32-S3** — disable DCache or use cache-aligned DMA buffers with clean/invalidate. We disable it.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 3. **`-(int)0 == 0`** — checking `if (-result)` to detect errors doesn't work when result is 0 (success and failure look the same). Always use explicit error codes.
 4. **NEVER auto-run untested code on_boot** — we bricked the NSPanel 3x doing this. Test manually first.
-5. **USB CDC needs ReceivePacket() primed in CDC_Init** — without it, the OUT endpoint never starts listening. No data reception.
+5. **USB Serial (CH343) needs ReceivePacket() primed in CDC_Init** — without it, the OUT endpoint never starts listening. No data reception.
 
 ### DFU Reboot (Betaflight Method)
 
 The firmware supports reboot-to-DFU via USB command:
-1. Send `R` byte over USB CDC
+1. Send `R` byte over USB Serial (CH343)
 2. Firmware writes `0xDEADBEEF` to RTC backup register 0
 3. `NVIC_SystemReset()` — clean hardware reset
 4. On boot, `checkForBootloader()` (called after `HAL_Init()`) reads the magic
-5. If magic found: clears it, remaps system memory, jumps to STM32 bootloader at `0x1FF00000`
+<<<<<<< HEAD
+5. If magic found: clears it, remaps system memory, jumps to ESP32 BALANCE bootloader at `0x1FF00000`
+=======
+5. If magic found: clears it, remaps system memory, jumps to ESP32-S3 bootloader at `0x1FF00000`
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 6. Board appears as DFU device, ready for `dfu-util` flash
 
 ### Build & Flash
@@ -198,14 +240,14 @@ Fallback: HSI 16MHz if HSE fails (PLL M=16)
 ## Current Status & Known Issues
 
 ### Working
-- USB CDC serial streaming (50Hz JSON: `{"ax":...,"ay":...,"az":...,"gx":...,"gy":...,"gz":...}`)
+- USB Serial (CH343) serial streaming (50Hz JSON: `{"ax":...,"ay":...,"az":...,"gx":...,"gy":...,"gz":...}`)
 - Clock config with HSE + HSI fallback
 - Reboot-to-DFU via USB 'R' command
 - LED status patterns (status.c)
 - Web UI with WebSerial + Three.js 3D visualization
 
 ### Broken / In Progress
-- **ICM-42688-P SPI reads return all zeros** — was the original IMU target, but SPI communication completely non-functional despite correct pin config. May be dead silicon. Switched to MPU6000 as primary.
+- **QMI8658-P SPI reads return all zeros** — was the original IMU target, but SPI communication completely non-functional despite correct pin config. May be dead silicon. Switched to MPU6000 as primary.
 - **MPU6000 driver** — header exists but implementation needs completion
 - **PID balance loop** — not yet implemented
 - **Hoverboard ESC UART** — protocol defined, driver not written
@@ -243,7 +285,7 @@ T:12.3,P:45,L:100,R:-80,S:3\n
 // T=tilt°, P=PID output, L/R=motor commands, S=state (0-3)
 ```
 
-### FC → USB CDC (50Hz JSON)
+### FC → USB Serial (CH343) (50Hz JSON)
 ```json
 {"ax":123,"ay":-456,"az":16384,"gx":10,"gy":-5,"gz":3,"t":250,"p":0,"bt":0}
 // Raw IMU values (int16), t=temp×10, p=pressure, bt=baro temp

docs/FACE_LCD_ANIMATION.md

@@ -1,6 +1,10 @@
 # Face LCD Animation System (Issue #507)
 
-Implements expressive face animations on an STM32 LCD display with 5 core emotions and smooth transitions.
+<<<<<<< HEAD
+Implements expressive face animations on an ESP32 LCD display with 5 core emotions and smooth transitions.
+=======
+Implements expressive face animations on an ESP32-S3 LCD display with 5 core emotions and smooth transitions.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ## Features
 
@@ -82,7 +86,11 @@ STATUS      → Echo current emotion + idle state
 - Colors: Monochrome (1-bit) or RGB565
 
 ### Microcontroller
-- STM32F7xx (Mamba F722S)
+<<<<<<< HEAD
+- ESP32xx (ESP32 BALANCE)
+=======
+- ESP32-S3xx (ESP32-S3 BALANCE)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 - Available UART: USART3 (PB10=TX, PB11=RX)
 - Clock: 216 MHz
 

docs/PLATFORM.md

@@ -81,7 +81,7 @@
    │                     │
    │  [RealSense D435i]  │   ← Front-facing, angled down ~10°
    │                     │     Height: ~400mm from ground
-   │  [Jetson Nano]      │   ← Center, in ventilated enclosure
+   │  [Jetson Orin Nano Super]      │   ← Center, in ventilated enclosure
    │  [WiFi/4G module]   │     Noctua fan draws air through
    │                     │
    │  [Speaker]  [LEDs]  │   ← Rear: audio feedback + status
@@ -173,7 +173,7 @@ PACK1 ═╤═ PACK2 (parallel, XT60)
         │     │
         │     └── UART TX/RX ──→ Jetson GPIO
         │
-        ├──→ DC-DC 36V→5V ──→ Jetson Nano (barrel jack 5V/4A)
+        ├──→ DC-DC 36V→5V ──→ Jetson Orin Nano Super (barrel jack 5V/4A)
         │                  ──→ USB hub (sensors)
         │
         ├──→ DC-DC 36V→12V ──→ LED strips

docs/SALTYLAB-DETAILED.md

@@ -33,7 +33,7 @@ Self-balancing two-wheeled indoor robot with AI brain.
 
 | Component | Voltage | Current | Power (W) | Notes |
 |-----------|---------|---------|-----------|-------|
-| Jetson Nano | 5V | 2-4A | 10-20W | AI inference mode: ~15W avg |
+| Jetson Orin Nano Super | 5V | 2-4A | 10-20W | AI inference mode: ~15W avg |
 | RealSense D435i | 5V (USB) | 0.7A | 3.5W | Depth + RGB streaming |
 | RPLIDAR A1M8 | 5V | 0.5A | 2.5W | Spinning at 5.5Hz |
 | BNO055 IMU | 3.3V | 0.01A | 0.04W | Negligible |
@@ -80,7 +80,7 @@ Self-balancing two-wheeled indoor robot with AI brain.
 | Battery pack (1x) | 2500 | Estimated, weigh to verify |
 | 2x 8" hub motors | 2400 | ~1200g each with tire |
 | ESC board | 150 | Single board |
-| Jetson Nano + heatsink | 280 | With Noctua fan |
+| Jetson Orin Nano Super + heatsink | 280 | With Noctua fan |
 | RealSense D435i | 72 | Very light |
 | RPLIDAR A1M8 | 170 | With motor |
 | BNO055 breakout | 5 | Tiny |
@@ -233,7 +233,7 @@ Self-balancing two-wheeled indoor robot with AI brain.
       0mm  — Base plate
      30mm  — Battery shelf (holds pack on its side)
     150mm  — ESC + DC-DC shelf  
-    250mm  — Jetson Nano shelf
+    250mm  — Jetson Orin Nano Super shelf
     300mm  — BNO055 (attached to spine directly)
     370mm  — RealSense bracket (front-facing arm)
     420mm  — LIDAR standoff begins
@@ -325,7 +325,7 @@ Self-balancing two-wheeled indoor robot with AI brain.
 - [ ] Assemble spine onto base plate
 - [ ] Mount battery to lowest shelf (velcro straps)
 - [ ] Mount ESC + DC-DC converters
-- [ ] Mount Jetson Nano on shelf, connect 5V power
+- [ ] Mount Jetson Orin Nano Super on shelf, connect 5V power
 - [ ] Wire Jetson UART → ESC UART
 - [ ] Install JetPack 4.6 on Jetson (if not already)
 - [ ] Write serial bridge: Jetson Python → ESC UART commands

docs/SALTYLAB.md

@@ -1,6 +1,6 @@
-# SaltyLab — Self-Balancing Indoor Bot 🔬
+# SAUL-TEE — Self-Balancing Wagon Robot 🔬
 
-Two-wheeled, self-balancing robot for indoor AI/SLAM experiments.
+Four-wheel wagon (870×510×550 mm, 23 kg). Full spec: `docs/SAUL-TEE-SYSTEM-REFERENCE.md`
 
 ## ⚠️ SAFETY — TOP PRIORITY
 
@@ -32,8 +32,8 @@ Two-wheeled, self-balancing robot for indoor AI/SLAM experiments.
 |------|--------|
 | 2x 8" pneumatic hub motors (36 PSI) | ✅ Have |
 | 1x hoverboard ESC (FOC firmware) | ✅ Have |
-| 1x Drone FC (STM32F745 + MPU-6000) | ✅ Have — balance brain |
-| 1x Jetson Nano + Noctua fan | ✅ Have |
+| 1x Drone FC (ESP32-S3 + QMI8658) | ✅ Have — balance brain |
+| 1x Jetson Orin Nano Super + Noctua fan | ✅ Have |
 | 1x RealSense D435i | ✅ Have |
 | 1x RPLIDAR A1M8 | ✅ Have |
 | 1x battery pack (36V) | ✅ Have |
@@ -49,20 +49,19 @@ Two-wheeled, self-balancing robot for indoor AI/SLAM experiments.
 | 1x BetaFPV ELRS 2.4GHz 1W TX module | ✅ Have — RC control + kill switch |
 | 1x ELRS receiver (matching) | ✅ Have — mounts on FC UART |
 
-### Drone FC Details — GEPRC GEP-F7 AIO
-- **MCU:** STM32F722RET6 (216MHz Cortex-M7, 512KB flash, 256KB RAM)
-- **IMU:** TDK ICM-42688-P (6-axis, 32kHz gyro, ultra-low noise, SPI) ← the good one!
-- **Flash:** 8MB Winbond W25Q64 (blackbox, unused)
-- **OSD:** AT7456E (unused)
-- **4-in-1 ESC:** Built into AIO board (unused — we use hoverboard ESC)
-- **DFU mode:** Hold yellow BOOT button while plugging USB
-- **Firmware:** Custom balance firmware (PlatformIO + STM32 HAL)
-- **UART pads (confirmed from silkscreen):**
-  - T1/R1 (bottom) → USART1 (PA9/PA10) → Jetson
-  - T2/R2 (right top) → USART2 (PA2/PA3) → Hoverboard ESC
-  - T3/R3 (bottom) → USART3 (PB10/PB11) → ELRS receiver
-  - T4/R4 (bottom) → UART4 → spare
-  - T5/R5 (right bottom) → UART5 → spare
+### ESP32-S3 BALANCE Board Details — Waveshare ESP32-S3 Touch LCD 1.28
+- **MCU:** ESP32-S3RET6 (Xtensa LX7 dual-core, 240MHz, 8MB Flash, 512KB SRAM)
+- **IMU:** QMI8658 (6-axis, 32kHz gyro, ultra-low noise, SPI) ← the good one!
+- **Display:** 1.28" round LCD (GC9A01 driver, 240x240)
+- **DFU mode:** Hold BOOT button while plugging USB
+- **Firmware:** Custom balance firmware (ESP-IDF / Arduino-ESP32)
+- **USB:** USB Serial via CH343 chip
+- **UART assignments:**
+  - UART0 → USB Serial (CH343) → debug/flash
+  - UART1 → Jetson Orin Nano Super
+  - UART2 → Hoverboard ESC
+  - UART3 → ELRS receiver
+  - UART4/5 → spare
 
 ## Architecture
 
@@ -74,7 +73,7 @@ Two-wheeled, self-balancing robot for indoor AI/SLAM experiments.
                     │ RealSense    │ ← Forward-facing depth+RGB
                     │ D435i        │
                     ├──────────────┤
-                    │ Jetson Nano  │ ← AI brain: navigation, person tracking
+                    │ Jetson Orin Nano Super  │ ← AI brain: navigation, person tracking
                     │              │   Sends velocity commands via UART
                     ├──────────────┤
                     │ Drone FC     │ ← Balance brain: IMU + PID @ 8kHz
@@ -92,145 +91,22 @@ Two-wheeled, self-balancing robot for indoor AI/SLAM experiments.
            └─────┘                   └─────┘
 ```
 
-## Self-Balancing Control — Custom Firmware on Drone FC
+## Self-Balancing Control — ESP32-S3 BALANCE Board
 
-### Why a Drone FC?
-The F745 board is just a premium STM32 dev board with a high-quality IMU (MPU-6000) already soldered on, proper voltage regulation, and multiple UARTs broken out. We write a lean custom balance firmware (~50 lines of C).
+> For full system architecture, firmware details, and protocol specs, see
+> **docs/SAUL-TEE-SYSTEM-REFERENCE.md**
 
-### Architecture
-```
-Jetson (speed+steer via UART1)
-    │
-    ▼
-Drone FC (F745 + MPU-6000)
-    │  - Reads IMU @ 8kHz (SPI)
-    │  - Runs PID balance loop
-    │  - Mixes balance correction + Jetson commands
-    │  - Outputs speed+steer via UART2
-    ▼
-Hoverboard ESC (FOC firmware)
-    │  - Receives UART commands
-    │  - Drives hub motors
-    ▼
-Left + Right wheels
-```
+The balance controller runs on the Waveshare ESP32-S3 Touch LCD 1.28 board
+(ESP32-S3 BALANCE). It reads the onboard QMI8658 IMU at 8kHz, runs a PID
+balance loop, and drives the hoverboard ESC via UART. Jetson Orin Nano Super
+sends velocity commands over UART1. ELRS receiver on UART3 provides RC
+override and kill-switch capability.
 
-- **No motor outputs used** — FC talks UART directly to hoverboard ESC
-- **Custom firmware only** — no third-party flight software
-- **Dead motor output irrelevant** — not using any PWM channels
-
-### Wiring
-
-```
-Jetson UART1        Drone FC (UART1)
-────────────        ────────────────
-TX (Pin 8)   ──→   RX
-RX (Pin 10)  ──→   TX
-GND          ──→   GND
-
-Drone FC (UART2)    Hoverboard ESC
-────────────────    ──────────────
-TX           ──→   RX (serial input)
-GND          ──→   GND
-5V (BEC)     ←──   ESC 5V out (powers FC)
-
-ELRS Receiver       Drone FC (UART3)
-─────────────       ────────────────
-TX           ──→   RX
-RX           ←──   TX (for telemetry/binding)
-GND          ──→   GND
-5V           ←──   5V
-```
-
-### Custom Firmware (STM32 C)
-
-```c
-// Core balance loop — runs in timer interrupt @ 1-8kHz
-void balance_loop(void) {
-    // 1. Read pitch angle from MPU-6000 (complementary filter)
-    float pitch = get_pitch_angle();  // SPI read + filter
-    
-    // 2. Get velocity command from Jetson (updated async via UART1 RX)
-    float target_speed = jetson_cmd.speed;   // -1000 to 1000
-    float target_steer = jetson_cmd.steer;   // -1000 to 1000
-    
-    // 3. PID on pitch error
-    //    Target angle shifts with speed command (lean forward = go forward)
-    float target_angle = target_speed * SPEED_TO_ANGLE_FACTOR;
-    float error = target_angle - pitch;
-    
-    integral += error * dt;
-    integral = clamp(integral, -MAX_I, MAX_I);  // anti-windup
-    float derivative = (error - prev_error) / dt;
-    prev_error = error;
-    
-    float output = Kp * error + Ki * integral + Kd * derivative;
-    
-    // 4. Mix balance + steering → hoverboard ESC UART command
-    int16_t left  = clamp(output + target_steer, -1000, 1000);
-    int16_t right = clamp(output - target_steer, -1000, 1000);
-    
-    // 5. Send to hoverboard ESC via UART2
-    send_hoverboard_cmd(left, right);
-    
-    // 6. Safety: kill motors if tipped beyond recovery
-    if (fabs(pitch) > MAX_TILT_DEG) {
-        send_hoverboard_cmd(0, 0);
-        disarm();
-    }
-    
-    // 7. Safety: RC kill switch (ELRS channel, checked every loop)
-    if (rc_channels.arm_switch == DISARMED) {
-        send_hoverboard_cmd(0, 0);
-        disarm();
-    }
-    
-    // 8. Safety: kill if Jetson UART heartbeat lost
-    if (millis() - jetson_last_rx > JETSON_TIMEOUT_MS) {
-        send_hoverboard_cmd(0, 0);
-        disarm();
-    }
-    
-    // 8. Safety: clamp output to max allowed speed
-    left  = clamp(left,  -max_speed_limit, max_speed_limit);
-    right = clamp(right, -max_speed_limit, max_speed_limit);
-}
-```
-
-### Hoverboard ESC UART Protocol
-```c
-typedef struct {
-    uint16_t start;    // 0xABCD
-    int16_t  speed;    // -1000 to 1000 (left)
-    int16_t  steer;    // -1000 to 1000 (right)
-    uint16_t checksum; // XOR of all bytes
-} HoverboardCmd;
-// 115200 baud, send at loop rate
-```
-
-### Jetson → FC Protocol (simple custom)
-```c
-typedef struct {
-    uint8_t  header;   // 0xAA
-    int16_t  speed;    // -1000 to 1000
-    int16_t  steer;    // -1000 to 1000
-    uint8_t  mode;     // 0=idle, 1=balance, 2=follow, 3=RC
-    uint8_t  checksum;
-} JetsonCmd;
-// 115200 baud, ~50Hz from Jetson is plenty
-```
-
-### PID Tuning
-| Param | Starting Value | Notes |
-|-------|---------------|-------|
-| Kp | 30-50 | Main balance response |
-| Ki | 0.5-2 | Drift correction |
-| Kd | 0.5-2 | Damping oscillation |
-| Loop rate | 1-8 kHz | Start at 1kHz, increase if needed |
-| Max tilt | ±25° | Beyond this = cut motors, require re-arm |
-| JETSON_TIMEOUT_MS | 200 | Kill motors if Jetson stops talking |
-| max_speed_limit | 100 | Start at 10% (100/1000), increase gradually |
-| SPEED_TO_ANGLE_FACTOR | 0.01-0.05 | How much lean per speed unit |
+The legacy STM32 firmware (Mamba F722S era) has been archived to
+=======
+The legacy STM32 firmware (STM32 era) has been archived to
+`legacy/stm32/` and is no longer built or deployed.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ## LED Subsystem (ESP32-C3)
 
@@ -280,8 +156,8 @@ GND             ──→ Common ground
 ```
 
 ### Dev Tools
-- **Flashing:** STM32CubeProgrammer via USB (DFU mode) or SWD
-- **IDE:** PlatformIO + STM32 HAL, or STM32CubeIDE
+- **Flashing:** ESP32-S3CubeProgrammer via USB (DFU mode) or SWD
+- **IDE:** PlatformIO + ESP-IDF, or ESP32-S3CubeIDE
 - **Debug:** SWD via ST-Link (or use FC's USB as virtual COM for printf debug)
 
 ## Physical Design
@@ -348,7 +224,7 @@ GND             ──→ Common ground
 
 ## Software Stack
 
-### Jetson Nano
+### Jetson Orin Nano Super
 - **OS:** JetPack 4.6.1 (Ubuntu 18.04)
 - **ROS2 Humble** (or Foxy) for:
   - `nav2` — navigation stack
@@ -375,8 +251,8 @@ GND             ──→ Common ground
 - [ ] Install hardware kill switch inline with 36V battery (NC — press to kill)
 - [ ] Set up ceiling tether point above test area (rated for >15kg)
 - [ ] Clear test area: 3m radius, no loose items, shoes on
-- [ ] Set up PlatformIO project for STM32F745 (STM32 HAL)
-- [ ] Write MPU-6000 SPI driver (read gyro+accel, complementary filter)
+- [ ] Set up PlatformIO project for ESP32-S3 (ESP-IDF)
+- [ ] Write QMI8658 SPI driver (read gyro+accel, complementary filter)
 - [ ] Write PID balance loop with ALL safety checks:
   - ±25° tilt cutoff → disarm, require manual re-arm
   - Watchdog timer (50ms hardware WDT)

docs/SAUL-TEE-SYSTEM-REFERENCE.md

@@ -0,0 +1,222 @@
+# SAUL-TEE System Reference — SaltyLab ESP32 Architecture
+*Authoritative source of truth for hardware, pins, protocols, and CAN assignments.*
+*Spec from hal@Orin, 2026-04-04.*
+
+---
+
+## Overview
+
+| Board | Role | MCU | USB chip |
+|-------|------|-----|----------|
+| **ESP32-S3 BALANCE** | PID balance loop, CAN→VESCs, LCD display | ESP32-S3 | CH343 USB-serial |
+| **ESP32-S3 IO** | RC input, motor drivers, sensors, LEDs, peripherals | ESP32-S3 | JTAG USB (native) |
+
+**Robot form factor:** 4-wheel wagon — 870 × 510 × 550 mm, ~23 kg
+**Power:** 36 V LiPo, DC-DC → 5 V and 12 V rails
+**Orin connection:** CANable2 USB → 500 kbps CAN (same bus as VESCs)
+
+---
+
+## ESP32-S3 BALANCE
+
+### Board
+Waveshare ESP32-S3 Touch LCD 1.28
+- GC9A01 round 240×240 LCD
+- CST816S capacitive touch
+- QMI8658 6-axis IMU (accel + gyro, SPI)
+- CH343 USB-to-serial chip
+
+### Pin Assignments
+
+| Function | GPIO | Notes |
+|----------|------|-------|
+| **QMI8658 IMU (SPI)** | | |
+| SCK | IO39 | |
+| MOSI | IO38 | |
+| MISO | IO40 | |
+| CS | IO41 | |
+| INT1 | IO42 | data-ready interrupt |
+| **GC9A01 LCD (shares SPI bus)** | | |
+| CS | IO12 | |
+| DC | IO11 | |
+| RST | IO10 | |
+| BL | IO9 | PWM backlight |
+| **CST816S Touch (I2C)** | | |
+| SDA | IO4 | |
+| SCL | IO5 | |
+| INT | IO6 | |
+| RST | IO7 | |
+| **CAN — SN65HVD230 transceiver** | | 500 kbps |
+| TX | IO43 | → SN65HVD230 TXD |
+| RX | IO44 | ← SN65HVD230 RXD |
+| **Inter-board UART (to IO board)** | | 460800 baud |
+| TX | IO17 | |
+| RX | IO18 | |
+
+### Responsibilities
+- Read QMI8658 @ 1 kHz (SPI, INT1-driven)
+- Complementary filter → pitch angle
+- PID balance loop (configurable Kp / Ki / Kd)
+- Send VESC speed commands via CAN (ID 68 = left, ID 56 = right)
+- Receive Orin velocity+mode commands via CAN (0x300–0x303)
+- Receive IO board status (arming, RC, faults) via UART protocol
+- Drive GC9A01 LCD: pitch, speed, battery %, error state
+- Enforce tilt cutoff at ±25°; IWDG 50 ms timeout
+- Publish telemetry on CAN 0x400–0x401 at 10 Hz
+
+---
+
+## ESP32-S3 IO
+
+### Board
+Bare ESP32-S3 devkit (JTAG USB)
+
+### Pin Assignments
+
+| Function | GPIO | Notes |
+|----------|------|-------|
+| **TBS Crossfire RC — UART0 (primary)** | | |
+| RX | IO44 | CRSF frames from Crossfire RX |
+| TX | IO43 | telemetry to Crossfire TX |
+| **ELRS failover — UART2** | | active if CRSF absent >100 ms |
+| RX | IO16 | |
+| TX | IO17 | |
+| **BTS7960 Motor Driver — Left** | | |
+| RPWM | IO1 | forward PWM |
+| LPWM | IO2 | reverse PWM |
+| R_EN | IO3 | right enable |
+| L_EN | IO4 | left enable |
+| **BTS7960 Motor Driver — Right** | | |
+| RPWM | IO5 | |
+| LPWM | IO6 | |
+| R_EN | IO7 | |
+| L_EN | IO8 | |
+| **I2C bus** | | |
+| SDA | IO11 | |
+| SCL | IO12 | |
+| NFC (PN532 or similar) | I2C | |
+| Barometer (BMP280/BMP388) | I2C | |
+| ToF (VL53L0X/VL53L1X) | I2C | |
+| **WS2812B LEDs** | | |
+| Data | IO13 | |
+| **Outputs** | | |
+| Horn / buzzer | IO14 | PWM tone |
+| Headlight | IO15 | PWM or digital |
+| Fan | IO16 | (if ELRS not fitted on UART2) |
+| **Inputs** | | |
+| Arming button | IO9 | active-low, hold 3 s to arm |
+| Kill switch sense | IO10 | hardware estop detect |
+| **Inter-board UART (to BALANCE board)** | | 460800 baud |
+| TX | IO18 | |
+| RX | IO21 | |
+
+### Responsibilities
+- Parse CRSF frames (TBS Crossfire, primary)
+- Parse ELRS frames (failover, activates if no CRSF for >100 ms)
+- Drive BTS7960 left/right PWM motor drivers
+- Read NFC, barometer, ToF via I2C
+- Drive WS2812B LEDs (armed/fault/idle patterns)
+- Control horn, headlight, fan, buzzer
+- Manage arming: hold button 3 s while upright → send ARM to BALANCE
+- Monitor kill switch input → immediate motor off + FAULT frame
+- Forward RC + sensor data to BALANCE via binary UART protocol
+- Report faults and RC-loss upstream
+
+---
+
+## Inter-Board Binary Protocol (UART @ 460800 baud)
+
+```
+[0xAA][LEN][TYPE][PAYLOAD × LEN bytes][CRC8]
+```
+- `0xAA` — start byte
+- `LEN` — payload length in bytes (uint8)
+- `TYPE` — message type (uint8)
+- `CRC8` — CRC-8/MAXIM over TYPE + PAYLOAD bytes
+
+### IO → BALANCE Messages
+
+| TYPE | Name | Payload | Description |
+|------|------|---------|-------------|
+| 0x01 | RC_CMD | int16 throttle, int16 steer, uint8 flags | flags: bit0=armed, bit1=kill |
+| 0x02 | SENSOR | uint16 tof_mm, int16 baro_delta_pa, uint8 nfc_present | |
+| 0x03 | FAULT | uint8 fault_flags | bit0=rc_loss, bit1=motor_fault, bit2=estop |
+
+### BALANCE → IO Messages
+
+| TYPE | Name | Payload | Description |
+|------|------|---------|-------------|
+| 0x10 | STATE | int16 pitch_x100, int16 pid_out, uint8 error_state | |
+| 0x11 | LED_CMD | uint8 pattern, uint8 r, uint8 g, uint8 b | |
+| 0x12 | BUZZER | uint8 tone_id, uint16 duration_ms | |
+
+---
+
+## CAN Bus — 500 kbps
+
+### Node Assignments
+
+| Node | CAN ID | Role |
+|------|--------|------|
+| VESC Left motor | **68** | Receives speed/duty via VESC CAN protocol |
+| VESC Right motor | **56** | Receives speed/duty via VESC CAN protocol |
+| ESP32-S3 BALANCE | — | Sends VESC commands; publishes telemetry |
+| Jetson Orin (CANable2) | — | Sends velocity commands; receives telemetry |
+
+### Frame Table
+
+| CAN ID | Direction | Description | Rate |
+|--------|-----------|-------------|------|
+| 0x300 | Orin → BALANCE | Velocity cmd: int16 speed_mmps, int16 steer_mrad | 20 Hz |
+| 0x301 | Orin → BALANCE | PID tuning: float Kp, float Ki, float Kd (3×4B IEEE-754) | on demand |
+| 0x302 | Orin → BALANCE | Mode: uint8 (0=off, 1=balance, 2=manual, 3=estop) | on demand |
+| 0x303 | Orin → BALANCE | Config: uint16 tilt_limit_x100, uint16 max_speed_mmps | on demand |
+| 0x400 | BALANCE → Orin | Telemetry A: int16 pitch_x100, int16 pid_out, int16 speed_mmps, uint8 state | 10 Hz |
+| 0x401 | BALANCE → Orin | Telemetry B: int16 vesc_l_rpm, int16 vesc_r_rpm, uint16 battery_mv, uint8 faults | 10 Hz |
+
+---
+
+## RC Channel Mapping (TBS Crossfire / ELRS CRSF)
+
+| CH | Function | Range (µs) | Notes |
+|----|----------|------------|-------|
+| 1 | Steer (Roll) | 988–2012 | ±100% → ±max steer |
+| 2 | Throttle (Pitch) | 988–2012 | forward / back speed |
+| 3 | Spare | 988–2012 | |
+| 4 | Spare | 988–2012 | |
+| 5 | ARM switch | <1500=disarm, >1500=arm | SB on TX |
+| 6 | **ESTOP** | <1500=normal, >1500=kill | SC on TX — checked first every loop |
+| 7 | Speed limit | 988–2012 | maps to 10–100% speed cap |
+| 8 | Spare | | |
+
+**RC loss:** No valid CRSF frame >100 ms → IO sends FAULT(rc_loss) → BALANCE cuts motors.
+
+---
+
+## Safety Invariants
+
+1. **Motors NEVER spin on power-on** — 3 s button hold required while upright
+2. **Tilt cutoff ±25°** — immediate motor zero, manual re-arm required
+3. **IWDG 50 ms** — firmware hang → motors cut
+4. **ESTOP RC channel** checked first in every loop iteration
+5. **Orin CAN timeout 500 ms** → revert to RC-only mode
+6. **Speed hard cap** — start at 10%, increase in 10% increments only after stable tethered testing
+7. **Never untethered** until stable for 5+ continuous minutes tethered
+
+---
+
+## USB Debug Commands (both boards, serial console)
+
+```
+help                     list commands
+status                   print pitch, PID state, CAN stats, UART stats
+pid <Kp> <Ki> <Kd>      set PID gains
+arm                      arm (if upright and safe)
+disarm                   disarm immediately
+estop                    emergency stop (requires re-arm)
+tilt_limit <deg>         set tilt cutoff angle (default 25)
+speed_limit <pct>        set speed cap percentage (default 10)
+can_stats                CAN bus counters (tx/rx/errors/busoff)
+uart_stats               inter-board UART frame counters
+reboot                   soft reboot
+```

docs/board-viz.html

@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta charset="utf-8">
-<title>GEPRC GEP-F722-45A AIO — Board Layout</title>
+<title>GEPRC GEP-F722-45A AIO — Board Layout (Legacy / Archived)</title>
 <style>
 * { margin: 0; padding: 0; box-sizing: border-box; }
 body { background: #1a1a2e; color: #eee; font-family: 'Courier New', monospace; display: flex; flex-direction: column; align-items: center; padding: 20px; }
@@ -112,8 +112,13 @@ h1 { color: #e94560; margin-bottom: 5px; font-size: 1.4em; }
 </style>
 </head>
 <body>
+<<<<<<< HEAD
+<h1>🤖 GEPRC GEP-F722-45A AIO — SaltyLab Pinout (Legacy / Archived)</h1>
+<p class="subtitle">ESP32RET6 + ICM-42688-P | Betaflight target: GEPR-GEPRC_F722_AIO</p>
+=======
 <h1>🤖 GEPRC GEP-F722-45A AIO — SaltyLab Pinout</h1>
-<p class="subtitle">STM32F722RET6 + ICM-42688-P | Betaflight target: GEPR-GEPRC_F722_AIO</p>
+<p class="subtitle">ESP32-S3RET6 + ICM-42688-P | Betaflight target: GEPR-GEPRC_F722_AIO</p>
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 <div class="container">
   <div class="board-wrap">
@@ -125,7 +130,11 @@ h1 { color: #e94560; margin-bottom: 5px; font-size: 1.4em; }
       <div class="mount br"></div>
 
       <!-- MCU -->
-      <div class="mcu"><div class="dot"></div>STM32<br>F722RET6<br>216MHz</div>
+<<<<<<< HEAD
+      <div class="mcu"><div class="dot"></div>ESP32<br>(legacy:<br>F722RET6)</div>
+=======
+      <div class="mcu"><div class="dot"></div>ESP32-S3<br>F722RET6<br>216MHz</div>
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
       <!-- IMU -->
       <div class="imu">ICM<br>42688</div>
@@ -206,7 +215,7 @@ h1 { color: #e94560; margin-bottom: 5px; font-size: 1.4em; }
     <h2>🔌 UART Assignments</h2>
     <div class="legend-item">
       <div class="swatch" style="background:#2196F3"></div>
-      <span><b>USART1</b> T1/R1 → Jetson Nano</span>
+      <span><b>USART1</b> T1/R1 → Jetson Orin Nano Super</span>
     </div>
     <div class="legend-item">
       <div class="swatch" style="background:#FF9800"></div>

docs/wiring-diagram.md

@@ -1,131 +1,155 @@
-# SaltyLab Wiring Diagram
+# SaltyLab / SAUL-TEE Wiring Reference
 
-## System Overview
+> ⚠️ **ARCHITECTURE CHANGE (2026-04-03):** Mamba F722S / STM32 retired.
+> New stack: **ESP32-S3 BALANCE** + **ESP32-S3 IO** + VESCs on 500 kbps CAN.
+> **Authoritative reference:** [`docs/SAUL-TEE-SYSTEM-REFERENCE.md`](SAUL-TEE-SYSTEM-REFERENCE.md)
+> Historical STM32/Mamba wiring below is **obsolete** — retained for reference only.
+
+---
+
+## ~~System Overview~~ (OBSOLETE — see SAUL-TEE-SYSTEM-REFERENCE.md)
 
 ```
 ┌─────────────────────────────────────────────────────────────────────┐
 │                        ORIN NANO SUPER                              │
 │                     (Top Plate — 25W)                               │
 │                                                                     │
-│  USB-C ──── STM32 CDC (/dev/stm32-bridge, 921600 baud)            │
+<<<<<<< HEAD
+│  USB-A ──── CANable2 USB-CAN adapter (slcan0, 500 kbps)           │
+│  USB-A ──── ESP32-S3 IO (/dev/esp32-io, 460800 baud)              │
+=======
+│  USB-C ──── ESP32-S3 CDC (/dev/esp32-bridge, 921600 baud)            │
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 │  USB-A1 ─── RealSense D435i (USB 3.1)                             │
 │  USB-A2 ─── RPLIDAR A1M8 (via CP2102 adapter, 115200)             │
 │  USB-C* ─── SIM7600A 4G/LTE modem (ttyUSB0-2, AT cmds + PPP)     │
 │  USB ─────── Leap Motion Controller (hand/gesture tracking)        │
-│  CSI-A ──── ArduCam adapter → 2× IMX219 (front + left)            │
-│  CSI-B ──── ArduCam adapter → 2× IMX219 (rear + right)            │
+│  CSI-A ──── ArduCam adapter → 2x IMX219 (front + left)            │
+│  CSI-B ──── ArduCam adapter → 2x IMX219 (rear + right)            │
 │  M.2 ───── 1TB NVMe SSD                                            │
 │  40-pin ─── ReSpeaker 2-Mic HAT (I2S + I2C, WM8960 codec)         │
 │  Pin 8 ──┐                                                         │
-│  Pin 10 ─┤ UART fallback to FC (ttyTHS0, 921600)                  │
+│  Pin 10 ─┤ UART fallback to ESP32-S3 BALANCE (ttyTHS0, 460800)    │
 │  Pin 6 ──┘ GND                                                     │
 │                                                                     │
 └─────────────────────────────────────────────────────────────────────┘
-         │ USB-C (data only)              │ UART fallback (3 wires)
-         │ 921600 baud                    │ 921600 baud, 3.3V
+         │ USB-A (CANable2)               │ UART fallback (3 wires)
+         │ SocketCAN slcan0               │ 460800 baud, 3.3V
+         │ 500 kbps                       │
          ▼                                ▼
 ┌─────────────────────────────────────────────────────────────────────┐
-│                     MAMBA F722S (FC)                                 │
+<<<<<<< HEAD
+│                  ESP32-S3 BALANCE                                    │
+│          (Waveshare Touch LCD 1.28, Middle Plate)                   │
+=======
+│                     ESP32-S3 BALANCE (FC)                                 │
 │                  (Middle Plate — foam mounted)                       │
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 │                                                                     │
-│  USB-C ──── Orin (CDC serial, primary link)                        │
-│                                                                     │
-│  USART2 (PA2=TX, PA3=RX) ──── Hoverboard ESC (26400 baud)         │
-│  UART4  (PA0=TX, PA1=RX) ──── ELRS RX (CRSF, 420000 baud)        │
-│  USART6 (PC6=TX, PC7=RX) ──── Orin UART fallback                  │
-│  UART5  (PC12=TX, PD2=RX) ─── Debug (optional)                    │
-│                                                                     │
-│  SPI1 ─── MPU6000 IMU (on-board, CW270)                           │
-│  I2C1 ─── BMP280 baro (on-board, disabled)                        │
-│  ADC ──── Battery voltage (PC1) + Current (PC3)                    │
-│  PB3 ──── WS2812B LED strip                                        │
-│  PB2 ──── Buzzer                                                    │
+│  CAN bus ──── CANable2 → Orin (primary link, ISO 11898)            │
+│  UART0 ──── Orin UART fallback (460800 baud, 3.3V)                │
+│  UART1 ──── VESC Left  (CAN ID 56) via UART/CAN bridge            │
+│  UART2 ──── VESC Right (CAN ID 68) via UART/CAN bridge            │
+│  I2C   ──── QMI8658 IMU (onboard, 6-DOF accel+gyro)               │
+│  SPI   ──── GC9A01 LCD (onboard, 240x240 round display)           │
+│  GPIO  ──── WS2812B LED strip                                      │
+│  GPIO  ──── Buzzer                                                  │
+│  ADC   ──── Battery voltage divider                                │
 │                                                                     │
 └─────────────────────────────────────────────────────────────────────┘
-         │ USART2                         │ UART4
-         │ PA2=TX → ESC RX               │ PA0=TX → ELRS TX
-         │ PA3=RX ← ESC TX               │ PA1=RX ← ELRS RX
-         │ GND ─── GND                   │ GND ─── GND
+         │ CAN bus (ISO 11898)            │ UART (460800 baud)
+         │ 500 kbps                       │
          ▼                                ▼
 ┌────────────────────────┐    ┌──────────────────────────┐
-│   HOVERBOARD ESC       │    │   ELRS 2.4GHz RX         │
-│   (Bottom Plate)       │    │   (beside FC)             │
+│   VESC Left (ID 56)    │    │   VESC Right (ID 68)     │
+│   (Bottom Plate)       │    │   (Bottom Plate)          │
+│                        │    │                            │
+│  BLDC hub motor        │    │  BLDC hub motor            │
+│  CAN 500 kbps          │    │  CAN 500 kbps             │
+│  FOC current control   │    │  FOC current control      │
+│  VESC Status 1 (0x900) │    │  VESC Status 1 (0x910)   │
 │                        │    │                            │
-│  2× BLDC hub motors    │    │  CRSF protocol            │
-│  26400 baud UART       │    │  420000 baud              │
-│  Frame: [0xABCD]       │    │  BetaFPV 1W TX → RX      │
-│  [steer][speed][csum]  │    │  CH3=speed CH4=steer      │
-│                        │    │  CH5=arm   CH6=mode       │
 └────────────────────────┘    └──────────────────────────┘
-         │                              
-    ┌────┴────┐                         
-    ▼         ▼                         
-  🛞 LEFT   RIGHT 🛞                    
-  MOTOR     MOTOR                       
+         │                              │
+    LEFT MOTOR                    RIGHT MOTOR
+```
 
 
 ## Wire-by-Wire Connections
 
-### 1. Orin ↔ FC (Primary: USB CDC)
+<<<<<<< HEAD
+### 1. Orin <-> ESP32-S3 BALANCE (Primary: CAN Bus via CANable2)
+=======
+### 1. Orin ↔ FC (Primary: USB Serial (CH343))
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
-| From | To | Wire Color | Notes |
-|------|----|-----------|-------|
-| Orin USB-C port | FC USB-C port | USB cable | Data only, FC powered from 5V bus |
+| From | To | Wire | Notes |
+|------|----|------|-------|
+| Orin USB-A | CANable2 USB | USB cable | SocketCAN slcan0 @ 500 kbps |
+| CANable2 CAN-H | ESP32-S3 BALANCE CAN-H | twisted pair | ISO 11898 differential |
+| CANable2 CAN-L | ESP32-S3 BALANCE CAN-L | twisted pair | ISO 11898 differential |
 
-- Device: `/dev/ttyACM0` → symlink `/dev/stm32-bridge`
+<<<<<<< HEAD
+- Interface: SocketCAN `slcan0`, 500 kbps
+- Device node: `/dev/canable2` (via udev, symlink to ttyUSBx)
+- Protocol: CAN frames --- ORIN_CMD_DRIVE (0x300), ORIN_CMD_MODE (0x301), ORIN_CMD_ESTOP (0x302)
+- Telemetry: BALANCE_STATUS (0x400), BALANCE_VESC (0x401), BALANCE_IMU (0x402), BALANCE_BATTERY (0x403)
+=======
+- Device: `/dev/ttyACM0` → symlink `/dev/esp32-bridge`
 - Baud: 921600, 8N1
 - Protocol: JSON telemetry (FC→Orin), ASCII commands (Orin→FC)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
-### 2. Orin ↔ FC (Fallback: Hardware UART)
+### 2. Orin <-> ESP32-S3 BALANCE (Fallback: Hardware UART)
 
-| Orin Pin | Signal | FC Pin | FC Signal |
-|----------|--------|--------|-----------|
-| Pin 8 | TXD0 | PC7 | USART6 RX |
-| Pin 10 | RXD0 | PC6 | USART6 TX |
-| Pin 6 | GND | GND | GND |
+| Orin Pin | Signal | ESP32-S3 Pin | Notes |
+|----------|--------|--------------|-------|
+| Pin 8 | TXD0 | GPIO17 (UART0 RX) | Orin TX -> BALANCE RX |
+| Pin 10 | RXD0 | GPIO18 (UART0 TX) | Orin RX <- BALANCE TX |
+| Pin 6 | GND | GND | Common ground |
 
 - Jetson device: `/dev/ttyTHS0`
-- Baud: 921600, 8N1
+- Baud: 460800, 8N1
 - Voltage: 3.3V both sides (no level shifter needed)
-- **Cross-connect:** Orin TX → FC RX, Orin RX ← FC TX
+- Cross-connect: Orin TX -> BALANCE RX, Orin RX <- BALANCE TX
 
-### 3. FC ↔ Hoverboard ESC
+### 3. Orin <-> ESP32-S3 IO (USB Serial)
 
-| FC Pin | Signal | ESC Pin | Notes |
-|--------|--------|---------|-------|
-| PA2 | USART2 TX | RX | FC sends speed/steer commands |
-| PA3 | USART2 RX | TX | ESC sends feedback (optional) |
+| From | To | Notes |
+|------|----|-------|
+| Orin USB-A | ESP32-S3 IO USB-C | USB cable, /dev/esp32-io |
+
+- Device node: `/dev/esp32-io` (udev symlink)
+- Baud: 460800, 8N1
+- Protocol: Binary frames `[0xAA][LEN][TYPE][PAYLOAD][CRC8]`
+- Use: IO expansion, GPIO control, sensor polling
+
+### 4. ESP32-S3 BALANCE <-> VESC Motors (CAN Bus)
+
+| BALANCE Pin | Signal | VESC Pin | Notes |
+|-------------|--------|----------|-------|
+| GPIO21 | CAN-H | CAN-H | ISO 11898 differential pair |
+| GPIO22 | CAN-L | CAN-L | ISO 11898 differential pair |
 | GND | GND | GND | Common ground |
 
-- Baud: 26400, 8N1
-- Protocol: Binary frame — `[0xABCD][steer:int16][speed:int16][checksum:uint16]`
-- Speed range: -1000 to +1000
-- **Keep wires short and twisted** (EMI from ESC)
-
-### 4. FC ↔ ELRS Receiver
-
-| FC Pin | Signal | ELRS Pin | Notes |
-|--------|--------|----------|-------|
-| PA0 | UART4 TX | RX | Telemetry to TX (optional) |
-| PA1 | UART4 RX | TX | CRSF frames from RX |
-| GND | GND | GND | Common ground |
-| 5V | — | VCC | Power ELRS from 5V bus |
-
-- Baud: 420000 (CRSF protocol)
-- Failsafe: disarm after 300ms without frame
+- Baud: 500 kbps CAN
+- VESC Left: CAN ID 56, VESC Right: CAN ID 68
+- Commands: COMM_SET_RPM, COMM_SET_CURRENT, COMM_SET_DUTY
+- Telemetry: VESC Status 1 at 50 Hz (RPM, current, duty)
 
 ### 5. Power Distribution
 
 ```
-BATTERY (36V) ──┬── Hoverboard ESC (36V direct)
+BATTERY (36V) ──┬── VESC Left  (36V direct -> BLDC left motor)
+                ├── VESC Right (36V direct -> BLDC right motor)
                 │
                 ├── 5V BEC/regulator ──┬── Orin (USB-C PD or barrel jack)
-                │                      ├── FC (via USB or 5V pad)
-                │                      ├── ELRS RX (5V)
+                │                      ├── ESP32-S3 BALANCE (5V via USB-C)
+                │                      ├── ESP32-S3 IO (5V via USB-C)
                 │                      ├── WS2812B LEDs (5V)
                 │                      └── RPLIDAR (5V via USB)
                 │
-                └── Battery monitor ──── FC ADC (PC1=voltage, PC3=current)
+                └── Battery monitor ──── ESP32-S3 BALANCE ADC (voltage divider)
 ```
 
 ### 6. Sensors on Orin (USB/CSI)
@@ -136,10 +160,39 @@ BATTERY (36V) ──┬── Hoverboard ESC (36V direct)
 | RPLIDAR A1M8 | USB-UART | USB-A | `/dev/rplidar` |
 | IMX219 front+left | MIPI CSI-2 | CSI-A (J5) | `/dev/video0,2` |
 | IMX219 rear+right | MIPI CSI-2 | CSI-B (J8) | `/dev/video4,6` |
-| 1TB NVMe | PCIe Gen3 ×4 | M.2 Key M | `/dev/nvme0n1` |
+| 1TB NVMe | PCIe Gen3 x4 | M.2 Key M | `/dev/nvme0n1` |
+| CANable2 | USB-CAN | USB-A | `/dev/canable2` -> `slcan0` |
 
 
-## FC UART Summary (MAMBA F722S)
+<<<<<<< HEAD
+## FC UART Summary (MAMBA F722S — OBSOLETE)
+
+| Interface | Pins | Baud/Rate | Assignment | Notes |
+|-----------|------|-----------|------------|-------|
+| UART0 | GPIO17=RX, GPIO18=TX | 460800 | Orin UART fallback | 3.3V, cross-connect |
+| UART1 | GPIO19=RX, GPIO20=TX | 115200 | Debug serial | Optional |
+| CAN (TWAI) | GPIO21=H, GPIO22=L | 500 kbps | CAN bus (VESCs + Orin) | SN65HVD230 transceiver |
+| I2C | GPIO4=SDA, GPIO5=SCL | 400 kHz | QMI8658 IMU (addr 0x6B) | Onboard |
+| SPI | GPIO36=MOSI, GPIO37=SCLK, GPIO35=CS | 40 MHz | GC9A01 LCD (onboard) | 240x240 round |
+| USB CDC | USB-C | 460800 | Orin USB fallback | /dev/esp32-balance |
+
+## CAN Frame ID Map
+
+| CAN ID | Direction | Name | Contents |
+|--------|-----------|------|----------|
+| 0x300 | Orin -> BALANCE | ORIN_CMD_DRIVE | left_rpm_f32, right_rpm_f32 (8 bytes LE) |
+| 0x301 | Orin -> BALANCE | ORIN_CMD_MODE | mode byte (0=IDLE, 1=DRIVE, 2=ESTOP) |
+| 0x302 | Orin -> BALANCE | ORIN_CMD_ESTOP | flags byte (bit0=stop, bit1=clear) |
+| 0x400 | BALANCE -> Orin | BALANCE_STATUS | pitch x10:i16, motor_cmd:u16, vbat_mv:u16, state:u8, flags:u8 |
+| 0x401 | BALANCE -> Orin | BALANCE_VESC | l_rpm x10:i16, r_rpm x10:i16, l_cur x10:i16, r_cur x10:i16 |
+| 0x402 | BALANCE -> Orin | BALANCE_IMU | pitch x100:i16, roll x100:i16, yaw x100:i16, ax x100:i16, ay x100:i16, az x100:i16 |
+| 0x403 | BALANCE -> Orin | BALANCE_BATTERY | vbat_mv:u16, current_ma:i16, soc_pct:u8 |
+| 0x900+ID | VESC Left -> | VESC_STATUS_1 | erpm:i32, current x10:i16, duty x1000:i16 |
+| 0x910+ID | VESC Right -> | VESC_STATUS_1 | erpm:i32, current x10:i16, duty x1000:i16 |
+
+VESC Left CAN ID = 56 (0x38), VESC Right CAN ID = 68 (0x44).
+=======
+## FC UART Summary (ESP32-S3 BALANCE)
 
 | UART | Pins | Baud | Assignment | Notes |
 |------|------|------|------------|-------|
@@ -149,7 +202,8 @@ BATTERY (36V) ──┬── Hoverboard ESC (36V direct)
 | UART4 | PA0=TX, PA1=RX | 420000 | ELRS RX (CRSF) | RC control |
 | UART5 | PC12=TX, PD2=RX | 115200 | Debug serial | Optional |
 | USART6 | PC6=TX, PC7=RX | 921600 | Jetson UART | Fallback link |
-| USB CDC | USB-C | 921600 | Jetson primary | `/dev/stm32-bridge` |
+| USB Serial (CH343) | USB-C | 921600 | Jetson primary | `/dev/esp32-bridge` |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 
 ### 7. ReSpeaker 2-Mic HAT (on Orin 40-pin header)
@@ -167,57 +221,63 @@ BATTERY (36V) ──┬── Hoverboard ESC (36V direct)
 | Pin 2, 4 | 5V | Power |
 | Pin 6, 9 | GND | Ground |
 
-- **Codec:** Wolfson WM8960 (I2C addr 0x1A)
-- **Mics:** 2× MEMS (left + right) — basic stereo / sound localization
-- **Speaker:** 3W class-D amp output (JST connector)
-- **Headset:** 3.5mm TRRS jack
-- **Requires:** WM8960 device tree overlay for Jetson (community port)
-- **Use:** Voice commands (faster-whisper), wake word (openWakeWord), audio feedback, status announcements
+- Codec: Wolfson WM8960 (I2C addr 0x1A)
+- Mics: 2x MEMS (left + right) --- basic stereo / sound localization
+- Speaker: 3W class-D amp output (JST connector)
+- Headset: 3.5mm TRRS jack
+- Requires: WM8960 device tree overlay for Jetson (community port)
+- Use: Voice commands (faster-whisper), wake word (openWakeWord), audio feedback, status announcements
 
 ### 8. SIM7600A 4G/LTE HAT (via USB)
 
 | Connection | Detail |
 |-----------|--------|
-| Interface | USB (micro-B on HAT → USB-A/C on Orin) |
+| Interface | USB (micro-B on HAT -> USB-A/C on Orin) |
 | Device nodes | `/dev/ttyUSB0` (AT), `/dev/ttyUSB1` (PPP/data), `/dev/ttyUSB2` (GPS NMEA) |
 | Power | 5V from USB or separate 5V supply (peak 2A during TX) |
 | SIM | Nano-SIM slot on HAT |
-| Antenna | 4G LTE + GPS/GNSS (external SMA antennas — mount high on chassis) |
+| Antenna | 4G LTE + GPS/GNSS (external SMA antennas --- mount high on chassis) |
 
-- **Data:** PPP or QMI for internet connectivity
-- **GPS/GNSS:** Built-in receiver, NMEA sentences on ttyUSB2 — outdoor positioning
-- **AT commands:** `AT+CGPS=1` (enable GPS), `AT+CGPSINFO` (get fix)
-- **Connected via USB** (not 40-pin) — avoids UART conflict with FC fallback, flexible antenna placement
-- **Use:** Remote telemetry, 4G connectivity outdoors, GPS positioning, remote SSH/control
+- Data: PPP or QMI for internet connectivity
+- GPS/GNSS: Built-in receiver, NMEA sentences on ttyUSB2 --- outdoor positioning
+- AT commands: `AT+CGPS=1` (enable GPS), `AT+CGPSINFO` (get fix)
+- Connected via USB (not 40-pin) --- avoids UART conflict with BALANCE fallback, flexible antenna placement
+- Use: Remote telemetry, 4G connectivity outdoors, GPS positioning, remote SSH/control
 
-### 10. Leap Motion Controller (USB)
+### 9. Leap Motion Controller (USB)
 
 | Connection | Detail |
 |-----------|--------|
-| Interface | USB 3.0 (micro-B on controller → USB-A on Orin) |
+| Interface | USB 3.0 (micro-B on controller -> USB-A on Orin) |
 | Power | ~0.5W |
-| Range | ~80cm, 150° FOV |
+| Range | ~80cm, 150 deg FOV |
 | SDK | Ultraleap Gemini V5+ (Linux ARM64 support) |
 | ROS2 | `leap_motion_ros2` wrapper available |
 
-- **2× IR cameras + 3× IR LEDs** — tracks all 10 fingers in 3D, sub-mm precision
-- **Mount:** Forward-facing on sensor tower or upward on Orin plate
-- **Use:** Gesture control (palm=stop, point=go, fist=arm), hand-following mode, demos
-- **Combined with ReSpeaker:** Voice + gesture control with zero hardware in hand
+- 2x IR cameras + 3x IR LEDs --- tracks all 10 fingers in 3D, sub-mm precision
+- Mount: Forward-facing on sensor tower or upward on Orin plate
+- Use: Gesture control (palm=stop, point=go, fist=arm), hand-following mode, demos
+- Combined with ReSpeaker: Voice + gesture control with zero hardware in hand
 
-### 11. Power Budget (USB)
+### 10. Power Budget (USB)
 
 | Device | Interface | Power Draw |
 |--------|-----------|------------|
-| STM32 FC (CDC) | USB-C | ~0.5W (data only, FC on 5V bus) |
+<<<<<<< HEAD
+| CANable2 USB-CAN | USB-A | ~0.5W |
+| ESP32-S3 BALANCE | USB-C | ~0.8W (WiFi off) |
+| ESP32-S3 IO | USB-C | ~0.5W |
+=======
+| ESP32-S3 FC (CDC) | USB-C | ~0.5W (data only, FC on 5V bus) |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | RealSense D435i | USB-A | ~1.5W (3.5W peak) |
 | RPLIDAR A1M8 | USB-A | ~2.6W (motor on) |
 | SIM7600A | USB | ~1W idle, 3W TX peak |
-| Leap Motion | USB | ~0.5W |
+| Leap Motion | USB-A | ~0.5W |
 | ReSpeaker HAT | 40-pin | ~0.5W |
-| **Total USB** | | **~6.5W typical, ~10.5W peak** |
+| **Total USB** | | **~7.9W typical, ~11W peak** |
 
-Orin Nano Super delivers up to 25W — USB peripherals are well within budget.
+Orin Nano Super delivers up to 25W --- USB peripherals are well within budget.
 
 ---
 
@@ -225,38 +285,46 @@ Orin Nano Super delivers up to 25W — USB peripherals are well within budget.
 
 ```
                     ┌──────────────┐
-                    │  ELRS TX     │ (in your hand)
+                    │  RC TX       │ (in your hand)
                     │  (2.4GHz)    │
                     └──────┬───────┘
                            │ radio
                     ┌──────▼───────┐
-                    │  ELRS RX     │ CRSF 420kbaud
+                    │  RC RX       │ CRSF 420kbaud (future)
                     └──────┬───────┘
-                           │ UART4
+                           │ UART
               ┌────────────▼────────────┐
-              │      MAMBA F722S        │
+<<<<<<< HEAD
+              │   ESP32-S3 BALANCE      │
+              │  (Waveshare LCD 1.28)   │
+=======
+              │      ESP32-S3 BALANCE        │
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
               │                         │
-              │  MPU6000 → Balance PID  │
-              │  CRSF → Mode Manager   │
+              │  QMI8658 -> Balance PID │
+              │  RC -> Mode Manager     │
               │  Safety Monitor         │
               │                         │
               └──┬──────────┬───────────┘
-    USART2 ─────┘          └───── USB CDC / USART6
+<<<<<<< HEAD
+    CAN 500kbps─┘          └───── CAN bus / UART fallback
+=======
+    USART2 ─────┘          └───── USB Serial (CH343) / USART6
     26400 baud                    921600 baud
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
          │                              │
-         ▼                              ▼
-┌────────────────┐          ┌───────────────────┐
-│ Hoverboard ESC │          │   Orin Nano Super  │
-│                │          │                     │
-│ L motor  R motor│         │  SLAM / Nav2 / AI  │
-│    🛞      🛞   │         │  Person following   │
-└────────────────┘          │  Voice commands     │
-                            │  4G telemetry       │
+    ┌────┴────────────┐                 ▼
+    │ CAN bus (500k)  │        ┌───────────────────┐
+    ├─ VESC Left  56  │        │   Orin Nano Super  │
+    └─ VESC Right 68  │        │                     │
+         │    │                │  SLAM / Nav2 / AI  │
+         ▼    ▼                │  Person following   │
+       LEFT  RIGHT             │  Voice commands     │
+       MOTOR MOTOR             │  4G telemetry       │
                                └──┬──────────┬───────┘
                                   │          │
                        ┌──────────▼─┐   ┌────▼──────────┐
                        │ ReSpeaker  │   │  SIM7600A     │
                        │ 2-Mic HAT  │   │  4G/LTE + GPS │
-                    │ 🎤 🔊      │   │  📡 🛰️        │
                        └────────────┘   └───────────────┘
 ```

esp32s3/balance/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.16)
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(esp32s3_balance)

esp32s3/balance/main/CMakeLists.txt

@@ -0,0 +1,22 @@
+idf_component_register(
+    SRCS
+        "main.c"
+        "orin_serial.c"
+        "vesc_can.c"
+        "gitea_ota.c"
+        "ota_self.c"
+        "uart_ota.c"
+        "ota_display.c"
+    INCLUDE_DIRS "."
+    REQUIRES
+        esp_wifi
+        esp_http_client
+        esp_https_ota
+        nvs_flash
+        app_update
+        mbedtls
+        cJSON
+        driver
+        freertos
+        esp_timer
+)

esp32s3/balance/main/config.h

@@ -0,0 +1,42 @@
+#pragma once
+
+/* ── ESP32-S3 BALANCE board — bd-66hx pin/config definitions ───────────────
+ *
+ * Hardware change from pre-bd-66hx design:
+ *   Previously: IO43/IO44 = CAN SN65HVD230 (shared Orin+VESC bus via CANable2)
+ *   After bd-66hx: IO43/IO44 = CH343 UART0 (Orin serial comms)
+ *                  IO2/IO1   = CAN SN65HVD230 rewired (VESC-only bus)
+ *
+ * The SN65HVD230 transceiver physical wiring must be updated from IO43/44
+ * to IO2/IO1 when deploying this firmware.  See docs/SAUL-TEE-SYSTEM-REFERENCE.md.
+ */
+
+/* ── Orin serial (CH343 USB-to-UART, 1a86:55d3 on Orin side) ── */
+#define ORIN_UART_PORT          UART_NUM_0
+#define ORIN_UART_BAUD          460800
+#define ORIN_UART_TX_GPIO       43      /* ESP32→CH343 RXD */
+#define ORIN_UART_RX_GPIO       44      /* CH343 TXD→ESP32 */
+#define ORIN_UART_RX_BUF        1024
+#define ORIN_TX_QUEUE_DEPTH     16
+
+/* ── VESC CAN TWAI (SN65HVD230 transceiver, rewired for bd-66hx) ── */
+#define VESC_CAN_TX_GPIO        2       /* ESP32 TWAI TX → SN65HVD230 TXD */
+#define VESC_CAN_RX_GPIO        1       /* SN65HVD230 RXD → ESP32 TWAI RX */
+#define VESC_CAN_RX_QUEUE       32
+
+/* VESC node IDs — matched to bd-wim1 TELEM_VESC_LEFT/RIGHT mapping */
+#define VESC_ID_A               56u     /* TELEM_VESC_LEFT  (0x81) */
+#define VESC_ID_B               68u     /* TELEM_VESC_RIGHT (0x82) */
+
+/* ── Safety / timing ── */
+#define HB_TIMEOUT_MS           500u    /* heartbeat watchdog: disarm if exceeded */
+#define DRIVE_TIMEOUT_MS        500u    /* drive command staleness timeout */
+#define TELEM_STATUS_PERIOD_MS  100u    /* 10 Hz status telemetry to Orin */
+#define TELEM_VESC_PERIOD_MS    100u    /* 10 Hz VESC telemetry to Orin */
+
+/* ── Drive → VESC RPM scaling ── */
+#define RPM_PER_SPEED_UNIT      5       /* speed_units=1000 → 5000 ERPM */
+#define RPM_PER_STEER_UNIT      3       /* steer differential scale */
+
+/* ── Tilt cutoff ── */
+#define TILT_CUTOFF_DEG         25.0f

esp32s3/balance/main/gitea_ota.c

@@ -0,0 +1,285 @@
+/* gitea_ota.c — Gitea version checker (bd-3hte)
+ *
+ * Uses esp_http_client + cJSON to query:
+ *   GET /api/v1/repos/{repo}/releases?limit=10
+ * Filters releases by tag prefix, extracts version and download URLs.
+ */
+
+#include "gitea_ota.h"
+#include "version.h"
+#include "esp_log.h"
+#include "esp_wifi.h"
+#include "esp_event.h"
+#include "esp_netif.h"
+#include "esp_http_client.h"
+#include "nvs_flash.h"
+#include "nvs.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "cJSON.h"
+#include <string.h>
+#include <stdio.h>
+
+static const char *TAG = "gitea_ota";
+
+ota_update_info_t g_balance_update = {0};
+ota_update_info_t g_io_update      = {0};
+
+/* ── WiFi connection ── */
+#define WIFI_CONNECTED_BIT  BIT0
+#define WIFI_FAIL_BIT       BIT1
+#define WIFI_MAX_RETRIES    5
+
+/* Compile-time WiFi fallback (override in NVS "wifi"/"ssid","pass") */
+#define DEFAULT_WIFI_SSID   "saltylab"
+#define DEFAULT_WIFI_PASS   ""
+
+static EventGroupHandle_t s_wifi_eg;
+static int s_wifi_retries = 0;
+
+static void wifi_event_handler(void *arg, esp_event_base_t base,
+                                int32_t id, void *data)
+{
+    if (base == WIFI_EVENT && id == WIFI_EVENT_STA_START) {
+        esp_wifi_connect();
+    } else if (base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) {
+        if (s_wifi_retries < WIFI_MAX_RETRIES) {
+            esp_wifi_connect();
+            s_wifi_retries++;
+        } else {
+            xEventGroupSetBits(s_wifi_eg, WIFI_FAIL_BIT);
+        }
+    } else if (base == IP_EVENT && id == IP_EVENT_STA_GOT_IP) {
+        s_wifi_retries = 0;
+        xEventGroupSetBits(s_wifi_eg, WIFI_CONNECTED_BIT);
+    }
+}
+
+static bool wifi_connect(void)
+{
+    char ssid[64] = DEFAULT_WIFI_SSID;
+    char pass[64] = DEFAULT_WIFI_PASS;
+
+    /* Try to read credentials from NVS */
+    nvs_handle_t nvs;
+    if (nvs_open("wifi", NVS_READONLY, &nvs) == ESP_OK) {
+        size_t sz = sizeof(ssid);
+        nvs_get_str(nvs, "ssid", ssid, &sz);
+        sz = sizeof(pass);
+        nvs_get_str(nvs, "pass", pass, &sz);
+        nvs_close(nvs);
+    }
+
+    s_wifi_eg = xEventGroupCreate();
+    s_wifi_retries = 0;
+
+    ESP_ERROR_CHECK(esp_netif_init());
+    ESP_ERROR_CHECK(esp_event_loop_create_default());
+    esp_netif_create_default_wifi_sta();
+
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
+
+    esp_event_handler_instance_t h1, h2;
+    ESP_ERROR_CHECK(esp_event_handler_instance_register(
+        WIFI_EVENT, ESP_EVENT_ANY_ID, wifi_event_handler, NULL, &h1));
+    ESP_ERROR_CHECK(esp_event_handler_instance_register(
+        IP_EVENT, IP_EVENT_STA_GOT_IP, wifi_event_handler, NULL, &h2));
+
+    wifi_config_t wcfg = {0};
+    strlcpy((char *)wcfg.sta.ssid,     ssid, sizeof(wcfg.sta.ssid));
+    strlcpy((char *)wcfg.sta.password, pass, sizeof(wcfg.sta.password));
+
+    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wcfg));
+    ESP_ERROR_CHECK(esp_wifi_start());
+
+    EventBits_t bits = xEventGroupWaitBits(s_wifi_eg,
+        WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE,
+        pdMS_TO_TICKS(15000));
+
+    esp_event_handler_instance_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, h2);
+    esp_event_handler_instance_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, h1);
+    vEventGroupDelete(s_wifi_eg);
+
+    if (bits & WIFI_CONNECTED_BIT) {
+        ESP_LOGI(TAG, "WiFi connected SSID=%s", ssid);
+        return true;
+    }
+    ESP_LOGW(TAG, "WiFi connect failed SSID=%s", ssid);
+    return false;
+}
+
+/* ── HTTP fetch into a heap buffer ── */
+#define HTTP_RESP_MAX   (8 * 1024)
+
+typedef struct { char *buf; int len; int cap; } http_buf_t;
+
+static esp_err_t http_event_cb(esp_http_client_event_t *evt)
+{
+    http_buf_t *b = (http_buf_t *)evt->user_data;
+    if (evt->event_id == HTTP_EVENT_ON_DATA && b) {
+        if (b->len + evt->data_len < b->cap) {
+            memcpy(b->buf + b->len, evt->data, evt->data_len);
+            b->len += evt->data_len;
+        }
+    }
+    return ESP_OK;
+}
+
+static char *http_get(const char *url)
+{
+    char *buf = malloc(HTTP_RESP_MAX);
+    if (!buf) return NULL;
+    http_buf_t b = {.buf = buf, .len = 0, .cap = HTTP_RESP_MAX};
+    buf[0] = '\0';
+
+    esp_http_client_config_t cfg = {
+        .url            = url,
+        .event_handler  = http_event_cb,
+        .user_data      = &b,
+        .timeout_ms     = GITEA_API_TIMEOUT_MS,
+        .skip_cert_common_name_check = true,
+    };
+    esp_http_client_handle_t client = esp_http_client_init(&cfg);
+    esp_err_t err = esp_http_client_perform(client);
+    int status = esp_http_client_get_status_code(client);
+    esp_http_client_cleanup(client);
+
+    if (err != ESP_OK || status != 200) {
+        ESP_LOGW(TAG, "HTTP GET %s → err=%d status=%d", url, err, status);
+        free(buf);
+        return NULL;
+    }
+    buf[b.len] = '\0';
+    return buf;
+}
+
+/* ── Version comparison: returns true if remote > local ── */
+static bool version_newer(const char *local, const char *remote)
+{
+    int la=0,lb=0,lc=0, ra=0,rb=0,rc=0;
+    sscanf(local,  "%d.%d.%d", &la, &lb, &lc);
+    sscanf(remote, "%d.%d.%d", &ra, &rb, &rc);
+    if (ra != la) return ra > la;
+    if (rb != lb) return rb > lb;
+    return rc > lc;
+}
+
+/* ── Parse releases JSON array, fill ota_update_info_t ── */
+static void parse_releases(const char *json, const char *tag_prefix,
+                             const char *bin_asset, const char *sha_asset,
+                             const char *local_version,
+                             ota_update_info_t *out)
+{
+    cJSON *arr = cJSON_Parse(json);
+    if (!arr || !cJSON_IsArray(arr)) {
+        ESP_LOGW(TAG, "JSON parse failed");
+        cJSON_Delete(arr);
+        return;
+    }
+
+    cJSON *rel;
+    cJSON_ArrayForEach(rel, arr) {
+        cJSON *tag_j = cJSON_GetObjectItem(rel, "tag_name");
+        if (!cJSON_IsString(tag_j)) continue;
+
+        const char *tag = tag_j->valuestring;
+        if (strncmp(tag, tag_prefix, strlen(tag_prefix)) != 0) continue;
+
+        /* Extract version after prefix */
+        const char *ver = tag + strlen(tag_prefix);
+        if (*ver == 'v') ver++;  /* strip leading 'v' */
+
+        if (!version_newer(local_version, ver)) continue;
+
+        /* Found a newer release — extract asset URLs */
+        cJSON *assets = cJSON_GetObjectItem(rel, "assets");
+        if (!cJSON_IsArray(assets)) continue;
+
+        out->available = false;
+        out->download_url[0] = '\0';
+        out->sha256[0] = '\0';
+        strlcpy(out->version, ver, sizeof(out->version));
+
+        cJSON *asset;
+        cJSON_ArrayForEach(asset, assets) {
+            cJSON *name_j = cJSON_GetObjectItem(asset, "name");
+            cJSON *url_j  = cJSON_GetObjectItem(asset, "browser_download_url");
+            if (!cJSON_IsString(name_j) || !cJSON_IsString(url_j)) continue;
+
+            if (strcmp(name_j->valuestring, bin_asset) == 0) {
+                strlcpy(out->download_url, url_j->valuestring,
+                        sizeof(out->download_url));
+                out->available = true;
+            } else if (strcmp(name_j->valuestring, sha_asset) == 0) {
+                /* Download the SHA256 asset inline */
+                char *sha = http_get(url_j->valuestring);
+                if (sha) {
+                    /* sha file is just hex+newline */
+                    size_t n = strspn(sha, "0123456789abcdefABCDEF");
+                    if (n == 64) {
+                        memcpy(out->sha256, sha, 64);
+                        out->sha256[64] = '\0';
+                    }
+                    free(sha);
+                }
+            }
+        }
+
+        if (out->available) {
+            ESP_LOGI(TAG, "update: tag=%s ver=%s", tag, out->version);
+        }
+        break;  /* use first matching release */
+    }
+
+    cJSON_Delete(arr);
+}
+
+/* ── Main check ── */
+void gitea_ota_check_now(void)
+{
+    char url[512];
+    snprintf(url, sizeof(url),
+             "%s/api/v1/repos/%s/releases?limit=10",
+             GITEA_BASE_URL, GITEA_REPO);
+
+    char *json = http_get(url);
+    if (!json) {
+        ESP_LOGW(TAG, "releases fetch failed");
+        return;
+    }
+
+    parse_releases(json, BALANCE_TAG_PREFIX, BALANCE_BIN_ASSET,
+                   BALANCE_SHA256_ASSET, BALANCE_FW_VERSION, &g_balance_update);
+    parse_releases(json, IO_TAG_PREFIX, IO_BIN_ASSET,
+                   IO_SHA256_ASSET, IO_FW_VERSION, &g_io_update);
+    free(json);
+}
+
+/* ── Background task ── */
+static void version_check_task(void *arg)
+{
+    /* Initial check immediately after WiFi up */
+    vTaskDelay(pdMS_TO_TICKS(2000));
+    gitea_ota_check_now();
+
+    for (;;) {
+        vTaskDelay(pdMS_TO_TICKS(VERSION_CHECK_PERIOD_MS));
+        gitea_ota_check_now();
+    }
+}
+
+void gitea_ota_init(void)
+{
+    ESP_ERROR_CHECK(nvs_flash_init());
+
+    if (!wifi_connect()) {
+        ESP_LOGW(TAG, "WiFi unavailable — version checks disabled");
+        return;
+    }
+
+    xTaskCreate(version_check_task, "ver_check", 6144, NULL, 3, NULL);
+    ESP_LOGI(TAG, "version check task started");
+}

esp32s3/balance/main/gitea_ota.h

@@ -0,0 +1,42 @@
+#pragma once
+/* gitea_ota.h — Gitea release version checker (bd-3hte)
+ *
+ * WiFi task: on boot and every 30 min, queries Gitea releases API,
+ * compares tag version against embedded FW_VERSION, stores update info.
+ *
+ * WiFi credentials read from NVS namespace "wifi" keys "ssid"/"pass".
+ * Fall back to compile-time defaults if NVS is empty.
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* Gitea instance */
+#define GITEA_BASE_URL      "http://gitea.vayrette.com"
+#define GITEA_REPO          "seb/saltylab-firmware"
+#define GITEA_API_TIMEOUT_MS 10000
+
+/* Version check interval */
+#define VERSION_CHECK_PERIOD_MS  (30u * 60u * 1000u)  /* 30 minutes */
+
+/* Max URL/version string lengths */
+#define OTA_URL_MAX     384
+#define OTA_VER_MAX     32
+#define OTA_SHA256_MAX  65
+
+typedef struct {
+    bool    available;
+    char    version[OTA_VER_MAX];      /* remote version string, e.g. "1.2.3" */
+    char    download_url[OTA_URL_MAX]; /* direct download URL for .bin */
+    char    sha256[OTA_SHA256_MAX];    /* hex SHA256 (from .sha256 asset), or "" */
+} ota_update_info_t;
+
+/* Shared state — written by gitea_ota_check_task, read by display/OTA tasks */
+extern ota_update_info_t g_balance_update;
+extern ota_update_info_t g_io_update;
+
+/* Initialize WiFi and start version check task */
+void gitea_ota_init(void);
+
+/* One-shot sync check (can be called from any task) */
+void gitea_ota_check_now(void);

esp32s3/balance/main/main.c

@@ -0,0 +1,114 @@
+/* main.c — ESP32-S3 BALANCE app_main (bd-66hx + OTA beads) */
+
+#include "orin_serial.h"
+#include "vesc_can.h"
+#include "gitea_ota.h"
+#include "ota_self.h"
+#include "uart_ota.h"
+#include "ota_display.h"
+#include "config.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "esp_log.h"
+#include "esp_timer.h"
+#include <string.h>
+
+static const char *TAG = "main";
+
+static QueueHandle_t s_orin_tx_q;
+
+/* ── Telemetry task: sends TELEM_STATUS to Orin at 10 Hz ── */
+static void telem_task(void *arg)
+{
+    for (;;) {
+        vTaskDelay(pdMS_TO_TICKS(TELEM_STATUS_PERIOD_MS));
+
+        uint32_t now_ms = (uint32_t)(esp_timer_get_time() / 1000LL);
+        bool hb_timeout = (now_ms - g_orin_ctrl.hb_last_ms) > HB_TIMEOUT_MS;
+
+        /* Determine balance state for telemetry */
+        bal_state_t state;
+        if (g_orin_ctrl.estop) {
+            state = BAL_ESTOP;
+        } else if (!g_orin_ctrl.armed) {
+            state = BAL_DISARMED;
+        } else {
+            state = BAL_ARMED;
+        }
+
+        /* flags: bit0=estop_active, bit1=heartbeat_timeout */
+        uint8_t flags = (g_orin_ctrl.estop ? 0x01u : 0x00u) |
+                        (hb_timeout         ? 0x02u : 0x00u);
+
+        /* Battery voltage from VESC_ID_A STATUS_5 (V×10 → mV) */
+        uint16_t vbat_mv = (uint16_t)((int32_t)g_vesc[0].voltage_x10 * 100);
+
+        orin_send_status(s_orin_tx_q,
+                         0,      /* pitch_x10: stub — full IMU in future bead */
+                         0,      /* motor_cmd: stub */
+                         vbat_mv,
+                         state,
+                         flags);
+    }
+}
+
+/* ── Drive task: applies Orin drive commands to VESCs @ 50 Hz ── */
+static void drive_task(void *arg)
+{
+    for (;;) {
+        vTaskDelay(pdMS_TO_TICKS(20));  /* 50 Hz */
+
+        uint32_t now_ms   = (uint32_t)(esp_timer_get_time() / 1000LL);
+        bool hb_timeout   = (now_ms - g_orin_ctrl.hb_last_ms) > HB_TIMEOUT_MS;
+        bool drive_stale  = (now_ms - g_orin_drive.updated_ms) > DRIVE_TIMEOUT_MS;
+
+        int32_t left_erpm  = 0;
+        int32_t right_erpm = 0;
+
+        if (g_orin_ctrl.armed && !g_orin_ctrl.estop &&
+            !hb_timeout && !drive_stale) {
+            int32_t spd = (int32_t)g_orin_drive.speed * RPM_PER_SPEED_UNIT;
+            int32_t str = (int32_t)g_orin_drive.steer * RPM_PER_STEER_UNIT;
+            left_erpm  = spd + str;
+            right_erpm = spd - str;
+        }
+
+        /* VESC_ID_A (56) = LEFT, VESC_ID_B (68) = RIGHT per bd-wim1 protocol */
+        vesc_can_send_rpm(VESC_ID_A, left_erpm);
+        vesc_can_send_rpm(VESC_ID_B, right_erpm);
+    }
+}
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "ESP32-S3 BALANCE starting");
+
+    /* OTA rollback health check — must be called within OTA_ROLLBACK_WINDOW_S */
+    ota_self_health_check();
+
+    /* Init peripherals */
+    orin_serial_init();
+    vesc_can_init();
+
+    /* TX queue for outbound serial frames */
+    s_orin_tx_q = xQueueCreate(ORIN_TX_QUEUE_DEPTH, sizeof(orin_tx_frame_t));
+    configASSERT(s_orin_tx_q);
+
+    /* Seed heartbeat timer so we don't immediately timeout */
+    g_orin_ctrl.hb_last_ms = (uint32_t)(esp_timer_get_time() / 1000LL);
+
+    /* Create tasks */
+    xTaskCreate(orin_serial_rx_task, "orin_rx",  4096, s_orin_tx_q, 10, NULL);
+    xTaskCreate(orin_serial_tx_task, "orin_tx",  2048, s_orin_tx_q,  9, NULL);
+    xTaskCreate(vesc_can_rx_task,    "vesc_rx",  4096, s_orin_tx_q, 10, NULL);
+    xTaskCreate(telem_task,          "telem",    2048, NULL,          5, NULL);
+    xTaskCreate(drive_task,          "drive",    2048, NULL,          8, NULL);
+
+    /* OTA subsystem — WiFi version checker + display overlay */
+    gitea_ota_init();
+    ota_display_init();
+
+    ESP_LOGI(TAG, "all tasks started");
+    /* app_main returns — FreeRTOS scheduler continues */
+}

esp32s3/balance/main/orin_serial.c

@@ -0,0 +1,354 @@
+/* orin_serial.c — Orin↔ESP32-S3 serial protocol (bd-66hx + bd-1s1s OTA cmds) */
+
+#include "orin_serial.h"
+#include "config.h"
+#include "gitea_ota.h"
+#include "ota_self.h"
+#include "uart_ota.h"
+#include "version.h"
+#include "driver/uart.h"
+#include "esp_log.h"
+#include "esp_timer.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include <string.h>
+#include <stdio.h>
+
+static const char *TAG = "orin";
+
+/* ── Shared state ── */
+orin_drive_t   g_orin_drive   = {0};
+orin_pid_t     g_orin_pid     = {0};
+orin_control_t g_orin_ctrl    = {.armed = false, .estop = false, .hb_last_ms = 0};
+
+/* ── CRC8-SMBUS (poly=0x07, init=0x00) ── */
+static uint8_t crc8(const uint8_t *data, uint8_t len)
+{
+    uint8_t crc = 0x00u;
+    for (uint8_t i = 0; i < len; i++) {
+        crc ^= data[i];
+        for (uint8_t b = 0; b < 8u; b++) {
+            crc = (crc & 0x80u) ? (uint8_t)((crc << 1u) ^ 0x07u) : (uint8_t)(crc << 1u);
+        }
+    }
+    return crc;
+}
+
+/* ── Frame builder ── */
+static void build_frame(orin_tx_frame_t *f, uint8_t out[/* ORIN_MAX_PAYLOAD + 4 */], uint8_t *out_len)
+{
+    /* [SYNC][LEN][TYPE][PAYLOAD...][CRC] */
+    uint8_t crc_buf[2u + ORIN_MAX_PAYLOAD];
+    crc_buf[0] = f->len;
+    crc_buf[1] = f->type;
+    memcpy(&crc_buf[2], f->payload, f->len);
+    uint8_t crc = crc8(crc_buf, (uint8_t)(2u + f->len));
+
+    out[0] = ORIN_SYNC;
+    out[1] = f->len;
+    out[2] = f->type;
+    memcpy(&out[3], f->payload, f->len);
+    out[3u + f->len] = crc;
+    *out_len = (uint8_t)(4u + f->len);
+}
+
+/* ── Enqueue helpers ── */
+static void enqueue(QueueHandle_t q, uint8_t type, const uint8_t *payload, uint8_t len)
+{
+    orin_tx_frame_t f = {.type = type, .len = len};
+    if (len > 0u && payload) {
+        memcpy(f.payload, payload, len);
+    }
+    if (xQueueSend(q, &f, 0) != pdTRUE) {
+        ESP_LOGW(TAG, "tx queue full, dropped type=0x%02x", type);
+    }
+}
+
+void orin_send_ack(QueueHandle_t q, uint8_t cmd_type)
+{
+    enqueue(q, RESP_ACK, &cmd_type, 1u);
+}
+
+void orin_send_nack(QueueHandle_t q, uint8_t cmd_type, uint8_t err)
+{
+    uint8_t p[2] = {cmd_type, err};
+    enqueue(q, RESP_NACK, p, 2u);
+}
+
+void orin_send_status(QueueHandle_t q,
+                      int16_t pitch_x10, int16_t motor_cmd,
+                      uint16_t vbat_mv, bal_state_t state, uint8_t flags)
+{
+    /* int16 pitch_x10, int16 motor_cmd, uint16 vbat_mv, uint8 state, uint8 flags — BE */
+    uint8_t p[8];
+    p[0] = (uint8_t)((uint16_t)pitch_x10 >> 8u);
+    p[1] = (uint8_t)((uint16_t)pitch_x10);
+    p[2] = (uint8_t)((uint16_t)motor_cmd >> 8u);
+    p[3] = (uint8_t)((uint16_t)motor_cmd);
+    p[4] = (uint8_t)(vbat_mv >> 8u);
+    p[5] = (uint8_t)(vbat_mv);
+    p[6] = (uint8_t)state;
+    p[7] = flags;
+    enqueue(q, TELEM_STATUS, p, 8u);
+}
+
+void orin_send_vesc(QueueHandle_t q, uint8_t telem_type,
+                    int32_t erpm, uint16_t voltage_mv,
+                    int16_t current_ma, uint16_t temp_c_x10)
+{
+    /* int32 erpm, uint16 voltage_mv, int16 current_ma, uint16 temp_c_x10 — BE */
+    uint8_t p[10];
+    uint32_t u = (uint32_t)erpm;
+    p[0] = (uint8_t)(u >> 24u);
+    p[1] = (uint8_t)(u >> 16u);
+    p[2] = (uint8_t)(u >>  8u);
+    p[3] = (uint8_t)(u);
+    p[4] = (uint8_t)(voltage_mv >> 8u);
+    p[5] = (uint8_t)(voltage_mv);
+    p[6] = (uint8_t)((uint16_t)current_ma >> 8u);
+    p[7] = (uint8_t)((uint16_t)current_ma);
+    p[8] = (uint8_t)(temp_c_x10 >> 8u);
+    p[9] = (uint8_t)(temp_c_x10);
+    enqueue(q, telem_type, p, 10u);
+}
+
+/* ── UART init ── */
+void orin_serial_init(void)
+{
+    uart_config_t cfg = {
+        .baud_rate  = ORIN_UART_BAUD,
+        .data_bits  = UART_DATA_8_BITS,
+        .parity     = UART_PARITY_DISABLE,
+        .stop_bits  = UART_STOP_BITS_1,
+        .flow_ctrl  = UART_HW_FLOWCTRL_DISABLE,
+    };
+    ESP_ERROR_CHECK(uart_param_config(ORIN_UART_PORT, &cfg));
+    ESP_ERROR_CHECK(uart_set_pin(ORIN_UART_PORT,
+                                  ORIN_UART_TX_GPIO, ORIN_UART_RX_GPIO,
+                                  UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
+    ESP_ERROR_CHECK(uart_driver_install(ORIN_UART_PORT, ORIN_UART_RX_BUF, 0,
+                                        0, NULL, 0));
+    ESP_LOGI(TAG, "UART%d init OK: tx=%d rx=%d baud=%d",
+             ORIN_UART_PORT, ORIN_UART_TX_GPIO, ORIN_UART_RX_GPIO, ORIN_UART_BAUD);
+}
+
+/* ── RX parser state machine ── */
+typedef enum {
+    WAIT_SYNC,
+    WAIT_LEN,
+    WAIT_TYPE,
+    WAIT_PAYLOAD,
+    WAIT_CRC,
+} rx_state_t;
+
+static void dispatch_cmd(uint8_t type, const uint8_t *payload, uint8_t len,
+                          QueueHandle_t tx_q)
+{
+    uint32_t now_ms = (uint32_t)(esp_timer_get_time() / 1000LL);
+
+    switch (type) {
+    case CMD_HEARTBEAT:
+        g_orin_ctrl.hb_last_ms = now_ms;
+        orin_send_ack(tx_q, type);
+        break;
+
+    case CMD_DRIVE:
+        if (len < 4u) { orin_send_nack(tx_q, type, ERR_BAD_LEN); break; }
+        if (g_orin_ctrl.estop) { orin_send_nack(tx_q, type, ERR_ESTOP_ACTIVE); break; }
+        if (!g_orin_ctrl.armed) { orin_send_nack(tx_q, type, ERR_DISARMED); break; }
+        g_orin_drive.speed      = (int16_t)(((uint16_t)payload[0] << 8u) | payload[1]);
+        g_orin_drive.steer      = (int16_t)(((uint16_t)payload[2] << 8u) | payload[3]);
+        g_orin_drive.updated_ms = now_ms;
+        g_orin_ctrl.hb_last_ms  = now_ms;  /* drive counts as heartbeat */
+        orin_send_ack(tx_q, type);
+        break;
+
+    case CMD_ESTOP:
+        if (len < 1u) { orin_send_nack(tx_q, type, ERR_BAD_LEN); break; }
+        g_orin_ctrl.estop = (payload[0] != 0u);
+        if (g_orin_ctrl.estop) {
+            g_orin_drive.speed = 0;
+            g_orin_drive.steer = 0;
+        }
+        orin_send_ack(tx_q, type);
+        break;
+
+    case CMD_ARM:
+        if (len < 1u) { orin_send_nack(tx_q, type, ERR_BAD_LEN); break; }
+        if (g_orin_ctrl.estop && payload[0] != 0u) {
+            /* cannot arm while estop is active */
+            orin_send_nack(tx_q, type, ERR_ESTOP_ACTIVE);
+            break;
+        }
+        g_orin_ctrl.armed = (payload[0] != 0u);
+        if (!g_orin_ctrl.armed) {
+            g_orin_drive.speed = 0;
+            g_orin_drive.steer = 0;
+        }
+        orin_send_ack(tx_q, type);
+        break;
+
+    case CMD_PID:
+        if (len < 12u) { orin_send_nack(tx_q, type, ERR_BAD_LEN); break; }
+        /* float32 big-endian: copy and swap bytes */
+        {
+            uint32_t raw;
+            raw = ((uint32_t)payload[0] << 24u) | ((uint32_t)payload[1] << 16u) |
+                  ((uint32_t)payload[2] <<  8u) |  (uint32_t)payload[3];
+            memcpy((void*)&g_orin_pid.kp, &raw, 4u);
+            raw = ((uint32_t)payload[4] << 24u) | ((uint32_t)payload[5] << 16u) |
+                  ((uint32_t)payload[6] <<  8u) |  (uint32_t)payload[7];
+            memcpy((void*)&g_orin_pid.ki, &raw, 4u);
+            raw = ((uint32_t)payload[8] << 24u) | ((uint32_t)payload[9] << 16u) |
+                  ((uint32_t)payload[10] << 8u) |  (uint32_t)payload[11];
+            memcpy((void*)&g_orin_pid.kd, &raw, 4u);
+            g_orin_pid.updated = true;
+        }
+        orin_send_ack(tx_q, type);
+        break;
+
+    case CMD_OTA_CHECK:
+        /* Trigger an immediate Gitea version check */
+        gitea_ota_check_now();
+        orin_send_version_info(tx_q, OTA_TARGET_BALANCE,
+                                BALANCE_FW_VERSION,
+                                g_balance_update.available
+                                    ? g_balance_update.version : "");
+        orin_send_version_info(tx_q, OTA_TARGET_IO,
+                                IO_FW_VERSION,
+                                g_io_update.available
+                                    ? g_io_update.version : "");
+        orin_send_ack(tx_q, type);
+        break;
+
+    case CMD_OTA_UPDATE:
+        if (len < 1u) { orin_send_nack(tx_q, type, ERR_BAD_LEN); break; }
+        {
+            uint8_t target = payload[0];
+            bool triggered = false;
+            if (target == OTA_TARGET_IO || target == OTA_TARGET_BOTH) {
+                if (!uart_ota_trigger()) {
+                    orin_send_nack(tx_q, type,
+                        g_io_update.available ? ERR_OTA_BUSY : ERR_OTA_NO_UPDATE);
+                    break;
+                }
+                triggered = true;
+            }
+            if (target == OTA_TARGET_BALANCE || target == OTA_TARGET_BOTH) {
+                if (!ota_self_trigger()) {
+                    if (!triggered) {
+                        orin_send_nack(tx_q, type,
+                            g_balance_update.available ? ERR_OTA_BUSY : ERR_OTA_NO_UPDATE);
+                        break;
+                    }
+                }
+            }
+            orin_send_ack(tx_q, type);
+        }
+        break;
+
+    default:
+        ESP_LOGW(TAG, "unknown cmd type=0x%02x", type);
+        break;
+    }
+}
+
+void orin_serial_rx_task(void *arg)
+{
+    QueueHandle_t tx_q = (QueueHandle_t)arg;
+    rx_state_t state   = WAIT_SYNC;
+    uint8_t    rx_len  = 0;
+    uint8_t    rx_type = 0;
+    uint8_t    payload[ORIN_MAX_PAYLOAD];
+    uint8_t    pay_idx = 0;
+
+    uint8_t byte;
+    for (;;) {
+        int r = uart_read_bytes(ORIN_UART_PORT, &byte, 1, pdMS_TO_TICKS(10));
+        if (r <= 0) {
+            continue;
+        }
+
+        switch (state) {
+        case WAIT_SYNC:
+            if (byte == ORIN_SYNC) { state = WAIT_LEN; }
+            break;
+
+        case WAIT_LEN:
+            if (byte > ORIN_MAX_PAYLOAD) {
+                /* oversize — send NACK and reset */
+                orin_send_nack(tx_q, 0x00u, ERR_BAD_LEN);
+                state = WAIT_SYNC;
+            } else {
+                rx_len = byte;
+                state  = WAIT_TYPE;
+            }
+            break;
+
+        case WAIT_TYPE:
+            rx_type = byte;
+            pay_idx = 0u;
+            state   = (rx_len == 0u) ? WAIT_CRC : WAIT_PAYLOAD;
+            break;
+
+        case WAIT_PAYLOAD:
+            payload[pay_idx++] = byte;
+            if (pay_idx == rx_len) { state = WAIT_CRC; }
+            break;
+
+        case WAIT_CRC: {
+            /* Verify CRC over [LEN, TYPE, PAYLOAD] */
+            uint8_t crc_buf[2u + ORIN_MAX_PAYLOAD];
+            crc_buf[0] = rx_len;
+            crc_buf[1] = rx_type;
+            memcpy(&crc_buf[2], payload, rx_len);
+            uint8_t expected = crc8(crc_buf, (uint8_t)(2u + rx_len));
+            if (byte != expected) {
+                ESP_LOGW(TAG, "CRC fail type=0x%02x got=0x%02x exp=0x%02x",
+                         rx_type, byte, expected);
+                orin_send_nack(tx_q, rx_type, ERR_BAD_CRC);
+            } else {
+                dispatch_cmd(rx_type, payload, rx_len, tx_q);
+            }
+            state = WAIT_SYNC;
+            break;
+        }
+        }
+    }
+}
+
+void orin_serial_tx_task(void *arg)
+{
+    QueueHandle_t tx_q = (QueueHandle_t)arg;
+    orin_tx_frame_t f;
+    uint8_t wire[4u + ORIN_MAX_PAYLOAD];
+    uint8_t wire_len;
+
+    for (;;) {
+        if (xQueueReceive(tx_q, &f, portMAX_DELAY) == pdTRUE) {
+            build_frame(&f, wire, &wire_len);
+            uart_write_bytes(ORIN_UART_PORT, (const char *)wire, wire_len);
+        }
+    }
+}
+
+/* ── OTA telemetry helpers (bd-1s1s) ── */
+
+void orin_send_ota_status(QueueHandle_t q, uint8_t target,
+                           uint8_t state, uint8_t progress, uint8_t err)
+{
+    /* TELEM_OTA_STATUS: uint8 target, uint8 state, uint8 progress, uint8 err */
+    uint8_t p[4] = {target, state, progress, err};
+    enqueue(q, TELEM_OTA_STATUS, p, 4u);
+}
+
+void orin_send_version_info(QueueHandle_t q, uint8_t target,
+                             const char *current, const char *available)
+{
+    /* TELEM_VERSION_INFO: uint8 target, char current[16], char available[16] */
+    uint8_t p[33];
+    p[0] = target;
+    strncpy((char *)&p[1],  current,   16); p[16] = '\0';
+    strncpy((char *)&p[17], available ? available : "", 16); p[32] = '\0';
+    enqueue(q, TELEM_VERSION_INFO, p, 33u);
+}

esp32s3/balance/main/orin_serial.h

@@ -0,0 +1,113 @@
+#pragma once
+/* orin_serial.h — Orin↔ESP32-S3 BALANCE USB/UART serial protocol (bd-66hx)
+ *
+ * Frame layout (matches bd-wim1 esp32_balance_protocol.py exactly):
+ *   [0xAA][LEN][TYPE][PAYLOAD × LEN bytes][CRC8-SMBUS]
+ *   CRC covers LEN + TYPE + PAYLOAD bytes.
+ *   All multi-byte payload fields are big-endian.
+ *
+ * Physical: UART0 → CH343 USB-serial → Orin /dev/esp32-balance  @ 460800 baud
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+
+/* ── Frame constants ── */
+#define ORIN_SYNC           0xAAu
+#define ORIN_MAX_PAYLOAD    62u
+
+/* ── Command types: Orin → ESP32 ── */
+#define CMD_HEARTBEAT       0x01u
+#define CMD_DRIVE           0x02u   /* int16 speed + int16 steer, BE */
+#define CMD_ESTOP           0x03u   /* uint8: 1=assert, 0=clear */
+#define CMD_ARM             0x04u   /* uint8: 1=arm, 0=disarm */
+#define CMD_PID             0x05u   /* float32 kp, ki, kd, BE */
+
+/* ── Telemetry types: ESP32 → Orin ── */
+#define TELEM_STATUS        0x80u   /* status @ 10 Hz */
+#define TELEM_VESC_LEFT     0x81u   /* VESC ID 56 telemetry @ 10 Hz */
+#define TELEM_VESC_RIGHT    0x82u   /* VESC ID 68 telemetry @ 10 Hz */
+#define TELEM_OTA_STATUS    0x83u   /* OTA state + progress (bd-1s1s) */
+#define TELEM_VERSION_INFO  0x84u   /* firmware version report (bd-1s1s) */
+#define RESP_ACK            0xA0u
+#define RESP_NACK           0xA1u
+
+/* ── OTA commands (Orin → ESP32, bd-1s1s) ── */
+#define CMD_OTA_CHECK       0x10u   /* no payload: trigger Gitea version check */
+#define CMD_OTA_UPDATE      0x11u   /* uint8 target: 0=balance, 1=io, 2=both */
+
+/* ── OTA target constants ── */
+#define OTA_TARGET_BALANCE  0x00u
+#define OTA_TARGET_IO       0x01u
+#define OTA_TARGET_BOTH     0x02u
+
+/* ── NACK error codes ── */
+#define ERR_BAD_CRC         0x01u
+#define ERR_BAD_LEN         0x02u
+#define ERR_ESTOP_ACTIVE    0x03u
+#define ERR_DISARMED        0x04u
+#define ERR_OTA_BUSY        0x05u
+#define ERR_OTA_NO_UPDATE   0x06u
+
+/* ── Balance state (mirrored from TELEM_STATUS.balance_state) ── */
+typedef enum {
+    BAL_DISARMED   = 0,
+    BAL_ARMED      = 1,
+    BAL_TILT_FAULT = 2,
+    BAL_ESTOP      = 3,
+} bal_state_t;
+
+/* ── Shared state written by RX task, consumed by main/vesc tasks ── */
+typedef struct {
+    volatile int16_t  speed;        /* -1000..+1000 */
+    volatile int16_t  steer;        /* -1000..+1000 */
+    volatile uint32_t updated_ms;   /* esp_timer tick at last CMD_DRIVE */
+} orin_drive_t;
+
+typedef struct {
+    volatile float    kp, ki, kd;
+    volatile bool     updated;
+} orin_pid_t;
+
+typedef struct {
+    volatile bool     armed;
+    volatile bool     estop;
+    volatile uint32_t hb_last_ms;   /* esp_timer tick at last CMD_HEARTBEAT/CMD_DRIVE */
+} orin_control_t;
+
+/* ── TX frame queue item ── */
+typedef struct {
+    uint8_t type;
+    uint8_t len;
+    uint8_t payload[ORIN_MAX_PAYLOAD];
+} orin_tx_frame_t;
+
+/* ── Globals (defined in orin_serial.c, extern here) ── */
+extern orin_drive_t   g_orin_drive;
+extern orin_pid_t     g_orin_pid;
+extern orin_control_t g_orin_ctrl;
+
+/* ── API ── */
+void orin_serial_init(void);
+
+/* Tasks — pass tx_queue as arg to both */
+void orin_serial_rx_task(void *arg);   /* arg = QueueHandle_t tx_queue */
+void orin_serial_tx_task(void *arg);   /* arg = QueueHandle_t tx_queue */
+
+/* Enqueue outbound frames */
+void orin_send_status(QueueHandle_t q,
+                      int16_t pitch_x10, int16_t motor_cmd,
+                      uint16_t vbat_mv, bal_state_t state, uint8_t flags);
+void orin_send_vesc(QueueHandle_t q, uint8_t telem_type,
+                    int32_t erpm, uint16_t voltage_mv,
+                    int16_t current_ma, uint16_t temp_c_x10);
+void orin_send_ack(QueueHandle_t q, uint8_t cmd_type);
+void orin_send_nack(QueueHandle_t q, uint8_t cmd_type, uint8_t err);
+
+/* OTA telemetry helpers (bd-1s1s) */
+void orin_send_ota_status(QueueHandle_t q, uint8_t target,
+                           uint8_t state, uint8_t progress, uint8_t err);
+void orin_send_version_info(QueueHandle_t q, uint8_t target,
+                             const char *current, const char *available);

esp32s3/balance/main/ota_display.c

@@ -0,0 +1,150 @@
+/* ota_display.c — OTA notification/progress UI on GC9A01 (bd-1yr8)
+ *
+ * Renders OTA state overlaid on the 240×240 round HUD display:
+ *   - BADGE: small dot on top-right when update available (idle state)
+ *   - UPDATE SCREEN: version compare, Update Balance / Update IO / Update All
+ *   - PROGRESS: arc around display perimeter + % + status text
+ *   - ERROR: red banner + "RETRY" prompt
+ *
+ * The display_draw_* primitives must be provided by the GC9A01 driver.
+ * Actual SPI driver implementation is in a separate driver bead.
+ */
+
+#include "ota_display.h"
+#include "gitea_ota.h"
+#include "version.h"
+#include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <stdio.h>
+#include <string.h>
+
+static const char *TAG = "ota_disp";
+
+/* Display centre and radius for the 240×240 GC9A01 */
+#define CX   120
+#define CY   120
+#define RAD  110
+
+/* ── Availability badge: 8×8 dot at top-right of display ── */
+static void draw_badge(bool balance_avail, bool io_avail)
+{
+    uint16_t col = (balance_avail || io_avail) ? COL_ORANGE : COL_BG;
+    display_fill_rect(200, 15, 12, 12, col);
+}
+
+/* ── Progress arc: sweeps 0→360° proportional to progress% ── */
+static void draw_progress_arc(uint8_t pct, uint16_t color)
+{
+    int end_deg = (int)(360 * pct / 100);
+    display_draw_arc(CX, CY, RAD, 0, end_deg, 6, color);
+}
+
+/* ── Status banner: 2 lines of text centred on display ── */
+static void draw_status(const char *line1, const char *line2,
+                         uint16_t fg, uint16_t bg)
+{
+    display_fill_rect(20, 90, 200, 60, bg);
+    if (line1 && line1[0])
+        display_draw_string(CX - (int)(strlen(line1) * 6 / 2), 96,
+                             line1, fg, bg);
+    if (line2 && line2[0])
+        display_draw_string(CX - (int)(strlen(line2) * 6 / 2), 116,
+                             line2, fg, bg);
+}
+
+/* ── Main render logic ── */
+void ota_display_update(void)
+{
+    /* Determine dominant OTA state */
+    ota_self_state_t  self  = g_ota_self_state;
+    uart_ota_send_state_t io_s = g_uart_ota_state;
+
+    switch (self) {
+    case OTA_SELF_DOWNLOADING:
+    case OTA_SELF_VERIFYING:
+    case OTA_SELF_APPLYING: {
+        /* Balance self-update in progress */
+        char pct_str[16];
+        snprintf(pct_str, sizeof(pct_str), "%d%%", g_ota_self_progress);
+        const char *phase = (self == OTA_SELF_VERIFYING) ? "Verifying..." :
+                            (self == OTA_SELF_APPLYING)  ? "Applying..." :
+                                                            "Downloading...";
+        draw_progress_arc(g_ota_self_progress, COL_BLUE);
+        draw_status("Updating Balance", pct_str, COL_WHITE, COL_BG);
+        ESP_LOGD(TAG, "balance OTA %s %d%%", phase, g_ota_self_progress);
+        return;
+    }
+    case OTA_SELF_REBOOTING:
+        draw_status("Update complete", "Rebooting...", COL_GREEN, COL_BG);
+        return;
+    case OTA_SELF_FAILED:
+        draw_progress_arc(0, COL_RED);
+        draw_status("Balance update", "FAILED  RETRY?", COL_RED, COL_BG);
+        return;
+    default:
+        break;
+    }
+
+    switch (io_s) {
+    case UART_OTA_S_DOWNLOADING:
+        draw_progress_arc(g_uart_ota_progress, COL_YELLOW);
+        draw_status("Downloading IO", "firmware...", COL_WHITE, COL_BG);
+        return;
+    case UART_OTA_S_SENDING: {
+        char pct_str[16];
+        snprintf(pct_str, sizeof(pct_str), "%d%%", g_uart_ota_progress);
+        draw_progress_arc(g_uart_ota_progress, COL_YELLOW);
+        draw_status("Updating IO", pct_str, COL_WHITE, COL_BG);
+        return;
+    }
+    case UART_OTA_S_DONE:
+        draw_status("IO update done", "", COL_GREEN, COL_BG);
+        return;
+    case UART_OTA_S_FAILED:
+        draw_progress_arc(0, COL_RED);
+        draw_status("IO update", "FAILED  RETRY?", COL_RED, COL_BG);
+        return;
+    default:
+        break;
+    }
+
+    /* Idle — show badge if update available */
+    bool bal_avail = g_balance_update.available;
+    bool io_avail  = g_io_update.available;
+    draw_badge(bal_avail, io_avail);
+
+    if (bal_avail || io_avail) {
+        /* Show available versions on display when idle */
+        char verline[32];
+        if (bal_avail) {
+            snprintf(verline, sizeof(verline), "Bal v%s rdy",
+                     g_balance_update.version);
+            draw_status(verline, io_avail ? "IO update rdy" : "",
+                         COL_ORANGE, COL_BG);
+        } else if (io_avail) {
+            snprintf(verline, sizeof(verline), "IO v%s rdy",
+                     g_io_update.version);
+            draw_status(verline, "", COL_ORANGE, COL_BG);
+        }
+    } else {
+        /* Clear OTA overlay area */
+        display_fill_rect(20, 90, 200, 60, COL_BG);
+        draw_badge(false, false);
+    }
+}
+
+/* ── Background display task (5 Hz) ── */
+static void ota_display_task(void *arg)
+{
+    for (;;) {
+        vTaskDelay(pdMS_TO_TICKS(200));
+        ota_display_update();
+    }
+}
+
+void ota_display_init(void)
+{
+    xTaskCreate(ota_display_task, "ota_disp", 2048, NULL, 3, NULL);
+    ESP_LOGI(TAG, "OTA display task started");
+}

esp32s3/balance/main/ota_display.h

@@ -0,0 +1,33 @@
+#pragma once
+/* ota_display.h — OTA notification UI on GC9A01 round LCD (bd-1yr8)
+ *
+ * GC9A01 240×240 round display via SPI (IO12 CS, IO11 DC, IO10 RST, IO9 BL).
+ * Calls into display_draw_* primitives (provided by display driver layer).
+ * This module owns the "OTA notification overlay" rendered over the HUD.
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "ota_self.h"
+#include "uart_ota.h"
+
+/* ── Display primitives API (must be provided by display driver) ── */
+void display_fill_rect(int x, int y, int w, int h, uint16_t rgb565);
+void display_draw_string(int x, int y, const char *str, uint16_t fg, uint16_t bg);
+void display_draw_arc(int cx, int cy, int r, int start_deg, int end_deg,
+                       int thickness, uint16_t color);
+
+/* ── Colour palette (RGB565) ── */
+#define COL_BG       0x0000u  /* black */
+#define COL_WHITE    0xFFFFu
+#define COL_GREEN    0x07E0u
+#define COL_YELLOW   0xFFE0u
+#define COL_RED      0xF800u
+#define COL_BLUE     0x001Fu
+#define COL_ORANGE   0xFD20u
+
+/* ── OTA display task: runs at 5 Hz, overlays OTA state on HUD ── */
+void ota_display_init(void);
+
+/* Called from main loop or display task to render the OTA overlay */
+void ota_display_update(void);

esp32s3/balance/main/ota_self.c

@@ -0,0 +1,183 @@
+/* ota_self.c — Balance self-OTA (bd-18nb)
+ *
+ * Uses esp_https_ota / esp_ota_ops to download from Gitea release URL,
+ * stream-verify SHA256 with mbedTLS, set new boot partition, and reboot.
+ * CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE in sdkconfig allows auto-rollback
+ * if the new image doesn't call esp_ota_mark_app_valid_cancel_rollback()
+ * within OTA_ROLLBACK_WINDOW_S seconds.
+ */
+
+#include "ota_self.h"
+#include "gitea_ota.h"
+#include "esp_log.h"
+#include "esp_ota_ops.h"
+#include "esp_http_client.h"
+#include "esp_timer.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "mbedtls/sha256.h"
+#include <string.h>
+#include <stdio.h>
+
+static const char *TAG = "ota_self";
+
+volatile ota_self_state_t g_ota_self_state   = OTA_SELF_IDLE;
+volatile uint8_t          g_ota_self_progress = 0;
+
+#define OTA_CHUNK_SIZE  4096
+
+/* ── SHA256 verify helper ── */
+static bool sha256_matches(const uint8_t *digest, const char *expected_hex)
+{
+    if (!expected_hex || expected_hex[0] == '\0') {
+        ESP_LOGW(TAG, "no SHA256 to verify — skipping");
+        return true;
+    }
+    char got[65] = {0};
+    for (int i = 0; i < 32; i++) {
+        snprintf(&got[i*2], 3, "%02x", digest[i]);
+    }
+    bool ok = (strncasecmp(got, expected_hex, 64) == 0);
+    if (!ok) {
+        ESP_LOGE(TAG, "SHA256 mismatch: got=%s exp=%s", got, expected_hex);
+    }
+    return ok;
+}
+
+/* ── OTA download + flash task ── */
+static void ota_self_task(void *arg)
+{
+    const char *url    = g_balance_update.download_url;
+    const char *sha256 = g_balance_update.sha256;
+
+    g_ota_self_state    = OTA_SELF_DOWNLOADING;
+    g_ota_self_progress = 0;
+
+    ESP_LOGI(TAG, "OTA start: %s", url);
+
+    esp_ota_handle_t       handle     = 0;
+    const esp_partition_t *ota_part   = esp_ota_get_next_update_partition(NULL);
+    if (!ota_part) {
+        ESP_LOGE(TAG, "no OTA partition");
+        g_ota_self_state = OTA_SELF_FAILED;
+        vTaskDelete(NULL);
+        return;
+    }
+
+    esp_err_t err = esp_ota_begin(ota_part, OTA_WITH_SEQUENTIAL_WRITES, &handle);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "ota_begin: %s", esp_err_to_name(err));
+        g_ota_self_state = OTA_SELF_FAILED;
+        vTaskDelete(NULL);
+        return;
+    }
+
+    /* Setup HTTP client */
+    esp_http_client_config_t hcfg = {
+        .url        = url,
+        .timeout_ms = 30000,
+        .buffer_size = OTA_CHUNK_SIZE,
+        .skip_cert_common_name_check = true,
+    };
+    esp_http_client_handle_t client = esp_http_client_init(&hcfg);
+    err = esp_http_client_open(client, 0);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "http_open: %s", esp_err_to_name(err));
+        esp_ota_abort(handle);
+        esp_http_client_cleanup(client);
+        g_ota_self_state = OTA_SELF_FAILED;
+        vTaskDelete(NULL);
+        return;
+    }
+
+    int content_len = esp_http_client_fetch_headers(client);
+    ESP_LOGI(TAG, "content-length: %d", content_len);
+
+    mbedtls_sha256_context sha_ctx;
+    mbedtls_sha256_init(&sha_ctx);
+    mbedtls_sha256_starts(&sha_ctx, 0);  /* 0 = SHA-256 */
+
+    static uint8_t buf[OTA_CHUNK_SIZE];
+    int total = 0;
+    int rd;
+    while ((rd = esp_http_client_read(client, (char *)buf, sizeof(buf))) > 0) {
+        mbedtls_sha256_update(&sha_ctx, buf, rd);
+        err = esp_ota_write(handle, buf, rd);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "ota_write: %s", esp_err_to_name(err));
+            esp_ota_abort(handle);
+            goto cleanup;
+        }
+        total += rd;
+        if (content_len > 0) {
+            g_ota_self_progress = (uint8_t)((total * 100) / content_len);
+        }
+    }
+    esp_http_client_close(client);
+
+    /* Verify SHA256 */
+    g_ota_self_state = OTA_SELF_VERIFYING;
+    uint8_t digest[32];
+    mbedtls_sha256_finish(&sha_ctx, digest);
+    if (!sha256_matches(digest, sha256)) {
+        ESP_LOGE(TAG, "SHA256 verification failed");
+        esp_ota_abort(handle);
+        g_ota_self_state = OTA_SELF_FAILED;
+        goto cleanup;
+    }
+
+    /* Finalize + set boot partition */
+    g_ota_self_state = OTA_SELF_APPLYING;
+    err = esp_ota_end(handle);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "ota_end: %s", esp_err_to_name(err));
+        g_ota_self_state = OTA_SELF_FAILED;
+        goto cleanup;
+    }
+
+    err = esp_ota_set_boot_partition(ota_part);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "set_boot_partition: %s", esp_err_to_name(err));
+        g_ota_self_state = OTA_SELF_FAILED;
+        goto cleanup;
+    }
+
+    g_ota_self_state    = OTA_SELF_REBOOTING;
+    g_ota_self_progress = 100;
+    ESP_LOGI(TAG, "OTA success — rebooting");
+    vTaskDelay(pdMS_TO_TICKS(500));
+    esp_restart();
+
+cleanup:
+    mbedtls_sha256_free(&sha_ctx);
+    esp_http_client_cleanup(client);
+    handle = 0;
+    vTaskDelete(NULL);
+}
+
+bool ota_self_trigger(void)
+{
+    if (!g_balance_update.available) {
+        ESP_LOGW(TAG, "no update available");
+        return false;
+    }
+    if (g_ota_self_state != OTA_SELF_IDLE) {
+        ESP_LOGW(TAG, "OTA already in progress (state=%d)", g_ota_self_state);
+        return false;
+    }
+    xTaskCreate(ota_self_task, "ota_self", 8192, NULL, 5, NULL);
+    return true;
+}
+
+void ota_self_health_check(void)
+{
+    /* Mark running image as valid — prevents rollback */
+    esp_err_t err = esp_ota_mark_app_valid_cancel_rollback();
+    if (err == ESP_OK) {
+        ESP_LOGI(TAG, "image marked valid");
+    } else if (err == ESP_ERR_NOT_SUPPORTED) {
+        /* Not an OTA image (e.g., flashed via JTAG) — ignore */
+    } else {
+        ESP_LOGW(TAG, "mark_valid: %s", esp_err_to_name(err));
+    }
+}

esp32s3/balance/main/ota_self.h

@@ -0,0 +1,34 @@
+#pragma once
+/* ota_self.h — Balance self-OTA (bd-18nb)
+ *
+ * Downloads balance-firmware.bin from Gitea release URL to the inactive
+ * OTA partition, verifies SHA256, sets boot partition, reboots.
+ * Auto-rollback if health check not called within ROLLBACK_WINDOW_S seconds.
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define OTA_ROLLBACK_WINDOW_S  30
+
+typedef enum {
+    OTA_SELF_IDLE      = 0,
+    OTA_SELF_CHECKING,    /* (unused — gitea_ota handles this) */
+    OTA_SELF_DOWNLOADING,
+    OTA_SELF_VERIFYING,
+    OTA_SELF_APPLYING,
+    OTA_SELF_REBOOTING,
+    OTA_SELF_FAILED,
+} ota_self_state_t;
+
+extern volatile ota_self_state_t g_ota_self_state;
+extern volatile uint8_t          g_ota_self_progress; /* 0-100 % */
+
+/* Trigger a Balance self-update.
+ * Uses g_balance_update (from gitea_ota). Non-blocking: starts in a task.
+ * Returns false if no update available or OTA already in progress. */
+bool ota_self_trigger(void);
+
+/* Called from app_main after boot to mark the running image as valid.
+ * Must be called within OTA_ROLLBACK_WINDOW_S after boot or rollback fires. */
+void ota_self_health_check(void);

esp32s3/balance/main/uart_ota.c

@@ -0,0 +1,241 @@
+/* uart_ota.c — UART OTA sender: Balance→IO board (bd-21hv)
+ *
+ * Downloads io-firmware.bin from Gitea, then sends to IO board via UART1.
+ * IO board must update itself BEFORE Balance self-update (per spec).
+ */
+
+#include "uart_ota.h"
+#include "gitea_ota.h"
+#include "esp_log.h"
+#include "esp_http_client.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "mbedtls/sha256.h"
+#include <string.h>
+#include <stdio.h>
+
+static const char *TAG = "uart_ota";
+
+volatile uart_ota_send_state_t g_uart_ota_state    = UART_OTA_S_IDLE;
+volatile uint8_t               g_uart_ota_progress  = 0;
+
+/* ── CRC8-SMBUS ── */
+static uint8_t crc8(const uint8_t *d, uint16_t len)
+{
+    uint8_t crc = 0;
+    for (uint16_t i = 0; i < len; i++) {
+        crc ^= d[i];
+        for (uint8_t b = 0; b < 8; b++)
+            crc = (crc & 0x80u) ? (uint8_t)((crc << 1u) ^ 0x07u) : (uint8_t)(crc << 1u);
+    }
+    return crc;
+}
+
+/* ── Build and send one UART OTA frame ── */
+static void send_frame(uint8_t type, uint16_t seq,
+                        const uint8_t *payload, uint16_t plen)
+{
+    /* [TYPE:1][SEQ:2 BE][LEN:2 BE][PAYLOAD][CRC8:1] */
+    uint8_t hdr[5];
+    hdr[0] = type;
+    hdr[1] = (uint8_t)(seq >> 8u);
+    hdr[2] = (uint8_t)(seq);
+    hdr[3] = (uint8_t)(plen >> 8u);
+    hdr[4] = (uint8_t)(plen);
+
+    /* CRC over hdr + payload */
+    uint8_t crc_buf[5 + OTA_UART_CHUNK_SIZE];
+    memcpy(crc_buf, hdr, 5);
+    if (plen > 0 && payload) memcpy(crc_buf + 5, payload, plen);
+    uint8_t crc = crc8(crc_buf, (uint16_t)(5 + plen));
+
+    uart_write_bytes(UART_OTA_PORT, (char *)hdr, 5);
+    if (plen > 0 && payload)
+        uart_write_bytes(UART_OTA_PORT, (char *)payload, plen);
+    uart_write_bytes(UART_OTA_PORT, (char *)&crc, 1);
+}
+
+/* ── Wait for ACK/NACK from IO board ── */
+static bool wait_ack(uint16_t expected_seq)
+{
+    /* Response frame: [TYPE:1][SEQ:2][LEN:2][PAYLOAD][CRC:1] */
+    uint8_t buf[16];
+    int timeout = OTA_UART_ACK_TIMEOUT_MS;
+    int got = 0;
+
+    while (timeout > 0 && got < 6) {
+        int r = uart_read_bytes(UART_OTA_PORT, buf + got, 1, pdMS_TO_TICKS(50));
+        if (r > 0) got++;
+        else timeout -= 50;
+    }
+
+    if (got < 3) return false;
+
+    uint8_t type = buf[0];
+    uint16_t seq = (uint16_t)((buf[1] << 8u) | buf[2]);
+
+    if (type == UART_OTA_ACK && seq == expected_seq) return true;
+    if (type == UART_OTA_NACK) {
+        uint8_t err = (got >= 6) ? buf[5] : 0;
+        ESP_LOGW(TAG, "NACK seq=%u err=%u", seq, err);
+    }
+    return false;
+}
+
+/* ── Download firmware to RAM buffer (max 1.75 MB) ── */
+static uint8_t *download_io_firmware(uint32_t *out_size)
+{
+    const char *url = g_io_update.download_url;
+    ESP_LOGI(TAG, "downloading IO fw: %s", url);
+
+    esp_http_client_config_t cfg = {
+        .url = url, .timeout_ms = 30000,
+        .skip_cert_common_name_check = true,
+    };
+    esp_http_client_handle_t client = esp_http_client_init(&cfg);
+    if (esp_http_client_open(client, 0) != ESP_OK) {
+        esp_http_client_cleanup(client);
+        return NULL;
+    }
+
+    int content_len = esp_http_client_fetch_headers(client);
+    if (content_len <= 0 || content_len > (int)(0x1B0000)) {
+        ESP_LOGE(TAG, "bad content-length: %d", content_len);
+        esp_http_client_cleanup(client);
+        return NULL;
+    }
+
+    uint8_t *buf = malloc(content_len);
+    if (!buf) {
+        ESP_LOGE(TAG, "malloc %d failed", content_len);
+        esp_http_client_cleanup(client);
+        return NULL;
+    }
+
+    int total = 0, rd;
+    while ((rd = esp_http_client_read(client, (char *)buf + total,
+                                       content_len - total)) > 0) {
+        total += rd;
+        g_uart_ota_progress = (uint8_t)((total * 50) / content_len); /* 0-50% for download */
+    }
+    esp_http_client_cleanup(client);
+
+    if (total != content_len) {
+        free(buf);
+        return NULL;
+    }
+    *out_size = (uint32_t)total;
+    return buf;
+}
+
+/* ── UART OTA send task ── */
+static void uart_ota_task(void *arg)
+{
+    g_uart_ota_state    = UART_OTA_S_DOWNLOADING;
+    g_uart_ota_progress = 0;
+
+    uint32_t fw_size = 0;
+    uint8_t *fw = download_io_firmware(&fw_size);
+    if (!fw) {
+        ESP_LOGE(TAG, "download failed");
+        g_uart_ota_state = UART_OTA_S_FAILED;
+        vTaskDelete(NULL);
+        return;
+    }
+
+    /* Compute SHA256 of downloaded firmware */
+    uint8_t digest[32];
+    mbedtls_sha256_context sha;
+    mbedtls_sha256_init(&sha);
+    mbedtls_sha256_starts(&sha, 0);
+    mbedtls_sha256_update(&sha, fw, fw_size);
+    mbedtls_sha256_finish(&sha, digest);
+    mbedtls_sha256_free(&sha);
+
+    g_uart_ota_state = UART_OTA_S_SENDING;
+
+    /* Send OTA_BEGIN: uint32 size + uint8[32] sha256 */
+    uint8_t begin_payload[36];
+    begin_payload[0] = (uint8_t)(fw_size >> 24u);
+    begin_payload[1] = (uint8_t)(fw_size >> 16u);
+    begin_payload[2] = (uint8_t)(fw_size >>  8u);
+    begin_payload[3] = (uint8_t)(fw_size);
+    memcpy(&begin_payload[4], digest, 32);
+
+    for (int retry = 0; retry < OTA_UART_MAX_RETRIES; retry++) {
+        send_frame(UART_OTA_BEGIN, 0, begin_payload, 36);
+        if (wait_ack(0)) goto send_data;
+        ESP_LOGW(TAG, "BEGIN retry %d", retry);
+    }
+    ESP_LOGE(TAG, "BEGIN failed");
+    free(fw);
+    g_uart_ota_state = UART_OTA_S_FAILED;
+    vTaskDelete(NULL);
+    return;
+
+send_data: {
+    uint32_t offset = 0;
+    uint16_t seq    = 1;
+    while (offset < fw_size) {
+        uint16_t chunk = (uint16_t)((fw_size - offset) < OTA_UART_CHUNK_SIZE
+                          ? (fw_size - offset) : OTA_UART_CHUNK_SIZE);
+        bool acked = false;
+        for (int retry = 0; retry < OTA_UART_MAX_RETRIES; retry++) {
+            send_frame(UART_OTA_DATA, seq, fw + offset, chunk);
+            if (wait_ack(seq)) { acked = true; break; }
+            ESP_LOGW(TAG, "DATA seq=%u retry=%d", seq, retry);
+        }
+        if (!acked) {
+            ESP_LOGE(TAG, "DATA seq=%u failed", seq);
+            send_frame(UART_OTA_ABORT, seq, NULL, 0);
+            free(fw);
+            g_uart_ota_state = UART_OTA_S_FAILED;
+            vTaskDelete(NULL);
+            return;
+        }
+        offset += chunk;
+        seq++;
+        /* 50-100% for sending phase */
+        g_uart_ota_progress = (uint8_t)(50u + (offset * 50u) / fw_size);
+    }
+
+    /* Send OTA_END */
+    for (int retry = 0; retry < OTA_UART_MAX_RETRIES; retry++) {
+        send_frame(UART_OTA_END, seq, NULL, 0);
+        if (wait_ack(seq)) break;
+    }
+    }
+
+    free(fw);
+    g_uart_ota_progress = 100;
+    g_uart_ota_state    = UART_OTA_S_DONE;
+    ESP_LOGI(TAG, "IO OTA complete — %lu bytes sent", (unsigned long)fw_size);
+    vTaskDelete(NULL);
+}
+
+bool uart_ota_trigger(void)
+{
+    if (!g_io_update.available) {
+        ESP_LOGW(TAG, "no IO update available");
+        return false;
+    }
+    if (g_uart_ota_state != UART_OTA_S_IDLE) {
+        ESP_LOGW(TAG, "UART OTA busy (state=%d)", g_uart_ota_state);
+        return false;
+    }
+    /* Init UART1 for OTA */
+    uart_config_t ucfg = {
+        .baud_rate  = UART_OTA_BAUD,
+        .data_bits  = UART_DATA_8_BITS,
+        .parity     = UART_PARITY_DISABLE,
+        .stop_bits  = UART_STOP_BITS_1,
+        .flow_ctrl  = UART_HW_FLOWCTRL_DISABLE,
+    };
+    uart_param_config(UART_OTA_PORT, &ucfg);
+    uart_set_pin(UART_OTA_PORT, UART_OTA_TX_GPIO, UART_OTA_RX_GPIO,
+                  UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+    uart_driver_install(UART_OTA_PORT, 2048, 0, 0, NULL, 0);
+
+    xTaskCreate(uart_ota_task, "uart_ota", 16384, NULL, 4, NULL);
+    return true;
+}

esp32s3/balance/main/uart_ota.h

@@ -0,0 +1,64 @@
+#pragma once
+/* uart_ota.h — UART OTA protocol for Balance→IO firmware update (bd-21hv)
+ *
+ * Balance downloads io-firmware.bin from Gitea, then streams it to the IO
+ * board over UART1 (GPIO17/18, 460800 baud) in 1 KB chunks with ACK.
+ *
+ * Protocol frame format (both directions):
+ *   [TYPE:1][SEQ:2 BE][LEN:2 BE][PAYLOAD:LEN][CRC8:1]
+ *   CRC8-SMBUS over TYPE+SEQ+LEN+PAYLOAD.
+ *
+ * Balance→IO:
+ *   OTA_BEGIN  (0xC0) payload: uint32 total_size BE + uint8[32] sha256
+ *   OTA_DATA   (0xC1) payload: uint8[] chunk (up to 1024 bytes)
+ *   OTA_END    (0xC2) no payload
+ *   OTA_ABORT  (0xC3) no payload
+ *
+ * IO→Balance:
+ *   OTA_ACK    (0xC4) payload: uint16 acked_seq BE
+ *   OTA_NACK   (0xC5) payload: uint16 failed_seq BE + uint8 err_code
+ *   OTA_STATUS (0xC6) payload: uint8 state + uint8 progress%
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* UART for Balance→IO OTA */
+#include "driver/uart.h"
+#define UART_OTA_PORT       UART_NUM_1
+#define UART_OTA_BAUD       460800
+#define UART_OTA_TX_GPIO    17
+#define UART_OTA_RX_GPIO    18
+
+#define OTA_UART_CHUNK_SIZE  1024
+#define OTA_UART_ACK_TIMEOUT_MS  3000
+#define OTA_UART_MAX_RETRIES     3
+
+/* Frame type bytes */
+#define UART_OTA_BEGIN   0xC0u
+#define UART_OTA_DATA    0xC1u
+#define UART_OTA_END     0xC2u
+#define UART_OTA_ABORT   0xC3u
+#define UART_OTA_ACK     0xC4u
+#define UART_OTA_NACK    0xC5u
+#define UART_OTA_STATUS  0xC6u
+
+/* NACK error codes */
+#define OTA_ERR_BAD_CRC  0x01u
+#define OTA_ERR_WRITE    0x02u
+#define OTA_ERR_SIZE     0x03u
+
+typedef enum {
+    UART_OTA_S_IDLE        = 0,
+    UART_OTA_S_DOWNLOADING,  /* downloading from Gitea */
+    UART_OTA_S_SENDING,      /* sending to IO board */
+    UART_OTA_S_DONE,
+    UART_OTA_S_FAILED,
+} uart_ota_send_state_t;
+
+extern volatile uart_ota_send_state_t g_uart_ota_state;
+extern volatile uint8_t               g_uart_ota_progress;
+
+/* Trigger IO firmware update. Uses g_io_update (from gitea_ota).
+ * Downloads bin, then streams via UART. Returns false if busy or no update. */
+bool uart_ota_trigger(void);

esp32s3/balance/main/version.h

@@ -0,0 +1,14 @@
+#pragma once
+/* Embedded firmware version — bump on each release */
+#define BALANCE_FW_VERSION      "1.0.0"
+#define IO_FW_VERSION           "1.0.0"
+
+/* Gitea release tag prefixes */
+#define BALANCE_TAG_PREFIX      "esp32-balance/"
+#define IO_TAG_PREFIX           "esp32-io/"
+
+/* Gitea release asset filenames */
+#define BALANCE_BIN_ASSET       "balance-firmware.bin"
+#define IO_BIN_ASSET            "io-firmware.bin"
+#define BALANCE_SHA256_ASSET    "balance-firmware.sha256"
+#define IO_SHA256_ASSET         "io-firmware.sha256"

esp32s3/balance/main/vesc_can.c

@@ -0,0 +1,119 @@
+/* vesc_can.c — VESC CAN TWAI driver (bd-66hx)
+ *
+ * Receives VESC STATUS/4/5 frames via TWAI, proxies to Orin over serial.
+ * Transmits SET_RPM commands from Orin drive requests.
+ */
+
+#include "vesc_can.h"
+#include "orin_serial.h"
+#include "config.h"
+#include "driver/twai.h"
+#include "esp_log.h"
+#include "esp_timer.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <string.h>
+
+static const char *TAG = "vesc_can";
+
+vesc_state_t g_vesc[2] = {0};
+
+/* Index for a given VESC node ID: 0=VESC_ID_A, 1=VESC_ID_B */
+static int vesc_idx(uint8_t id)
+{
+    if (id == VESC_ID_A) return 0;
+    if (id == VESC_ID_B) return 1;
+    return -1;
+}
+
+void vesc_can_init(void)
+{
+    twai_general_config_t gcfg = TWAI_GENERAL_CONFIG_DEFAULT(
+        (gpio_num_t)VESC_CAN_TX_GPIO,
+        (gpio_num_t)VESC_CAN_RX_GPIO,
+        TWAI_MODE_NORMAL);
+    gcfg.rx_queue_len = VESC_CAN_RX_QUEUE;
+
+    twai_timing_config_t  tcfg = TWAI_TIMING_CONFIG_500KBITS();
+    twai_filter_config_t  fcfg = TWAI_FILTER_CONFIG_ACCEPT_ALL();
+
+    ESP_ERROR_CHECK(twai_driver_install(&gcfg, &tcfg, &fcfg));
+    ESP_ERROR_CHECK(twai_start());
+    ESP_LOGI(TAG, "TWAI init OK: tx=%d rx=%d 500kbps", VESC_CAN_TX_GPIO, VESC_CAN_RX_GPIO);
+}
+
+void vesc_can_send_rpm(uint8_t vesc_id, int32_t erpm)
+{
+    uint32_t ext_id = ((uint32_t)VESC_PKT_SET_RPM << 8u) | vesc_id;
+    twai_message_t msg = {
+        .extd            = 1,
+        .identifier      = ext_id,
+        .data_length_code = 4,
+    };
+    uint32_t u = (uint32_t)erpm;
+    msg.data[0] = (uint8_t)(u >> 24u);
+    msg.data[1] = (uint8_t)(u >> 16u);
+    msg.data[2] = (uint8_t)(u >>  8u);
+    msg.data[3] = (uint8_t)(u);
+    twai_transmit(&msg, pdMS_TO_TICKS(5));
+}
+
+void vesc_can_rx_task(void *arg)
+{
+    QueueHandle_t tx_q = (QueueHandle_t)arg;
+    twai_message_t msg;
+
+    for (;;) {
+        if (twai_receive(&msg, pdMS_TO_TICKS(50)) != ESP_OK) {
+            continue;
+        }
+        if (!msg.extd) {
+            continue;  /* ignore standard frames */
+        }
+
+        uint8_t pkt_type = (uint8_t)(msg.identifier >> 8u);
+        uint8_t vesc_id  = (uint8_t)(msg.identifier & 0xFFu);
+        int idx = vesc_idx(vesc_id);
+        if (idx < 0) {
+            continue;  /* not our VESC */
+        }
+
+        uint32_t now_ms = (uint32_t)(esp_timer_get_time() / 1000LL);
+        vesc_state_t *s = &g_vesc[idx];
+
+        switch (pkt_type) {
+        case VESC_PKT_STATUS:
+            if (msg.data_length_code < 8u) { break; }
+            s->erpm = (int32_t)(
+                ((uint32_t)msg.data[0] << 24u) | ((uint32_t)msg.data[1] << 16u) |
+                ((uint32_t)msg.data[2] <<  8u) |  (uint32_t)msg.data[3]);
+            s->current_x10 = (int16_t)(((uint16_t)msg.data[4] << 8u) | msg.data[5]);
+            s->last_rx_ms  = now_ms;
+            /* Proxy to Orin: voltage from STATUS_5 (may be zero until received) */
+            {
+                uint8_t ttype = (vesc_id == VESC_ID_A) ? TELEM_VESC_LEFT : TELEM_VESC_RIGHT;
+                /* voltage_mv: V×10 → mV (/10 * 1000 = *100); current_ma: A×10 → mA (*100) */
+                uint16_t vmv = (uint16_t)((int32_t)s->voltage_x10 * 100);
+                int16_t  ima = (int16_t)((int32_t)s->current_x10 * 100);
+                orin_send_vesc(tx_q, ttype, s->erpm, vmv, ima,
+                               (uint16_t)s->temp_mot_x10);
+            }
+            break;
+
+        case VESC_PKT_STATUS_4:
+            if (msg.data_length_code < 6u) { break; }
+            /* T_fet×10, T_mot×10, I_in×10 */
+            s->temp_mot_x10 = (int16_t)(((uint16_t)msg.data[2] << 8u) | msg.data[3]);
+            break;
+
+        case VESC_PKT_STATUS_5:
+            if (msg.data_length_code < 6u) { break; }
+            /* int32 tacho (ignored), int16 V_in×10 */
+            s->voltage_x10 = (int16_t)(((uint16_t)msg.data[4] << 8u) | msg.data[5]);
+            break;
+
+        default:
+            break;
+        }
+    }
+}

esp32s3/balance/main/vesc_can.h

@@ -0,0 +1,36 @@
+#pragma once
+/* vesc_can.h — VESC CAN TWAI driver for ESP32-S3 BALANCE (bd-66hx)
+ *
+ * VESC extended CAN ID: (packet_type << 8) | vesc_node_id
+ * Physical layer: TWAI peripheral → SN65HVD230 → 500 kbps shared bus
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+
+/* ── VESC packet types ── */
+#define VESC_PKT_SET_RPM    3u
+#define VESC_PKT_STATUS     9u    /* int32 erpm, int16 I×10, int16 duty×1000 */
+#define VESC_PKT_STATUS_4   16u   /* int16 T_fet×10, T_mot×10, I_in×10 */
+#define VESC_PKT_STATUS_5   27u   /* int32 tacho, int16 V_in×10 */
+
+/* ── VESC telemetry snapshot ── */
+typedef struct {
+    int32_t  erpm;          /* electrical RPM (STATUS) */
+    int16_t  current_x10;   /* phase current A×10 (STATUS) */
+    int16_t  voltage_x10;   /* bus voltage V×10 (STATUS_5) */
+    int16_t  temp_mot_x10;  /* motor temp °C×10 (STATUS_4) */
+    uint32_t last_rx_ms;    /* esp_timer ms of last STATUS frame */
+} vesc_state_t;
+
+/* ── Globals (two VESC nodes: index 0 = VESC_ID_A=56, 1 = VESC_ID_B=68) ── */
+extern vesc_state_t g_vesc[2];
+
+/* ── API ── */
+void vesc_can_init(void);
+void vesc_can_send_rpm(uint8_t vesc_id, int32_t erpm);
+
+/* RX task — pass tx_queue as arg; forwards STATUS frames to Orin over serial */
+void vesc_can_rx_task(void *arg);   /* arg = QueueHandle_t orin_tx_queue */

esp32s3/balance/partitions.csv

@@ -0,0 +1,7 @@
+# ESP32-S3 BALANCE — 4 MB flash, dual OTA partitions
+# Name,     Type,  SubType,  Offset,    Size
+nvs,        data,  nvs,      0x9000,    0x5000,
+otadata,    data,  ota,      0xe000,    0x2000,
+app0,       app,   ota_0,    0x10000,   0x1B0000,
+app1,       app,   ota_1,    0x1C0000,  0x1B0000,
+nvs_user,   data,  nvs,      0x370000,  0x50000,

esp32s3/balance/sdkconfig.defaults

@@ -0,0 +1,19 @@
+CONFIG_IDF_TARGET="esp32s3"
+CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
+CONFIG_FREERTOS_HZ=1000
+CONFIG_ESP_TASK_WDT_EN=y
+CONFIG_ESP_TASK_WDT_TIMEOUT_S=5
+CONFIG_TWAI_ISR_IN_IRAM=y
+CONFIG_UART_ISR_IN_IRAM=y
+CONFIG_ESP_CONSOLE_UART_DEFAULT=y
+CONFIG_ESP_CONSOLE_UART_NUM=0
+CONFIG_ESP_CONSOLE_UART_BAUDRATE=115200
+CONFIG_LOG_DEFAULT_LEVEL_INFO=y
+
+# OTA — bd-3gwo: dual OTA partitions + rollback
+CONFIG_PARTITION_TABLE_CUSTOM=y
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
+CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y
+CONFIG_OTA_ALLOW_HTTP=y
+CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP=y
+CONFIG_MBEDTLS_CERTIFICATE_BUNDLE=y

esp32s3/io/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.16)
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(esp32s3_io)

esp32s3/io/main/CMakeLists.txt

@@ -0,0 +1,10 @@
+idf_component_register(
+    SRCS "main.c" "uart_ota_recv.c"
+    INCLUDE_DIRS "."
+    REQUIRES
+        app_update
+        mbedtls
+        driver
+        freertos
+        esp_timer
+)

esp32s3/io/main/config.h

@@ -0,0 +1,35 @@
+#pragma once
+/* ESP32-S3 IO board — pin assignments (SAUL-TEE-SYSTEM-REFERENCE.md) */
+
+/* ── Inter-board UART (to/from BALANCE board) ── */
+#define IO_UART_PORT        UART_NUM_0
+#define IO_UART_BAUD        460800
+#define IO_UART_TX_GPIO     43   /* IO board UART0_TXD → BALANCE RX */
+#define IO_UART_RX_GPIO     44   /* IO board UART0_RXD ← BALANCE TX */
+/* Note: SAUL-TEE spec says IO TX=IO18, RX=IO21; BALANCE TX=IO17, RX=IO18.
+ * This is UART0 on the IO devkit (GPIO43/44). Adjust to match actual wiring. */
+
+/* ── BTS7960 Left motor driver ── */
+#define MOTOR_L_RPWM    1
+#define MOTOR_L_LPWM    2
+#define MOTOR_L_EN_R    3
+#define MOTOR_L_EN_L    4
+
+/* ── BTS7960 Right motor driver ── */
+#define MOTOR_R_RPWM    5
+#define MOTOR_R_LPWM    6
+#define MOTOR_R_EN_R    7
+#define MOTOR_R_EN_L    8
+
+/* ── Arming button / kill switch ── */
+#define ARM_BTN_GPIO    9
+#define KILL_GPIO       10
+
+/* ── WS2812B LED strip ── */
+#define LED_DATA_GPIO   13
+
+/* ── OTA UART — receives firmware from BALANCE (bd-21hv) ── */
+/* Uses same IO_UART_PORT since Balance drives OTA over the inter-board link */
+
+/* ── Firmware version ── */
+#define IO_FW_VERSION   "1.0.0"

esp32s3/io/main/main.c

@@ -0,0 +1,42 @@
+/* main.c — ESP32-S3 IO board app_main */
+
+#include "uart_ota_recv.h"
+#include "config.h"
+#include "esp_log.h"
+#include "esp_ota_ops.h"
+#include "driver/uart.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+static const char *TAG = "io_main";
+
+static void uart_init(void)
+{
+    uart_config_t cfg = {
+        .baud_rate  = IO_UART_BAUD,
+        .data_bits  = UART_DATA_8_BITS,
+        .parity     = UART_PARITY_DISABLE,
+        .stop_bits  = UART_STOP_BITS_1,
+        .flow_ctrl  = UART_HW_FLOWCTRL_DISABLE,
+    };
+    uart_param_config(IO_UART_PORT, &cfg);
+    uart_set_pin(IO_UART_PORT, IO_UART_TX_GPIO, IO_UART_RX_GPIO,
+                  UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
+    uart_driver_install(IO_UART_PORT, 4096, 0, 0, NULL, 0);
+}
+
+void app_main(void)
+{
+    ESP_LOGI(TAG, "ESP32-S3 IO v%s starting", IO_FW_VERSION);
+
+    /* Mark running image valid (OTA rollback support) */
+    esp_ota_mark_app_valid_cancel_rollback();
+
+    uart_init();
+    uart_ota_recv_init();
+
+    /* IO board main loop placeholder — RC/motor/sensor tasks added in later beads */
+    while (1) {
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}

esp32s3/io/main/uart_ota_recv.c

@@ -0,0 +1,210 @@
+/* uart_ota_recv.c — IO board OTA receiver (bd-21hv)
+ *
+ * Listens on UART0 for OTA frames from Balance board.
+ * Writes incoming chunks to the inactive OTA partition, verifies SHA256,
+ * then reboots into new firmware.
+ */
+
+#include "uart_ota_recv.h"
+#include "config.h"
+#include "esp_log.h"
+#include "esp_ota_ops.h"
+#include "driver/uart.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "mbedtls/sha256.h"
+#include <string.h>
+
+static const char *TAG = "io_ota";
+
+volatile io_ota_state_t g_io_ota_state    = IO_OTA_IDLE;
+volatile uint8_t        g_io_ota_progress = 0;
+
+/* Frame type bytes (same as uart_ota.h sender side) */
+#define OTA_BEGIN   0xC0u
+#define OTA_DATA    0xC1u
+#define OTA_END     0xC2u
+#define OTA_ABORT   0xC3u
+#define OTA_ACK     0xC4u
+#define OTA_NACK    0xC5u
+
+#define CHUNK_MAX   1024
+
+static uint8_t crc8(const uint8_t *d, uint16_t len)
+{
+    uint8_t crc = 0;
+    for (uint16_t i = 0; i < len; i++) {
+        crc ^= d[i];
+        for (uint8_t b = 0; b < 8; b++)
+            crc = (crc & 0x80u) ? (uint8_t)((crc << 1u) ^ 0x07u) : (uint8_t)(crc << 1u);
+    }
+    return crc;
+}
+
+static void send_ack(uint16_t seq)
+{
+    uint8_t frame[6];
+    frame[0] = OTA_ACK;
+    frame[1] = (uint8_t)(seq >> 8u);
+    frame[2] = (uint8_t)(seq);
+    frame[3] = 0; frame[4] = 0;  /* LEN=0 */
+    uint8_t crc = crc8(frame, 5);
+    frame[5] = crc;
+    uart_write_bytes(IO_UART_PORT, (char *)frame, 6);
+}
+
+static void send_nack(uint16_t seq, uint8_t err)
+{
+    uint8_t frame[8];
+    frame[0] = OTA_NACK;
+    frame[1] = (uint8_t)(seq >> 8u);
+    frame[2] = (uint8_t)(seq);
+    frame[3] = 0; frame[4] = 1;  /* LEN=1 */
+    frame[5] = err;
+    uint8_t crc = crc8(frame, 6);
+    frame[6] = crc;
+    uart_write_bytes(IO_UART_PORT, (char *)frame, 7);
+}
+
+/* Read exact n bytes with timeout */
+static bool uart_read_exact(uint8_t *buf, int n, int timeout_ms)
+{
+    int got = 0;
+    while (got < n && timeout_ms > 0) {
+        int r = uart_read_bytes(IO_UART_PORT, buf + got, n - got,
+                                pdMS_TO_TICKS(50));
+        if (r > 0) got += r;
+        else timeout_ms -= 50;
+    }
+    return got == n;
+}
+
+static void ota_recv_task(void *arg)
+{
+    esp_ota_handle_t       handle    = 0;
+    const esp_partition_t *ota_part  = esp_ota_get_next_update_partition(NULL);
+    mbedtls_sha256_context sha;
+    mbedtls_sha256_init(&sha);
+    uint32_t expected_size = 0;
+    uint8_t  expected_digest[32] = {0};
+    uint32_t received = 0;
+    bool     ota_started = false;
+    static uint8_t payload[CHUNK_MAX];
+
+    for (;;) {
+        /* Read frame header: TYPE(1) + SEQ(2) + LEN(2) = 5 bytes */
+        uint8_t hdr[5];
+        if (!uart_read_exact(hdr, 5, 5000)) continue;
+
+        uint8_t  type = hdr[0];
+        uint16_t seq  = (uint16_t)((hdr[1] << 8u) | hdr[2]);
+        uint16_t plen = (uint16_t)((hdr[3] << 8u) | hdr[4]);
+
+        if (plen > CHUNK_MAX + 36) {
+            ESP_LOGW(TAG, "oversized frame plen=%u", plen);
+            continue;
+        }
+
+        /* Read payload + CRC */
+        if (plen > 0 && !uart_read_exact(payload, plen, 2000)) continue;
+        uint8_t crc_rx;
+        if (!uart_read_exact(&crc_rx, 1, 500)) continue;
+
+        /* Verify CRC over hdr+payload */
+        uint8_t crc_buf[5 + CHUNK_MAX + 36];
+        memcpy(crc_buf, hdr, 5);
+        if (plen > 0) memcpy(crc_buf + 5, payload, plen);
+        uint8_t expected_crc = crc8(crc_buf, (uint16_t)(5 + plen));
+        if (crc_rx != expected_crc) {
+            ESP_LOGW(TAG, "CRC fail seq=%u", seq);
+            send_nack(seq, 0x01u);  /* OTA_ERR_BAD_CRC */
+            continue;
+        }
+
+        switch (type) {
+        case OTA_BEGIN:
+            if (plen < 36) { send_nack(seq, 0x03u); break; }
+            expected_size = ((uint32_t)payload[0] << 24u) |
+                            ((uint32_t)payload[1] << 16u) |
+                            ((uint32_t)payload[2] <<  8u) |
+                             (uint32_t)payload[3];
+            memcpy(expected_digest, &payload[4], 32);
+
+            if (!ota_part || esp_ota_begin(ota_part, OTA_WITH_SEQUENTIAL_WRITES,
+                                            &handle) != ESP_OK) {
+                send_nack(seq, 0x02u);
+                break;
+            }
+            mbedtls_sha256_starts(&sha, 0);
+            received   = 0;
+            ota_started = true;
+            g_io_ota_state    = IO_OTA_RECEIVING;
+            g_io_ota_progress = 0;
+            ESP_LOGI(TAG, "OTA begin: %lu bytes", (unsigned long)expected_size);
+            send_ack(seq);
+            break;
+
+        case OTA_DATA:
+            if (!ota_started) { send_nack(seq, 0x02u); break; }
+            if (esp_ota_write(handle, payload, plen) != ESP_OK) {
+                send_nack(seq, 0x02u);
+                esp_ota_abort(handle);
+                ota_started = false;
+                g_io_ota_state = IO_OTA_FAILED;
+                break;
+            }
+            mbedtls_sha256_update(&sha, payload, plen);
+            received += plen;
+            if (expected_size > 0)
+                g_io_ota_progress = (uint8_t)((received * 100u) / expected_size);
+            send_ack(seq);
+            break;
+
+        case OTA_END: {
+            if (!ota_started) { send_nack(seq, 0x02u); break; }
+            g_io_ota_state = IO_OTA_VERIFYING;
+
+            uint8_t digest[32];
+            mbedtls_sha256_finish(&sha, digest);
+            if (memcmp(digest, expected_digest, 32) != 0) {
+                ESP_LOGE(TAG, "SHA256 mismatch");
+                esp_ota_abort(handle);
+                send_nack(seq, 0x01u);
+                g_io_ota_state = IO_OTA_FAILED;
+                break;
+            }
+
+            if (esp_ota_end(handle) != ESP_OK ||
+                esp_ota_set_boot_partition(ota_part) != ESP_OK) {
+                send_nack(seq, 0x02u);
+                g_io_ota_state = IO_OTA_FAILED;
+                break;
+            }
+
+            g_io_ota_state    = IO_OTA_REBOOTING;
+            g_io_ota_progress = 100;
+            ESP_LOGI(TAG, "OTA done — rebooting");
+            send_ack(seq);
+            vTaskDelay(pdMS_TO_TICKS(500));
+            esp_restart();
+            break;
+        }
+
+        case OTA_ABORT:
+            if (ota_started) { esp_ota_abort(handle); ota_started = false; }
+            g_io_ota_state = IO_OTA_IDLE;
+            ESP_LOGW(TAG, "OTA aborted");
+            break;
+
+        default:
+            break;
+        }
+    }
+}
+
+void uart_ota_recv_init(void)
+{
+    /* UART0 already initialized for inter-board comms; just create the task */
+    xTaskCreate(ota_recv_task, "io_ota_recv", 8192, NULL, 6, NULL);
+    ESP_LOGI(TAG, "OTA receiver task started");
+}

esp32s3/io/main/uart_ota_recv.h

@@ -0,0 +1,20 @@
+#pragma once
+/* uart_ota_recv.h — IO board: receives OTA firmware from Balance (bd-21hv) */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef enum {
+    IO_OTA_IDLE       = 0,
+    IO_OTA_RECEIVING,
+    IO_OTA_VERIFYING,
+    IO_OTA_APPLYING,
+    IO_OTA_REBOOTING,
+    IO_OTA_FAILED,
+} io_ota_state_t;
+
+extern volatile io_ota_state_t g_io_ota_state;
+extern volatile uint8_t        g_io_ota_progress;
+
+/* Start listening for OTA frames on UART0 */
+void uart_ota_recv_init(void);

esp32s3/io/partitions.csv

@@ -0,0 +1,7 @@
+# ESP32-S3 IO — 4 MB flash, dual OTA partitions
+# Name,     Type,  SubType,  Offset,    Size
+nvs,        data,  nvs,      0x9000,    0x5000,
+otadata,    data,  ota,      0xe000,    0x2000,
+app0,       app,   ota_0,    0x10000,   0x1B0000,
+app1,       app,   ota_1,    0x1C0000,  0x1B0000,
+nvs_user,   data,  nvs,      0x370000,  0x50000,

esp32s3/io/sdkconfig.defaults

@@ -0,0 +1,13 @@
+CONFIG_IDF_TARGET="esp32s3"
+CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
+CONFIG_FREERTOS_HZ=1000
+CONFIG_ESP_TASK_WDT_EN=y
+CONFIG_ESP_TASK_WDT_TIMEOUT_S=5
+CONFIG_UART_ISR_IN_IRAM=y
+CONFIG_ESP_CONSOLE_UART_DEFAULT=y
+CONFIG_LOG_DEFAULT_LEVEL_INFO=y
+
+# OTA — bd-3gwo: dual OTA partitions + rollback
+CONFIG_PARTITION_TABLE_CUSTOM=y
+CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
+CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y

include/can_driver.h

@@ -1,101 +0,0 @@
-#ifndef CAN_DRIVER_H
-#define CAN_DRIVER_H
-
-#include <stdint.h>
-#include <stdbool.h>
-
-/* CAN bus driver for BLDC motor controllers (Issue #597)
- * CAN1 on PB8 (RX, AF9) / PB9 (TX, AF9) at 500 kbps   (Issue #676 remap)
- * APB1 = 54 MHz: PSC=6, BS1=13tq, BS2=4tq, SJW=1tq → 18 tq/bit = 500 kbps
- */
-
-/* Node IDs */
-#define CAN_NUM_MOTORS          2u
-#define CAN_NODE_LEFT           0u
-#define CAN_NODE_RIGHT          1u
-
-/* CAN frame IDs */
-#define CAN_ID_VEL_CMD_BASE     0x100u   /* TX: 0x100 + node_id — velocity/torque command */
-#define CAN_ID_ENABLE_CMD_BASE  0x110u   /* TX: 0x110 + node_id — enable/disable */
-#define CAN_ID_FEEDBACK_BASE    0x200u   /* RX: 0x200 + node_id — position/velocity/current */
-
-/* Filter: accept standard IDs 0x200–0x21F */
-#define CAN_FILTER_STDID        0x200u
-#define CAN_FILTER_MASK         0x7E0u
-
-/* Bit timing (500 kbps @ 54 MHz APB1) */
-#define CAN_PRESCALER           6u
-
-/* TX rate */
-#define CAN_TX_RATE_HZ          100u
-
-/* Node alive timeout */
-#define CAN_NODE_TIMEOUT_MS     100u
-
-/* TX command frame (8 bytes payload, DLC=4 for vel cmd) */
-typedef struct {
-    int16_t velocity_rpm;   /* target RPM (+/- = fwd/rev) */
-    int16_t torque_x100;    /* torque limit × 100 (0 = unlimited) */
-} can_cmd_t;
-
-/* RX feedback frame (DLC=8) */
-typedef struct {
-    int16_t  velocity_rpm;      /* actual RPM */
-    int16_t  current_ma;        /* phase current in mA */
-    int16_t  position_x100;     /* position × 100 (degrees or encoder counts) */
-    int8_t   temperature_c;     /* controller temperature °C */
-    uint8_t  fault;             /* fault flags (0 = healthy) */
-    uint32_t last_rx_ms;        /* HAL_GetTick() at last valid frame */
-} can_feedback_t;
-
-/* Bus statistics */
-typedef struct {
-    uint32_t tx_count;   /* frames transmitted */
-    uint32_t rx_count;   /* frames received */
-    uint16_t err_count;  /* HAL-level errors */
-    uint8_t  bus_off;    /* 1 = bus-off state */
-    uint8_t  _pad;
-} can_stats_t;
-
-/* Initialise CAN2 peripheral, GPIO, and filter bank 14 */
-void can_driver_init(void);
-
-/* Send velocity+torque command to one node */
-void can_driver_send_cmd(uint8_t node_id, const can_cmd_t *cmd);
-
-/* Send enable/disable command to one node */
-void can_driver_send_enable(uint8_t node_id, bool enable);
-
-/* Copy latest feedback snapshot (returns false if node never heard from) */
-bool can_driver_get_feedback(uint8_t node_id, can_feedback_t *out);
-
-/* Returns true if node has been heard within CAN_NODE_TIMEOUT_MS */
-bool can_driver_is_alive(uint8_t node_id, uint32_t now_ms);
-
-/* Copy bus statistics snapshot */
-void can_driver_get_stats(can_stats_t *out);
-
-/* Drain RX FIFO0; call every main-loop tick */
-void can_driver_process(void);
-
-/* ---- Extended / standard frame support (Issue #674) ---- */
-
-/* Callback for extended-ID (29-bit) frames arriving in FIFO1 (VESC STATUS) */
-typedef void (*can_ext_frame_cb_t)(uint32_t ext_id, const uint8_t *data, uint8_t len);
-
-/* Callback for standard-ID (11-bit) frames arriving in FIFO0 (Orin commands) */
-typedef void (*can_std_frame_cb_t)(uint16_t std_id, const uint8_t *data, uint8_t len);
-
-/* Register callback for 29-bit extended frames (register before can_driver_init) */
-void can_driver_set_ext_cb(can_ext_frame_cb_t cb);
-
-/* Register callback for 11-bit standard frames (register before can_driver_init) */
-void can_driver_set_std_cb(can_std_frame_cb_t cb);
-
-/* Transmit a 29-bit extended-ID data frame (VESC RPM/current commands) */
-void can_driver_send_ext(uint32_t ext_id, const uint8_t *data, uint8_t len);
-
-/* Transmit an 11-bit standard-ID data frame (Orin telemetry broadcast) */
-void can_driver_send_std(uint16_t std_id, const uint8_t *data, uint8_t len);
-
-#endif /* CAN_DRIVER_H */

jetson/Dockerfile

@@ -2,7 +2,7 @@
 # Base: JetPack 6 (L4T R36.2.0) + CUDA 12.x / Ubuntu 22.04
 #
 # Hardware: Jetson Orin Nano Super 8GB (67 TOPS, 1024-core Ampere)
-# Previous: Jetson Nano 4GB (JetPack 4.6 / L4T R32.6.1) — see git history
+# Previous: Jetson Orin Nano Super 4GB (JetPack 4.6 / L4T R32.6.1) — see git history
 
 FROM nvcr.io/nvidia/l4t-jetpack:r36.2.0
 

jetson/README.md

@@ -1,12 +1,12 @@
-# Jetson Nano — AI/SLAM Platform Setup
+# Jetson Orin Nano Super — AI/SLAM Platform Setup
 
-Self-balancing robot: Jetson Nano dev environment for ROS2 Humble + SLAM stack.
+Self-balancing robot: Jetson Orin Nano Super dev environment for ROS2 Humble + SLAM stack.
 
 ## Stack
 
 | Component | Version / Part |
 |-----------|---------------|
-| Platform | Jetson Nano 4GB |
+| Platform | Jetson Orin Nano Super 4GB |
 | JetPack | 4.6 (L4T R32.6.1, CUDA 10.2) |
 | ROS2 | Humble Hawksbill |
 | DDS | CycloneDDS |
@@ -14,7 +14,11 @@ Self-balancing robot: Jetson Nano dev environment for ROS2 Humble + SLAM stack.
 | Nav | Nav2 |
 | Depth camera | Intel RealSense D435i |
 | LiDAR | RPLIDAR A1M8 |
-| MCU bridge | STM32F722 (USB CDC @ 921600) |
+<<<<<<< HEAD
+| MCU bridge | ESP32 (USB CDC @ 921600) |
+=======
+| MCU bridge | ESP32-S3 (USB Serial (CH343) @ 921600) |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ## Quick Start
 
@@ -42,7 +46,11 @@ bash scripts/build-and-run.sh shell
 ```
 jetson/
 ├── Dockerfile              # L4T base + ROS2 Humble + SLAM packages
-├── docker-compose.yml      # Multi-service stack (ROS2, RPLIDAR, D435i, STM32)
+<<<<<<< HEAD
+├── docker-compose.yml      # Multi-service stack (ROS2, RPLIDAR, D435i, ESP32 BALANCE)
+=======
+├── docker-compose.yml      # Multi-service stack (ROS2, RPLIDAR, D435i, ESP32-S3)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 ├── README.md               # This file
 ├── docs/
 │   ├── pinout.md           # GPIO/I2C/UART pinout reference

jetson/config/RECOVERY_BEHAVIORS.md

@@ -34,7 +34,11 @@ Recovery behaviors are triggered when Nav2 encounters navigation failures (path
 
 The emergency stop system (Issue #459, `saltybot_emergency` package) runs independently of Nav2 and takes absolute priority.
 
-Recovery behaviors cannot interfere with E-stop because the emergency system operates at the motor driver level on the STM32 firmware.
+<<<<<<< HEAD
+Recovery behaviors cannot interfere with E-stop because the emergency system operates at the motor driver level on the ESP32 BALANCE firmware.
+=======
+Recovery behaviors cannot interfere with E-stop because the emergency system operates at the motor driver level on the ESP32-S3 firmware.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ## Behavior Tree Sequence
 

jetson/config/nav2_params.yaml

@@ -12,7 +12,11 @@
 #   /scan                    — RPLIDAR A1M8  (obstacle layer)
 #   /camera/depth/color/points — RealSense D435i (voxel layer)
 #
-# Output: /cmd_vel (Twist) — STM32 bridge consumes this topic.
+<<<<<<< HEAD
+# Output: /cmd_vel (Twist) — ESP32 bridge consumes this topic.
+=======
+# Output: /cmd_vel (Twist) — ESP32-S3 bridge consumes this topic.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 bt_navigator:
   ros__parameters:

jetson/docker-compose.yml

@@ -31,7 +31,7 @@ services:
       - ./config:/config:ro
     devices:
       - /dev/rplidar:/dev/rplidar
-      - /dev/stm32-bridge:/dev/stm32-bridge
+      - /dev/esp32-bridge:/dev/esp32-bridge
       - /dev/bus/usb:/dev/bus/usb
       - /dev/i2c-7:/dev/i2c-7
       - /dev/video0:/dev/video0
@@ -97,13 +97,17 @@ services:
           rgb_camera.profile:=640x480x30
       "
 
-  # ── STM32 bridge node (bidirectional serial<->ROS2) ────────────────────────
-  stm32-bridge:
+<<<<<<< HEAD
+  # ── ESP32 bridge node (bidirectional serial<->ROS2) ────────────────────────
+=======
+  # ── ESP32-S3 bridge node (bidirectional serial<->ROS2) ────────────────────────
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
+  esp32-bridge:
     image: saltybot/ros2-humble:jetson-orin
     build:
       context: .
       dockerfile: Dockerfile
-    container_name: saltybot-stm32-bridge
+    container_name: saltybot-esp32-bridge
     restart: unless-stopped
     runtime: nvidia
     network_mode: host
@@ -111,13 +115,13 @@ services:
       - ROS_DOMAIN_ID=42
       - RMW_IMPLEMENTATION=rmw_cyclonedds_cpp
     devices:
-      - /dev/stm32-bridge:/dev/stm32-bridge
+      - /dev/esp32-bridge:/dev/esp32-bridge
     command: >
       bash -c "
         source /opt/ros/humble/setup.bash &&
         ros2 launch saltybot_bridge bridge.launch.py
           mode:=bidirectional
-          serial_port:=/dev/stm32-bridge
+          serial_port:=/dev/esp32-bridge
       "
 
   # ── 4x IMX219 CSI cameras ──────────────────────────────────────────────────
@@ -192,7 +196,7 @@ services:
     network_mode: host
     depends_on:
       - saltybot-ros2
-      - stm32-bridge
+      - esp32-bridge
       - csi-cameras
     environment:
       - ROS_DOMAIN_ID=42
@@ -208,8 +212,13 @@ services:
       "
 
 
-  # -- Remote e-stop bridge (MQTT over 4G -> STM32 CDC) ----------------------
-  # Subscribes to saltybot/estop MQTT topic. {"kill":true} -> 'E\r\n' to STM32.
+<<<<<<< HEAD
+  # -- Remote e-stop bridge (MQTT over 4G -> ESP32 CDC) ----------------------
+  # Subscribes to saltybot/estop MQTT topic. {"kill":true} -> 'E\r\n' to ESP32 BALANCE.
+=======
+  # -- Remote e-stop bridge (MQTT over 4G -> ESP32-S3 CDC) ----------------------
+  # Subscribes to saltybot/estop MQTT topic. {"kill":true} -> 'E\r\n' to ESP32-S3.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
   # Cellular watchdog: 5s MQTT drop in AUTO mode -> 'F\r\n' (ESTOP_CELLULAR_TIMEOUT).
   remote-estop:
     image: saltybot/ros2-humble:jetson-orin
@@ -221,12 +230,12 @@ services:
     runtime: nvidia
     network_mode: host
     depends_on:
-      - stm32-bridge
+      - esp32-bridge
     environment:
       - ROS_DOMAIN_ID=42
       - RMW_IMPLEMENTATION=rmw_cyclonedds_cpp
     devices:
-      - /dev/stm32-bridge:/dev/stm32-bridge
+      - /dev/esp32-bridge:/dev/esp32-bridge
     volumes:
       - ./ros2_ws/src:/ros2_ws/src:rw
       - ./config:/config:ro
@@ -316,7 +325,7 @@ services:
     runtime: nvidia
     network_mode: host
     depends_on:
-      - stm32-bridge
+      - esp32-bridge
     environment:
       - NVIDIA_VISIBLE_DEVICES=all
       - NVIDIA_DRIVER_CAPABILITIES=all,audio

jetson/docs/pinout.md

@@ -1,5 +1,9 @@
 # Jetson Orin Nano Super — GPIO / I2C / UART / CSI Pinout Reference
-## Self-Balancing Robot: STM32F722 Bridge + RealSense D435i + RPLIDAR A1M8 + 4× IMX219
+<<<<<<< HEAD
+## Self-Balancing Robot: ESP32 Bridge + RealSense D435i + RPLIDAR A1M8 + 4× IMX219
+=======
+## Self-Balancing Robot: ESP32-S3 Bridge + RealSense D435i + RPLIDAR A1M8 + 4× IMX219
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 Last updated: 2026-02-28
 JetPack version: 6.x (L4T R36.x / Ubuntu 22.04)
@@ -43,21 +47,37 @@ i2cdetect -l
 
 ---
 
-## 1. STM32F722 Bridge (USB CDC — Primary)
+<<<<<<< HEAD
+## 1. ESP32 Bridge (USB CDC — Primary)
 
-The STM32 acts as a real-time motor + IMU controller. Communication is via **USB CDC serial**.
+The ESP32 BALANCE acts as a real-time motor + IMU controller. Communication is via **USB CDC serial**.
+=======
+## 1. ESP32-S3 Bridge (USB Serial (CH343) — Primary)
 
-### USB CDC Connection
+The ESP32-S3 acts as a real-time motor + IMU controller. Communication is via **USB Serial (CH343) serial**.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
+
+### USB Serial (CH343) Connection
 | Connection | Detail |
 |-----------|--------|
-| Interface | USB Micro-B on STM32 dev board → USB-A on Jetson |
-| Device node | `/dev/ttyACM0` → symlink `/dev/stm32-bridge` (via udev) |
-| Baud rate | 921600 (configured in STM32 firmware) |
+<<<<<<< HEAD
+| Interface | USB on ESP32 BALANCE board → USB-A on Jetson |
+| Device node | `/dev/ttyACM0` → symlink `/dev/esp32-bridge` (via udev) |
+| Baud rate | 921600 (configured in ESP32 BALANCE firmware) |
+=======
+| Interface | USB Micro-B on ESP32-S3 dev board → USB-A on Jetson |
+| Device node | `/dev/ttyACM0` → symlink `/dev/esp32-bridge` (via udev) |
+| Baud rate | 921600 (configured in ESP32-S3 firmware) |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | Protocol | JSON telemetry RX + ASCII command TX (see bridge docs) |
 | Power | Powered via robot 5V bus (data-only via USB) |
 
 ### Hardware UART (Fallback — 40-pin header)
-| Jetson Pin | Signal | STM32 Pin | Notes |
+<<<<<<< HEAD
+| Jetson Pin | Signal | ESP32 Pin | Notes |
+=======
+| Jetson Pin | Signal | ESP32-S3 Pin | Notes |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 |-----------|--------|-----------|-------|
 | Pin 8 (TXD0) | TX → | PA10 (UART1 RX) | Cross-connect TX→RX |
 | Pin 10 (RXD0) | RX ← | PA9 (UART1 TX) | Cross-connect RX→TX |
@@ -65,7 +85,11 @@ The STM32 acts as a real-time motor + IMU controller. Communication is via **USB
 
 **Jetson device node:** `/dev/ttyTHS0`
 **Baud rate:** 921600, 8N1
-**Voltage level:** 3.3V — both Jetson Orin and STM32F722 are 3.3V GPIO
+<<<<<<< HEAD
+**Voltage level:** 3.3V — both Jetson Orin and ESP32 are 3.3V GPIO
+=======
+**Voltage level:** 3.3V — both Jetson Orin and ESP32-S3 are 3.3V GPIO
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ```bash
 # Verify UART
@@ -75,13 +99,23 @@ sudo usermod -aG dialout $USER
 picocom -b 921600 /dev/ttyTHS0
 ```
 
-**ROS2 topics (STM32 bridge node):**
+<<<<<<< HEAD
+**ROS2 topics (ESP32 bridge node):**
 | ROS2 Topic | Direction | Content |
 |-----------|-----------|---------
-| `/saltybot/imu` | STM32→Jetson | IMU data (accel, gyro) at 50Hz |
-| `/saltybot/balance_state` | STM32→Jetson | Motor cmd, pitch, state |
-| `/cmd_vel` | Jetson→STM32 | Velocity commands → `C<spd>,<str>\n` |
-| `/saltybot/estop` | Jetson→STM32 | Emergency stop |
+| `/saltybot/imu` | ESP32 BALANCE→Jetson | IMU data (accel, gyro) at 50Hz |
+| `/saltybot/balance_state` | ESP32 BALANCE→Jetson | Motor cmd, pitch, state |
+| `/cmd_vel` | Jetson→ESP32 BALANCE | Velocity commands → `C<spd>,<str>\n` |
+| `/saltybot/estop` | Jetson→ESP32 BALANCE | Emergency stop |
+=======
+**ROS2 topics (ESP32-S3 bridge node):**
+| ROS2 Topic | Direction | Content |
+|-----------|-----------|---------
+| `/saltybot/imu` | ESP32-S3→Jetson | IMU data (accel, gyro) at 50Hz |
+| `/saltybot/balance_state` | ESP32-S3→Jetson | Motor cmd, pitch, state |
+| `/cmd_vel` | Jetson→ESP32-S3 | Velocity commands → `C<spd>,<str>\n` |
+| `/saltybot/estop` | Jetson→ESP32-S3 | Emergency stop |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 ---
 
@@ -266,7 +300,11 @@ sudo mkdir -p /mnt/nvme
 |------|------|----------|
 | USB-A (top, blue) | USB 3.1 Gen 1 | RealSense D435i |
 | USB-A (bottom) | USB 2.0 | RPLIDAR (via USB-UART adapter) |
-| USB-C | USB 3.1 Gen 1 (+ DP) | STM32 CDC or host flash |
+<<<<<<< HEAD
+| USB-C | USB 3.1 Gen 1 (+ DP) | ESP32 CDC or host flash |
+=======
+| USB-C | USB 3.1 Gen 1 (+ DP) | ESP32-S3 CDC or host flash |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | Micro-USB | Debug/flash | JetPack flash only |
 
 ---
@@ -277,10 +315,17 @@ sudo mkdir -p /mnt/nvme
 |-------------|----------|---------|----------|
 | 3 | SDA1 | 3.3V | I2C data (i2c-7) |
 | 5 | SCL1 | 3.3V | I2C clock (i2c-7) |
-| 8 | TXD0 | 3.3V | UART TX → STM32 (fallback) |
-| 10 | RXD0 | 3.3V | UART RX ← STM32 (fallback) |
+<<<<<<< HEAD
+| 8 | TXD0 | 3.3V | UART TX → ESP32 BALANCE (fallback) |
+| 10 | RXD0 | 3.3V | UART RX ← ESP32 BALANCE (fallback) |
 | USB-A ×2 | — | 5V | D435i, RPLIDAR |
-| USB-C | — | 5V | STM32 CDC |
+| USB-C | — | 5V | ESP32 CDC |
+=======
+| 8 | TXD0 | 3.3V | UART TX → ESP32-S3 (fallback) |
+| 10 | RXD0 | 3.3V | UART RX ← ESP32-S3 (fallback) |
+| USB-A ×2 | — | 5V | D435i, RPLIDAR |
+| USB-C | — | 5V | ESP32-S3 CDC |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | CSI-A (J5) | MIPI CSI-2 | — | Cameras front + left |
 | CSI-B (J8) | MIPI CSI-2 | — | Cameras rear + right |
 | M.2 Key M | PCIe Gen3 ×4 | — | NVMe SSD |
@@ -298,9 +343,13 @@ Apply stable device names:
 KERNEL=="ttyUSB*", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="ea60", \
   SYMLINK+="rplidar", MODE="0666"
 
-# STM32 USB CDC (STMicroelectronics)
+<<<<<<< HEAD
+# ESP32 USB CDC (STMicroelectronics)
+=======
+# ESP32-S3 USB Serial (CH343) (STMicroelectronics)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 KERNEL=="ttyACM*", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="5740", \
-  SYMLINK+="stm32-bridge", MODE="0666"
+  SYMLINK+="esp32-bridge", MODE="0666"
 
 # Intel RealSense D435i
 SUBSYSTEM=="usb", ATTRS{idVendor}=="8086", ATTRS{idProduct}=="0b3a", \

jetson/docs/power-budget.md

@@ -56,7 +56,11 @@ sudo jtop
 |-----------|----------|------------|----------|-----------|-------|
 | RealSense D435i | 0.3 | 1.5 | 3.5 | USB 3.1 | Peak during boot/init |
 | RPLIDAR A1M8 | 0.4 | 2.6 | 3.0 | USB (UART adapter) | Motor spinning |
-| STM32F722 bridge | 0.0 | 0.0 | 0.0 | USB CDC | Self-powered from robot 5V |
+<<<<<<< HEAD
+| ESP32 bridge | 0.0 | 0.0 | 0.0 | USB CDC | Self-powered from robot 5V |
+=======
+| ESP32-S3 bridge | 0.0 | 0.0 | 0.0 | USB Serial (CH343) | Self-powered from robot 5V |
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 | 4× IMX219 cameras | 0.2 | 2.0 | 2.4 | MIPI CSI-2 | ~0.5W per camera active |
 | **Peripheral Subtotal** | **0.9** | **6.1** | **8.9** | | |
 
@@ -72,7 +76,7 @@ sudo jtop
 
 ## Budget Analysis vs Previous Platform
 
-| Metric | Jetson Nano | Jetson Orin Nano Super |
+| Metric | Jetson Orin Nano Super | Jetson Orin Nano Super |
 |--------|------------|------------------------|
 | TDP | 10W | 25W |
 | CPU | 4× Cortex-A57 @ 1.43GHz | 6× A78AE @ 1.5GHz |
@@ -151,7 +155,11 @@ LiPo 4S (16.8V max)
        ├─► DC-DC Buck → 5V 6A ──► Jetson Orin barrel jack (30W)
        │   (e.g., XL4016E1)
        │
-       ├─► DC-DC Buck → 5V 3A ──► STM32 + logic 5V rail
+<<<<<<< HEAD
+       ├─► DC-DC Buck → 5V 3A ──► ESP32 + logic 5V rail
+=======
+       ├─► DC-DC Buck → 5V 3A ──► ESP32-S3 + logic 5V rail
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
        │
        └─► Hoverboard ESC ──► Hub motors (48V loop)
 ```

jetson/ros2_ws/src/saltybot_bridge/config/bridge_params.yaml

@@ -2,7 +2,7 @@
 # Used by both serial_bridge_node (RX-only) and saltybot_cmd_node (bidirectional)
 
 # ── Serial ─────────────────────────────────────────────────────────────────────
-# Use /dev/stm32-bridge if udev rule from jetson/docs/pinout.md is applied.
+# Use /dev/esp32-bridge if udev rule from jetson/docs/pinout.md is applied.
 serial_port:      /dev/ttyACM0
 baud_rate:        921600
 timeout:          0.05   # serial readline timeout (seconds)
@@ -11,7 +11,11 @@ reconnect_delay:  2.0    # seconds between reconnect attempts on serial disconne
 # ── saltybot_cmd_node (bidirectional) only ─────────────────────────────────────
 
 # Heartbeat: H\n sent every heartbeat_period seconds.
-# STM32 reverts steer to 0 after JETSON_HB_TIMEOUT_MS (500ms) without heartbeat.
+<<<<<<< HEAD
+# ESP32 BALANCE reverts steer to 0 after JETSON_HB_TIMEOUT_MS (500ms) without heartbeat.
+=======
+# ESP32-S3 reverts steer to 0 after JETSON_HB_TIMEOUT_MS (500ms) without heartbeat.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 heartbeat_period: 0.2    # seconds (= 200ms)
 
 # Twist → ESC command scaling

jetson/ros2_ws/src/saltybot_bridge/config/cmd_vel_bridge_params.yaml

@@ -1,5 +1,9 @@
 # cmd_vel_bridge_params.yaml
-# Configuration for cmd_vel_bridge_node — Nav2 /cmd_vel → STM32 autonomous drive.
+<<<<<<< HEAD
+# Configuration for cmd_vel_bridge_node — Nav2 /cmd_vel → ESP32 BALANCE autonomous drive.
+=======
+# Configuration for cmd_vel_bridge_node — Nav2 /cmd_vel → ESP32-S3 autonomous drive.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 #
 # Run with:
 #   ros2 launch saltybot_bridge cmd_vel_bridge.launch.py
@@ -7,14 +11,18 @@
 #   ros2 launch saltybot_bridge cmd_vel_bridge.launch.py max_linear_vel:=0.3
 
 # ── Serial ─────────────────────────────────────────────────────────────────────
-# Use /dev/stm32-bridge if udev rule from jetson/docs/pinout.md is applied.
+# Use /dev/esp32-bridge if udev rule from jetson/docs/pinout.md is applied.
 serial_port:      /dev/ttyACM0
 baud_rate:        921600
 timeout:          0.05       # serial readline timeout (s)
 reconnect_delay:  2.0        # seconds between reconnect attempts
 
 # ── Heartbeat ──────────────────────────────────────────────────────────────────
-# STM32 jetson_cmd module reverts steer to 0 after JETSON_HB_TIMEOUT_MS (500ms).
+<<<<<<< HEAD
+# ESP32 BALANCE jetson_cmd module reverts steer to 0 after JETSON_HB_TIMEOUT_MS (500ms).
+=======
+# ESP32-S3 jetson_cmd module reverts steer to 0 after JETSON_HB_TIMEOUT_MS (500ms).
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 # Keep heartbeat well below that threshold.
 heartbeat_period: 0.2        # seconds (200ms)
 
@@ -50,5 +58,9 @@ ramp_rate:        500        # ESC units/second
 # ── Deadman switch ─────────────────────────────────────────────────────────────
 # If /cmd_vel is not received for this many seconds, target speed/steer are
 # zeroed immediately. The ramp then drives the robot to a stop.
-# 500ms matches the STM32 jetson heartbeat timeout for consistency.
+<<<<<<< HEAD
+# 500ms matches the ESP32 BALANCE jetson heartbeat timeout for consistency.
+=======
+# 500ms matches the ESP32-S3 jetson heartbeat timeout for consistency.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 cmd_vel_timeout:  0.5        # seconds

jetson/ros2_ws/src/saltybot_bridge/config/esp32_cmd_params.yaml

@@ -0,0 +1,49 @@
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/config/stm32_cmd_params.yaml
+# stm32_cmd_params.yaml — Configuration for stm32_cmd_node (ESP32-S3 IO bridge)
+# Connects to ESP32-S3 IO board via USB-CDC @ 460800 baud.
+# Frame format: [0xAA][LEN][TYPE][PAYLOAD][CRC8]
+# Spec: docs/SAUL-TEE-SYSTEM-REFERENCE.md §5
+
+# ── Serial port ────────────────────────────────────────────────────────────────
+# Use /dev/esp32-io if udev rule is applied (see jetson/docs/udev-rules.md).
+# ESP32-S3 IO appears as USB-JTAG/Serial device; no external UART bridge needed.
+serial_port:      /dev/esp32-io
+baud_rate:        460800
+reconnect_delay:  2.0        # seconds between reconnect attempts
+
+# ── Heartbeat ─────────────────────────────────────────────────────────────────
+# HEARTBEAT (0x20) sent every heartbeat_period.
+# ESP32 IO watchdog fires if no heartbeat for ~500 ms.
+heartbeat_period: 0.2        # 200 ms → well within 500 ms watchdog
+=======
+# esp32_cmd_params.yaml — Configuration for esp32_cmd_node (Issue #119)
+# Binary-framed Jetson↔ESP32-S3 bridge at 921600 baud.
+
+# ── Serial port ────────────────────────────────────────────────────────────────
+# Use /dev/esp32-bridge if the udev rule is applied:
+#   SUBSYSTEM=="tty", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="5740",
+#   SYMLINK+="esp32-bridge", MODE="0660", GROUP="dialout"
+serial_port:      /dev/ttyACM0
+baud_rate:        921600
+reconnect_delay:  2.0        # seconds between USB reconnect attempts
+
+# ── Heartbeat ─────────────────────────────────────────────────────────────────
+# HEARTBEAT frame sent every heartbeat_period seconds.
+# ESP32-S3 fires watchdog and reverts to safe state if no frame received for 500ms.
+heartbeat_period: 0.2        # 200ms → well within 500ms ESP32-S3 watchdog
+
+# ── Watchdog (Jetson-side) ────────────────────────────────────────────────────
+# If no /cmd_vel message received for watchdog_timeout seconds,
+# send SPEED_STEER(0,0) to stop the robot.
+watchdog_timeout: 0.5        # 500ms
+
+# ── Twist velocity scaling ────────────────────────────────────────────────────
+# speed = clamp(linear.x  * speed_scale, -1000, 1000)  (m/s → ESC units)
+# steer = clamp(angular.z * steer_scale, -1000, 1000)  (rad/s → ESC units)
+#
+# Default: 1 m/s → 1000 ESC units, ±2 rad/s → ±1000 steer.
+# Negative steer_scale flips ROS2 CCW+ convention to match ESC steer direction.
+# Tune speed_scale to set the physical top speed.
+speed_scale:  1000.0
+steer_scale:  -500.0
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/config/esp32_cmd_params.yaml

jetson/ros2_ws/src/saltybot_bridge/config/estop_params.yaml

@@ -1,6 +1,6 @@
 remote_estop_node:
   ros__parameters:
-    serial_port:               /dev/stm32-bridge
+    serial_port:               /dev/esp32-bridge
     baud_rate:                 921600
     mqtt_host:                 "mqtt.example.com"
     mqtt_port:                 1883

jetson/ros2_ws/src/saltybot_bridge/config/stm32_cmd_params.yaml

@@ -1,30 +0,0 @@
-# stm32_cmd_params.yaml — Configuration for stm32_cmd_node (Issue #119)
-# Binary-framed Jetson↔STM32 bridge at 921600 baud.
-
-# ── Serial port ────────────────────────────────────────────────────────────────
-# Use /dev/stm32-bridge if the udev rule is applied:
-#   SUBSYSTEM=="tty", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="5740",
-#   SYMLINK+="stm32-bridge", MODE="0660", GROUP="dialout"
-serial_port:      /dev/ttyACM0
-baud_rate:        921600
-reconnect_delay:  2.0        # seconds between USB reconnect attempts
-
-# ── Heartbeat ─────────────────────────────────────────────────────────────────
-# HEARTBEAT frame sent every heartbeat_period seconds.
-# STM32 fires watchdog and reverts to safe state if no frame received for 500ms.
-heartbeat_period: 0.2        # 200ms → well within 500ms STM32 watchdog
-
-# ── Watchdog (Jetson-side) ────────────────────────────────────────────────────
-# If no /cmd_vel message received for watchdog_timeout seconds,
-# send SPEED_STEER(0,0) to stop the robot.
-watchdog_timeout: 0.5        # 500ms
-
-# ── Twist velocity scaling ────────────────────────────────────────────────────
-# speed = clamp(linear.x  * speed_scale, -1000, 1000)  (m/s → ESC units)
-# steer = clamp(angular.z * steer_scale, -1000, 1000)  (rad/s → ESC units)
-#
-# Default: 1 m/s → 1000 ESC units, ±2 rad/s → ±1000 steer.
-# Negative steer_scale flips ROS2 CCW+ convention to match ESC steer direction.
-# Tune speed_scale to set the physical top speed.
-speed_scale:  1000.0
-steer_scale:  -500.0

jetson/ros2_ws/src/saltybot_bridge/launch/bridge.launch.py

@@ -6,7 +6,11 @@ Two deployment modes:
   1. Full bidirectional (recommended for Nav2):
        ros2 launch saltybot_bridge bridge.launch.py mode:=bidirectional
      Starts saltybot_cmd_node — owns serial port, handles both RX telemetry
-     and TX /cmd_vel → STM32 commands + heartbeat.
+<<<<<<< HEAD
+     and TX /cmd_vel → ESP32 BALANCE commands + heartbeat.
+=======
+     and TX /cmd_vel → ESP32-S3 commands + heartbeat.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
   2. RX-only (telemetry monitor, no drive commands):
        ros2 launch saltybot_bridge bridge.launch.py mode:=rx_only
@@ -40,7 +44,7 @@ def _launch_nodes(context, *args, **kwargs):
         return [Node(
             package="saltybot_bridge",
             executable="serial_bridge_node",
-            name="stm32_serial_bridge",
+            name="esp32_serial_bridge",
             output="screen",
             parameters=[params],
         )]
@@ -65,7 +69,11 @@ def generate_launch_description():
         DeclareLaunchArgument("mode",         default_value="bidirectional",
                               description="bidirectional | rx_only"),
         DeclareLaunchArgument("serial_port",  default_value="/dev/ttyACM0",
-                              description="STM32 USB CDC device node"),
+<<<<<<< HEAD
+                              description="ESP32 USB CDC device node"),
+=======
+                              description="ESP32-S3 USB CDC device node"),
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         DeclareLaunchArgument("baud_rate",    default_value="921600"),
         DeclareLaunchArgument("speed_scale",  default_value="1000.0",
                               description="m/s → ESC units (linear.x scale)"),

jetson/ros2_ws/src/saltybot_bridge/launch/cmd_vel_bridge.launch.py

@@ -1,10 +1,18 @@
 """
-cmd_vel_bridge.launch.py — Nav2 cmd_vel → STM32 autonomous drive bridge.
+<<<<<<< HEAD
+cmd_vel_bridge.launch.py — Nav2 cmd_vel → ESP32 BALANCE autonomous drive bridge.
+=======
+cmd_vel_bridge.launch.py — Nav2 cmd_vel → ESP32-S3 autonomous drive bridge.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 Starts cmd_vel_bridge_node, which owns the serial port exclusively and provides:
   - /cmd_vel subscription with velocity limits + smooth ramp
   - Deadman switch (zero speed if /cmd_vel silent > cmd_vel_timeout)
-  - Mode gate (drives only when STM32 is in AUTONOMOUS mode, md=2)
+<<<<<<< HEAD
+  - Mode gate (drives only when ESP32 BALANCE is in AUTONOMOUS mode, md=2)
+=======
+  - Mode gate (drives only when ESP32-S3 is in AUTONOMOUS mode, md=2)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
   - Telemetry RX → /saltybot/imu, /saltybot/balance_state, /diagnostics
   - /saltybot/cmd publisher (observability)
 
@@ -72,12 +80,20 @@ def generate_launch_description():
             description="Full path to cmd_vel_bridge_params.yaml (overrides inline args)"),
         DeclareLaunchArgument(
             "serial_port",     default_value="/dev/ttyACM0",
-            description="STM32 USB CDC device node"),
+<<<<<<< HEAD
+            description="ESP32 USB CDC device node"),
+=======
+            description="ESP32-S3 USB CDC device node"),
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         DeclareLaunchArgument(
             "baud_rate",       default_value="921600"),
         DeclareLaunchArgument(
             "heartbeat_period",default_value="0.2",
-            description="Heartbeat interval (s); must be < STM32 HB timeout (0.5s)"),
+<<<<<<< HEAD
+            description="Heartbeat interval (s); must be < ESP32 BALANCE HB timeout (0.5s)"),
+=======
+            description="Heartbeat interval (s); must be < ESP32-S3 HB timeout (0.5s)"),
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         DeclareLaunchArgument(
             "max_linear_vel",  default_value="0.5",
             description="Hard speed cap before scaling (m/s)"),

jetson/ros2_ws/src/saltybot_bridge/launch/esp32_cmd.launch.py

@@ -0,0 +1,60 @@
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/launch/stm32_cmd.launch.py
+"""stm32_cmd.launch.py — Launch the ESP32-S3 IO auxiliary bridge node.
+
+Connects to ESP32-S3 IO board via USB-CDC @ 460800 baud (inter-board protocol).
+Handles RC monitoring, sensor data, LED/output commands.
+Primary drive path uses CAN (can_bridge_node / saltybot_can_node), not this node.
+
+Spec: docs/SAUL-TEE-SYSTEM-REFERENCE.md §5
+
+Usage:
+  ros2 launch saltybot_bridge stm32_cmd.launch.py
+  ros2 launch saltybot_bridge stm32_cmd.launch.py serial_port:=/dev/ttyACM0
+=======
+"""esp32_cmd.launch.py — Launch the binary-framed ESP32-S3 command node (Issue #119).
+
+Usage:
+  # Default (binary protocol, bidirectional):
+  ros2 launch saltybot_bridge esp32_cmd.launch.py
+
+  # Override serial port:
+  ros2 launch saltybot_bridge esp32_cmd.launch.py serial_port:=/dev/ttyACM1
+
+  # Custom velocity scales:
+  ros2 launch saltybot_bridge esp32_cmd.launch.py speed_scale:=800.0 steer_scale:=-400.0
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/launch/esp32_cmd.launch.py
+"""
+
+import os
+from ament_index_python.packages import get_package_share_directory
+from launch import LaunchDescription
+from launch.actions import DeclareLaunchArgument
+from launch.substitutions import LaunchConfiguration
+from launch_ros.actions import Node
+
+
+def generate_launch_description() -> LaunchDescription:
+    pkg = get_package_share_directory("saltybot_bridge")
+    params_file = os.path.join(pkg, "config", "esp32_cmd_params.yaml")
+
+    return LaunchDescription([
+        DeclareLaunchArgument("serial_port",     default_value="/dev/esp32-io"),
+        DeclareLaunchArgument("baud_rate",        default_value="460800"),
+        DeclareLaunchArgument("heartbeat_period", default_value="0.2"),
+
+        Node(
+            package="saltybot_bridge",
+            executable="esp32_cmd_node",
+            name="esp32_cmd_node",
+            output="screen",
+            emulate_tty=True,
+            parameters=[
+                params_file,
+                {
+                    "serial_port":      LaunchConfiguration("serial_port"),
+                    "baud_rate":        LaunchConfiguration("baud_rate"),
+                    "heartbeat_period": LaunchConfiguration("heartbeat_period"),
+                },
+            ],
+        ),
+    ])

jetson/ros2_ws/src/saltybot_bridge/launch/stm32_cmd.launch.py

@@ -1,52 +0,0 @@
-"""stm32_cmd.launch.py — Launch the binary-framed STM32 command node (Issue #119).
-
-Usage:
-  # Default (binary protocol, bidirectional):
-  ros2 launch saltybot_bridge stm32_cmd.launch.py
-
-  # Override serial port:
-  ros2 launch saltybot_bridge stm32_cmd.launch.py serial_port:=/dev/ttyACM1
-
-  # Custom velocity scales:
-  ros2 launch saltybot_bridge stm32_cmd.launch.py speed_scale:=800.0 steer_scale:=-400.0
-"""
-
-import os
-from ament_index_python.packages import get_package_share_directory
-from launch import LaunchDescription
-from launch.actions import DeclareLaunchArgument
-from launch.substitutions import LaunchConfiguration
-from launch_ros.actions import Node
-
-
-def generate_launch_description() -> LaunchDescription:
-    pkg = get_package_share_directory("saltybot_bridge")
-    params_file = os.path.join(pkg, "config", "stm32_cmd_params.yaml")
-
-    return LaunchDescription([
-        DeclareLaunchArgument("serial_port",      default_value="/dev/ttyACM0"),
-        DeclareLaunchArgument("baud_rate",         default_value="921600"),
-        DeclareLaunchArgument("speed_scale",       default_value="1000.0"),
-        DeclareLaunchArgument("steer_scale",       default_value="-500.0"),
-        DeclareLaunchArgument("watchdog_timeout",  default_value="0.5"),
-        DeclareLaunchArgument("heartbeat_period",  default_value="0.2"),
-
-        Node(
-            package="saltybot_bridge",
-            executable="stm32_cmd_node",
-            name="stm32_cmd_node",
-            output="screen",
-            emulate_tty=True,
-            parameters=[
-                params_file,
-                {
-                    "serial_port":      LaunchConfiguration("serial_port"),
-                    "baud_rate":        LaunchConfiguration("baud_rate"),
-                    "speed_scale":      LaunchConfiguration("speed_scale"),
-                    "steer_scale":      LaunchConfiguration("steer_scale"),
-                    "watchdog_timeout": LaunchConfiguration("watchdog_timeout"),
-                    "heartbeat_period": LaunchConfiguration("heartbeat_period"),
-                },
-            ],
-        ),
-    ])

jetson/ros2_ws/src/saltybot_bridge/launch/uart_bridge.launch.py

@@ -2,7 +2,11 @@
 uart_bridge.launch.py — FC↔Orin UART bridge (Issue #362)
 
 Launches serial_bridge_node configured for Jetson Orin UART port.
-Bridges Flight Controller (STM32F722) telemetry from /dev/ttyTHS1 into ROS2.
+<<<<<<< HEAD
+Bridges Flight Controller (ESP32) telemetry from /dev/ttyTHS1 into ROS2.
+=======
+Bridges Flight Controller (ESP32-S3) telemetry from /dev/ttyTHS1 into ROS2.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 Published topics (same as USB CDC bridge):
   /saltybot/imu              sensor_msgs/Imu         — pitch/roll/yaw as angular velocity
@@ -20,7 +24,11 @@ Usage:
 
 Prerequisites:
   - Flight Controller connected to /dev/ttyTHS1 @ 921600 baud
-  - STM32 firmware transmitting JSON telemetry frames (50 Hz)
+<<<<<<< HEAD
+  - ESP32 BALANCE firmware transmitting JSON telemetry frames (50 Hz)
+=======
+  - ESP32-S3 firmware transmitting JSON telemetry frames (50 Hz)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
   - ROS2 environment sourced (source install/setup.bash)
 
 Note:

jetson/ros2_ws/src/saltybot_bridge/package.xml

@@ -4,9 +4,9 @@
   <name>saltybot_bridge</name>
   <version>0.1.0</version>
   <description>
-    STM32F722 USB CDC serial bridge for saltybot.
+    ESP32-S3 USB CDC serial bridge for saltybot.
     serial_bridge_node: JSON telemetry RX → sensor_msgs/Imu + diagnostics.
-    stm32_cmd_node (Issue #119): binary-framed protocol — STX/TYPE/LEN/CRC16/ETX,
+    esp32_cmd_node (Issue #119): binary-framed protocol — STX/TYPE/LEN/CRC16/ETX,
       commands: HEARTBEAT, SPEED_STEER, ARM, SET_MODE, PID_UPDATE;
       telemetry: IMU, BATTERY, MOTOR_RPM, ARM_STATE, ERROR; watchdog 500ms.
     battery_node (Issue #125): SoC tracking, threshold alerts, SQLite history.

jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/battery_node.py

@@ -1,6 +1,6 @@
 """battery_node.py — Battery management for saltybot (Issue #125).
 
-Subscribes to /saltybot/telemetry/battery (JSON from stm32_cmd_node) and:
+Subscribes to /saltybot/telemetry/battery (JSON from esp32_cmd_node) and:
   - Publishes sensor_msgs/BatteryState on /saltybot/battery
   - Publishes JSON alerts on /saltybot/battery/alert at threshold crossings
   - Reduces speed limit at low SoC via /saltybot/speed_limit (std_msgs/Float32)
@@ -14,7 +14,11 @@ Alert levels (SoC thresholds):
    5%  EMERGENCY — publish zero /cmd_vel, disarm, log + alert
 
 SoC source priority:
-  1. soc_pct field from STM32 BATTERY telemetry (fuel gauge or lookup on STM32)
+<<<<<<< HEAD
+  1. soc_pct field from ESP32 BATTERY telemetry (fuel gauge or lookup on ESP32 BALANCE)
+=======
+  1. soc_pct field from ESP32-S3 BATTERY telemetry (fuel gauge or lookup on ESP32-S3)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
   2. Voltage-based lookup table (3S LiPo curve) if soc_pct == 0 and voltage known
 
 Parameters (config/battery_params.yaml):
@@ -320,7 +324,11 @@ class BatteryNode(Node):
         self._speed_limit_pub.publish(msg)
 
     def _execute_safe_stop(self) -> None:
-        """Send zero /cmd_vel and disarm the STM32."""
+<<<<<<< HEAD
+        """Send zero /cmd_vel and disarm the ESP32 BALANCE."""
+=======
+        """Send zero /cmd_vel and disarm the ESP32-S3."""
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         self.get_logger().fatal("EMERGENCY: publishing zero /cmd_vel and disarming")
         # Publish zero velocity
         zero_twist = Twist()

jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/cmd_vel_bridge_node.py

@@ -1,5 +1,9 @@
 """
-cmd_vel_bridge_node — Nav2 /cmd_vel → STM32 drive command bridge.
+<<<<<<< HEAD
+cmd_vel_bridge_node — Nav2 /cmd_vel → ESP32 BALANCE drive command bridge.
+=======
+cmd_vel_bridge_node — Nav2 /cmd_vel → ESP32-S3 drive command bridge.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 Extends the basic saltybot_cmd_node with four additions required for safe
 autonomous operation on a self-balancing robot:
@@ -12,7 +16,11 @@ autonomous operation on a self-balancing robot:
   3. Deadman switch    — if /cmd_vel is silent for cmd_vel_timeout seconds,
                          zero targets immediately (Nav2 node crash / planner
                          stall → robot coasts to stop rather than running away).
-  4. Mode gate         — only issue non-zero drive commands when STM32 reports
+<<<<<<< HEAD
+  4. Mode gate         — only issue non-zero drive commands when ESP32 BALANCE reports
+=======
+  4. Mode gate         — only issue non-zero drive commands when ESP32-S3 reports
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
                          md=2 (AUTONOMOUS). In any other mode (RC_MANUAL,
                          RC_ASSISTED) Jetson cannot override the RC pilot.
                          On mode re-entry current ramp state resets to 0 so
@@ -20,9 +28,15 @@ autonomous operation on a self-balancing robot:
 
 Serial protocol (C<speed>,<steer>\\n / H\\n — same as saltybot_cmd_node):
   C<spd>,<str>\\n  — drive command. speed/steer: -1000..+1000 integers.
-  H\\n             — heartbeat. STM32 reverts steer to 0 after 500ms silence.
+<<<<<<< HEAD
+  H\\n             — heartbeat. ESP32 BALANCE reverts steer to 0 after 500ms silence.
 
-Telemetry (50 Hz from STM32):
+Telemetry (50 Hz from ESP32 BALANCE):
+=======
+  H\\n             — heartbeat. ESP32-S3 reverts steer to 0 after 500ms silence.
+
+Telemetry (50 Hz from ESP32-S3):
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
   Same RX/publish pipeline as saltybot_cmd_node.
   The "md" field (0=MANUAL,1=ASSISTED,2=AUTO) is parsed for the mode gate.
 
@@ -134,7 +148,7 @@ class CmdVelBridgeNode(Node):
         self._current_speed = 0   # ramped output actually sent
         self._current_steer = 0
         self._last_cmd_vel  = 0.0 # wall clock (seconds) of last /cmd_vel msg
-        self._stm32_mode    = 0   # parsed "md" field: 0=MANUAL,1=ASSISTED,2=AUTO
+        self._esp32_mode    = 0   # parsed "md" field: 0=MANUAL,1=ASSISTED,2=AUTO
         self._last_state    = -1
         self._frame_count   = 0
         self._error_count   = 0
@@ -150,7 +164,11 @@ class CmdVelBridgeNode(Node):
         self._open_serial()
 
         # ── Timers ────────────────────────────────────────────────────────────
-        # Telemetry read at 100 Hz (STM32 sends at 50 Hz)
+<<<<<<< HEAD
+        # Telemetry read at 100 Hz (ESP32 BALANCE sends at 50 Hz)
+=======
+        # Telemetry read at 100 Hz (ESP32-S3 sends at 50 Hz)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         self._read_timer    = self.create_timer(0.01,             self._read_cb)
         # Control loop at 50 Hz: ramp + deadman + mode gate + send
         self._control_timer = self.create_timer(1.0 / _CONTROL_HZ, self._control_cb)
@@ -225,7 +243,7 @@ class CmdVelBridgeNode(Node):
 
         # Mode gate: in non-AUTONOMOUS mode, zero and reset ramp state so
         # re-entry always accelerates smoothly from 0.
-        if self._stm32_mode != MODE_AUTONOMOUS:
+        if self._esp32_mode != MODE_AUTONOMOUS:
             self._current_speed = 0
             self._current_steer = 0
             speed, steer = 0, 0
@@ -238,7 +256,11 @@ class CmdVelBridgeNode(Node):
             speed = self._current_speed
             steer = self._current_steer
 
-        # Send to STM32
+<<<<<<< HEAD
+        # Send to ESP32 BALANCE
+=======
+        # Send to ESP32-S3
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         frame = f"C{speed},{steer}\n".encode("ascii")
         if not self._write(frame):
             self.get_logger().warn(
@@ -256,7 +278,11 @@ class CmdVelBridgeNode(Node):
     # ── Heartbeat TX ──────────────────────────────────────────────────────────
 
     def _heartbeat_cb(self):
-        """H\\n keeps STM32 jetson_cmd heartbeat alive regardless of mode."""
+<<<<<<< HEAD
+        """H\\n keeps ESP32 BALANCE jetson_cmd heartbeat alive regardless of mode."""
+=======
+        """H\\n keeps ESP32-S3 jetson_cmd heartbeat alive regardless of mode."""
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         self._write(b"H\n")
 
     # ── Telemetry RX ──────────────────────────────────────────────────────────
@@ -319,7 +345,7 @@ class CmdVelBridgeNode(Node):
         state     = int(data["s"])
         mode      = int(data.get("md", 0))  # 0=MANUAL if not present
 
-        self._stm32_mode = mode
+        self._esp32_mode = mode
         self._frame_count += 1
 
         self._publish_imu(pitch_deg, roll_deg, yaw_deg, now)
@@ -378,7 +404,11 @@ class CmdVelBridgeNode(Node):
         diag.header.stamp = stamp
         status = DiagnosticStatus()
         status.name        = "saltybot/balance_controller"
-        status.hardware_id = "stm32f722"
+<<<<<<< HEAD
+        status.hardware_id = "esp32"
+=======
+        status.hardware_id = "esp32s322"
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         status.message     = f"{state_label} [{mode_label}]"
         status.level = (
             DiagnosticStatus.OK    if state == 1 else
@@ -406,11 +436,19 @@ class CmdVelBridgeNode(Node):
         status = DiagnosticStatus()
         status.level       = DiagnosticStatus.ERROR
         status.name        = "saltybot/balance_controller"
-        status.hardware_id = "stm32f722"
+<<<<<<< HEAD
+        status.hardware_id = "esp32"
         status.message     = f"IMU fault errno={errno}"
         diag.status.append(status)
         self._diag_pub.publish(diag)
-        self.get_logger().error(f"STM32 IMU fault: errno={errno}")
+        self.get_logger().error(f"ESP32 BALANCE IMU fault: errno={errno}")
+=======
+        status.hardware_id = "esp32s322"
+        status.message     = f"IMU fault errno={errno}"
+        diag.status.append(status)
+        self._diag_pub.publish(diag)
+        self.get_logger().error(f"ESP32-S3 IMU fault: errno={errno}")
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
     # ── Lifecycle ─────────────────────────────────────────────────────────────
 

jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py

@@ -1,32 +1,53 @@
-"""stm32_cmd_node.py — Full bidirectional binary-framed STM32↔Jetson bridge.
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
+"""stm32_cmd_node.py — Orin ↔ ESP32-S3 IO auxiliary bridge node.
+=======
+"""esp32_cmd_node.py — Full bidirectional binary-framed ESP32-S3↔Jetson bridge.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
 
-Issue #119: replaces the ASCII-protocol saltybot_cmd_node with a robust binary
-framing protocol (STX/TYPE/LEN/PAYLOAD/CRC16/ETX) at 921600 baud.
+Connects to the ESP32-S3 IO board via USB-CDC (/dev/esp32-io) using the
+inter-board binary protocol (docs/SAUL-TEE-SYSTEM-REFERENCE.md §5).
 
-TX commands (Jetson → STM32):
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
+This node is NOT the primary drive path (that is CAN via can_bridge_node).
+It handles auxiliary I/O: RC monitoring, sensor data, LED/output control.
+=======
+TX commands (Jetson → ESP32-S3):
   SPEED_STEER  — 50 Hz from /cmd_vel subscription
-  HEARTBEAT    — 200 ms timer (STM32 watchdog fires at 500 ms)
+  HEARTBEAT    — 200 ms timer (ESP32-S3 watchdog fires at 500 ms)
   ARM          — via /saltybot/arm service
   SET_MODE     — via /saltybot/set_mode service
   PID_UPDATE   — via /saltybot/pid_update topic
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
 
-Watchdog: if /cmd_vel is silent for 500 ms, send SPEED_STEER(0,0) and log warning.
+Frame format: [0xAA][LEN][TYPE][PAYLOAD][CRC8]  @ 460800 baud
 
-RX telemetry (STM32 → Jetson):
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
+RX from ESP32 IO:
+  RC_CHANNELS (0x01) → /saltybot/rc_channels  (std_msgs/String JSON)
+  SENSORS     (0x02) → /saltybot/sensors       (std_msgs/String JSON)
+=======
+RX telemetry (ESP32-S3 → Jetson):
   IMU          → /saltybot/imu           (sensor_msgs/Imu)
   BATTERY      → /saltybot/telemetry/battery (std_msgs/String JSON)
   MOTOR_RPM    → /saltybot/telemetry/motor_rpm (std_msgs/String JSON)
   ARM_STATE    → /saltybot/arm_state     (std_msgs/String JSON)
   ERROR        → /saltybot/error         (std_msgs/String JSON)
   All frames   → /diagnostics            (diagnostic_msgs/DiagnosticArray)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
 
-Auto-reconnect: USB disconnect is detected when serial.read() raises; node
-continuously retries at reconnect_delay interval.
-
-This node owns /dev/ttyACM0 exclusively — do NOT run alongside
-serial_bridge_node or saltybot_cmd_node on the same port.
+TX to ESP32 IO:
+  LED_CMD     (0x10) ← /saltybot/leds          (std_msgs/String JSON)
+  OUTPUT_CMD  (0x11) ← /saltybot/outputs       (std_msgs/String JSON)
+  HEARTBEAT   (0x20)  — sent every heartbeat_period (keep IO watchdog alive)
 
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
 Parameters (config/stm32_cmd_params.yaml):
+  serial_port       /dev/esp32-io
+  baud_rate         460800
+  reconnect_delay   2.0
+  heartbeat_period  0.2   (ESP32 IO watchdog fires at ~500 ms)
+=======
+Parameters (config/esp32_cmd_params.yaml):
   serial_port       /dev/ttyACM0
   baud_rate         921600
   reconnect_delay   2.0   (seconds)
@@ -34,12 +55,12 @@ Parameters (config/stm32_cmd_params.yaml):
   watchdog_timeout  0.5   (seconds — no /cmd_vel → send zero-speed)
   speed_scale       1000.0 (linear.x m/s → ESC units)
   steer_scale      -500.0  (angular.z rad/s → ESC units, neg to flip convention)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
 """
 
 from __future__ import annotations
 
 import json
-import math
 import threading
 import time
 
@@ -50,119 +71,82 @@ from rclpy.qos import HistoryPolicy, QoSProfile, ReliabilityPolicy
 import serial
 
 from diagnostic_msgs.msg import DiagnosticArray, DiagnosticStatus, KeyValue
-from geometry_msgs.msg import Twist
-from sensor_msgs.msg import Imu
 from std_msgs.msg import String
-from std_srvs.srv import SetBool, Trigger
 
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
 from .stm32_protocol import (
+    BAUD_RATE,
+=======
+from .esp32_protocol import (
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
     FrameParser,
-    ImuFrame, BatteryFrame, MotorRpmFrame, ArmStateFrame, ErrorFrame,
-    encode_heartbeat, encode_speed_steer, encode_arm, encode_set_mode,
-    encode_pid_update,
+    RcChannels,
+    SensorData,
+    encode_heartbeat,
+    encode_led_cmd,
+    encode_output_cmd,
 )
 
-# ── Constants ─────────────────────────────────────────────────────────────────
-
-IMU_FRAME_ID = "imu_link"
-_ARM_LABEL   = {0: "DISARMED", 1: "ARMED", 2: "TILT_FAULT"}
-
-
-def _clamp(v: float, lo: float, hi: float) -> float:
-    return max(lo, min(hi, v))
-
-
-# ── Node ──────────────────────────────────────────────────────────────────────
 
 class Stm32CmdNode(Node):
-    """Binary-framed Jetson↔STM32 bridge node."""
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
+    """Orin ↔ ESP32-S3 IO auxiliary bridge node."""
+=======
+    """Binary-framed Jetson↔ESP32-S3 bridge node."""
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
 
     def __init__(self) -> None:
-        super().__init__("stm32_cmd_node")
+        super().__init__("esp32_cmd_node")
 
-        # ── Parameters ────────────────────────────────────────────────────────
-        self.declare_parameter("serial_port",      "/dev/ttyACM0")
-        self.declare_parameter("baud_rate",        921600)
+        # ── Parameters ────────────────────────────────────────────────────
+        self.declare_parameter("serial_port",      "/dev/esp32-io")
+        self.declare_parameter("baud_rate",        BAUD_RATE)
         self.declare_parameter("reconnect_delay",  2.0)
         self.declare_parameter("heartbeat_period", 0.2)
-        self.declare_parameter("watchdog_timeout", 0.5)
-        self.declare_parameter("speed_scale",      1000.0)
-        self.declare_parameter("steer_scale",      -500.0)
 
-        port                  = self.get_parameter("serial_port").value
-        baud                  = self.get_parameter("baud_rate").value
+        self._port_name       = self.get_parameter("serial_port").value
+        self._baud            = self.get_parameter("baud_rate").value
         self._reconnect_delay = self.get_parameter("reconnect_delay").value
         self._hb_period       = self.get_parameter("heartbeat_period").value
-        self._wd_timeout      = self.get_parameter("watchdog_timeout").value
-        self._speed_scale     = self.get_parameter("speed_scale").value
-        self._steer_scale     = self.get_parameter("steer_scale").value
 
-        # ── QoS ───────────────────────────────────────────────────────────────
-        sensor_qos = QoSProfile(
-            reliability=ReliabilityPolicy.BEST_EFFORT,
-            history=HistoryPolicy.KEEP_LAST, depth=10,
-        )
+        # ── QoS ───────────────────────────────────────────────────────────
         rel_qos = QoSProfile(
             reliability=ReliabilityPolicy.RELIABLE,
             history=HistoryPolicy.KEEP_LAST, depth=10,
         )
 
-        # ── Publishers ────────────────────────────────────────────────────────
-        self._imu_pub      = self.create_publisher(Imu,    "/saltybot/imu",           sensor_qos)
-        self._arm_pub      = self.create_publisher(String, "/saltybot/arm_state",      rel_qos)
-        self._error_pub    = self.create_publisher(String, "/saltybot/error",          rel_qos)
-        self._battery_pub  = self.create_publisher(String, "/saltybot/telemetry/battery",  rel_qos)
-        self._rpm_pub      = self.create_publisher(String, "/saltybot/telemetry/motor_rpm", rel_qos)
+        # ── Publishers ────────────────────────────────────────────────────
+        self._rc_pub   = self.create_publisher(String,          "/saltybot/rc_channels", rel_qos)
+        self._sens_pub = self.create_publisher(String,          "/saltybot/sensors",     rel_qos)
         self._diag_pub = self.create_publisher(DiagnosticArray, "/diagnostics",          rel_qos)
 
-        # ── Subscribers ───────────────────────────────────────────────────────
-        self._cmd_vel_sub = self.create_subscription(
-            Twist, "/cmd_vel", self._on_cmd_vel, rel_qos,
-        )
-        self._pid_sub = self.create_subscription(
-            String, "/saltybot/pid_update", self._on_pid_update, rel_qos,
-        )
+        # ── Subscriptions ─────────────────────────────────────────────────
+        self.create_subscription(String, "/saltybot/leds",    self._on_leds,    rel_qos)
+        self.create_subscription(String, "/saltybot/outputs", self._on_outputs, rel_qos)
 
-        # ── Services ──────────────────────────────────────────────────────────
-        self._arm_srv  = self.create_service(SetBool, "/saltybot/arm",      self._svc_arm)
-        self._mode_srv = self.create_service(SetBool, "/saltybot/set_mode", self._svc_set_mode)
-
-        # ── Serial state ──────────────────────────────────────────────────────
-        self._port_name = port
-        self._baud      = baud
+        # ── Serial state ──────────────────────────────────────────────────
         self._ser: serial.Serial | None = None
         self._ser_lock = threading.Lock()
         self._parser   = FrameParser()
+        self._rx_count = 0
 
-        # ── TX state ──────────────────────────────────────────────────────────
-        self._last_speed    = 0
-        self._last_steer    = 0
-        self._last_cmd_t    = time.monotonic()
-        self._watchdog_sent = False     # tracks whether we already sent zero
-
-        # ── Diagnostics state ──────────────────────────────────────────────────
-        self._last_arm_state   = -1
-        self._last_battery_mv  = 0
-        self._rx_frame_count   = 0
-
-        # ── Open serial and start timers ──────────────────────────────────────
+        # ── Open serial and start timers ──────────────────────────────────
         self._open_serial()
 
-        # Read at 200 Hz (serial RX thread is better, but timer keeps ROS2 integration clean)
         self._read_timer = self.create_timer(0.005,           self._read_cb)
-        # Heartbeat TX
         self._hb_timer   = self.create_timer(self._hb_period, self._heartbeat_cb)
-        # Watchdog check (fires at 2× watchdog_timeout for quick detection)
-        self._wd_timer   = self.create_timer(self._wd_timeout / 2, self._watchdog_cb)
-        # Periodic diagnostics
         self._diag_timer = self.create_timer(1.0,             self._publish_diagnostics)
 
         self.get_logger().info(
-            f"stm32_cmd_node started — {port} @ {baud} baud | "
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
+            f"stm32_cmd_node started — {self._port_name} @ {self._baud} baud"
+=======
+            f"esp32_cmd_node started — {port} @ {baud} baud | "
             f"HB {int(self._hb_period * 1000)}ms | WD {int(self._wd_timeout * 1000)}ms"
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
         )
 
-    # ── Serial management ─────────────────────────────────────────────────────
+    # ── Serial management ─────────────────────────────────────────────────
 
     def _open_serial(self) -> bool:
         with self._ser_lock:
@@ -170,7 +154,7 @@ class Stm32CmdNode(Node):
                 self._ser = serial.Serial(
                     port=self._port_name,
                     baudrate=self._baud,
-                    timeout=0.005,          # non-blocking reads
+                    timeout=0.005,
                     write_timeout=0.1,
                 )
                 self._ser.reset_input_buffer()
@@ -185,17 +169,7 @@ class Stm32CmdNode(Node):
                 self._ser = None
                 return False
 
-    def _close_serial(self) -> None:
-        with self._ser_lock:
-            if self._ser and self._ser.is_open:
-                try:
-                    self._ser.close()
-                except Exception:
-                    pass
-            self._ser = None
-
     def _write(self, data: bytes) -> bool:
-        """Thread-safe serial write. Returns False if port is not open."""
         with self._ser_lock:
             if self._ser is None or not self._ser.is_open:
                 return False
@@ -207,16 +181,15 @@ class Stm32CmdNode(Node):
                 self._ser = None
                 return False
 
-    # ── RX — read callback ────────────────────────────────────────────────────
+    # ── RX ────────────────────────────────────────────────────────────────
 
     def _read_cb(self) -> None:
-        """Read bytes from serial and feed them to the frame parser."""
         raw: bytes | None = None
-        reconnect_needed  = False
+        reconnect = False
 
         with self._ser_lock:
             if self._ser is None or not self._ser.is_open:
-                reconnect_needed = True
+                reconnect = True
             else:
                 try:
                     n = self._ser.in_waiting
@@ -225,9 +198,9 @@ class Stm32CmdNode(Node):
                 except serial.SerialException as exc:
                     self.get_logger().error(f"Serial read error: {exc}")
                     self._ser = None
-                    reconnect_needed = True
+                    reconnect = True
 
-        if reconnect_needed:
+        if reconnect:
             self.get_logger().warn(
                 "Serial disconnected — will retry",
                 throttle_duration_sec=self._reconnect_delay,
@@ -240,24 +213,41 @@ class Stm32CmdNode(Node):
             return
 
         for byte in raw:
-            frame = self._parser.feed(byte)
-            if frame is not None:
-                self._rx_frame_count += 1
-                self._dispatch_frame(frame)
+            msg = self._parser.feed(byte)
+            if msg is not None:
+                self._rx_count += 1
+                self._dispatch(msg)
 
-    def _dispatch_frame(self, frame) -> None:
-        """Route a decoded frame to the appropriate publisher."""
+    def _dispatch(self, msg) -> None:
         now = self.get_clock().now().to_msg()
+        ts  = f"{now.sec}.{now.nanosec:09d}"
 
-        if isinstance(frame, ImuFrame):
-            self._publish_imu(frame, now)
+        if isinstance(msg, RcChannels):
+            out = String()
+            out.data = json.dumps({
+                "channels": msg.channels,
+                "source":   msg.source,
+                "ts":       ts,
+            })
+            self._rc_pub.publish(out)
 
-        elif isinstance(frame, BatteryFrame):
-            self._publish_battery(frame, now)
+        elif isinstance(msg, SensorData):
+            out = String()
+            out.data = json.dumps({
+                "pressure_pa":   msg.pressure_pa,
+                "temperature_c": msg.temperature_c,
+                "tof_mm":        msg.tof_mm,
+                "ts":            ts,
+            })
+            self._sens_pub.publish(out)
 
-        elif isinstance(frame, MotorRpmFrame):
-            self._publish_motor_rpm(frame, now)
+        elif isinstance(msg, tuple):
+            type_code, _ = msg
+            self.get_logger().debug(f"Unknown inter-board type 0x{type_code:02X}")
 
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
+    # ── TX ────────────────────────────────────────────────────────────────
+=======
         elif isinstance(frame, ArmStateFrame):
             self._publish_arm_state(frame, now)
 
@@ -283,7 +273,7 @@ class Stm32CmdNode(Node):
         msg.angular_velocity.x = math.radians(frame.pitch_deg)
         msg.angular_velocity.y = math.radians(frame.roll_deg)
         msg.angular_velocity.z = math.radians(frame.yaw_deg)
-        cov = math.radians(0.3) ** 2    # ±0.3° noise estimate from STM32 BMI088
+        cov = math.radians(0.3) ** 2    # ±0.3° noise estimate from ESP32-S3 BMI088
         msg.angular_velocity_covariance[0] = cov
         msg.angular_velocity_covariance[4] = cov
         msg.angular_velocity_covariance[8] = cov
@@ -340,7 +330,7 @@ class Stm32CmdNode(Node):
 
     def _publish_error(self, frame: ErrorFrame, stamp) -> None:
         self.get_logger().error(
-            f"STM32 error code=0x{frame.error_code:02X} sub=0x{frame.subcode:02X}"
+            f"ESP32-S3 error code=0x{frame.error_code:02X} sub=0x{frame.subcode:02X}"
         )
         payload = {
             "error_code": frame.error_code,
@@ -368,102 +358,79 @@ class Stm32CmdNode(Node):
                 "SPEED_STEER dropped — serial not open",
                 throttle_duration_sec=2.0,
             )
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
 
     def _heartbeat_cb(self) -> None:
-        """Send HEARTBEAT every heartbeat_period (default 200ms)."""
         self._write(encode_heartbeat())
 
-    def _watchdog_cb(self) -> None:
-        """Send zero-speed if /cmd_vel silent for watchdog_timeout seconds."""
-        if time.monotonic() - self._last_cmd_t >= self._wd_timeout:
-            if not self._watchdog_sent:
-                self.get_logger().warn(
-                    f"No /cmd_vel for {self._wd_timeout:.1f}s — sending zero-speed"
-                )
-                self._watchdog_sent = True
-            self._last_speed = 0
-            self._last_steer = 0
-            self._write(encode_speed_steer(0, 0))
-
-    def _on_pid_update(self, msg: String) -> None:
-        """Parse JSON /saltybot/pid_update and send PID_UPDATE frame."""
+    def _on_leds(self, msg: String) -> None:
+        """Parse JSON {"pattern":N,"r":R,"g":G,"b":B} and send LED_CMD."""
         try:
-            data = json.loads(msg.data)
-            kp = float(data["kp"])
-            ki = float(data["ki"])
-            kd = float(data["kd"])
-        except (ValueError, KeyError, json.JSONDecodeError) as exc:
-            self.get_logger().error(f"Bad PID update JSON: {exc}")
-            return
-        frame = encode_pid_update(kp, ki, kd)
-        if self._write(frame):
-            self.get_logger().info(f"PID update: kp={kp}, ki={ki}, kd={kd}")
-        else:
-            self.get_logger().warn("PID_UPDATE dropped — serial not open")
-
-    # ── Services ──────────────────────────────────────────────────────────────
-
-    def _svc_arm(self, request: SetBool.Request, response: SetBool.Response):
-        """SetBool(True) = arm, SetBool(False) = disarm."""
-        arm = request.data
-        frame = encode_arm(arm)
-        ok = self._write(frame)
-        response.success = ok
-        response.message = ("ARMED" if arm else "DISARMED") if ok else "serial not open"
-        self.get_logger().info(
-            f"ARM service: {'arm' if arm else 'disarm'} — {'sent' if ok else 'FAILED'}"
+            d = json.loads(msg.data)
+            frame = encode_led_cmd(
+                int(d.get("pattern", 0)),
+                int(d.get("r", 0)),
+                int(d.get("g", 0)),
+                int(d.get("b", 0)),
             )
-        return response
+        except (ValueError, KeyError, json.JSONDecodeError) as exc:
+            self.get_logger().error(f"Bad /saltybot/leds JSON: {exc}")
+            return
+        self._write(frame)
 
-    def _svc_set_mode(self, request: SetBool.Request, response: SetBool.Response):
-        """SetBool: data maps to mode byte (True=1, False=0)."""
-        mode = 1 if request.data else 0
-        frame = encode_set_mode(mode)
-        ok = self._write(frame)
-        response.success = ok
-        response.message = f"mode={mode}" if ok else "serial not open"
-        return response
+    def _on_outputs(self, msg: String) -> None:
+        """Parse JSON {"horn":bool,"buzzer":bool,"headlight":0-255,"fan":0-255}."""
+        try:
+            d = json.loads(msg.data)
+            frame = encode_output_cmd(
+                bool(d.get("horn",     False)),
+                bool(d.get("buzzer",   False)),
+                int(d.get("headlight", 0)),
+                int(d.get("fan",       0)),
+            )
+        except (ValueError, KeyError, json.JSONDecodeError) as exc:
+            self.get_logger().error(f"Bad /saltybot/outputs JSON: {exc}")
+            return
+        self._write(frame)
 
-    # ── Diagnostics ───────────────────────────────────────────────────────────
+    # ── Diagnostics ───────────────────────────────────────────────────────
 
     def _publish_diagnostics(self) -> None:
         diag = DiagnosticArray()
         diag.header.stamp = self.get_clock().now().to_msg()
-
         status = DiagnosticStatus()
-        status.name        = "saltybot/stm32_cmd_node"
-        status.hardware_id = "stm32f722"
+<<<<<<< HEAD:jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/stm32_cmd_node.py
+        status.name        = "saltybot/esp32_io_bridge"
+        status.hardware_id = "esp32-s3-io"
+=======
+        status.name        = "saltybot/esp32_cmd_node"
+        status.hardware_id = "esp32s322"
 
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only):jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_cmd_node.py
         port_ok = self._ser is not None and self._ser.is_open
-        if port_ok:
-            status.level   = DiagnosticStatus.OK
-            status.message = "Serial OK"
-        else:
-            status.level   = DiagnosticStatus.ERROR
-            status.message = f"Serial disconnected: {self._port_name}"
-
-        wd_age = time.monotonic() - self._last_cmd_t
+        status.level   = DiagnosticStatus.OK if port_ok else DiagnosticStatus.ERROR
+        status.message = "Serial OK" if port_ok else f"Disconnected: {self._port_name}"
         status.values  = [
             KeyValue(key="serial_port", value=self._port_name),
+            KeyValue(key="baud_rate",   value=str(self._baud)),
             KeyValue(key="port_open",   value=str(port_ok)),
-            KeyValue(key="rx_frames",      value=str(self._rx_frame_count)),
+            KeyValue(key="rx_frames",   value=str(self._rx_count)),
             KeyValue(key="rx_errors",   value=str(self._parser.frames_error)),
-            KeyValue(key="last_speed",     value=str(self._last_speed)),
-            KeyValue(key="last_steer",     value=str(self._last_steer)),
-            KeyValue(key="cmd_vel_age_s",  value=f"{wd_age:.2f}"),
-            KeyValue(key="battery_mv",     value=str(self._last_battery_mv)),
-            KeyValue(key="arm_state",      value=_ARM_LABEL.get(self._last_arm_state, "?")),
         ]
         diag.status.append(status)
         self._diag_pub.publish(diag)
 
-    # ── Lifecycle ─────────────────────────────────────────────────────────────
+    # ── Lifecycle ─────────────────────────────────────────────────────────
 
     def destroy_node(self) -> None:
-        # Send zero-speed + disarm on shutdown
-        self._write(encode_speed_steer(0, 0))
-        self._write(encode_arm(False))
-        self._close_serial()
+        self._write(encode_heartbeat(state=0))
+        with self._ser_lock:
+            if self._ser and self._ser.is_open:
+                try:
+                    self._ser.close()
+                except Exception:
+                    pass
+            self._ser = None
         super().destroy_node()
 
 

jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/esp32_protocol.py

@@ -1,7 +1,7 @@
-"""stm32_protocol.py — Binary frame codec for Jetson↔STM32 communication.
+"""esp32_protocol.py — Binary frame codec for Jetson↔ESP32-S3 communication.
 
-Issue #119: defines the binary serial protocol between the Jetson Nano and the
-STM32F722 flight controller over USB CDC @ 921600 baud.
+Issue #119: defines the binary serial protocol between the Jetson Orin Nano Super and the
+ESP32-S3 ESP32-S3 BALANCE over USB CDC @ 921600 baud.
 
 Frame layout (all multi-byte fields are big-endian):
   ┌──────┬──────┬──────┬──────────────────┬───────────┬──────┐
@@ -12,14 +12,14 @@ Frame layout (all multi-byte fields are big-endian):
 CRC16 covers: TYPE + LEN + PAYLOAD (not STX, ETX, or CRC bytes themselves).
 CRC algorithm: CCITT-16, polynomial=0x1021, init=0xFFFF, no final XOR.
 
-Command types (Jetson → STM32):
+Command types (Jetson → ESP32-S3):
   0x01  HEARTBEAT   — no payload              (len=0)
   0x02  SPEED_STEER — int16 speed + int16 steer (len=4)  range: -1000..+1000
   0x03  ARM         — uint8 (0=disarm, 1=arm)  (len=1)
   0x04  SET_MODE    — uint8 mode               (len=1)
   0x05  PID_UPDATE  — float32 kp + ki + kd     (len=12)
 
-Telemetry types (STM32 → Jetson):
+Telemetry types (ESP32-S3 → Jetson):
   0x10  IMU         — int16×6: pitch,roll,yaw (×100 deg), ax,ay,az (×100 m/s²) (len=12)
   0x11  BATTERY     — uint16 voltage_mv + int16 current_ma + uint8 soc_pct (len=5)
   0x12  MOTOR_RPM   — int16 left_rpm + int16 right_rpm     (len=4)
@@ -27,11 +27,11 @@ Telemetry types (STM32 → Jetson):
   0x14  ERROR       — uint8 error_code + uint8 subcode      (len=2)
 
 Usage:
-  # Encoding (Jetson → STM32)
+  # Encoding (Jetson → ESP32-S3)
   frame = encode_speed_steer(300, -150)
   ser.write(frame)
 
-  # Decoding (STM32 → Jetson), one byte at a time
+  # Decoding (ESP32-S3 → Jetson), one byte at a time
   parser = FrameParser()
   for byte in incoming_bytes:
       result = parser.feed(byte)
@@ -87,7 +87,7 @@ class ImuFrame:
 class BatteryFrame:
     voltage_mv:  int      # millivolts (e.g. 11100 = 11.1 V)
     current_ma:  int      # milliamps (negative = charging)
-    soc_pct:     int      # state of charge 0–100 (from STM32 fuel gauge or lookup)
+    soc_pct:     int      # state of charge 0–100 (from ESP32-S3 fuel gauge or lookup)
 
 
 @dataclass
@@ -183,7 +183,7 @@ class ParseError(Exception):
 
 
 class FrameParser:
-    """Byte-by-byte streaming parser for STM32 telemetry frames.
+    """Byte-by-byte streaming parser for ESP32-S3 telemetry frames.
 
     Feed individual bytes via feed(); returns a decoded TelemetryFrame (or raw
     bytes tuple) when a complete valid frame is received.

jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/remote_estop_node.py

@@ -1,8 +1,15 @@
 """
-remote_estop_node.py -- Remote e-stop bridge: MQTT -> STM32 USB CDC
+<<<<<<< HEAD
+remote_estop_node.py -- Remote e-stop bridge: MQTT -> ESP32 USB CDC
 
-{"kill": true}  -> writes 'E\n' to STM32 (ESTOP_REMOTE, immediate motor cutoff)
-{"kill": false} -> writes 'Z\n' to STM32 (clear latch, robot can re-arm)
+{"kill": true}  -> writes 'E\n' to ESP32 BALANCE (ESTOP_REMOTE, immediate motor cutoff)
+{"kill": false} -> writes 'Z\n' to ESP32 BALANCE (clear latch, robot can re-arm)
+=======
+remote_estop_node.py -- Remote e-stop bridge: MQTT -> ESP32-S3 USB CDC
+
+{"kill": true}  -> writes 'E\n' to ESP32-S3 (ESTOP_REMOTE, immediate motor cutoff)
+{"kill": false} -> writes 'Z\n' to ESP32-S3 (clear latch, robot can re-arm)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 Cellular watchdog: if MQTT link drops for > cellular_timeout_s while in
 AUTO mode, automatically sends 'F\n' (ESTOP_CELLULAR_TIMEOUT).
@@ -26,7 +33,7 @@ class RemoteEstopNode(Node):
     def __init__(self):
         super().__init__('remote_estop_node')
 
-        self.declare_parameter('serial_port', '/dev/stm32-bridge')
+        self.declare_parameter('serial_port', '/dev/esp32-bridge')
         self.declare_parameter('baud_rate', 921600)
         self.declare_parameter('mqtt_host', 'mqtt.example.com')
         self.declare_parameter('mqtt_port', 1883)

jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/saltybot_can_node.py

@@ -322,7 +322,11 @@ class SaltybotCanNode(Node):
         diag.header.stamp = stamp
         st = DiagnosticStatus()
         st.name        = "saltybot/balance_controller"
-        st.hardware_id = "stm32f722"
+<<<<<<< HEAD
+        st.hardware_id = "esp32"
+=======
+        st.hardware_id = "esp32s322"
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         st.message     = state_label
         st.level       = (DiagnosticStatus.OK    if state == 1 else
                           DiagnosticStatus.WARN   if state == 0 else

jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/saltybot_cmd_node.py

@@ -1,20 +1,38 @@
 """
-saltybot_cmd_node — full bidirectional STM32↔Jetson bridge
+<<<<<<< HEAD
+saltybot_cmd_node — full bidirectional ESP32 BALANCE↔Jetson bridge
+=======
+saltybot_cmd_node — full bidirectional ESP32-S3↔Jetson bridge
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 Combines telemetry RX (from serial_bridge_node) with drive command TX.
 
 Owns /dev/ttyACM0 exclusively — do NOT run alongside serial_bridge_node.
 
-RX path (50Hz from STM32):
+<<<<<<< HEAD
+RX path (50Hz from ESP32 BALANCE):
   JSON telemetry → /saltybot/imu, /saltybot/balance_state, /diagnostics
 
 TX path:
-  /cmd_vel (geometry_msgs/Twist) → C<speed>,<steer>\\n  → STM32
-  Heartbeat timer (200ms)        → H\\n                 → STM32
+  /cmd_vel (geometry_msgs/Twist) → C<speed>,<steer>\\n  → ESP32 BALANCE
+  Heartbeat timer (200ms)        → H\\n                 → ESP32 BALANCE
 
 Protocol:
-  H\\n              — heartbeat. STM32 reverts steer to 0 if gap > 500ms.
+  H\\n              — heartbeat. ESP32 BALANCE reverts steer to 0 if gap > 500ms.
   C<spd>,<str>\\n   — drive command. speed/steer: -1000..+1000 integers.
-                      C command also refreshes STM32 heartbeat timer.
+                      C command also refreshes ESP32 BALANCE heartbeat timer.
+=======
+RX path (50Hz from ESP32-S3):
+  JSON telemetry → /saltybot/imu, /saltybot/balance_state, /diagnostics
+
+TX path:
+  /cmd_vel (geometry_msgs/Twist) → C<speed>,<steer>\\n  → ESP32-S3
+  Heartbeat timer (200ms)        → H\\n                 → ESP32-S3
+
+Protocol:
+  H\\n              — heartbeat. ESP32-S3 reverts steer to 0 if gap > 500ms.
+  C<spd>,<str>\\n   — drive command. speed/steer: -1000..+1000 integers.
+                      C command also refreshes ESP32-S3 heartbeat timer.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 Twist mapping (configurable via ROS2 params):
   speed = clamp(linear.x  * speed_scale, -1000, 1000)
@@ -100,7 +118,11 @@ class SaltybotCmdNode(Node):
         self._open_serial()
 
         # ── Timers ────────────────────────────────────────────────────────────
-        # Telemetry read at 100Hz (STM32 sends at 50Hz)
+<<<<<<< HEAD
+        # Telemetry read at 100Hz (ESP32 BALANCE sends at 50Hz)
+=======
+        # Telemetry read at 100Hz (ESP32-S3 sends at 50Hz)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         self._read_timer = self.create_timer(0.01, self._read_cb)
         # Heartbeat TX at configured period (default 200ms)
         self._hb_timer   = self.create_timer(self._hb_period, self._heartbeat_cb)
@@ -266,7 +288,11 @@ class SaltybotCmdNode(Node):
         diag.header.stamp = stamp
         status = DiagnosticStatus()
         status.name = "saltybot/balance_controller"
-        status.hardware_id = "stm32f722"
+<<<<<<< HEAD
+        status.hardware_id = "esp32"
+=======
+        status.hardware_id = "esp32s322"
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         status.message = state_label
         if state == 1:
             status.level = DiagnosticStatus.OK
@@ -294,11 +320,19 @@ class SaltybotCmdNode(Node):
         status = DiagnosticStatus()
         status.level = DiagnosticStatus.ERROR
         status.name = "saltybot/balance_controller"
-        status.hardware_id = "stm32f722"
+<<<<<<< HEAD
+        status.hardware_id = "esp32"
         status.message = f"IMU fault errno={errno}"
         diag.status.append(status)
         self._diag_pub.publish(diag)
-        self.get_logger().error(f"STM32 IMU fault: errno={errno}")
+        self.get_logger().error(f"ESP32 BALANCE IMU fault: errno={errno}")
+=======
+        status.hardware_id = "esp32s322"
+        status.message = f"IMU fault errno={errno}"
+        diag.status.append(status)
+        self._diag_pub.publish(diag)
+        self.get_logger().error(f"ESP32-S3 IMU fault: errno={errno}")
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
     # ── TX — command send ─────────────────────────────────────────────────────
 
@@ -316,7 +350,11 @@ class SaltybotCmdNode(Node):
             )
 
     def _heartbeat_cb(self):
-        """Send H\\n heartbeat. STM32 reverts steer to 0 if gap > 500ms."""
+<<<<<<< HEAD
+        """Send H\\n heartbeat. ESP32 BALANCE reverts steer to 0 if gap > 500ms."""
+=======
+        """Send H\\n heartbeat. ESP32-S3 reverts steer to 0 if gap > 500ms."""
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         self._write(b"H\n")
 
     # ── Lifecycle ─────────────────────────────────────────────────────────────

jetson/ros2_ws/src/saltybot_bridge/saltybot_bridge/serial_bridge_node.py

@@ -1,6 +1,10 @@
 """
 saltybot_bridge — serial_bridge_node
-STM32F722 USB CDC → ROS2 topic publisher
+<<<<<<< HEAD
+ESP32 USB CDC → ROS2 topic publisher
+=======
+ESP32-S3 USB CDC → ROS2 topic publisher
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 Telemetry frame (50 Hz, newline-delimited JSON):
   {"p":<pitch×10>,"r":<roll×10>,"e":<err×10>,"ig":<integral×10>,
@@ -29,7 +33,11 @@ from sensor_msgs.msg import Imu
 from std_msgs.msg import String
 from diagnostic_msgs.msg import DiagnosticArray, DiagnosticStatus, KeyValue
 
-# Balance state labels matching STM32 balance_state_t enum
+<<<<<<< HEAD
+# Balance state labels matching ESP32 BALANCE balance_state_t enum
+=======
+# Balance state labels matching ESP32-S3 balance_state_t enum
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 _STATE_LABEL = {0: "DISARMED", 1: "ARMED", 2: "TILT_FAULT"}
 
 # Sensor frame_id published in Imu header
@@ -38,7 +46,7 @@ IMU_FRAME_ID = "imu_link"
 
 class SerialBridgeNode(Node):
     def __init__(self):
-        super().__init__("stm32_serial_bridge")
+        super().__init__("esp32_serial_bridge")
 
         # ── Parameters ────────────────────────────────────────────────────────
         self.declare_parameter("serial_port", "/dev/ttyACM0")
@@ -83,7 +91,11 @@ class SerialBridgeNode(Node):
 
         # ── Open serial and start read timer ──────────────────────────────────
         self._open_serial()
-        # Poll at 100 Hz — STM32 sends at 50 Hz, so we never miss a frame
+<<<<<<< HEAD
+        # Poll at 100 Hz — ESP32 BALANCE sends at 50 Hz, so we never miss a frame
+=======
+        # Poll at 100 Hz — ESP32-S3 sends at 50 Hz, so we never miss a frame
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         self._timer = self.create_timer(0.01, self._read_cb)
 
         self.get_logger().info(
@@ -117,7 +129,11 @@ class SerialBridgeNode(Node):
 
     def write_serial(self, data: bytes) -> bool:
         """
-        Send raw bytes to STM32 over the open serial port.
+<<<<<<< HEAD
+        Send raw bytes to ESP32 BALANCE over the open serial port.
+=======
+        Send raw bytes to ESP32-S3 over the open serial port.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         Returns False if port is not open (caller should handle gracefully).
         Note: for bidirectional use prefer saltybot_cmd_node which owns TX natively.
         """
@@ -206,7 +222,11 @@ class SerialBridgeNode(Node):
         """
         Publish sensor_msgs/Imu.
 
-        The STM32 IMU gives Euler angles (pitch/roll from accelerometer+gyro
+<<<<<<< HEAD
+        The ESP32 BALANCE IMU gives Euler angles (pitch/roll from accelerometer+gyro
+=======
+        The ESP32-S3 IMU gives Euler angles (pitch/roll from accelerometer+gyro
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         fusion, yaw from gyro integration). We publish them as angular_velocity
         for immediate use by slam_toolbox / robot_localization.
 
@@ -264,7 +284,11 @@ class SerialBridgeNode(Node):
         diag.header.stamp = stamp
         status = DiagnosticStatus()
         status.name = "saltybot/balance_controller"
-        status.hardware_id = "stm32f722"
+<<<<<<< HEAD
+        status.hardware_id = "esp32"
+=======
+        status.hardware_id = "esp32s322"
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
         status.message = state_label
 
         if state == 1:   # ARMED
@@ -293,11 +317,19 @@ class SerialBridgeNode(Node):
         status = DiagnosticStatus()
         status.level = DiagnosticStatus.ERROR
         status.name = "saltybot/balance_controller"
-        status.hardware_id = "stm32f722"
+<<<<<<< HEAD
+        status.hardware_id = "esp32"
         status.message = f"IMU fault errno={errno}"
         diag.status.append(status)
         self._diag_pub.publish(diag)
-        self.get_logger().error(f"STM32 reported IMU fault: errno={errno}")
+        self.get_logger().error(f"ESP32 BALANCE reported IMU fault: errno={errno}")
+=======
+        status.hardware_id = "esp32s322"
+        status.message = f"IMU fault errno={errno}"
+        diag.status.append(status)
+        self._diag_pub.publish(diag)
+        self.get_logger().error(f"ESP32-S3 reported IMU fault: errno={errno}")
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
     def destroy_node(self):
         self._close_serial()

jetson/ros2_ws/src/saltybot_bridge/setup.py

@@ -13,7 +13,7 @@ setup(
             "launch/bridge.launch.py",
             "launch/cmd_vel_bridge.launch.py",
             "launch/remote_estop.launch.py",
-            "launch/stm32_cmd.launch.py",
+            "launch/esp32_cmd.launch.py",
             "launch/battery.launch.py",
             "launch/uart_bridge.launch.py",
         ]),
@@ -21,7 +21,7 @@ setup(
             "config/bridge_params.yaml",
             "config/cmd_vel_bridge_params.yaml",
             "config/estop_params.yaml",
-            "config/stm32_cmd_params.yaml",
+            "config/esp32_cmd_params.yaml",
             "config/battery_params.yaml",
         ]),
     ],
@@ -29,7 +29,11 @@ setup(
     zip_safe=True,
     maintainer="sl-jetson",
     maintainer_email="sl-jetson@saltylab.local",
-    description="STM32 USB CDC → ROS2 serial bridge for saltybot",
+<<<<<<< HEAD
+    description="ESP32 USB CDC → ROS2 serial bridge for saltybot",
+=======
+    description="ESP32-S3 USB CDC → ROS2 serial bridge for saltybot",
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
     license="MIT",
     tests_require=["pytest"],
     entry_points={
@@ -41,8 +45,13 @@ setup(
             # Nav2 cmd_vel bridge: velocity limits + ramp + deadman + mode gate
             "cmd_vel_bridge_node = saltybot_bridge.cmd_vel_bridge_node:main",
             "remote_estop_node  = saltybot_bridge.remote_estop_node:main",
-            # Binary-framed STM32 command node (Issue #119)
+<<<<<<< HEAD
+            # Binary-framed ESP32 BALANCE command node (Issue #119)
             "stm32_cmd_node    = saltybot_bridge.stm32_cmd_node:main",
+=======
+            # Binary-framed ESP32-S3 command node (Issue #119)
+            "esp32_cmd_node    = saltybot_bridge.esp32_cmd_node:main",
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
             # Battery management node (Issue #125)
             "battery_node      = saltybot_bridge.battery_node:main",
             # Production CAN bridge: FC telemetry RX + /cmd_vel TX over CAN (Issues #680, #672, #685)

jetson/ros2_ws/src/saltybot_bridge/test/test_cmd.py

@@ -1,5 +1,9 @@
 """
-Unit tests for Jetson→STM32 command serialization logic.
+<<<<<<< HEAD
+Unit tests for Jetson→ESP32 BALANCE command serialization logic.
+=======
+Unit tests for Jetson→ESP32-S3 command serialization logic.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 Tests Twist→speed/steer conversion and frame formatting.
 Run with: pytest jetson/ros2_ws/src/saltybot_bridge/test/test_cmd.py
 """

jetson/ros2_ws/src/saltybot_bridge/test/test_cmd_vel_bridge.py

@@ -139,10 +139,10 @@ class TestModeGate:
     MODE_ASSISTED  = 1
     MODE_AUTONOMOUS = 2
 
-    def _apply_mode_gate(self, stm32_mode, current_speed, current_steer,
+    def _apply_mode_gate(self, esp32_mode, current_speed, current_steer,
                           target_speed, target_steer, step=10):
         """Mirror of _control_cb mode gate logic."""
-        if stm32_mode != self.MODE_AUTONOMOUS:
+        if esp32_mode != self.MODE_AUTONOMOUS:
             # Reset ramp state, send zero
             return 0, 0, 0, 0  # (current_speed, current_steer, sent_speed, sent_steer)
         new_s = _ramp_toward(current_speed, target_speed, step)

jetson/ros2_ws/src/saltybot_bridge/test/test_esp32_cmd_node.py

@@ -1,4 +1,4 @@
-"""test_stm32_cmd_node.py — Unit tests for Stm32CmdNode with mock serial port.
+"""test_esp32_cmd_node.py — Unit tests for Stm32CmdNode with mock serial port.
 
 Tests:
   - Serial open/close lifecycle
@@ -12,7 +12,7 @@ Tests:
   - Zero-speed sent on node shutdown
   - CRC errors counted correctly
 
-Run with: pytest test/test_stm32_cmd_node.py -v
+Run with: pytest test/test_esp32_cmd_node.py -v
 No ROS2 runtime required — uses mock Node infrastructure.
 """
 
@@ -29,7 +29,7 @@ import pytest
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
-from saltybot_bridge.stm32_protocol import (
+from saltybot_bridge.esp32_protocol import (
     STX, ETX, CmdType, TelType,
     encode_speed_steer, encode_heartbeat, encode_arm, encode_pid_update,
     _build_frame, _crc16_ccitt,
@@ -219,10 +219,10 @@ class TestMockSerialTX:
 class TestMockSerialRX:
     """Test RX parsing path using MockSerial with pre-loaded telemetry data."""
 
-    from saltybot_bridge.stm32_protocol import FrameParser
+    from saltybot_bridge.esp32_protocol import FrameParser
 
     def test_rx_imu_frame(self):
-        from saltybot_bridge.stm32_protocol import FrameParser, ImuFrame
+        from saltybot_bridge.esp32_protocol import FrameParser, ImuFrame
         raw = _imu_frame_bytes(pitch=500, roll=-200, yaw=100, ax=0, ay=0, az=981)
         ms  = MockSerial(rx_data=raw)
         parser = FrameParser()
@@ -241,7 +241,7 @@ class TestMockSerialRX:
         assert f.accel_z   == pytest.approx(9.81)
 
     def test_rx_battery_frame(self):
-        from saltybot_bridge.stm32_protocol import FrameParser, BatteryFrame
+        from saltybot_bridge.esp32_protocol import FrameParser, BatteryFrame
         raw = _battery_frame_bytes(v_mv=10500, i_ma=1200, soc=45)
         ms  = MockSerial(rx_data=raw)
         parser = FrameParser()
@@ -257,7 +257,7 @@ class TestMockSerialRX:
         assert f.soc_pct    == 45
 
     def test_rx_multiple_frames_in_one_read(self):
-        from saltybot_bridge.stm32_protocol import FrameParser
+        from saltybot_bridge.esp32_protocol import FrameParser
         raw = (_imu_frame_bytes() + _arm_state_frame_bytes() + _battery_frame_bytes())
         ms  = MockSerial(rx_data=raw)
         parser = FrameParser()
@@ -271,7 +271,7 @@ class TestMockSerialRX:
         assert parser.frames_error == 0
 
     def test_rx_bad_crc_counted_as_error(self):
-        from saltybot_bridge.stm32_protocol import FrameParser
+        from saltybot_bridge.esp32_protocol import FrameParser
         raw = bytearray(_arm_state_frame_bytes(state=1))
         raw[-3] ^= 0xFF    # corrupt CRC
         ms = MockSerial(rx_data=bytes(raw))
@@ -282,7 +282,7 @@ class TestMockSerialRX:
         assert parser.frames_error == 1
 
     def test_rx_resync_after_corrupt_byte(self):
-        from saltybot_bridge.stm32_protocol import FrameParser, ArmStateFrame
+        from saltybot_bridge.esp32_protocol import FrameParser, ArmStateFrame
         garbage = b"\xDE\xAD\x00\x00"
         valid   = _arm_state_frame_bytes(state=1)
         ms = MockSerial(rx_data=garbage + valid)

jetson/ros2_ws/src/saltybot_bridge/test/test_esp32_protocol.py

@@ -1,4 +1,4 @@
-"""test_stm32_protocol.py — Unit tests for binary STM32 frame codec.
+"""test_esp32_protocol.py — Unit tests for binary ESP32-S3 frame codec.
 
 Tests:
   - CRC16-CCITT correctness
@@ -12,7 +12,7 @@ Tests:
   - Speed/steer clamping in encode_speed_steer
   - Round-trip encode → decode for all known telemetry types
 
-Run with: pytest test/test_stm32_protocol.py -v
+Run with: pytest test/test_esp32_protocol.py -v
 """
 
 from __future__ import annotations
@@ -25,7 +25,7 @@ import os
 # ── Path setup (no ROS2 install needed) ──────────────────────────────────────
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
-from saltybot_bridge.stm32_protocol import (
+from saltybot_bridge.esp32_protocol import (
     STX, ETX,
     CmdType, TelType,
     ImuFrame, BatteryFrame, MotorRpmFrame, ArmStateFrame, ErrorFrame,

jetson/ros2_ws/src/saltybot_bridge/test/test_parse.py

@@ -1,5 +1,9 @@
 """
-Unit tests for STM32 telemetry parsing logic.
+<<<<<<< HEAD
+Unit tests for ESP32 BALANCE telemetry parsing logic.
+=======
+Unit tests for ESP32-S3 telemetry parsing logic.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 Run with: pytest jetson/ros2_ws/src/saltybot_bridge/test/test_parse.py
 """
 

jetson/ros2_ws/src/saltybot_bridge_msgs/msg/WheelTicks.msg

@@ -1,4 +1,4 @@
-# WheelTicks.msg — cumulative wheel encoder tick counts from STM32 (Issue #184)
+# WheelTicks.msg — cumulative wheel encoder tick counts from ESP32-S3 (Issue #184)
 #
 # left_ticks  : cumulative left  encoder count (int32, wraps at ±2^31)
 # right_ticks : cumulative right encoder count (int32, wraps at ±2^31)

jetson/ros2_ws/src/saltybot_bridge_msgs/package.xml

@@ -3,7 +3,7 @@
 <package format="3">
   <name>saltybot_bridge_msgs</name>
   <version>0.1.0</version>
-  <description>STM32 bridge message definitions — wheel encoder ticks and low-level hardware telemetry (Issue #184)</description>
+  <description>ESP32-S3 bridge message definitions — wheel encoder ticks and low-level hardware telemetry (Issue #184)</description>
   <maintainer email="sl-perception@saltylab.local">sl-perception</maintainer>
   <license>MIT</license>
 

jetson/ros2_ws/src/saltybot_bringup/config/nav2_params.yaml

@@ -19,7 +19,11 @@
 #   inflation_radius: 0.3m (robot_radius 0.15m + 0.15m padding)
 #   DepthCostmapLayer in-layer inflation: 0.10m (pre-inflation before inflation_layer)
 #
-# Output: /cmd_vel (Twist) — STM32 bridge consumes this topic.
+<<<<<<< HEAD
+# Output: /cmd_vel (Twist) — ESP32 bridge consumes this topic.
+=======
+# Output: /cmd_vel (Twist) — ESP32-S3 bridge consumes this topic.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
 bt_navigator:
   ros__parameters:

jetson/ros2_ws/src/saltybot_bringup/config/rosbridge_params.yaml

@@ -53,7 +53,14 @@ rosbridge_websocket:
        "/vesc/left/state",
        "/vesc/right/state",
        "/tf",
-       "/tf_static"]
+       "/tf_static",
+       "/saltybot/phone/gps",
+       "/saltybot/phone/imu",
+       "/saltybot/phone/battery",
+       "/saltybot/phone/bridge/status",
+       "/gps/fix",
+       "/gps/vel",
+       "/saltybot/ios/gps"]
 
     services_glob: "[]"       # no service calls via WebSocket
     params_glob:   "[]"       # no parameter access via WebSocket
@@ -67,7 +74,7 @@ rosbridge_websocket:
 
     # Delay between consecutive outgoing messages (ms). 0 = unlimited.
     # Set > 0 (e.g. 10) if browser JS event loop is overwhelmed.
-    delay_between_messages: 0
+    delay_between_messages: 0.0
 
     # ── Logging ───────────────────────────────────────────────────────────────
     # Set to true to log every publish/subscribe call (verbose, dev only).

jetson/ros2_ws/src/saltybot_bringup/config/saltybot_params.yaml

@@ -2,12 +2,16 @@
 # Master configuration for full stack bringup
 
 # ────────────────────────────────────────────────────────────────────────────
-# HARDWARE — STM32 Bridge & Motor Control
+<<<<<<< HEAD
+# HARDWARE — ESP32 BALANCE Bridge & Motor Control
+=======
+# HARDWARE — ESP32-S3 Bridge & Motor Control
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 # ────────────────────────────────────────────────────────────────────────────
 
 saltybot_bridge_node:
   ros__parameters:
-    serial_port: "/dev/stm32-bridge"
+    serial_port: "/dev/esp32-bridge"
     baud_rate: 921600
     timeout: 0.05
     reconnect_delay: 2.0

jetson/ros2_ws/src/saltybot_bringup/launch/full_stack.launch.py

@@ -39,7 +39,7 @@ Modes
     ─ UWB driver (2-anchor DW3000, publishes /uwb/target)
     ─ YOLOv8n person detection (TensorRT)
     ─ Person follower with UWB+camera fusion
-    ─ cmd_vel bridge → STM32 (deadman + ramp + AUTONOMOUS gate)
+    ─ cmd_vel bridge → ESP32-S3 (deadman + ramp + AUTONOMOUS gate)
     ─ rosbridge WebSocket (port 9090)
 
   outdoor
@@ -57,8 +57,8 @@ Modes
 Launch sequence (wall-clock delays — conservative for cold start)
 ─────────────────────────────────────────────────────────────────
    t= 0s  robot_description   (URDF + TF tree)
-   t= 0s  STM32 bridge        (serial port owner — must be first)
-   t= 2s  cmd_vel bridge      (consumes /cmd_vel, needs STM32 bridge up)
+   t= 0s  ESP32-S3 bridge        (serial port owner — must be first)
+   t= 2s  cmd_vel bridge      (consumes /cmd_vel, needs ESP32-S3 bridge up)
    t= 2s  sensors             (RPLIDAR + RealSense)
    t= 4s  UWB driver          (independent serial device)
    t= 4s  CSI cameras         (optional, independent)
@@ -71,10 +71,10 @@ Launch sequence (wall-clock delays — conservative for cold start)
 
 Safety wiring
 ─────────────
-  • STM32 bridge must be up before cmd_vel bridge sends any command.
+  • ESP32-S3 bridge must be up before cmd_vel bridge sends any command.
   • cmd_vel bridge has 500ms deadman: stops robot if /cmd_vel goes silent.
-  • STM32 AUTONOMOUS mode gate (md=2) in cmd_vel bridge — robot stays still
-    until STM32 firmware is in AUTONOMOUS mode regardless of /cmd_vel.
+  • ESP32-S3 AUTONOMOUS mode gate (md=2) in cmd_vel bridge — robot stays still
+    until ESP32-S3 firmware is in AUTONOMOUS mode regardless of /cmd_vel.
   • follow_enabled:=false disables person follower without stopping the node.
   • To e-stop at runtime: ros2 topic pub /saltybot/estop std_msgs/Bool '{data: true}'
 
@@ -91,7 +91,7 @@ Topics published by this stack
   /person/target                   PoseStamped    (camera position, base_link)
   /person/detections               Detection2DArray
   /cmd_vel                         Twist          (from follower or Nav2)
-  /saltybot/cmd                    String         (to STM32)
+  /saltybot/cmd                    String         (to ESP32-S3)
   /saltybot/imu                    Imu
   /saltybot/balance_state          String
 """
@@ -209,7 +209,7 @@ def generate_launch_description():
     enable_bridge_arg = DeclareLaunchArgument(
         "enable_bridge",
         default_value="true",
-        description="Launch STM32 serial bridge + cmd_vel bridge (disable for sim/rosbag)",
+        description="Launch ESP32-S3 serial bridge + cmd_vel bridge (disable for sim/rosbag)",
     )
 
     enable_rosbridge_arg = DeclareLaunchArgument(
@@ -267,10 +267,10 @@ enable_mission_logging_arg = DeclareLaunchArgument(
         description="UWB anchor-1 serial port (starboard/right side)",
     )
 
-    stm32_port_arg = DeclareLaunchArgument(
-        "stm32_port",
-        default_value="/dev/stm32-bridge",
-        description="STM32 USB CDC serial port",
+    esp32_port_arg = DeclareLaunchArgument(
+        "esp32_port",
+        default_value="/dev/esp32-bridge",
+        description="ESP32-S3 USB CDC serial port",
     )
 
     # ── Shared substitution handles ───────────────────────────────────────────
@@ -282,7 +282,7 @@ enable_mission_logging_arg = DeclareLaunchArgument(
     max_linear_vel  = LaunchConfiguration("max_linear_vel")
     uwb_port_a      = LaunchConfiguration("uwb_port_a")
     uwb_port_b      = LaunchConfiguration("uwb_port_b")
-    stm32_port      = LaunchConfiguration("stm32_port")
+    esp32_port      = LaunchConfiguration("esp32_port")
 
     # ── t=0s  Robot description (URDF + TF tree) ──────────────────────────────
     robot_description = IncludeLaunchDescription(
@@ -290,15 +290,15 @@ enable_mission_logging_arg = DeclareLaunchArgument(
         launch_arguments={"use_sim_time": use_sim_time}.items(),
     )
 
-    # ── t=0s  STM32 bidirectional serial bridge ────────────────────────────────
-    stm32_bridge = GroupAction(
+    # ── t=0s  ESP32-S3 bidirectional serial bridge ───────────────────────────────
+    esp32_bridge = GroupAction(
         condition=IfCondition(LaunchConfiguration("enable_bridge")),
         actions=[
             IncludeLaunchDescription(
                 _launch("saltybot_bridge", "launch", "bridge.launch.py"),
                 launch_arguments={
                     "mode":        "bidirectional",
-                    "serial_port": stm32_port,
+                    "serial_port": esp32_port,
                 }.items(),
             ),
         ],
@@ -320,7 +320,7 @@ enable_mission_logging_arg = DeclareLaunchArgument(
         ],
     )
 
-    # ── t=2s  cmd_vel safety bridge (depends on STM32 bridge) ────────────────
+    # ── t=2s  cmd_vel safety bridge (depends on ESP32-S3 bridge) ────────────────
     cmd_vel_bridge = TimerAction(
         period=2.0,
         actions=[
@@ -577,14 +577,14 @@ enable_mission_logging_arg,
         max_linear_vel_arg,
         uwb_port_a_arg,
         uwb_port_b_arg,
-        stm32_port_arg,
+        esp32_port_arg,
 
         # Startup banner
         banner,
 
         # t=0s
         robot_description,
-        stm32_bridge,
+        esp32_bridge,
 
         # t=0.5s
         mission_logging,

jetson/ros2_ws/src/saltybot_bringup/launch/realsense.launch.py

@@ -1,7 +1,7 @@
 """
 realsense.launch.py — Intel RealSense D435i driver (standalone)
 
-Launches realsense2_camera_node with Jetson Nano power-budget settings:
+Launches realsense2_camera_node with Jetson Orin Nano Super power-budget settings:
   - 640×480 @ 15fps (depth + RGB) — saves ~0.4W vs 30fps
   - IMU enabled with linear interpolation (unified /camera/imu topic)
   - Depth aligned to color frame

jetson/ros2_ws/src/saltybot_bringup/launch/saltybot_bringup.launch.py

@@ -15,11 +15,15 @@ Usage
   ros2 launch saltybot_bringup saltybot_bringup.launch.py
   ros2 launch saltybot_bringup saltybot_bringup.launch.py profile:=minimal
   ros2 launch saltybot_bringup saltybot_bringup.launch.py profile:=debug
-  ros2 launch saltybot_bringup saltybot_bringup.launch.py profile:=full stm32_port:=/dev/ttyUSB0
+  ros2 launch saltybot_bringup saltybot_bringup.launch.py profile:=full esp32_port:=/dev/ttyUSB0
 
 Startup sequence
 ────────────────
-  GROUP A — Drivers      t= 0 s  STM32 bridge, RealSense+RPLIDAR, motor daemon, IMU
+<<<<<<< HEAD
+  GROUP A — Drivers      t= 0 s  ESP32 bridge, RealSense+RPLIDAR, motor daemon, IMU
+=======
+  GROUP A — Drivers      t= 0 s  ESP32-S3 bridge, RealSense+RPLIDAR, motor daemon, IMU
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
   health gate ───────────────────────────────────────────────── t= 8 s (full/debug)
   GROUP B — Perception   t= 8 s  UWB, person detection, object detection, depth costmap, gimbal
   health gate ───────────────────────────────────────────────── t=16 s (full/debug)
@@ -35,7 +39,7 @@ Shutdown
 
 Hardware conditionals
 ─────────────────────
-  Missing devices (stm32_port, uwb_port_a/b, gimbal_port) skip that driver.
+  Missing devices (esp32_port, uwb_port_a/b, gimbal_port) skip that driver.
   All conditionals are evaluated at launch time via PathJoinSubstitution + IfCondition.
 """
 
@@ -120,10 +124,14 @@ def generate_launch_description() -> LaunchDescription:  # noqa: C901
         description="Use /clock from rosbag/simulator",
     )
 
-    stm32_port_arg = DeclareLaunchArgument(
-        "stm32_port",
-        default_value="/dev/stm32-bridge",
-        description="STM32 USART bridge serial device",
+    esp32_port_arg = DeclareLaunchArgument(
+        "esp32_port",
+        default_value="/dev/esp32-bridge",
+<<<<<<< HEAD
+        description="ESP32 UART bridge serial device",
+=======
+        description="ESP32-S3 USART bridge serial device",
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
     )
 
     uwb_port_a_arg = DeclareLaunchArgument(
@@ -160,7 +168,7 @@ def generate_launch_description() -> LaunchDescription:  # noqa: C901
 
     profile         = LaunchConfiguration("profile")
     use_sim_time    = LaunchConfiguration("use_sim_time")
-    stm32_port      = LaunchConfiguration("stm32_port")
+    esp32_port      = LaunchConfiguration("esp32_port")
     uwb_port_a      = LaunchConfiguration("uwb_port_a")
     uwb_port_b      = LaunchConfiguration("uwb_port_b")
     gimbal_port     = LaunchConfiguration("gimbal_port")
@@ -198,7 +206,11 @@ def generate_launch_description() -> LaunchDescription:  # noqa: C901
 
     # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
     # GROUP A — DRIVERS   (t = 0 s, all profiles)
-    # Dependency order: STM32 bridge first, then sensors, then motor daemon.
+<<<<<<< HEAD
+    # Dependency order: ESP32 bridge first, then sensors, then motor daemon.
+=======
+    # Dependency order: ESP32-S3 bridge first, then sensors, then motor daemon.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
     # Health gate: subsequent groups delayed until t_perception (8 s full/debug).
     # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
@@ -212,12 +224,16 @@ def generate_launch_description() -> LaunchDescription:  # noqa: C901
         launch_arguments={"use_sim_time": use_sim_time}.items(),
     )
 
-    # STM32 bidirectional bridge (JLINK USART1)
-    stm32_bridge = IncludeLaunchDescription(
+<<<<<<< HEAD
+    # ESP32 BALANCE bridge
+=======
+    # ESP32-S3 bidirectional bridge (JLINK USART1)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
+    esp32_bridge = IncludeLaunchDescription(
         _launch("saltybot_bridge", "launch", "bridge.launch.py"),
         launch_arguments={
             "mode":        "bidirectional",
-            "serial_port": stm32_port,
+            "serial_port": esp32_port,
         }.items(),
     )
 
@@ -232,7 +248,11 @@ def generate_launch_description() -> LaunchDescription:  # noqa: C901
         ],
     )
 
-    # Motor daemon: /cmd_vel → STM32 DRIVE frames (depends on bridge at t=0)
+<<<<<<< HEAD
+    # Motor daemon: /cmd_vel → ESP32 BALANCE DRIVE frames (depends on bridge at t=0)
+=======
+    # Motor daemon: /cmd_vel → ESP32-S3 DRIVE frames (depends on bridge at t=0)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
     motor_daemon = TimerAction(
         period=2.5,
         actions=[
@@ -541,7 +561,7 @@ def generate_launch_description() -> LaunchDescription:  # noqa: C901
         # ── Arguments ──────────────────────────────────────────────────────────
         profile_arg,
         use_sim_time_arg,
-        stm32_port_arg,
+        esp32_port_arg,
         uwb_port_a_arg,
         uwb_port_b_arg,
         gimbal_port_arg,
@@ -559,7 +579,7 @@ def generate_launch_description() -> LaunchDescription:  # noqa: C901
 
         # ── GROUP A: Drivers (all profiles, t=0–4s) ───────────────────────────
         robot_description,
-        stm32_bridge,
+        esp32_bridge,
         sensors,
         motor_daemon,
         sensor_health,

jetson/ros2_ws/src/saltybot_bringup/saltybot_bringup/_wheel_odom.py

@@ -20,7 +20,11 @@ theta is kept in (−π, π] after every step.
 
 Int32 rollover
 --------------
-STM32 encoder counters are int32 and wrap at ±2^31.  `unwrap_delta` handles
+<<<<<<< HEAD
+ESP32 BALANCE encoder counters are int32 and wrap at ±2^31.  `unwrap_delta` handles
+=======
+ESP32-S3 encoder counters are int32 and wrap at ±2^31.  `unwrap_delta` handles
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 this by detecting jumps larger than half the int32 range and adjusting by the
 full range:
 

jetson/ros2_ws/src/saltybot_bringup/saltybot_bringup/launch_profiles.py

@@ -29,7 +29,7 @@ class Profile:
     name: str
 
     # ── Group A: Drivers (always on in all profiles) ──────────────────────
-    enable_stm32_bridge: bool = True
+    enable_esp32_bridge: bool = True
     enable_sensors:      bool = True   # RealSense + RPLIDAR
     enable_motor_daemon: bool = True
     enable_imu:          bool = True
@@ -69,14 +69,18 @@ class Profile:
     t_ui:         float = 22.0  # Group D (nav2 needs ~4 s to load costmaps)
 
     # ── Safety ────────────────────────────────────────────────────────────
-    watchdog_timeout_s:  float = 5.0   # max silence from STM32 bridge (s)
+<<<<<<< HEAD
+    watchdog_timeout_s:  float = 5.0   # max silence from ESP32 bridge (s)
+=======
+    watchdog_timeout_s:  float = 5.0   # max silence from ESP32-S3 bridge (s)
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
     cmd_vel_deadman_s:   float = 0.5   # cmd_vel watchdog in bridge
     max_linear_vel:      float = 0.5   # m/s cap passed to bridge + follower
     follow_distance_m:   float = 1.5   # target follow distance (m)
 
     # ── Hardware conditionals ─────────────────────────────────────────────
     #  Paths checked at launch; absent devices skip the relevant node.
-    stm32_port:  str = "/dev/stm32-bridge"
+    esp32_port:  str = "/dev/esp32-bridge"
     uwb_port_a:  str = "/dev/uwb-anchor0"
     uwb_port_b:  str = "/dev/uwb-anchor1"
     gimbal_port: str = "/dev/ttyTHS1"
@@ -90,7 +94,11 @@ class Profile:
 # ── Profile factory ────────────────────────────────────────────────────────────
 
 def _minimal() -> Profile:
-    """Minimal: STM32 bridge + sensors + motor daemon.
+<<<<<<< HEAD
+    """Minimal: ESP32 bridge + sensors + motor daemon.
+=======
+    """Minimal: ESP32-S3 bridge + sensors + motor daemon.
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 
     Safe drive control only.  No AI, no nav, no social.
     Boot time ~4 s.  RAM ~400 MB.
@@ -115,7 +123,7 @@ def _full() -> Profile:
     return Profile(
         name="full",
         # Drivers
-        enable_stm32_bridge=True,
+        enable_esp32_bridge=True,
         enable_sensors=True,
         enable_motor_daemon=True,
         enable_imu=True,

jetson/ros2_ws/src/saltybot_bringup/saltybot_bringup/wheel_odom_node.py

@@ -1,7 +1,11 @@
 """
 wheel_odom_node.py — Differential drive wheel encoder odometry (Issue #184).
 
-Subscribes to raw encoder tick counts from the STM32 bridge, integrates
+<<<<<<< HEAD
+Subscribes to raw encoder tick counts from the ESP32 bridge, integrates
+=======
+Subscribes to raw encoder tick counts from the ESP32-S3 bridge, integrates
+>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
 differential drive kinematics, and publishes nav_msgs/Odometry at 50 Hz.
 Optionally broadcasts the odom → base_link TF transform.
 

jetson/ros2_ws/src/saltybot_bringup/systemd/can-bringup.service

@@ -1,5 +1,5 @@
 [Unit]
-Description=CANable 2.0 CAN bus bringup (can0, 500 kbps)
+Description=CANable 2.0 CAN bus bringup (can0, 1 Mbps DroneCAN — Here4 GPS)
 Documentation=https://gitea.vayrette.com/seb/saltylab-firmware/issues/643
 # Wait until the gs_usb net device appears; udev fires After=sys-subsystem-net-devices-can0.device
 After=network.target sys-subsystem-net-devices-can0.device
@@ -10,7 +10,7 @@ BindsTo=sys-subsystem-net-devices-can0.device
 Type=oneshot
 RemainAfterExit=yes
 
-ExecStart=/usr/sbin/ip link set can0 up type can bitrate 500000
+ExecStart=/usr/sbin/ip link set can0 up type can bitrate 1000000
 ExecStop=/usr/sbin/ip link set can0 down
 
 StandardOutput=journal