Guide · checked on 16 November 2026
Testing STM32 firmware without a board: simulator or real hardware, remotely
With no board on the desk you have two routes: simulate the microcontroller on your machine, or send the firmware to a real board wired somewhere else. They complement each other. This page says what each tool covers, including when Cloudhil is the wrong choice.
The short answer
- Logic, unit tests, continuous integration: a simulator. It is free, fast, has no time limit, and you can step through the code.
- Clocks, timers, execution time, a real peripheral: a real board. A simulator runs a model; what it did not model, it cannot show.
- Long bring-up, logic analyser, signals to inject: buy the board. No remote service replaces a probe on the desk.
The options, one by one
| Tool | What runs your code | STM32 coverage | Pick it for |
|---|---|---|---|
| Renode | Software model, on your machine. Open source (Antmicro). | Boards listed: STM32F4 Discovery, STM32F7 Discovery, F103 Blue Pill, Nucleo-64. Chip models for F429 and H743/H747/H753 are present. | Continuous integration, multi-node systems, debugging with GDB. |
| QEMU | Software model, on your machine. Open source. | Five boards: STM32VLDISCOVERY, Netduino 2, Netduino Plus 2, Olimex STM32-H405, B-L475E-IOT01A. GPIO, I2C, DMA, CRC, RTC and watchdogs are not modelled. | Code that mostly depends on the CPU: algorithms, RTOS, serial. |
| Wokwi | Software model, in the browser or VS Code. | Three parts: STM32C031 (Nucleo C031C6), STM32L031 (Nucleo L031K6), STM32F103C8 (Blue Pill). | Learning, showing a circuit built from virtual parts. |
| LabWired | Software model, from the command line. MIT-licensed core. | Cortex-M0+, M3, M4, M7 and M33; STM32L476 named as an example. Publishes the known gaps between its model and hardware. | Repeatable checks launched by an agent or in continuous integration. |
| Cloudhil | The real microcontroller, on a remote bench. | Three boards: NUCLEO-F429ZI (Cortex-M4), STM32H735G-DK (Cortex-M7), NUCLEO-N657X0-Q (Cortex-M55). Plus an NXP LPC55S69. | Confirming a result or a duration on silicon, in one run of 20 seconds at most. |
| Buying the board | The real microcontroller, at your place. | All of them, subject to stock. | Long bring-up, electrical measurements, sensors to wire. |
Sources, read on 16 November 2026: Renode supported boards, QEMU STM32 boards, Wokwi supported hardware, CNX Software's write-up of LabWired. These lists change: check your part before choosing.
What a real board adds
- The real programmer. The file is written to flash by the probe, then read back and verified.
- The real clocks. The oscillator, dividers and timers are the chip's own, not a model's assumption.
- Measured durations. A cycle count taken by a hardware timer includes the real flash, cache and pipeline.
Example: in run 55a44d094f0af392, a CRC-32 over 8 KiB took 507,926 cycles on an STM32F429, counted by the chip's TIM2 timer. The same run also exposed a measurement error caused by the compiler. A simulator would have exposed it too: a real board does not replace reading the code.
What Cloudhil does not do
- No debugging: no GDB, no breakpoints, no access to the probe.
- No long runs: 20 seconds at most, then halt and erase.
- No signal injection: you cannot wire anything to the pins or drive them with a stimulus.
- No volume: one board of each model, one run at a time, and at most ten runs per day per network.
- On F429 and H735 the code runs unprivileged behind memory protection: some system register writes are ignored.
Using both
- On every change: build and run the tests in a simulator.
- When the result depends on hardware (duration, timer, clock, FPU): send the same ELF file to the real board.
- In the report: write “simulated” or “tested on hardware, run id …”. Do not mix the two.
Frequently asked questions
How can I test STM32 firmware without owning the board?
There are two routes. A simulator (Renode, QEMU, Wokwi, LabWired) runs the firmware on a software model of the microcontroller, on your machine. A remote bench such as Cloudhil flashes the firmware on a real board and returns the result. A simulator suits logic and repeated runs; a real board confirms clocks, peripherals and performance.
Can I test firmware on real STM32 hardware remotely?
Yes. With Cloudhil you compile on your machine and send the ELF file in one HTTPS request. It is loaded on a real NUCLEO-F429ZI, STM32H735G-DK or NUCLEO-N657X0-Q, runs for at most 20 seconds, then the result comes back as JSON and the board is erased. Run 55a44d094f0af392, on 16 November 2026, took 86 seconds from upload to result. Since 17 November 2026 the bench erases only what was written: a 2-second run now comes back in about 10 to 35 seconds.
Renode or Cloudhil: which one should I use?
They do different jobs. Renode is an open-source simulator: free, no time limit, step debugging, well suited to continuous integration. Cloudhil runs the firmware on real silicon for a short run, with no debugger. Use Renode on every change, and Cloudhil before stating that firmware was tested on hardware.
Do Wokwi and QEMU support STM32?
Partly. As of 16 November 2026, the Wokwi documentation lists three STM32 parts: STM32C031 (Nucleo C031C6), STM32L031 (Nucleo L031K6) and STM32F103C8 (Blue Pill). The QEMU documentation lists five STM32 boards and states that GPIO, I2C, DMA, the hardware CRC unit, the RTC and the watchdogs are not modelled.
Can an AI agent test the firmware it writes?
Yes. An agent can run a simulator from the command line, or send the compiled file to Cloudhil over HTTPS or MCP (https://cloudhil.com/mcp) and read the verdict returned by the board. In both cases it should say which one was used: simulated is not tested on hardware.
Try it on a real board
An agent key, a voucher, an ELF file: the first run takes five minutes.