suzui-rs is a niche but practical Rust project that reads Suzuki engine control unit (ECU) parameters using the Serial Data Line (SDL) protocol and displays them in a terminal user interface (TUI). What makes it stand out is the hardware hack underneath: running a Rust TUI on a Raspberry Pi and outputting composite video directly to a car stereo’s CVBS input, effectively creating a DIY in-car diagnostic display without diving into embedded no_std development.
What suzui-rs does and how it works
At its core, suzui-rs is a Rust application that listens to the SDL protocol to poll data from a Suzuki ECU. It tracks over 20 engine parameters including RPM, temperatures, manifold pressure, fuel consumption metrics, and various binary switch states. This data feed is then rendered as a terminal UI using the ratatui crate, a Rust library for building text-based user interfaces.
The project originally started as a prototype in a different language but was rewritten in Rust to leverage Rust’s safety, performance, and modern ecosystem. The terminal interface is designed to run on a Raspberry Pi deployed in a car, where the Pi outputs composite video (CVBS) to the car stereo’s AUX input. This output is achieved via a VAG KKL cable connected to the Pi, which handles the SDL communication.
A notable feature is the simulation mode, which allows desktop development without connecting to actual hardware. This improves the developer experience by decoupling UI development from the embedded hardware dependency.
Under the hood, the architecture involves three main components:
- SDL protocol handler: Decodes the serial data line messages from the ECU.
- Data model: Maintains the engine parameters and state.
- TUI renderer: Updates the terminal UI in real-time using ratatui.
This setup avoids typical embedded development complexities by running Linux on the Raspberry Pi and using standard Rust tooling.
What makes suzui-rs technically interesting
The project’s technical strength lies in its combination of real-time systems programming, hardware interfacing, and creative UX design — all within a terminal UI context.
The decision to build the UI as a TUI rather than a graphical app is a tradeoff that simplifies rendering and keeps the resource footprint low on the Raspberry Pi. The ratatui crate is well-suited for such dashboards, supporting gauges, tables, and popups which suzui-rs uses to display engine parameters and diagnostics codes.
Handling the SDL protocol is non-trivial. It requires precise timing and understanding of the serial data line signaling from Suzuki ECUs. The project encapsulates this complexity in Rust code that is both safe and performant, reducing the chance of runtime errors that are common in C-based embedded code.
Another interesting aspect is the hardware integration. Instead of using a dedicated embedded display or touchscreen, suzui-rs outputs composite video that plugs into the car stereo’s auxiliary input. This is an unusual but clever hack that leverages existing car hardware without extensive wiring or modification.
The repo also discusses advanced diagnostic trouble code (DTC) handling. The current approach is to show popups for DTCs and highlight fault conditions in the relevant UI sections. There is ongoing work to differentiate current vs history codes and to implement automatic clearing of codes based on vehicle signals. This shows the project is evolving with practical real-world diagnostic needs in mind.
The immobilizer interference accidentally doubling as an anti-theft system is a humorous bonus, illustrating the unexpected quirks of automotive hardware hacking.
Explore the project
The repository’s README provides detailed insights into the design considerations and future feature plans but does not include straightforward installation or startup commands. Instead, the project expects users to be comfortable with Rust development and Raspberry Pi setup.
To explore the codebase, start with the src directory where the main Rust modules live. The main.rs file initializes the app, sets up the SDL communication, and launches the ratatui-based UI.
Key parts of the code include:
- The SDL protocol implementation, responsible for reading and parsing serial data.
- The TUI components, handling layout and data display.
- The simulation mode, allowing developers to run the UI without hardware connected.
The README also outlines plans for improved DTC handling and UX enhancements, which are good indicators of where the project is headed.
Overall, the repo is a good study in combining systems programming with creative hardware integration and user interface design in Rust.
Verdict
suzui-rs is a specialized tool for Suzuki car enthusiasts or developers interested in automotive diagnostics and embedded Rust programming. Its approach of using a Rust TUI running on a Raspberry Pi and outputting composite video to a car stereo is unconventional but practical for DIY in-car diagnostics.
The project requires a good understanding of Rust, Linux on Raspberry Pi, and automotive protocols, so it’s not a drop-in solution for casual users. The lack of straightforward installation instructions means it’s more of a reference or a starting point for custom projects.
The tradeoff of using a TUI instead of a graphical interface keeps resource demands low but limits UI flexibility. The hardware hack of composite video output is clever but might not fit all car setups.
If you’re into automotive hardware hacking, real-time Rust programming, or TUI design, suzui-rs offers a neat example of how these can combine. Just be prepared for some hands-on work and hardware tinkering.
→ GitHub Repo: thatdevsherry/suzui-rs ⭐ 103 · Rust