racecar-35 — track telemetry dash, logger & cloud

What racecar-35 is

racecar-35 is the data system for the car, not just a gauge. The trunk box senses the engine and chassis, logs everything to SD at full rate and ships each session to the cloud. The cabin screen (CrowPanel, ESP32-S3, 7″ 800×480) shows the driver what matters live — speed, RPM band, shift flash, best/last/delta timing, GPS heading and sensor warnings — and is the WiFi/OTA path for the whole car.

  +--------------+  Serial2 (UART)  +---------------+  Serial3 (UART) +---------------------+
  |  u-blox GNSS | <--------------> |  Teensy 4.1   | <------------> |  CrowPanel S3 7"    |
  |              |  38400/9600 baud |  trunk logger |  115200 8N1    |  cabin display      |
  +--------------+                  +-------+-------+                +----------+----------+
                                            |                                   |
                                     SD logging / sensors                    WiFi  |
                                     SD chunks (Rev C)                           |
                                            v                                   v
                                  +--------------------------+      +------------------------+
                                  | ESP32-S3 NET module      |      | OTA + upload           |
                                  | (Rev C, SPI0, planned)   |      | fallback (working)     |
                                  +-----------+--------------+      +-----------+------------+
                                              |  HTTPS                          |
                                              +------------+--------------------+
                                                           v
                                        https://racecar.api.blueuc.com
                                        FastAPI cloud receiver  --  sessions, laps,
                                        maps, overlays, AI coach, firmware OTA

In the trunk

Teensy 4.1 — GNSS, MPU-6050 IMU, tach, oil pressure, coolant (NTC) and AEM AFR inputs, microSD session logging, CAN capture.

In the cabin

CrowPanel Advance 7.0 (ESP32-S3) running the LovyanGFX dash UI. RGB332 framebuffer, delta bar, shift flash, sensor warnings, REC handshake watchdog.

In the cloud

Session upload and archive, automatic lap detection, line view, video overlay export, GPS basemap, CAN capture tools, AI race coach, firmware/OTA hosting and share links.

Hardware

The current board is Rev C — a real, routed electrical design that has passed ERC/DRC and netlist checks. It is an unbuilt engineering prototype: it is not independently reviewed, not fabricated, and the new WiFi/RTC features it carries are not implemented in firmware yet.

Revision	State	Notes
Rev A / Rev B	Retired	Archived under `hardware/_archive/`. Sources still supply render assets; not orderable designs.
Rev C	Current prototype	130 × 140 mm, 136 PCB parts, 76 nets, 392 connected pads, 427 pin/geometry assertions, zero ERC/DRC and zero unconnected. All six screw terminals on one left edge. Gerbers, BOM and assembly docs exist in engineering-prototype (unapproved first-build) mode.
Rev D	In layout	Four-layer integrated trunk logger. BOM revision 1 fixed six unprocurable/mis-specified parts.

Rev C connectors (left edge)

Ref	Function
J1	POWER
J2	SCREEN
J3	TACH
J4	OIL pressure
J5	NTC coolant
J6	AEM (AFR / lambda gauge output)

What Rev C adds

On-board WiFi module — ESP32-S3-WROOM-1-N8R2 (8 MB flash / 2 MB PSRAM, internal PCB antenna, −40…85 °C). External antennas and the 1U pigtail were rejected.
SPI0 link, Teensy master — so SD chunks can be uploaded directly from the trunk module instead of pushing a long UART run. Teensy pins reserved: 10 CS / 11 MOSI / 12 MISO / 13 SCK, 5 READY / 6 NET reset. (Current code still blinks pin 13 — that must be disabled before SPI is used.)
Dedicated NET supply — TRACO TSR 1-2433 fed from the Pololu protected input (VRP), never from the Teensy 3.3 V rail.
RTC retention — replaceable 3 V CR2032 on Teensy VBAT / GND via J9; RTC only, no charger.
Ethernet stays removed — the car is WiFi-only since v0.1.148; the screen keeps WiFi for OTA and optional upload fallback.

Firmware

Two PlatformIO projects in one repository, each with its own build environment.

Project	Target	Path
Teensy firmware	Teensy 4.1	`platformio.ini`, `src/main.cpp`
Dash UI	CrowPanel ESP32-S3 Advance 7.0	`crowpanel-ui/` (`DASH_BOARD=71`)

Recent releases

Version	What it brought
v0.1.149	Opt-in AFR/lambda logging from the external AEM 30-0300 gauge output (white signal / brown reference) on a protected, clamped ADC input — not a direct oxygen sensor.
v0.1.148	WiFi-only: Ethernet/W5500 support and the Internet-route setting removed; WiFi credentials and status always visible.
v0.1.147	New dash layout (delta bar, BEST, GPS 3D, TIME), band-only shift flash, sensor-warning block, REC handshake watchdog, screen-side test simulator, RGB332 framebuffer (kills the shake).
v0.1.146	CrowPanel Advance 7.0 board support; touch-debug UART0 prints stripped.
v0.1.144	Speed up uploads; SD session history.

Build & flash

$ pio run -t upload                 # Teensy 4.1 (tap the program button on first boot)
$ cd crowpanel-ui && pio run -t upload   # Dash UI

Important: disconnect the two UART jumpers between the Teensy and the CrowPanel before flashing the screen. UART0 (GPIO 43/44) is shared with the CH340 USB-serial chip, so with the Teensy connected both devices drive the same wire and the upload fails or corrupts. After a verified upload, unplug USB-C, reconnect the Teensy, then power the panel again.

How a session gets to the cloud

Drive. The trunk logger reads GNSS, IMU, tach, oil, coolant and AFR, and writes full-rate NDJSON to microSD. The cabin screen shows the live dash over UART.
Stop-and-recover. The screen's REC handshake watchdog verifies the recording handshake; session files and sidecars are finalised on the card.
Upload. The car joins WiFi (screen today, on-board NET module once Rev C firmware lands) and POSTs the session to the cloud receiver with its API key. Uploads are resumable, so a dropped link continues where it stopped.
Process. The server stores the session, detects laps, builds the line view and GPS track, and indexes it for the review pages.
Review. Team members open the session on the web — lap table, speed/throttle traces, GPS map, camera overlay, corner-by-corner coach notes — or share a read-only link.

Remote firmware is published from the same server: the dash downloads its own update and can push the matching Teensy image over UART.

The Dash Cloud

Everything the car records lands here. Sign in with your team account to browse sessions, compare laps and read the coach notes.

Session library

Every uploaded run, sorted by car, track and date, with the raw NDJSON, sidecars and debug logs kept alongside the processed result.

Lap detection & timing

Laps are found from the GPS line, timed, and can be excluded or renamed. Session histories roll up per driver and per car.

Line view & compare

Two laps on one map, one drawn in red, with interpolated reference dots so a stepped sample never hides the real line.

GPS track map

Keyless basemap of the session line, with corner numbering from start/finish going LEFT/RIGHT, and named tracks you can edit.

Video overlay

Burns speed, RPM, lap delta and sensor readouts onto your camera footage for the same session file.

AI race coach

Corner-by-corner analysis with per-session history, so you can reopen a corner after a change and see whether it actually helped.

CAN captures

Upload and inspect raw CAN logs straight from the car's bus, decoded from the same server.

Firmware & OTA hosting

The server publishes build manifests; the dash pulls its own update over WiFi and can hand the Teensy image across UART.

Sharing

Revocable read-only links for a single session, so a driver or a tuner can look without an account.

Accounts & API keys

Google sign-in for people, per-device API keys for the cars, with visibility controls over who sees which driver's data.

API & endpoints

The cloud receiver is a FastAPI service. Interactive API docs and the OpenAPI schema are available on the same host as the login.

Endpoint	Purpose
`GET /health`	Liveness probe for the service and its storage.
`GET /login`	Browser sign-in (team account).
`POST /sessions`	Car-side session upload (resumable), authenticated by device API key.
`GET /sessions`	List the sessions you are allowed to see.
`GET /sessions/{user}/{file}/data`	Processed channels for one session.
`GET /sessions/{user}/{file}/laps`	Detected laps and timings, with exclusions.
`GET /sessions/{user}/{file}/lines`	Line geometries for the map and comparisons.
`GET /sessions/{user}/{file}/ai`	AI coach output history for the session.
`GET /coach/{user}`	Coach queue and per-corner notes for a driver.
`GET /tracks`	Known tracks and their start/finish definitions.
`GET /firmware/manifest.json`	Published firmware builds for OTA updates.
`GET /account/apikey`	Issue or rotate a device API key.
`GET /shared/{token}`	Read-only shared session view.

Base URL: https://racecar.api.blueuc.com. The legacy hostname stays live for dash uploads; api.racecar35.com is the reserved replacement.

Where this is going

Rev C first build. The board passes ERC/DRC and has real Gerbers, but it still needs a genuine hash-pinned named review, fabrication and bench validation before it is a product.
On-board NET firmware. The ESP32-S3 SPI upload path (SD chunks straight to HTTPS) is designed and pinned out, not implemented. Until it lands, the screen's existing OTA and upload paths stay intact.
RTC hardening. Time-validity checks, protection against corrupted set-time commands and a fresh SNTP resync still need writing, and there is no GPS UTC → RTC setter in the current source yet.
AFR / lambda. The protected, clamped ADC input is in Rev C; it needs independent review and physical validation on the car before the values are trusted.
Rev D. A four-layer integrated trunk logger is in layout, with the first BOM revision already correcting six unprocurable or mis-specified parts.
Cloud naming. The API stays reachable on its current hostname and gains api.racecar35.com; dash uploads continue on the legacy address so nothing on the car has to change.