Embassy — Async Embedded Framework for Rust Microcontrollers

Introduction

Embassy is an embedded framework for Rust that brings async/await programming to microcontrollers. Instead of a traditional RTOS with threads and context switches, Embassy uses Rust's async executor to run concurrent tasks cooperatively, resulting in smaller binaries and lower RAM usage while maintaining a familiar programming model.

What Embassy Does

• Provides an async executor optimized for embedded systems with zero-alloc operation
• Offers HAL (Hardware Abstraction Layer) crates for STM32, nRF, RP2040, and ESP32
• Includes async drivers for UART, SPI, I2C, USB, Bluetooth, and Wi-Fi
• Supplies timing utilities with hardware timer integration for delays and timeouts
• Enables concurrent firmware tasks without manual state machines or RTOS threads

Architecture Overview

Embassy consists of an executor that polls async tasks using hardware interrupts as wakers, plus HAL crates wrapping chip peripherals as async-capable drivers. The executor uses no heap allocation — all tasks are statically allocated at compile time. When no task is ready, the executor puts the CPU to sleep until a hardware interrupt fires. This provides concurrency with minimal power consumption and predictable memory usage.

Self-Hosting & Configuration

• Requires Rust nightly for async trait support in embedded contexts
• Target chip selected via Cargo features (e.g., embassy-stm32 with chip feature)
• probe-rs tool handles flashing and RTT-based logging
• Memory layout defined via memory.x linker script per target board
• Cargo.toml features control which peripherals and protocols are compiled in

Key Features

• True async/await on bare metal with no heap allocation required
• Automatic low-power sleep when all tasks are idle
• Type-safe peripheral access preventing pin conflicts at compile time
• Built-in async networking stack (embassy-net) with TCP, UDP, DHCP, and DNS
• Integrated defmt logging framework for efficient binary-format debug output

Comparison with Similar Tools

• RTIC — Interrupt-driven concurrency; Embassy uses async tasks which are more composable
• FreeRTOS (Rust bindings) — C-based with Rust wrappers; Embassy is pure Rust with ownership guarantees
• Zephyr — Full RTOS in C; Embassy leverages Rust type system for compile-time safety
• TinyGo — Go for embedded; Embassy provides zero-cost abstractions without GC
• bare-metal Rust (no framework) — Manual interrupt handling; Embassy adds structured concurrency

FAQ

Q: Does Embassy replace an RTOS? A: For many use cases, yes. Async tasks provide concurrency without context switching overhead. For hard real-time with strict priority preemption, consider RTIC alongside Embassy.

Q: Which chips are supported? A: STM32 (most families), nRF52/nRF53/nRF91, RP2040/RP2350, and ESP32 series via esp-hal integration.

Q: Does Embassy support networking? A: Yes. embassy-net provides async TCP/UDP sockets. Wi-Fi and Ethernet drivers are available for supported chips.

Q: How does power consumption compare to an RTOS? A: Embassy automatically enters low-power sleep when idle, often achieving lower consumption than polling-based RTOS patterns.

Sources

• https://github.com/embassy-rs/embassy
• https://embassy.dev/book/