Real-Time Vehicle Telemetry

This project is a motorsport-grade telemetry dashboard system built to capture and display live vehicle data with precision and speed. Providing insights into vehicle performance and automating watching metrics in the background enhancing safety and performance by allowing drivers to keep focused on the road rather than the tachometer. Starting from basic OBD-II query's, it evolved into a direct CAN-bus data pipeline with a 10ms refresh rate, fast enough for professional-level telemetry.

Designed for performance, modularity, and scalability the system dynamically reconfigures itself based on external config files customised for each vehicle and supports automatic vehicle recognition to load the appropriate configuration.

The Challenge

Standard OBD-II interfaces were never built for racing, rather emissions control and diagnostics. A 500ms update felt unresponsive when monitoring throttle or engine load. True real-time telemetry meant transitioning away from OBD-II and tapping directly into the car’s Controller Area Network (CAN).

Decoding the raw CAN messages, identifying voltage, RPM, and sensor bytes through an optimised ETL data pipeline efficiently transforming data in a way where the context was built into the architecture keeping the application flow and logic robust. Making many features a result and inherent part of the architecture itself. That was the real engineering.

Architecture & Tech

The system follows an proprietary MVC like architecture customised for modularity, scalability and plug and play flexibility. Keeping the system design clean, modular and data-driven:

Each signal (RPM, temp, throttle) is defined in a config file. The dashboard layout adapts automatically — just like a pit engineer switching telemetry views mid-race. The examples displayed are just the start. New sensors, channels, or derived data can be implemented through configuration files without changing the core code.

In Action

Below are samples of the dashboard visualisations, showing real-time updates from the CAN bus feed. The latency is under 10ms, giving smooth, instantaneous reactions to every vehicle input.

Results & Performance

The optimized CAN pipeline achieved 10ms refresh rate across multiple data streams, enabling real-time visualization for dashboards, telemetry logging, and even future predictive analytics.

The final implementation is modular, adaptive, and race-ready. Built to scale with future integrations such as over-the-air configs, remote cloud telemetry and machine-learning assisted derived metrics.

Reflection

Building this system combined embedded systems, software architecture, and UX design. The result is a flexible telemetry platform that can run in a race car or lab bench equally well.

For security and competitiveness, CAN decoding formulas and IDs are kept private, but the public documentation and configuration model demonstrate the engineering principles behind it.