UART logging requires firmware changes
Every value you want to see costs a code edit, a rebuild and a reflash. The logging path itself consumes cycles and bandwidth, so the instrumented build no longer behaves like the one you ship.
Embedded debugging
Real-time embedded variable tracing through SWD
Visualize MCU variables directly from firmware without modifying your code.
The problem
Seeing inside a running target is still hard
Firmware behaves in time, but the standard tools either change the firmware, stop it, or can only reach the pins.
Debuggers are not built for continuous visualization
Breakpoints and watch windows answer "what is this value right now". They cannot show you how a signal evolves across minutes of runtime, and halting the core destroys the timing you were trying to observe.
Oscilloscope access is limited
A scope only sees what reaches a pin. Internal state — a PID term, a state machine, a filter output — has no physical test point, and channel count runs out fast.
The approach
SWD Tracer reads what your build already knows
The symbol data is in the ELF file and the debug port can read memory on the fly. SWD Tracer connects the two.
-
ELF/DWARF based variable discovery
Your build already describes every global and static: name, address, type and layout. SWD Tracer reads that debug information straight from the ELF file, so the variable list matches the firmware exactly.
-
SWD data acquisition
The debug port reads target memory over the system bus while the core keeps executing. No halts, no hooks, no instrumentation — the firmware runs exactly as it will in the field.
-
Real-time plots and dashboards
Sampled values stream into live time-series plots and numeric readouts. Arrange them into dashboards, save them with the project, and reopen them on the next debugging session.
Features
Built for the way firmware is actually debugged
Zero firmware instrumentation
No printf, no hooks, no ring buffers. Your firmware ships exactly as you debugged it.
ELF symbol parsing
Globals, statics, structs and enums are read straight from DWARF debug information.
Real-time visualization
Continuous time-series plots of live values, sampled while the core keeps running.
Dashboard system
Arrange plots and readouts into saved layouts, one per debugging task.
Derived variables
Compute expressions from traced values without changing the target.
Embedded debugging workflow
Built around the tools already on your bench: your ELF, your probe, your target.
Architecture
From source to signal
Debug information flows out of your normal build; values flow back off the running target. Nothing in the middle touches your code.
Source code main.c
Compiler arm-none-eabi-gcc
ELF / DWARF symbols + types
SWD Tracer resolve + sample
MCU SWD @ running core
Visualization plots + dashboards
Writing
Latest articles
Reading MCU variables without touching your firmware
How ELF/DWARF symbol information plus SWD memory access make it possible to observe live variables in a running target without adding a single line of instrumentation.
Projects
Related embedded work
SWD Tracer
In progressReal-time variable tracing for ARM Cortex-M targets over SWD, driven by ELF/DWARF symbol data — no firmware instrumentation required.