🚛 CAN Bus Analytics Platform

📌 Project Overview

This project is a full-stack CAN bus data analytics platform designed for heavy vehicles (e.g., trucks). It ingests raw CAN log files, decodes them using DBC files, stores the results, and presents them through a web dashboard with diagnostics and visualisations.

The system demonstrates:

Secure backend API development
Data parsing and transformation (CAN → structured signals)
Database design and management
Frontend data visualisation
End-to-end software engineering practices

🧱 System Architecture

Backend (Python / FastAPI)

REST API built with FastAPI
Authentication using JWT tokens
Data decoding using cantools + DBC files
ORM via SQLAlchemy
Database: PostgreSQL

Frontend (Next.js / React)

Built with Next.js (App Router)
Interactive dashboard
File upload with progress feedback
Data visualisation using Recharts

Data Flow

User uploads CAN log file
Backend creates upload job
File is parsed + decoded using DBC
Data stored in PostgreSQL:
- Raw frames
- Decoded signals
Frontend queries API for:
- Summary
- Time-series data
- Diagnostics
Data displayed as charts + stats

🔐 Security Features

JWT-based authentication
Password hashing using bcrypt
Multi-tenant design (org_id separation)
Protected endpoints via dependency injection
Input validation with Pydantic

🗄️ Database Design

Core Tables

User – authentication + organisation
Truck – user-owned vehicles
Upload – uploaded files
RawFrame – raw CAN data
DecodedSignal – decoded signal values

⚙️ Setup Instructions

1. Backend Setup

cd backend
python -m venv .venv
.venv\Scripts\activate  # Windows

pip install -r requirements.txt

2. Configure Environment

Create .env file:

DATABASE_URL=postgresql://postgres:YOUR_PASSWORD@localhost:5432/canapp
SECRET_KEY=your_secret_key

3. Run Backend

uvicorn app.main:app --reload --port 8010

Backend runs at:

http://127.0.0.1:8010

4. Frontend Setup

cd frontend
npm install
npm run dev

Frontend runs at:

http://localhost:3000

📡 API Usage (Swagger)

Swagger UI:

http://127.0.0.1:8010/docs

🔑 Authentication Flow

1. Register

POST /auth/register

2. Login

POST /auth/login

Response:

{
  "access_token": "...",
  "token_type": "bearer"
}

3. Authorize in Swagger

Click Authorize (🔒)
Enter:

Bearer YOUR_TOKEN

🚛 Core API Endpoints

Trucks

POST /trucks → Create truck
GET /trucks → List trucks

Uploads

POST /trucks/{id}/uploads/canlog
GET /uploads/{id}/status

Dashboard

GET /trucks/{id}/dashboard-summary

Signals

GET /trucks/{id}/signals
GET /trucks/{id}/signals/{signal}/stats
GET /trucks/{id}/signals/{signal}/timeseries

Diagnostics

GET /trucks/{id}/diagnostics

📊 Features

✅ File Upload System

Upload CAN .TXT files
Background processing
Real-time progress feedback
Upload history tracking

✅ Data Decoding

Supports multiple DBC files
Best-effort decoding strategy
Handles unknown PGNs gracefully

✅ Dashboard

Summary statistics
Recommended signals
Upload history
Diagnostics panel

✅ Signal Explorer

Select any decoded signal
View:
- Min / Max / Avg
- Time-series chart

✅ Diagnostics Engine

Rule-based system
Example rules:
- Flatline detection
- Out-of-range detection
Severity levels:
- Info / Warning / Critical

📈 Example Output

Dashboard Summary

Total frames
Total decoded signals
Signal types
Top signals

Diagnostics Example

{
  "signal": "EngineCoolantTemperature",
  "message": "Remained constant across all recorded points"
}

🧠 Key Learning Outcomes

This project demonstrates:

Software Engineering

Modular backend design
API-first architecture
Separation of concerns

Data Engineering

Parsing raw CAN logs
DBC-based decoding
Efficient storage of time-series data

Web Development

Full-stack integration
React state management
API-driven UI

Security

JWT authentication
Password hashing
Multi-user isolation

Data Analysis

Signal aggregation
Statistical summaries
Diagnostic rule engine

🚀 Future Improvements

Real-time CAN streaming
Advanced diagnostics (ML-based anomaly detection)
Multi-signal graph comparison
Alert system (email/SMS)
Role-based access control
Docker deployment

📎 Notes for Evaluation

The system handles 17k+ CAN frames per upload
Efficient decoding using DBC lookup strategies
Demonstrates end-to-end pipeline from raw data → insights
Designed with scalability and extensibility in mind

👨‍💻 Author

Ianis Ghita

ghitai/12174865_6003CMD_Dissertation_and_Project_Artefact

About

Resources

Stars

Watchers

Forks

Releases

Languages