Software · Embedded · Personal Project · ESP32
IoT Firmware AI HackLab
An embedded experimentation lab built around a real ESP32. Explore firmware behavior, detect anomalies, and analyze constrained hardware through a full inspection pipeline, from device to dashboard.
Why This Project Exists
Firmware as something to observe, stress and inspect.
Most IoT projects read data, send it to a dashboard and stop. Here the firmware is the object of study: an embedded-to-analysis pipeline on a real ESP32, built to show what the device is actually doing.
The gap
Firmware is invisible
In most embedded projects, firmware runs but isn't observed. Bugs, anomalies, and unexpected behaviors exist but aren't captured until something breaks in production.
The ambition
Make it inspectable
Build a platform that treats firmware output as analyzable data, with a defined pipeline from device behavior to human-readable insight.
The constraint
Real hardware only
No simulator, no mocked board: a real ESP32 under real firmware execution, with real signal noise.
Real Hardware
One ESP32, validated on physical hardware.
- Board deployed and physically connected
- Firmware executing under test conditions
- Telemetry streamed to the analysis layer
- Anomalies surfaced by the inspection pipeline
System Design
Three layers, one coherent pipeline.
Each layer has a clear responsibility. Together they turn firmware execution into interpretable, actionable data.
01 - Embedded Layer
ESP32 Platform
- ESP32 running real firmware in controlled test conditions
- Observable device behavior under defined scenarios
- Continuous telemetry output, logs, signals, state changes
02 - Analysis Layer
Python Processing
- Ingestion of raw firmware telemetry from the device
- Anomaly-oriented reasoning, not just logging
- Behavior inspection and pattern extraction
03 - Interface Layer
FastAPI + Streamlit
- FastAPI backend exposes processed inspection results
- Streamlit frontend for clear, readable visualization
- Direct interpretation of embedded outputs for the operator
Architecture
Device to dashboard.
A linear, inspectable chain: each handoff is explicit and verifiable.
Validation
What was validated.
Lessons Learned
Lessons learned
01
How to treat firmware as an observable artifact, not just executable code, and design around that assumption from the start.
02
How to connect real embedded hardware to a software-side analysis pipeline, and make the handoff reliable enough to trust.
03
How to build a credible experimental environment from minimal physical hardware.
Tech Stack