⚡ Restoring physical stalks to the Tesla Model 3 Highland and remapping capacitive steering wheel buttons using a FreeRTOS ESP32 LIN/CAN gateway & React Native HUD
A high-impact hardware-software retrofitting platform engineered to solve a major user experience pain point: the complete absence of physical control stalks on the Tesla Model 3 Highland. TesLimitless retrofits custom-engineered physical turn-signal and high-beam stalks back onto the steering column, and repurposes the now-redundant factory capacitive steering wheel buttons for customized macros. Running a custom asymmetric dual-core FreeRTOS C++ firmware stack on an ESP32, the system acts as a real-time LIN-bus Man-in-the-Middle (MITM) gateway between the car body controller and the steering wheel assembly. When a physical stalk is pressed or a steering button is touched, the ESP32 intercepts the frame, transmits a mock 'idle' payload to mask the default factory action, and injects custom CAN-bus commands safely via the diagnostic port. The landscape React Native companion app acts as both a premium cockpit HUD and a customization mapping controller. Users can dynamically remap steering wheel controls via the mobile UI—for example, binding the capacitive high-beam button to toggle Comfort/Sport acceleration—streaming configuration tables over BLE to the ESP32 for execution.
Sub-1.5ms LIN-bus active MITM interception and forwarding latency; under 10ms CAN-bus sniffing and decoding cycle; sub-16ms update periods for BLE telemetry streaming.
Hardware-accelerated rendering of the dynamic SVG power/regen visualization arc; telemetry state changes processed with sub-16ms UI updates matching the BLE streaming cycle.
Zero server or external runtime expenses utilizing strictly direct on-device peripheral decoding and local P2P Bluetooth communication.
Retrofitted custom-engineered physical turn-signal and high-beam stalks onto the Highland steering column, routing physical switches through an ESP32 while serving as a real-time LIN-bus MITM gateway (19200 baud) to override factory controls.
Developed a custom remapping system that intercepts steering wheel LIN-bus frames, dynamically injects spoofed 'idle' payloads to mask physical inputs from the vehicle body controller, and translates those inputs into custom CAN-bus macros.
Designed a non-invasive CAN integration connecting the ESP32 to the high-speed vehicle network strictly through the Tesla diagnostic port, reading live telemetry and injecting remapped command frames safely.
Leveraged high-priority FreeRTOS task pinning to bind safety-critical LIN-bus frame interception loops directly to Core 1, ensuring microsecond-accurate determinism with zero risk of processing starvation.
Exhaustive situation-action-result breakdowns showcasing problem-solving and architectural execution.
Real-time LIN-bus master-slave communication on the Tesla Model 3 Highland requires steering wheel responses to body controller poll queries to be processed and forwarded within a strict 1-2ms response window to prevent frame timeout errors. Executing slow BLE transport, analog polling, or high-throughput CAN sniffing on a single-thread loop caused execution delays, leading to LIN response timeouts, haptic system dropouts, and vehicle communication error codes.
Leveraged an asymmetric dual-core FreeRTOS C++ firmware layout on the ESP32. Locked the safety-critical, time-sensitive LIN-bus MITM transceiver listener and injector tasks directly to Core 1 using high-priority FreeRTOS task pinning, while offloading high-throughput CAN packet sniffing, analog edge-trigger checks, and BLE client streaming to Core 2.
Low-level component relationships, system boundaries, and runtime flows.
The platform connects a dual-core ESP32 processor to an MCP2515 CAN controller via high-speed SPI (GPIO 5 as CS) and a dual TJA1021 LIN-bus transceiver array. The LIN interface acts as a physical MITM gateway (pins 16/17 for body controller, pins 32/33 for capacitive steering assembly) to capture turn signal and stalk inputs. By returning mock idle payloads over LIN, the ESP32 overrides standard vehicle controls. For CAN integration, the controller interfaces directly with the vehicle's diagnostic port, reading high-speed telemetry frames and injecting remapped actions safely. These low-level processing domains are isolated on-chip using FreeRTOS core-affinity mapping, broadcasting dynamic state changes up to the landscape React Native cockpit HUD app over a custom BLE GATT notification service (12345678-1234-5678-1234-56789abcdef0), which concurrently transmits user customization mappings back to the transceiver controller.
Hardware and software layer separation routing Core 1 and Core 2 tasks through physical transceivers.
When dealing with real-time vehicle electronics integration, safety-critical bus loops must enforce strict hardware-level isolation boundaries and deterministic watchdog safety circuits using multi-core OS features like FreeRTOS before introducing high-level networking features.
Rendered live in real-time. Direct URL: /teslimitless-video.mp4
Engineered an analog resistor-ladder button network (SW1 to SW5) on ESP32 GPIO 34 as a secondary input simulator for bench-testing CAN-bus injection routines prior to physical LIN-bus integration.
Designed a custom, landscape-optimized React Native cockpit HUD using react-native-ble-plx that performs smooth state-interpolation of telemetry, rendering an interactive, color-coded battery status indicator and a dynamic SVG power/regen visualization arc.
Completely isolated the physical LIN-bus MITM intercept loop from networking and display overhead, guaranteeing deterministic sub-1.5ms response forwarding with zero LIN-bus timeout errors or haptic system dropouts.
Initial attempts to hijack capacitive turn signals and column commands directly on the high-speed chassis CAN-bus suffered from severe bus noise, packet collisions, and could not easily bypass or prevent the car's default factory responses to physical stalk presses.
Shifted the engineering strategy to place the ESP32 directly as a physical MITM gateway on the steering wheel LIN-bus. Reverse-engineered the capacitive button touch profiles and programmed the ESP32 to selectively overwrite these packets, returning a spoofed 'idle' state to the car's body controller over LIN-bus while generating and transmitting customized commands over the high-speed CAN-bus instead.
Enabled absolute control over Highland capacitive inputs—effectively remapping turn signals, wipers, and media scrolls to custom macros without triggering default factory actions or dashboard error alerts.
Streaming large JSON telemetry payloads or raw packets directly via Bluetooth Low Energy saturated the characteristic bandwidth, causing packet buffering, lagging speedometers, and jerky HUD UI updates in the React Native companion app.
Implemented an efficient, compacted telemetry data structure mapping compressed values directly to the BLE GATT server notification loop, coupled with a customized requestAnimationFrame-based timing interpolator in the React Native state manager.
Bypassed mobile OS Bluetooth transmission buffers, delivering fluid, jitter-free dashboard telemetry updates and achieving a response lag below 16ms for real-time turn signal and power animations.
