ThisCalculator

Everyday

Run Zephyr on ESP32 in QEMU Without a Board

Updated · Standard formula, shown below

Run Zephyr on ESP32 in QEMU Without a Board

Yes, you can run Zephyr firmware on an ESP32 without physical hardware by using QEMU’s built-in ESP32 machine emulation. This lets you test Zephyr applications, exercise drivers, and debug logic in a virtual environment before flashing a real chip. The setup involves installing QEMU with ESP32 support, building Zephyr for the `esp32` board target, and launching it with the right QEMU command.

Why Use QEMU for Zephyr Development

QEMU provides a full system emulation of the ESP32, including its Xtensa CPU, memory, and peripheral registers. For Zephyr developers, this means you can run the same binary you would flash on hardware, but in a controlled, reproducible environment. This is especially useful for CI/CD pipelines, automated testing, and learning Zephyr without buying a board.

Key benefits include:

  • No hardware cost or setup time.
  • Deterministic execution for debugging and regression tests.
  • Ability to simulate multiple boards or configurations quickly.
  • Safe experimentation with low-level code that might brick physical hardware.

However, QEMU does not emulate every peripheral perfectly. Wi-Fi, Bluetooth, and some analog features are not fully supported, so you cannot test those features virtually.

How QEMU Emulates the ESP32

QEMU’s ESP32 machine model (often called `esp32` or `esp32-devkitc`) emulates the Tensilica Xtensa LX6 dual-core processor, along with UART, GPIO, SPI, I2C, and timer peripherals. The emulation is based on the ESP32 technical reference manual and is continuously improved by the open-source community.

Zephyr’s `esp32` board configuration includes a QEMU target that sets the correct memory map and peripheral addresses. When you build a Zephyr application for `esp32` with the `-DQEMU=1` flag (or set the board to `esp32/qemu`), the build system generates a binary that QEMU can load directly.

Prerequisites and Setup

To get started, you need a Linux or macOS host (Windows works with WSL2 or MSYS2). Install the following:

  • Zephyr SDK (includes the Xtensa toolchain and QEMU binaries)
  • West (Zephyr’s meta-tool)
  • Python 3 and pip packages (pyelftools, etc.)
  • Optional: a recent QEMU build with ESP32 support (Zephyr SDK’s QEMU is usually sufficient)

Follow the official Zephyr Getting Started Guide to set up the workspace. Then create a simple application or use one of the samples, like `hello_world`.

Building and Running a Sample

Once your environment is ready, build a sample for the ESP32 QEMU target:

  1. Navigate to your Zephyr workspace and source the environment: source zephyr/zephyr-env.sh
  2. Build the hello_world sample: west build -b esp32/qemu zephyr/samples/hello_world
  3. Run it in QEMU: west build -t run

The `west build -t run` command launches QEMU with the correct flags, and you should see the serial output in your terminal. To exit QEMU, press Ctrl-A then X.

Common Issues and Troubleshooting

If you encounter problems, here are typical fixes:

  • Missing QEMU binary: Ensure the Zephyr SDK is correctly installed and that `qemu-system-xtensa` is in your PATH. You can also install a standalone QEMU with ESP32 support.
  • Build errors about missing modules: Run west update to fetch all required Zephyr modules.
  • No output from QEMU: Check that you used the `esp32/qemu` board target, not the physical `esp32` board. The QEMU target has a different configuration.
  • Flash size or memory errors: Adjust the `CONFIG_ESP32_*` options in your prj.conf to match the emulated flash size (default 4MB).

Alternatives to QEMU for ESP32

If QEMU does not meet your needs, consider these alternatives:

  • Renode: Another emulator that supports ESP32 and integrates with Zephyr’s testing framework.
  • Native POSIX board: Zephyr can compile for Linux or macOS, letting you run logic without any emulator, but you lose hardware-specific code.
  • Real hardware: For Wi-Fi/BT testing, a physical ESP32 devkit is the only reliable option.

Frequently Asked Questions

Can I run Zephyr on ESP32 without a board using QEMU? Yes, QEMU emulates the ESP32 processor and several peripherals, allowing you to run Zephyr binaries. Wi-Fi and Bluetooth are not emulated, so those features cannot be tested.

What is the difference between `esp32` and `esp32/qemu` board targets? The `esp32/qemu` target is specifically configured for QEMU, with a different memory layout and no assumption of physical flash. The plain `esp32` target expects a real chip and may not boot under QEMU.

Do I need a special QEMU version? The Zephyr SDK includes a patched QEMU that supports the ESP32. If you use a system QEMU, ensure it is version 6.0 or later and built with `–target-list=xtensa-softmmu`.

Can I debug with GDB in QEMU? Yes, you can start QEMU with `-s -S` and connect GDB to port 1234. Zephyr’s build system also has a `west build -t debug` target that sets this up automatically.

How do I test networking or GPIO in QEMU? GPIO can be simulated by writing to the emulated registers, but there is no physical output. Networking is not supported for ESP32 in QEMU; use the native POSIX board or real hardware for such tests.

Is QEMU fast enough for development? Yes, for most non-real-time tasks. The emulation runs at near-native speed for simple code, though complex operations like floating-point math may be slower.

Related

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.