Compare commits
No commits in common. "main" and "sl-android/issue-700-ble-pairing-ui" have entirely different histories.
main
...
sl-android
@ -1,162 +0,0 @@
|
||||
# .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}"
|
||||
@ -7,11 +7,7 @@ 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)
|
||||
<<<<<<< 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)
|
||||
- Sent via USB CDC to the STM32 firmware
|
||||
- Robot arms after ARMING_HOLD_MS (~500ms) safety hold period
|
||||
- Works even when RC is not connected or not armed
|
||||
|
||||
@ -46,11 +42,7 @@ The robot can now be armed and operated autonomously from the Jetson without req
|
||||
|
||||
## Command Protocol
|
||||
|
||||
<<<<<<< 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)
|
||||
### From Jetson to STM32 (USB CDC)
|
||||
```
|
||||
A — Request arm (triggers safety hold, then motors enable)
|
||||
D — Request disarm (immediate motor stop)
|
||||
@ -60,11 +52,7 @@ H — Heartbeat (refresh timeout timer, every 500ms)
|
||||
C<spd>,<str> — Drive command: speed, steer (also refreshes heartbeat)
|
||||
```
|
||||
|
||||
<<<<<<< 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)
|
||||
### From STM32 to Jetson (USB CDC)
|
||||
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)
|
||||
|
||||
31
CLAUDE.md
31
CLAUDE.md
@ -1,36 +1,17 @@
|
||||
# SaltyLab Firmware — Agent Playbook
|
||||
|
||||
## Project
|
||||
<<<<<<< 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)
|
||||
Self-balancing two-wheeled robot: STM32F722 flight controller, hoverboard hub motors, Jetson Nano for AI/SLAM.
|
||||
|
||||
## Team
|
||||
| Agent | Role | Focus |
|
||||
|-------|------|-------|
|
||||
<<<<<<< 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-firmware** | Embedded Firmware Lead | STM32 HAL, USB CDC 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 Orin Nano Super, RealSense D435i, RPLIDAR, ROS2, Nav2 |
|
||||
>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
|
||||
| **sl-perception** | Perception / SLAM Engineer | Jetson Nano, RealSense D435i, RPLIDAR, ROS2, Nav2 |
|
||||
|
||||
## Status
|
||||
USB Serial (CH343) TX bug resolved (PR #10 — DCache MPU non-cacheable region + IWDG ordering fix).
|
||||
USB CDC TX bug resolved (PR #10 — DCache MPU non-cacheable region + IWDG ordering fix).
|
||||
|
||||
## Repo Structure
|
||||
- `projects/saltybot/SALTYLAB.md` — Design doc
|
||||
@ -48,11 +29,11 @@ USB Serial (CH343) TX bug resolved (PR #10 — DCache MPU non-cacheable region +
|
||||
| `saltyrover-dev` | Integration — rover variant |
|
||||
| `saltytank` | Stable — tracked tank variant |
|
||||
| `saltytank-dev` | Integration — tank variant |
|
||||
| `main` | Shared code only (IMU drivers, USB Serial (CH343), balance core, safety) |
|
||||
| `main` | Shared code only (IMU drivers, USB CDC, balance core, safety) |
|
||||
|
||||
### Rules
|
||||
- Agents branch FROM `<variant>-dev` and PR back TO `<variant>-dev`
|
||||
- Shared/infrastructure code (IMU drivers, USB Serial (CH343), balance core, safety) goes in `main`
|
||||
- Shared/infrastructure code (IMU drivers, USB CDC, 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`
|
||||
|
||||
52
TEAM.md
52
TEAM.md
@ -1,22 +1,12 @@
|
||||
# SaltyLab — Ideal Team
|
||||
|
||||
## Project
|
||||
<<<<<<< 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.
|
||||
Self-balancing two-wheeled robot using a drone flight controller (STM32F722), hoverboard hub motors, and eventually a Jetson Nano 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 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)
|
||||
- **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`
|
||||
|
||||
---
|
||||
|
||||
@ -24,30 +14,18 @@ Self-balancing two-wheeled robot using a drone ESP32-S3 BALANCE (ESP32-S3), hove
|
||||
|
||||
### 1. Embedded Firmware Engineer (Lead)
|
||||
**Must-have:**
|
||||
<<<<<<< HEAD
|
||||
- Deep ESP32 (Arduino/ESP-IDF) or STM32 HAL experience
|
||||
- Deep STM32 HAL experience (F7 series specifically)
|
||||
- USB OTG FS / CDC ACM debugging (TxState, endpoint management, DMA conflicts)
|
||||
- SPI + UART + USB coexistence on ESP32
|
||||
- PlatformIO or bare-metal ESP32 toolchain
|
||||
- SPI + UART + USB coexistence on STM32
|
||||
- PlatformIO or bare-metal STM32 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:**
|
||||
- ESP32-S3 peripheral coexistence (SPI + UART + USB)
|
||||
- Betaflight/iNav/ArduPilot codebase familiarity
|
||||
- PID control loop tuning for balance robots
|
||||
- FOC motor control (hoverboard ESC protocol)
|
||||
|
||||
<<<<<<< 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)
|
||||
**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.
|
||||
|
||||
### 2. Control Systems / Robotics Engineer
|
||||
**Must-have:**
|
||||
@ -65,7 +43,7 @@ Self-balancing two-wheeled robot using a drone ESP32-S3 BALANCE (ESP32-S3), hove
|
||||
|
||||
### 3. Perception / SLAM Engineer (Phase 2)
|
||||
**Must-have:**
|
||||
- Jetson Orin Nano Super / NVIDIA Jetson platform
|
||||
- Jetson Nano / NVIDIA Jetson platform
|
||||
- Intel RealSense D435i depth camera
|
||||
- RPLIDAR integration
|
||||
- SLAM (ORB-SLAM3, RTAB-Map, or similar)
|
||||
@ -76,23 +54,19 @@ Self-balancing two-wheeled robot using a drone ESP32-S3 BALANCE (ESP32-S3), hove
|
||||
- Obstacle avoidance
|
||||
- Nav2 stack
|
||||
|
||||
**Why:** Phase 2 goal is autonomous navigation. Jetson Orin Nano Super with RealSense + RPLIDAR for indoor mapping and person following.
|
||||
**Why:** Phase 2 goal is autonomous navigation. Jetson Nano with RealSense + RPLIDAR for indoor mapping and person following.
|
||||
|
||||
---
|
||||
|
||||
## Hardware Reference
|
||||
| Component | Details |
|
||||
|-----------|---------|
|
||||
<<<<<<< HEAD
|
||||
| FC | ESP32 BALANCE (ESP32RET6, MPU6000) |
|
||||
=======
|
||||
| FC | ESP32-S3 BALANCE (ESP32-S3RET6, QMI8658) |
|
||||
>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
|
||||
| FC | MAMBA F722S (STM32F722RET6, MPU6000) |
|
||||
| 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 Orin Nano Super + Noctua fan |
|
||||
| AI Brain | Jetson Nano + Noctua fan |
|
||||
| Depth | Intel RealSense D435i |
|
||||
| LIDAR | RPLIDAR A1M8 |
|
||||
| Spare IMUs | BNO055, MPU6050 |
|
||||
@ -100,4 +74,4 @@ Self-balancing two-wheeled robot using a drone ESP32-S3 BALANCE (ESP32-S3), hove
|
||||
## Repo
|
||||
- Gitea: https://gitea.vayrette.com/seb/saltylab-firmware
|
||||
- Design doc: `projects/saltybot/SALTYLAB.md`
|
||||
- Bug doc: `legacy/stm32/USB_CDC_BUG.md` (archived — STM32 era)
|
||||
- Bug doc: `USB_CDC_BUG.md`
|
||||
|
||||
@ -127,7 +127,7 @@ loop — USB would never enumerate cleanly.
|
||||
| LED2 | PC15 | GPIO |
|
||||
| Buzzer | PB2 | GPIO/TIM4_CH3 |
|
||||
|
||||
MCU: ESP32RET6 (ESP32 BALANCE FC, Betaflight target DIAT-MAMBAF722_2022B)
|
||||
MCU: STM32F722RET6 (MAMBA F722S FC, Betaflight target DIAT-MAMBAF722_2022B)
|
||||
|
||||
---
|
||||
|
||||
@ -60,7 +60,7 @@ color("Purple", 0.9)
|
||||
translate([0, 0, h_fc])
|
||||
cube([36, 36, 5], center=true);
|
||||
|
||||
// Jetson Orin Nano Super
|
||||
// Jetson Nano
|
||||
color("LimeGreen", 0.7)
|
||||
translate([0, 0, h_jetson])
|
||||
cube([100, 80, 29], center=true);
|
||||
|
||||
@ -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 Orin Nano Super ---
|
||||
// --- Jetson Nano ---
|
||||
jetson_w = 100;
|
||||
jetson_d = 80;
|
||||
jetson_h = 29; // With heatsink
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
// ============================================
|
||||
// SaltyLab — Jetson Orin Nano Super Shelf
|
||||
// SaltyLab — Jetson Nano Shelf
|
||||
// 120×100×15mm PETG
|
||||
// Mounts Jetson Orin Nano Super to 2020 extrusion
|
||||
// Mounts Jetson Nano to 2020 extrusion
|
||||
// ============================================
|
||||
include <dimensions.scad>
|
||||
|
||||
|
||||
@ -56,24 +56,15 @@
|
||||
3. Fasten 4× M4×12 SHCS. Torque 2.5 N·m.
|
||||
4. Insert battery pack; route Velcro straps through slots and cinch.
|
||||
|
||||
<<<<<<< HEAD
|
||||
### 7 MCU mount (ESP32 BALANCE + ESP32 IO)
|
||||
|
||||
> ⚠️ **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)
|
||||
### 7 FC mount (MAMBA F722S)
|
||||
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.
|
||||
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.
|
||||
|
||||
### 8 Jetson Orin Nano Super mount plate
|
||||
### 8 Jetson Nano 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 Orin Nano Super B01 carrier onto plate standoffs; fasten M3×6 BHCS.
|
||||
3. Set Jetson Nano B01 carrier onto plate standoffs; fasten M3×6 BHCS.
|
||||
|
||||
### 9 Bumper brackets
|
||||
1. Slide 22mm EMT conduit through saddle clamp openings.
|
||||
@ -95,8 +86,7 @@
|
||||
| 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 |
|
||||
| ESP32 BALANCE hole pattern | TBD — await spec from max | ±0.2 mm |
|
||||
| ESP32 IO hole pattern | TBD — await spec from max | ±0.2 mm |
|
||||
| FC hole pattern | 30.5 × 30.5 mm | ±0.2 mm |
|
||||
| Jetson hole pattern | 58 × 58 mm | ±0.2 mm |
|
||||
| Battery tray inner | 185 × 72 × 52 mm | +2 / 0 mm |
|
||||
|
||||
|
||||
@ -41,11 +41,7 @@ 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 |
|
||||
<<<<<<< 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)
|
||||
| 6 | FC standoff M3×6mm nylon | 4 | Nylon | — | MAMBA F722S vibration isolation |
|
||||
| 7 | Ø4mm × 16mm alignment pin | 8 | Steel dowel | — | Dropout clamp-to-plate alignment |
|
||||
|
||||
### Battery Stem Clamp (`stem_battery_clamp.scad`) — Part B
|
||||
@ -74,7 +70,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 Orin Nano Super mount plate | 1 | 4mm 5052 aluminium or 4mm PETG FDM | B01 58×58mm hole pattern |
|
||||
| 13 | Jetson Nano 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 |
|
||||
|
||||
@ -92,23 +88,12 @@ 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 |
|
||||
|---|------|-----|------|-------|
|
||||
<<<<<<< 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 |
|
||||
| 13 | STM32 MAMBA F722S 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 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)
|
||||
| 16 | Jetson Nano B01 module | 1 | 69.6×45mm module + carrier | 58×58mm M3 carrier hole pattern |
|
||||
| 17 | Nylon M3 standoff 8mm | 4 | F/F nylon | Jetson board standoffs |
|
||||
|
||||
---
|
||||
@ -159,8 +144,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 | ESP32 mount + miscellaneous |
|
||||
| 30 | M3×6 BHCS | 4 | ISO 4762, SS | ESP32 board bolts (qty TBD pending board spec) |
|
||||
| 29 | M3×10 SHCS | 12 | ISO 4762, SS | FC mount + miscellaneous |
|
||||
| 30 | M3×6 BHCS | 4 | ISO 4762, SS | FC board bolts |
|
||||
| 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 | |
|
||||
|
||||
@ -8,9 +8,9 @@
|
||||
// Requirements:
|
||||
// - 600mm wheelbase
|
||||
// - 2x hoverboard hub motors (170mm OD)
|
||||
// - ESP32-S3 ESP32-S3 BALANCE FC mount (30.5x30.5mm pattern)
|
||||
// - STM32 MAMBA F722S FC mount (30.5x30.5mm pattern)
|
||||
// - Battery tray (24V 4Ah — ~180x70x50mm pack)
|
||||
// - Jetson Orin Nano Super B01 mount plate (100x80mm, M3 holes)
|
||||
// - Jetson Nano 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 (ESP32-S3 BALANCE — 30.5 × 30.5 mm M3 pattern) ──────────────────────
|
||||
// ── FC mount (MAMBA F722S — 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 Orin Nano Super B01 mount plate ──────────────────────────────────────────────
|
||||
// ── Jetson Nano 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) {
|
||||
// ESP32-S3 BALANCE: 30.5×30.5 mm M3 pattern, centred at origin
|
||||
// MAMBA F722S: 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 Orin Nano Super B01 mount plate ─────────────────────────────────────────────
|
||||
// ─── Jetson Nano B01 mount plate ─────────────────────────────────────────────
|
||||
// Positioned rear of deck, elevated on standoffs
|
||||
module jetson_mount_plate() {
|
||||
jet_x = 60; // offset toward rear
|
||||
|
||||
@ -104,11 +104,7 @@ 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 |
|
||||
<<<<<<< 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)
|
||||
| FC (MAMBA F722S) | Passive; FC has own EMI shield | 85 °C | <60 °C ambient OK |
|
||||
| ESC × 2 | Al pad → lid | 100 °C Tj | Target ≤ 60 °C |
|
||||
| D435i | Passive; housing vent gap on rear cap | 45 °C surface | — |
|
||||
|
||||
|
||||
@ -65,7 +65,7 @@ CLAMP_ALIGN_D = 4.1; // Ø4 pin
|
||||
// D-cut bore clearance
|
||||
DCUT_CL = 0.3;
|
||||
|
||||
// FC mount — ESP32-S3 BALANCE 30.5 × 30.5 mm M3
|
||||
// FC mount — MAMBA F722S 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 (ESP32-S3 BALANCE 30.5 × 30.5 M3) ────────────────────────
|
||||
// ── FC mount (MAMBA F722S 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])
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
// • Ventilation slots — all 4 walls + lid
|
||||
//
|
||||
// Shared mounting patterns (swappable with SaltyLab):
|
||||
// FC : 30.5 × 30.5 mm M3 (ESP32-S3 BALANCE / Pixhawk)
|
||||
// FC : 30.5 × 30.5 mm M3 (MAMBA F722S / Pixhawk)
|
||||
// Jetson: 58 × 49 mm M3 (Orin NX / Nano Devkit carrier)
|
||||
//
|
||||
// Coordinate: bay centred at origin; Z=0 = deck top face.
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
// • Weight target: <2 kg frame (excl. motors/electronics)
|
||||
//
|
||||
// Shared SaltyLab patterns (swappable electronics):
|
||||
// FC : 30.5 × 30.5 mm M3 (ESP32-S3 BALANCE / Pixhawk)
|
||||
// FC : 30.5 × 30.5 mm M3 (MAMBA F722S / 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 — ESP32-S3 BALANCE / Pixhawk (30.5 × 30.5 mm M3) ────────────────────
|
||||
// ── FC mount — MAMBA F722S / Pixhawk (30.5 × 30.5 mm M3) ────────────────────
|
||||
// Shared with SaltyLab — swappable electronics
|
||||
FC_PITCH = 30.5;
|
||||
FC_HOLE_D = 3.2;
|
||||
|
||||
@ -1,296 +0,0 @@
|
||||
// ============================================================
|
||||
// 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();
|
||||
}
|
||||
@ -2,44 +2,22 @@
|
||||
|
||||
You're working on **SaltyLab**, a self-balancing two-wheeled indoor robot. Read this entire file before touching anything.
|
||||
|
||||
## ⚠️ ARCHITECTURE — SAUL-TEE (finalised 2026-04-04)
|
||||
## Project Overview
|
||||
|
||||
<<<<<<< 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. **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.
|
||||
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.
|
||||
|
||||
```
|
||||
Jetson (speed+steer via UART1) ←→ ELRS RC (UART3, kill switch)
|
||||
│
|
||||
▼
|
||||
ESP32-S3 BALANCE (MPU6000 IMU, PID balance)
|
||||
MAMBA F722S (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:
|
||||
@ -57,14 +35,10 @@ This is not a toy. 8" hub motors + 36V battery can crush fingers, break toes, an
|
||||
## Repository Layout
|
||||
|
||||
```
|
||||
<<<<<<< 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)
|
||||
firmware/ # STM32 HAL firmware (PlatformIO)
|
||||
├── src/
|
||||
│ ├── main.c # Entry point, clock config, main loop
|
||||
│ ├── icm42688.c # QMI8658-P SPI driver (backup IMU — currently broken)
|
||||
│ ├── icm42688.c # ICM-42688-P SPI driver (backup IMU — currently broken)
|
||||
│ ├── bmp280.c # Barometer driver (disabled)
|
||||
│ └── status.c # LED + buzzer status patterns
|
||||
├── include/
|
||||
@ -75,7 +49,7 @@ firmware/ # ESP-IDF firmware (PlatformIO)
|
||||
│ ├── crsf.h # ELRS CRSF protocol
|
||||
│ ├── bmp280.h
|
||||
│ └── status.h
|
||||
├── lib/USB_CDC/ # USB Serial (CH343) stack (serial over USB)
|
||||
├── lib/USB_CDC/ # USB CDC stack (serial over USB)
|
||||
│ ├── src/ # CDC implementation, USB descriptors, PCD config
|
||||
│ └── include/
|
||||
└── platformio.ini # Build config
|
||||
@ -108,24 +82,16 @@ PLATFORM.md # Hardware platform reference
|
||||
|
||||
## Hardware Quick Reference
|
||||
|
||||
<<<<<<< HEAD
|
||||
### ESP32 BALANCE Flight Controller
|
||||
### MAMBA F722S Flight Controller
|
||||
|
||||
| Spec | Value |
|
||||
|------|-------|
|
||||
| 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)
|
||||
| MCU | STM32F722RET6 (Cortex-M7, 216MHz, 512KB flash, 256KB RAM) |
|
||||
| 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 | QMI8658-P (on same SPI1, CS unknown — currently non-functional) |
|
||||
| Secondary IMU | ICM-42688-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 |
|
||||
@ -138,7 +104,7 @@ PLATFORM.md # Hardware platform reference
|
||||
|
||||
| UART | Pins | Connected To | Baud |
|
||||
|------|------|-------------|------|
|
||||
| USART1 | PA9/PA10 | Jetson Orin Nano Super | 115200 |
|
||||
| USART1 | PA9/PA10 | Jetson Nano | 115200 |
|
||||
| USART2 | PA2/PA3 | Hoverboard ESC | 115200 |
|
||||
| USART3 | PB10/PB11 | ELRS Receiver | 420000 (CRSF) |
|
||||
| UART4 | — | Spare | — |
|
||||
@ -159,7 +125,7 @@ PLATFORM.md # Hardware platform reference
|
||||
| FC board size | ~36mm square |
|
||||
| Hub motor body | Ø200mm (~8") |
|
||||
| Motor axle | Ø12mm, 45mm long |
|
||||
| Jetson Orin Nano Super | 100×80×29mm, M2.5 holes at 86×58mm |
|
||||
| Jetson Nano | 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 |
|
||||
@ -194,27 +160,19 @@ 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.
|
||||
<<<<<<< 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)
|
||||
2. **DCache breaks SPI on STM32F7** — disable DCache or use cache-aligned DMA buffers with clean/invalidate. We disable it.
|
||||
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 Serial (CH343) needs ReceivePacket() primed in CDC_Init** — without it, the OUT endpoint never starts listening. No data reception.
|
||||
5. **USB CDC 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 Serial (CH343)
|
||||
1. Send `R` byte over USB CDC
|
||||
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
|
||||
<<<<<<< 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)
|
||||
5. If magic found: clears it, remaps system memory, jumps to STM32 bootloader at `0x1FF00000`
|
||||
6. Board appears as DFU device, ready for `dfu-util` flash
|
||||
|
||||
### Build & Flash
|
||||
@ -240,14 +198,14 @@ Fallback: HSI 16MHz if HSE fails (PLL M=16)
|
||||
## Current Status & Known Issues
|
||||
|
||||
### Working
|
||||
- USB Serial (CH343) serial streaming (50Hz JSON: `{"ax":...,"ay":...,"az":...,"gx":...,"gy":...,"gz":...}`)
|
||||
- USB CDC 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
|
||||
- **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.
|
||||
- **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.
|
||||
- **MPU6000 driver** — header exists but implementation needs completion
|
||||
- **PID balance loop** — not yet implemented
|
||||
- **Hoverboard ESC UART** — protocol defined, driver not written
|
||||
@ -285,7 +243,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 Serial (CH343) (50Hz JSON)
|
||||
### FC → USB CDC (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
|
||||
|
||||
@ -1,10 +1,6 @@
|
||||
# Face LCD Animation System (Issue #507)
|
||||
|
||||
<<<<<<< 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)
|
||||
Implements expressive face animations on an STM32 LCD display with 5 core emotions and smooth transitions.
|
||||
|
||||
## Features
|
||||
|
||||
@ -86,11 +82,7 @@ STATUS → Echo current emotion + idle state
|
||||
- Colors: Monochrome (1-bit) or RGB565
|
||||
|
||||
### Microcontroller
|
||||
<<<<<<< HEAD
|
||||
- ESP32xx (ESP32 BALANCE)
|
||||
=======
|
||||
- ESP32-S3xx (ESP32-S3 BALANCE)
|
||||
>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
|
||||
- STM32F7xx (Mamba F722S)
|
||||
- Available UART: USART3 (PB10=TX, PB11=RX)
|
||||
- Clock: 216 MHz
|
||||
|
||||
|
||||
@ -81,7 +81,7 @@
|
||||
│ │
|
||||
│ [RealSense D435i] │ ← Front-facing, angled down ~10°
|
||||
│ │ Height: ~400mm from ground
|
||||
│ [Jetson Orin Nano Super] │ ← Center, in ventilated enclosure
|
||||
│ [Jetson Nano] │ ← 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 Orin Nano Super (barrel jack 5V/4A)
|
||||
├──→ DC-DC 36V→5V ──→ Jetson Nano (barrel jack 5V/4A)
|
||||
│ ──→ USB hub (sensors)
|
||||
│
|
||||
├──→ DC-DC 36V→12V ──→ LED strips
|
||||
|
||||
@ -33,7 +33,7 @@ Self-balancing two-wheeled indoor robot with AI brain.
|
||||
|
||||
| Component | Voltage | Current | Power (W) | Notes |
|
||||
|-----------|---------|---------|-----------|-------|
|
||||
| Jetson Orin Nano Super | 5V | 2-4A | 10-20W | AI inference mode: ~15W avg |
|
||||
| Jetson Nano | 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 Orin Nano Super + heatsink | 280 | With Noctua fan |
|
||||
| Jetson Nano + 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 Orin Nano Super shelf
|
||||
250mm — Jetson Nano 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 Orin Nano Super on shelf, connect 5V power
|
||||
- [ ] Mount Jetson Nano 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
|
||||
|
||||
196
docs/SALTYLAB.md
196
docs/SALTYLAB.md
@ -1,6 +1,6 @@
|
||||
# SAUL-TEE — Self-Balancing Wagon Robot 🔬
|
||||
# SaltyLab — Self-Balancing Indoor Bot 🔬
|
||||
|
||||
Four-wheel wagon (870×510×550 mm, 23 kg). Full spec: `docs/SAUL-TEE-SYSTEM-REFERENCE.md`
|
||||
Two-wheeled, self-balancing robot for indoor AI/SLAM experiments.
|
||||
|
||||
## ⚠️ SAFETY — TOP PRIORITY
|
||||
|
||||
@ -32,8 +32,8 @@ Four-wheel wagon (870×510×550 mm, 23 kg). Full spec: `docs/SAUL-TEE-SYSTEM-REF
|
||||
|------|--------|
|
||||
| 2x 8" pneumatic hub motors (36 PSI) | ✅ Have |
|
||||
| 1x hoverboard ESC (FOC firmware) | ✅ Have |
|
||||
| 1x Drone FC (ESP32-S3 + QMI8658) | ✅ Have — balance brain |
|
||||
| 1x Jetson Orin Nano Super + Noctua fan | ✅ Have |
|
||||
| 1x Drone FC (STM32F745 + MPU-6000) | ✅ Have — balance brain |
|
||||
| 1x Jetson Nano + Noctua fan | ✅ Have |
|
||||
| 1x RealSense D435i | ✅ Have |
|
||||
| 1x RPLIDAR A1M8 | ✅ Have |
|
||||
| 1x battery pack (36V) | ✅ Have |
|
||||
@ -49,19 +49,20 @@ Four-wheel wagon (870×510×550 mm, 23 kg). Full spec: `docs/SAUL-TEE-SYSTEM-REF
|
||||
| 1x BetaFPV ELRS 2.4GHz 1W TX module | ✅ Have — RC control + kill switch |
|
||||
| 1x ELRS receiver (matching) | ✅ Have — mounts on FC UART |
|
||||
|
||||
### 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
|
||||
### 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
|
||||
|
||||
## Architecture
|
||||
|
||||
@ -73,7 +74,7 @@ Four-wheel wagon (870×510×550 mm, 23 kg). Full spec: `docs/SAUL-TEE-SYSTEM-REF
|
||||
│ RealSense │ ← Forward-facing depth+RGB
|
||||
│ D435i │
|
||||
├──────────────┤
|
||||
│ Jetson Orin Nano Super │ ← AI brain: navigation, person tracking
|
||||
│ Jetson Nano │ ← AI brain: navigation, person tracking
|
||||
│ │ Sends velocity commands via UART
|
||||
├──────────────┤
|
||||
│ Drone FC │ ← Balance brain: IMU + PID @ 8kHz
|
||||
@ -91,22 +92,145 @@ Four-wheel wagon (870×510×550 mm, 23 kg). Full spec: `docs/SAUL-TEE-SYSTEM-REF
|
||||
└─────┘ └─────┘
|
||||
```
|
||||
|
||||
## Self-Balancing Control — ESP32-S3 BALANCE Board
|
||||
## Self-Balancing Control — Custom Firmware on Drone FC
|
||||
|
||||
> For full system architecture, firmware details, and protocol specs, see
|
||||
> **docs/SAUL-TEE-SYSTEM-REFERENCE.md**
|
||||
### 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).
|
||||
|
||||
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.
|
||||
### 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 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)
|
||||
- **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 |
|
||||
|
||||
## LED Subsystem (ESP32-C3)
|
||||
|
||||
@ -156,8 +280,8 @@ GND ──→ Common ground
|
||||
```
|
||||
|
||||
### Dev Tools
|
||||
- **Flashing:** ESP32-S3CubeProgrammer via USB (DFU mode) or SWD
|
||||
- **IDE:** PlatformIO + ESP-IDF, or ESP32-S3CubeIDE
|
||||
- **Flashing:** STM32CubeProgrammer via USB (DFU mode) or SWD
|
||||
- **IDE:** PlatformIO + STM32 HAL, or STM32CubeIDE
|
||||
- **Debug:** SWD via ST-Link (or use FC's USB as virtual COM for printf debug)
|
||||
|
||||
## Physical Design
|
||||
@ -224,7 +348,7 @@ GND ──→ Common ground
|
||||
|
||||
## Software Stack
|
||||
|
||||
### Jetson Orin Nano Super
|
||||
### Jetson Nano
|
||||
- **OS:** JetPack 4.6.1 (Ubuntu 18.04)
|
||||
- **ROS2 Humble** (or Foxy) for:
|
||||
- `nav2` — navigation stack
|
||||
@ -251,8 +375,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 ESP32-S3 (ESP-IDF)
|
||||
- [ ] Write QMI8658 SPI driver (read gyro+accel, complementary filter)
|
||||
- [ ] Set up PlatformIO project for STM32F745 (STM32 HAL)
|
||||
- [ ] Write MPU-6000 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)
|
||||
|
||||
@ -1,222 +0,0 @@
|
||||
# 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
|
||||
```
|
||||
@ -2,7 +2,7 @@
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<title>GEPRC GEP-F722-45A AIO — Board Layout (Legacy / Archived)</title>
|
||||
<title>GEPRC GEP-F722-45A AIO — Board Layout</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,13 +112,8 @@ 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">ESP32-S3RET6 + ICM-42688-P | Betaflight target: GEPR-GEPRC_F722_AIO</p>
|
||||
>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
|
||||
<p class="subtitle">STM32F722RET6 + ICM-42688-P | Betaflight target: GEPR-GEPRC_F722_AIO</p>
|
||||
|
||||
<div class="container">
|
||||
<div class="board-wrap">
|
||||
@ -130,11 +125,7 @@ h1 { color: #e94560; margin-bottom: 5px; font-size: 1.4em; }
|
||||
<div class="mount br"></div>
|
||||
|
||||
<!-- MCU -->
|
||||
<<<<<<< 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)
|
||||
<div class="mcu"><div class="dot"></div>STM32<br>F722RET6<br>216MHz</div>
|
||||
|
||||
<!-- IMU -->
|
||||
<div class="imu">ICM<br>42688</div>
|
||||
@ -215,7 +206,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 Orin Nano Super</span>
|
||||
<span><b>USART1</b> T1/R1 → Jetson Nano</span>
|
||||
</div>
|
||||
<div class="legend-item">
|
||||
<div class="swatch" style="background:#FF9800"></div>
|
||||
|
||||
@ -1,155 +1,131 @@
|
||||
# SaltyLab / SAUL-TEE Wiring Reference
|
||||
# SaltyLab Wiring Diagram
|
||||
|
||||
> ⚠️ **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)
|
||||
## System Overview
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────────────┐
|
||||
│ ORIN NANO SUPER │
|
||||
│ (Top Plate — 25W) │
|
||||
│ │
|
||||
<<<<<<< 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-C ──── STM32 CDC (/dev/stm32-bridge, 921600 baud) │
|
||||
│ 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 → 2x IMX219 (front + left) │
|
||||
│ CSI-B ──── ArduCam adapter → 2x IMX219 (rear + right) │
|
||||
│ CSI-A ──── ArduCam adapter → 2× IMX219 (front + left) │
|
||||
│ CSI-B ──── ArduCam adapter → 2× 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 ESP32-S3 BALANCE (ttyTHS0, 460800) │
|
||||
│ Pin 10 ─┤ UART fallback to FC (ttyTHS0, 921600) │
|
||||
│ Pin 6 ──┘ GND │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────────────┘
|
||||
│ USB-A (CANable2) │ UART fallback (3 wires)
|
||||
│ SocketCAN slcan0 │ 460800 baud, 3.3V
|
||||
│ 500 kbps │
|
||||
│ USB-C (data only) │ UART fallback (3 wires)
|
||||
│ 921600 baud │ 921600 baud, 3.3V
|
||||
▼ ▼
|
||||
┌─────────────────────────────────────────────────────────────────────┐
|
||||
<<<<<<< HEAD
|
||||
│ ESP32-S3 BALANCE │
|
||||
│ (Waveshare Touch LCD 1.28, Middle Plate) │
|
||||
=======
|
||||
│ ESP32-S3 BALANCE (FC) │
|
||||
│ MAMBA F722S (FC) │
|
||||
│ (Middle Plate — foam mounted) │
|
||||
>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
|
||||
│ │
|
||||
│ 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 │
|
||||
│ 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 (ISO 11898) │ UART (460800 baud)
|
||||
│ 500 kbps │
|
||||
│ USART2 │ UART4
|
||||
│ PA2=TX → ESC RX │ PA0=TX → ELRS TX
|
||||
│ PA3=RX ← ESC TX │ PA1=RX ← ELRS RX
|
||||
│ GND ─── GND │ GND ─── GND
|
||||
▼ ▼
|
||||
┌────────────────────────┐ ┌──────────────────────────┐
|
||||
│ 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) │
|
||||
│ HOVERBOARD ESC │ │ ELRS 2.4GHz RX │
|
||||
│ (Bottom Plate) │ │ (beside FC) │
|
||||
│ │ │ │
|
||||
│ 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 MOTOR RIGHT MOTOR
|
||||
```
|
||||
│
|
||||
┌────┴────┐
|
||||
▼ ▼
|
||||
🛞 LEFT RIGHT 🛞
|
||||
MOTOR MOTOR
|
||||
|
||||
|
||||
## Wire-by-Wire Connections
|
||||
|
||||
<<<<<<< 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)
|
||||
### 1. Orin ↔ FC (Primary: USB CDC)
|
||||
|
||||
| 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 |
|
||||
| From | To | Wire Color | Notes |
|
||||
|------|----|-----------|-------|
|
||||
| Orin USB-C port | FC USB-C port | USB cable | Data only, FC powered from 5V bus |
|
||||
|
||||
<<<<<<< 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`
|
||||
- Device: `/dev/ttyACM0` → symlink `/dev/stm32-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 <-> ESP32-S3 BALANCE (Fallback: Hardware UART)
|
||||
### 2. Orin ↔ FC (Fallback: Hardware UART)
|
||||
|
||||
| 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 |
|
||||
| Orin Pin | Signal | FC Pin | FC Signal |
|
||||
|----------|--------|--------|-----------|
|
||||
| Pin 8 | TXD0 | PC7 | USART6 RX |
|
||||
| Pin 10 | RXD0 | PC6 | USART6 TX |
|
||||
| Pin 6 | GND | GND | GND |
|
||||
|
||||
- Jetson device: `/dev/ttyTHS0`
|
||||
- Baud: 460800, 8N1
|
||||
- Baud: 921600, 8N1
|
||||
- Voltage: 3.3V both sides (no level shifter needed)
|
||||
- Cross-connect: Orin TX -> BALANCE RX, Orin RX <- BALANCE TX
|
||||
- **Cross-connect:** Orin TX → FC RX, Orin RX ← FC TX
|
||||
|
||||
### 3. Orin <-> ESP32-S3 IO (USB Serial)
|
||||
### 3. FC ↔ Hoverboard ESC
|
||||
|
||||
| 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 |
|
||||
| FC Pin | Signal | ESC Pin | Notes |
|
||||
|--------|--------|---------|-------|
|
||||
| PA2 | USART2 TX | RX | FC sends speed/steer commands |
|
||||
| PA3 | USART2 RX | TX | ESC sends feedback (optional) |
|
||||
| GND | GND | GND | Common ground |
|
||||
|
||||
- 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)
|
||||
- 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
|
||||
|
||||
### 5. Power Distribution
|
||||
|
||||
```
|
||||
BATTERY (36V) ──┬── VESC Left (36V direct -> BLDC left motor)
|
||||
├── VESC Right (36V direct -> BLDC right motor)
|
||||
BATTERY (36V) ──┬── Hoverboard ESC (36V direct)
|
||||
│
|
||||
├── 5V BEC/regulator ──┬── Orin (USB-C PD or barrel jack)
|
||||
│ ├── ESP32-S3 BALANCE (5V via USB-C)
|
||||
│ ├── ESP32-S3 IO (5V via USB-C)
|
||||
│ ├── FC (via USB or 5V pad)
|
||||
│ ├── ELRS RX (5V)
|
||||
│ ├── WS2812B LEDs (5V)
|
||||
│ └── RPLIDAR (5V via USB)
|
||||
│
|
||||
└── Battery monitor ──── ESP32-S3 BALANCE ADC (voltage divider)
|
||||
└── Battery monitor ──── FC ADC (PC1=voltage, PC3=current)
|
||||
```
|
||||
|
||||
### 6. Sensors on Orin (USB/CSI)
|
||||
@ -160,39 +136,10 @@ BATTERY (36V) ──┬── VESC Left (36V direct -> BLDC left motor)
|
||||
| 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 x4 | M.2 Key M | `/dev/nvme0n1` |
|
||||
| CANable2 | USB-CAN | USB-A | `/dev/canable2` -> `slcan0` |
|
||||
| 1TB NVMe | PCIe Gen3 ×4 | M.2 Key M | `/dev/nvme0n1` |
|
||||
|
||||
|
||||
<<<<<<< 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)
|
||||
## FC UART Summary (MAMBA F722S)
|
||||
|
||||
| UART | Pins | Baud | Assignment | Notes |
|
||||
|------|------|------|------------|-------|
|
||||
@ -202,8 +149,7 @@ VESC Left CAN ID = 56 (0x38), VESC Right CAN ID = 68 (0x44).
|
||||
| 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 Serial (CH343) | USB-C | 921600 | Jetson primary | `/dev/esp32-bridge` |
|
||||
>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
|
||||
| USB CDC | USB-C | 921600 | Jetson primary | `/dev/stm32-bridge` |
|
||||
|
||||
|
||||
### 7. ReSpeaker 2-Mic HAT (on Orin 40-pin header)
|
||||
@ -221,63 +167,57 @@ VESC Left CAN ID = 56 (0x38), VESC Right CAN ID = 68 (0x44).
|
||||
| Pin 2, 4 | 5V | Power |
|
||||
| Pin 6, 9 | GND | Ground |
|
||||
|
||||
- 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
|
||||
- **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
|
||||
|
||||
### 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 BALANCE 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 FC fallback, flexible antenna placement
|
||||
- **Use:** Remote telemetry, 4G connectivity outdoors, GPS positioning, remote SSH/control
|
||||
|
||||
### 9. Leap Motion Controller (USB)
|
||||
### 10. 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 deg FOV |
|
||||
| Range | ~80cm, 150° FOV |
|
||||
| SDK | Ultraleap Gemini V5+ (Linux ARM64 support) |
|
||||
| ROS2 | `leap_motion_ros2` wrapper available |
|
||||
|
||||
- 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
|
||||
- **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
|
||||
|
||||
### 10. Power Budget (USB)
|
||||
### 11. Power Budget (USB)
|
||||
|
||||
| Device | Interface | Power Draw |
|
||||
|--------|-----------|------------|
|
||||
<<<<<<< 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)
|
||||
| STM32 FC (CDC) | USB-C | ~0.5W (data only, FC on 5V bus) |
|
||||
| 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-A | ~0.5W |
|
||||
| Leap Motion | USB | ~0.5W |
|
||||
| ReSpeaker HAT | 40-pin | ~0.5W |
|
||||
| **Total USB** | | **~7.9W typical, ~11W peak** |
|
||||
| **Total USB** | | **~6.5W typical, ~10.5W 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.
|
||||
|
||||
---
|
||||
|
||||
@ -285,46 +225,38 @@ Orin Nano Super delivers up to 25W --- USB peripherals are well within budget.
|
||||
|
||||
```
|
||||
┌──────────────┐
|
||||
│ RC TX │ (in your hand)
|
||||
│ ELRS TX │ (in your hand)
|
||||
│ (2.4GHz) │
|
||||
└──────┬───────┘
|
||||
│ radio
|
||||
┌──────▼───────┐
|
||||
│ RC RX │ CRSF 420kbaud (future)
|
||||
│ ELRS RX │ CRSF 420kbaud
|
||||
└──────┬───────┘
|
||||
│ UART
|
||||
│ UART4
|
||||
┌────────────▼────────────┐
|
||||
<<<<<<< HEAD
|
||||
│ ESP32-S3 BALANCE │
|
||||
│ (Waveshare LCD 1.28) │
|
||||
=======
|
||||
│ ESP32-S3 BALANCE │
|
||||
>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
|
||||
│ MAMBA F722S │
|
||||
│ │
|
||||
│ QMI8658 -> Balance PID │
|
||||
│ RC -> Mode Manager │
|
||||
│ MPU6000 → Balance PID │
|
||||
│ CRSF → Mode Manager │
|
||||
│ Safety Monitor │
|
||||
│ │
|
||||
└──┬──────────┬───────────┘
|
||||
<<<<<<< HEAD
|
||||
CAN 500kbps─┘ └───── CAN bus / UART fallback
|
||||
=======
|
||||
USART2 ─────┘ └───── USB Serial (CH343) / USART6
|
||||
USART2 ─────┘ └───── USB CDC / USART6
|
||||
26400 baud 921600 baud
|
||||
>>>>>>> 291dd68 (feat: remove all STM32/Mamba/BlackPill references — ESP32-S3 only)
|
||||
│ │
|
||||
┌────┴────────────┐ ▼
|
||||
│ 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 │
|
||||
└────────────┘ └───────────────┘
|
||||
▼ ▼
|
||||
┌────────────────┐ ┌───────────────────┐
|
||||
│ Hoverboard ESC │ │ Orin Nano Super │
|
||||
│ │ │ │
|
||||
│ L motor R motor│ │ SLAM / Nav2 / AI │
|
||||
│ 🛞 🛞 │ │ Person following │
|
||||
└────────────────┘ │ Voice commands │
|
||||
│ 4G telemetry │
|
||||
└──┬──────────┬───────┘
|
||||
│ │
|
||||
┌──────────▼─┐ ┌────▼──────────┐
|
||||
│ ReSpeaker │ │ SIM7600A │
|
||||
│ 2-Mic HAT │ │ 4G/LTE + GPS │
|
||||
│ 🎤 🔊 │ │ 📡 🛰️ │
|
||||
└────────────┘ └───────────────┘
|
||||
```
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
cmake_minimum_required(VERSION 3.16)
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
project(esp32s3_balance)
|
||||
@ -1,22 +0,0 @@
|
||||
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
|
||||
)
|
||||
@ -1,42 +0,0 @@
|
||||
#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
|
||||
@ -1,285 +0,0 @@
|
||||
/* 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");
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
#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);
|
||||
@ -1,114 +0,0 @@
|
||||
/* 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 */
|
||||
}
|
||||
@ -1,354 +0,0 @@
|
||||
/* 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);
|
||||
}
|
||||
@ -1,113 +0,0 @@
|
||||
#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);
|
||||
@ -1,150 +0,0 @@
|
||||
/* 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");
|
||||
}
|
||||
@ -1,33 +0,0 @@
|
||||
#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);
|
||||
@ -1,183 +0,0 @@
|
||||
/* 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));
|
||||
}
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
#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);
|
||||
@ -1,241 +0,0 @@
|
||||
/* 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;
|
||||
}
|
||||
@ -1,64 +0,0 @@
|
||||
#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);
|
||||
@ -1,14 +0,0 @@
|
||||
#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"
|
||||
@ -1,119 +0,0 @@
|
||||
/* 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,36 +0,0 @@
|
||||
#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 */
|
||||
@ -1,7 +0,0 @@
|
||||
# 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,
|
||||
|
@ -1,19 +0,0 @@
|
||||
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
|
||||
@ -1,3 +0,0 @@
|
||||
cmake_minimum_required(VERSION 3.16)
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
project(esp32s3_io)
|
||||
@ -1,10 +0,0 @@
|
||||
idf_component_register(
|
||||
SRCS "main.c" "uart_ota_recv.c"
|
||||
INCLUDE_DIRS "."
|
||||
REQUIRES
|
||||
app_update
|
||||
mbedtls
|
||||
driver
|
||||
freertos
|
||||
esp_timer
|
||||
)
|
||||
@ -1,35 +0,0 @@
|
||||
#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"
|
||||
@ -1,42 +0,0 @@
|
||||
/* 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));
|
||||
}
|
||||
}
|
||||
@ -1,210 +0,0 @@
|
||||
/* 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");
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
#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);
|
||||
@ -1,7 +0,0 @@
|
||||
# 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,
|
||||
|
@ -1,13 +0,0 @@
|
||||
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
|
||||
101
include/can_driver.h
Normal file
101
include/can_driver.h
Normal file
@ -0,0 +1,101 @@
|
||||
#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 */
|
||||
@ -101,7 +101,6 @@
|
||||
#define JLINK_TLM_ODOM 0x8Cu /* jlink_tlm_odom_t (16 bytes, Issue #632) */
|
||||
#define JLINK_TLM_BARO 0x8Du /* jlink_tlm_baro_t (12 bytes, Issue #672) */
|
||||
#define JLINK_TLM_VESC_STATE 0x8Eu /* jlink_tlm_vesc_state_t (22 bytes, Issue #674) */
|
||||
#define JLINK_TLM_CAN_WDOG 0x8Fu /* jlink_tlm_can_wdog_t (16 bytes, Issue #694) */
|
||||
|
||||
/* ---- Telemetry STATUS payload (20 bytes, packed) ---- */
|
||||
typedef struct __attribute__((packed)) {
|
||||
@ -251,19 +250,6 @@ typedef struct __attribute__((packed)) {
|
||||
int16_t humidity_pct_x10; /* %RH × 10 (BME280 only); -1 = BMP280/absent */
|
||||
} jlink_tlm_baro_t; /* 12 bytes */
|
||||
|
||||
/* ---- Telemetry CAN_WDOG payload (16 bytes, packed) Issue #694 ---- */
|
||||
/* Sent at 1 Hz; reports CAN bus-error severity and restart history. */
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint32_t restart_count; /* SW bus-off restarts since boot */
|
||||
uint32_t busoff_count; /* lifetime bus-off entry events */
|
||||
uint16_t errpassive_count; /* error-passive transitions */
|
||||
uint16_t errwarn_count; /* error-warning transitions */
|
||||
uint8_t error_state; /* can_error_state_t: 0=OK,1=WARN,2=EP,3=BOFF */
|
||||
uint8_t tec; /* transmit error counter (ESR[23:16]) */
|
||||
uint8_t rec; /* receive error counter (ESR[31:24]) */
|
||||
uint8_t _pad; /* reserved */
|
||||
} jlink_tlm_can_wdog_t; /* 16 bytes */
|
||||
|
||||
/* ---- Telemetry VESC_STATE payload (22 bytes, packed) Issue #674 ---- */
|
||||
/* Sent at VESC_TLM_HZ (1 Hz) by vesc_can_send_tlm(). */
|
||||
typedef struct __attribute__((packed)) {
|
||||
@ -432,10 +418,4 @@ void jlink_send_baro_tlm(const jlink_tlm_baro_t *tlm);
|
||||
*/
|
||||
void jlink_send_vesc_state_tlm(const jlink_tlm_vesc_state_t *tlm);
|
||||
|
||||
/*
|
||||
* jlink_send_can_wdog_tlm(tlm) - transmit JLINK_TLM_CAN_WDOG (0x8F) frame
|
||||
* (22 bytes total) at 1 Hz. Issue #694.
|
||||
*/
|
||||
void jlink_send_can_wdog_tlm(const jlink_tlm_can_wdog_t *tlm);
|
||||
|
||||
#endif /* JLINK_H */
|
||||
@ -32,7 +32,6 @@
|
||||
#define ORIN_CAN_ID_MODE 0x302u
|
||||
#define ORIN_CAN_ID_ESTOP 0x303u
|
||||
#define ORIN_CAN_ID_LED_CMD 0x304u /* LED pattern override (Issue #685) */
|
||||
#define ORIN_CAN_ID_PID_SET 0x305u /* PID gain update: kp/ki/kd (Issue #693) */
|
||||
|
||||
/* ---- FC → Orin telemetry IDs ---- */
|
||||
#define ORIN_CAN_ID_FC_STATUS 0x400u /* balance state + pitch + vbat at 10 Hz */
|
||||
@ -40,7 +39,6 @@
|
||||
#define ORIN_CAN_ID_FC_IMU 0x402u /* full IMU angles + cal status at 50 Hz (Issue #680) */
|
||||
#define ORIN_CAN_ID_FC_BARO 0x403u /* barometer pressure/temp/altitude at 1 Hz (Issue #672) */
|
||||
#define ORIN_CAN_ID_FC_BTN 0x404u /* button event on-demand (Issue #682) */
|
||||
#define ORIN_CAN_ID_FC_PID_ACK 0x405u /* PID gain ACK: echoes applied kp/ki/kd (Issue #693) */
|
||||
|
||||
/* ---- Timing ---- */
|
||||
#define ORIN_HB_TIMEOUT_MS 500u /* Orin offline after 500 ms without any frame */
|
||||
@ -58,11 +56,6 @@ typedef struct {
|
||||
volatile uint8_t estop_req; /* set on ESTOP(1), cleared by main */
|
||||
volatile uint8_t estop_clear_req; /* set on ESTOP(0), cleared by main */
|
||||
volatile uint32_t last_rx_ms; /* HAL_GetTick() of last received frame */
|
||||
/* PID_SET (Issue #693) -- set by orin_can_on_frame(), consumed by main */
|
||||
volatile uint8_t pid_updated; /* set on PID_SET, cleared by main */
|
||||
volatile uint16_t pid_kp_x100; /* Kp * 100 (0..50000) */
|
||||
volatile uint16_t pid_ki_x100; /* Ki * 100 (0..5000) */
|
||||
volatile uint16_t pid_kd_x100; /* Kd * 100 (0..5000) */
|
||||
} OrinCanState;
|
||||
|
||||
extern volatile OrinCanState orin_can_state;
|
||||
@ -171,21 +164,4 @@ void orin_can_broadcast_baro(uint32_t now_ms,
|
||||
*/
|
||||
void orin_can_send_btn_event(uint8_t event_id, uint8_t balance_state);
|
||||
|
||||
/* orin_can_send_pid_ack() -- send FC_PID_ACK (0x405). Issue #693. */
|
||||
void orin_can_send_pid_ack(float kp, float ki, float kd);
|
||||
|
||||
/* PID_SET (0x305) -- 6-byte payload: kp*100, ki*100, kd*100 (uint16 BE each) */
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint16_t kp_x100;
|
||||
uint16_t ki_x100;
|
||||
uint16_t kd_x100;
|
||||
} orin_can_pid_set_t;
|
||||
|
||||
/* FC_PID_ACK (0x405) -- FC -> Orin echo of applied gains */
|
||||
typedef struct __attribute__((packed)) {
|
||||
uint16_t kp_x100;
|
||||
uint16_t ki_x100;
|
||||
uint16_t kd_x100;
|
||||
} orin_can_fc_pid_ack_t;
|
||||
|
||||
#endif /* ORIN_CAN_H */
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user