Skip to content
CAI
Software that uses CAICheck a score

embassy-rs/embassy

68.4

Adequate · 27 October 2026

410.7k

lines of production code

Rust

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Embassy is an embedded Rust framework that provides an asynchronous runtime and hardware abstraction layers for microcontrollers such as ARM Cortex-M, RISC-V, and AVR. It enables non-blocking I/O and task scheduling, supporting applications from simple sensor nodes to complex networked devices with cellular, Wi-Fi, or Ethernet connectivity. The system includes comprehensive peripheral drivers, networking stacks, cryptographic operations, and bootloader subsystems for secure over-the-air updates.

How it got here

2020–2022 — Embassy framework initialization and HAL expansion

87 changes.

This period established the Embassy embedded framework repository and executed a comprehensive expansion of hardware abstraction layers for STM32, nRF, and RP2040/235x microcontrollers. The work involved introducing new peripheral drivers, refactoring core networking and synchronization primitives, and providing extensive example suites to demonstrate async capabilities across diverse platforms.

2023–2024 — Hardware expansion and bootloader subsystem

87 changes.

This period focused on significantly expanding hardware support by adding HALs for NXP, new drivers for STM32 and nRF peripherals, and comprehensive example projects across multiple platforms. It also introduced a robust firmware update framework with embassy-boot and USB DFU support, alongside foundational infrastructure like the embassy-hal-internal crate and async adapter utilities.

2025–2026 — New platform HALs and crypto infrastructure

134 changes.

This period focused on expanding hardware support by introducing initial HALs for the MSPM0, MCXA, Microchip MEC/CEC, Ambiq Apollo3, and NXP i.MX RT600 families. It also established a unified cryptographic foundation through the new embassy-crypto crate, providing a driver-backed API for both software and hardware accelerators across multiple platforms.

Features

Add BDMA ring buffer support with stop/resume control

The embassy-stm32 BDMA driver now includes a dedicated ringbuffered module, exposing \ReadableRingBuffer\ for continuous DMA reception. Users can start, stop, and resume transfers via the new \stop()\ and \start()\ methods, allowing for controlled data ingestion without losing the circular buffer state. The implementation handles half-transfer and transfer-complete interrupts to manage buffer synchronization and waker signaling, and provides utilities like \read\_latest()\ for scenarios where overruns should be silently discarded.

_embassy-stm32/src/dma/dma\bdma · high confidence

Add Bluetooth (BLE) HCI transport support

The driver now exposes a Bluetooth HCI transport layer alongside its existing WiFi capabilities. When the \bluetooth\ feature is enabled, the \State\ struct allocates dedicated buffers for Bluetooth, and the \HostedResources\ returned by \new()\ includes a \BtDriver\ implementing \bt\_hci\_transport::Transport\. This allows host stacks like \trouble-host\ to communicate with the ESP coprocessor's Bluetooth controller over the same SPI/SDIO link used for WiFi, with packet multiplexing handled internally via the \Hci\ interface type.

embassy-net-esp-hosted/src · high confidence

Add CRC driver with version-specific implementations

The embassy-stm32 crate now includes a Cyclic Redundancy Check (CRC) driver that supports multiple hardware versions via feature flags (crc\_v1, crc\_v2, crc\_v3). The v1 implementation provides a simple interface for basic CRC32 operations, automatically handling clock enable/disable and offering methods to feed words and read results. The v2/v3 implementation adds configurable options for input/output bit reversal, polynomial size, initialization values, and custom polynomials, along with support for feeding bytes, halfwords, and words. This allows users to perform CRC calculations on STM32 microcontrollers with varying CRC peripheral capabilities.

embassy-stm32/src/crc · high confidence

Add CRYP driver with AES, DES, and TDES support

The embassy-stm32 crate now includes a new hardware crypto accelerator (CRYP) driver. This driver provides implementations for AES (ECB, CBC modes), DES, and Triple DES (ECB, CBC modes), allowing users to perform symmetric encryption and decryption directly on supported STM32 microcontrollers.

embassy-stm32/src/cryp · high confidence

Add CTimer capture and PWM drivers for MCXA

The CTimer peripheral now supports capture and PWM functionality. Users can utilize the new Capture driver to record timestamps on rising, falling, or both signal edges, with support for calculating period and frequency from tick differences. Additionally, the PWM driver allows configuration of frequency and duty cycle on specific channels, enabling control of output signals via the CTimer hardware.

embassy-mcxa/src/ctimer · high confidence

Add Cortex-M4 inter-core communication example for STM32WL55

A new example project for the STM32WL55CM4 (Cortex-M4) core has been added to demonstrate inter-core communication via the IPCC peripheral. The example configures shared memory and MPU settings to allow the CM4 core to toggle an LED state in coordination with the secondary core, including necessary Cargo, build, and memory layout configurations.

examples/stm32wl55cm4 · high confidence

Add Cortex-R52 SMP example for MPS3-AN536

Adds a new example for the Cortex-R52 based MPS3-AN536 machine, including configuration for QEMU to run with two cores (\smp=2\) and a \fizzbuzz-smp\ binary that demonstrates multi-core execution. The example sets up the GICv3 interrupt controller for both cores, configures the virtual timer for timekeeping across cores, and provides a \hello\ binary for single-core operation.

examples/mps3-an536 · high confidence

Add DSI display example for STM32F469

A new example application (dsi\_bsp.rs) has been added to the STM32F469 examples directory, demonstrating how to drive an LCD display using the DSI host and LTDC peripherals on the STM32F469NI-DISCO board. The example includes the necessary build configuration (cargo config and build script) to target the ARM Cortex-M4 architecture and links against the defmt logging framework, allowing users to see a Ferris image rendered on the screen.

examples/stm32f469 · high confidence

Add DateTime abstraction with Unix epoch conversion support

The embassy-rp crate now includes a shared DateTime abstraction for RTC and other time-keeping peripherals, available in embassy-rp/src/datetime. This new module provides DateTime and DayOfWeek types that can be backed by the chrono crate (when the chrono feature is enabled) or use a standalone no-dependencies implementation. Users can now convert between DateTime objects and Unix timestamps (milliseconds since 1970-01-01 00:00:00 UTC) using the timestamp\_millis and from\_timestamp\_millis functions, with proper validation and error handling for invalid dates, times, and out-of-range values.

embassy-rp/src/datetime · high confidence

Add Digital Temperature Sensor (DTS) driver for STM32

Users can now read temperature data from the on-chip Digital Temperature Sensor on supported STM32 families (H5, H7, H7R, H7S, and N6). The new \embassy\_stm32::dts\ module provides an asynchronous \read()\ method for blocking until a measurement is ready, as well as an immediate \read\_immediate()\ method for non-blocking access. The driver supports configurable sample times and trigger selections (software, LPTIM, or EXTI) and automatically applies factory calibration values to convert raw measurements into accurate temperature readings.

embassy-stm32/src/dts · high confidence

Add ESP-Hosted protocol bindings for FG and MCU variants

The \embassy-net-esp-hosted\ crate now includes generated protobuf message bindings for two distinct ESP-Hosted communication variants: the FreeRTOS Gateway (FG) and the MCU (ESP-Hosted-MCU). This change introduces the \src/proto/fg\ and \src/proto/mcu\ modules, which contain the Rust structs and enums derived from \esp\_hosted\_config.proto\ and \esp\_hosted\_rpc.proto\ respectively. These bindings enable the library to serialize and deserialize control path messages for WiFi operations (such as scanning, connection, and configuration) and OTA updates on both hardware targets, with the specific variant activated via the \esp-hosted-fg\ or \esp-hosted-mcu\ Cargo features. Also in this area: Support for 64-character passwords and RSSI in scan results.

embassy-net-esp-hosted/src/proto, embassy-net-esp-hosted/src/proto/fg, embassy-net-esp-hosted/src/proto/mcu · high confidence

Add Embassy time driver for ARM CMSDK timers

Users can now use the ARM CMSDK timer as a time source in Embassy applications. This change adds a new driver implementation in embassy-time/src/driver\_cmsdk that provides initialization functions (init and init\_cortex\_m) to configure the timer hardware and register interrupt handlers for timekeeping and alarms, enabling accurate time management on CMSDK-based hardware.

_embassy-time/src/driver\cmsdk · high confidence

Add Embassy-based examples for MSPM0C1104 and MSPM0G3519

New example applications are now available for the MSPM0C1104 and MSPM0G3519 microcontrollers, demonstrating GPIO, button input, UART, clock output, and watchdog timer functionality using the Embassy async runtime. These examples provide reference implementations for common hardware interactions on these specific chips.

examples/mspm0c1104, examples/mspm0g3519 · high confidence

Add GATT client and server APIs for STM32WBA BLE

This change introduces a new GATT module for the STM32WBA Bluetooth stack, providing both client and server capabilities. The GattClient enables common BLE workflows such as discovering primary services, characteristics, and descriptors by UUID or handle, as well as reading and writing characteristic and descriptor values (including long writes and multiple reads). The GattServer allows building the local GATT database by adding primary or secondary services and characteristics with configurable properties, security permissions, and event masks. Supporting types (Uuid, ServiceHandle, CharProperties, etc.) and a comprehensive set of GATT events (including notifications, indications, MTU exchange, and extended ATT bearer states) are also added to facilitate robust BLE attribute protocol interactions.

embassy-stm32-wpan/src/bluetooth/gatt · high confidence

Add HCI command layer for STM32WBA BLE stack

Introduces the Host Controller Interface (HCI) implementation for the STM32WBA series, replacing the previous IPCC-based approach with direct C function calls to the WBA BLE stack. This change adds a new \command.rs\ module that exposes HCI commands such as advertising control, connection management, and CTE (Constant Tone Extension) direction finding support, along with \types.rs\ defining necessary status codes and packet structures.

embassy-stm32-wpan/src/bluetooth/hci · high confidence

Add HSPI peripheral support for STM32U5

The embassy-stm32 library now includes a driver for the High-Speed Serial Peripheral Interface (HSPI) peripheral, specifically targeting STM32U5 devices. This new module provides configuration structures for HSPI modes (such as Indirect Write/Read, Auto Polling, and Memory Mapped), lane widths, and memory types, along with a driver struct that manages GPIO pins and DMA channels for serial communication.

embassy-stm32/src/hspi · high confidence

Add Half-Duplex SPI and SDIO network interfaces

The \embassy-net-esp-hosted\ library now supports two additional hardware transport layers for connecting to the ESP co-processor: a Half-Duplex SPI interface (\hd\_spi.rs\) and an SDIO interface (\sdio.rs\). The Half-Duplex SPI implementation is designed for \esp-hosted-mcu\ and uses a \Data\_Ready\ pin for flow control, while the SDIO implementation works with both \esp-hosted-mcu\ and \esp-hosted-fg\ but requires the co-processor to be configured in packet mode. These new interfaces complement the existing Full-Duplex SPI support, allowing users to select the transport method that best fits their hardware constraints.

embassy-net-esp-hosted/src/iface · high confidence

Add Hardware Semaphore (HSEM) driver for STM32

Introduces the \embassy-stm32/src/hsem\ module, providing asynchronous hardware semaphore support for STM32 microcontrollers. This new capability allows applications to synchronize access to shared resources across multiple CPU cores using both fast 1-step and standard 2-step locking procedures, with interrupt-driven waiting and automatic wake-up handling.

embassy-stm32/src/hsem · high confidence

Add I2C controller and target drivers for MCXA

The embassy-mcxa I2C module now provides full driver support for the LPI2C peripheral, including both controller (master) and target (slave) implementations. The controller driver supports blocking, interrupt-based async, and DMA-based async operations across Standard (100 kHz), Fast (400 kHz), and Fast-Plus (1 MHz) speeds, with comprehensive error handling for conditions like NACKs and arbitration loss. The target driver implements the embedded-hal I2c Target trait, allowing devices to respond to read/write requests, handle general calls, and manage SMBus alerts in both blocking and async modes, with DMA support for efficient data transfer.

embassy-mcxa/src/i2c · high confidence

Add I3C controller and target drivers for NXP MCXA

Introduces a new I3C subsystem for the MCXA platform, providing both controller and target roles. The controller driver supports I3C enumeration, hot-join handling, in-band interrupts (IBIs), and DMA-based transfers, while the target driver enables devices to join the bus, handle directed IBIs with mandatory data bytes, and manage I3C-specific configuration such as vendor IDs and device characteristics.

embassy-mcxa/src/i3c · high confidence

Add ICACHE memory remap region configuration

Users can now configure up to four memory-remap regions on supported STM32 chips (U5, U3, WBA, H5, L5) to route external memory traffic through the instruction cache. This allows code fetched from external memory (such as OCTOSPI/XSPI flash) to be served via the faster internal cache instead of the slower external bus. The new \region.rs\ module provides APIs to enable and disable these remap regions, specifying base addresses, remap targets, region sizes, AHB master routing, and burst types.

embassy-stm32/src/icache · high confidence

Add LPC55S69 example project with async and blocking driver demos

The examples/lpc55s69 directory now contains a complete, buildable example project for the NXP LPC55S69 microcontroller. It includes configuration for the ARM Cortex-M4F target, a linker script, and a README describing the available demos. The project provides source code for several driver examples: GPIO-based LED blinking (using both NOP delays and embassy-time), button input handling, ADC reading (both async and blocking modes), I2C communication with an MPU6500 sensor, PWM output, SPI transfer, and USART serial communication (both async with DMA and blocking modes). It also includes a comprehensive CASPER coprocesser test binary that exercises various arithmetic and memory operations.

examples/lpc55s69 · high confidence

Add LPTMR driver and selectable time backend for MCXA

Introduces a new Low-Power Timer (LPTMR) driver for the MCXA series, providing a configurable timer peripheral with support for async waits via WaitCell. Additionally, it adds a free-running LPTMR time backend that serves as an alternative system time source, allowing users to select LPTMR as the underlying hardware driver for embassy-time.

embassy-mcxa/src/lptmr · high confidence

Add MIMXRT1011 example project with GPIO and time drivers

A new example project for the NXP MIMXRT1011 (i.MX RT1010) platform has been added, providing blinky and button-demo binaries that utilize the embassy\_nxp GPIO and embassy\_time drivers. The project includes a FlexSPI configuration block (FCB) to support QSPI flash operations and is configured to build for the thumbv7em-none-eabihf target, allowing it to run on the IMXRT1010-EVK, Adafruit Metro M7, and Makerdiary iMX RT1011 Nano Kit boards.

examples/mimxrt1011 · high confidence

Add MSPM0 timer and simple PWM driver

Introduces a new timer (TIM) module for the MSPM0 series, including marker traits for timer instances (2/4 channel, 32-bit, advanced) and pins, along with a simple PWM driver. The PWM driver supports configurable clock sources (LFCLK, MFCLK), frequencies, and counting modes (edge-aligned up/down, center-aligned) for up to four channels, allowing users to generate PWM signals on supported hardware pins.

embassy-mspm0/src/tim · high confidence

Add MSPM0G5187 example project with GPIO, button, clock output, and watchdog demos

Users can now run Embassy examples for the MSPM0G5187 MCU (e.g., \cargo run --bin blinky\). This location adds the project scaffolding (\.cargo/config.toml\, \Cargo.toml\, \build.rs\, \memory.x\) and four binary examples: \blinky\ (GPIO output toggle), \button\ (GPIO input with LED toggle), \clk\_out\ (clock output via SYSRST/CLK\_OUT), and \wwdt\ (windowed watchdog timer with pet/timeout behavior).

examples/mspm0g5187 · high confidence

Add MSPM0L1306 example project with peripheral demos

Introduces a new example project for the MSPM0L1306 microcontroller, providing a complete build configuration (Cargo, linker, memory map) and source code for key peripherals. Users can now run demonstrations for ADC (reading a thermistor), GPIO (blinky, button), I2C (master blocking/async and target mode), UART (blocking echo), watchdog (WWDT), and clock output (ClkOut).

examples/mspm0l1306 · high confidence

Add Microchip MEC1723N example project with Embassy HAL support

This change introduces a new example project for the Microchip MEC1723N microcontroller, providing a complete build configuration and a suite of demonstration applications. The project includes linker scripts and memory definitions to support running code from RAM, along with Cargo configuration for probe-rs debugging. It features Embassy-based examples for GPIO (blinky, button), I2C (async and blocking), PWM, and UART (async and blocking), demonstrating the integration of the new embassy-microchip HAL.

examples/microchip · high confidence

Add NRF bootloader example with watchdog flash protection

A new bootloader example for Nordic NRF platforms has been added, implementing a watchdog-protected flash access mechanism via \WatchdogFlash\. The entry point initializes the MCU, configures the watchdog timer, and starts the bootloader using either the standard NVMC or the RRAMC peripheral (selected via the \nrf54\ feature flag) to ensure flash operations remain safe during potential watchdog timeouts.

examples/boot/bootloader/nrf · high confidence

Add NXP i.MX RT1060-EVK board support

Users can now build and run Embassy OS examples on the NXP i.MX RT1060-EVK development board. This change introduces a new example directory containing a blinky demo (toggling an LED), a button input demo (with software debouncing), and the necessary board-specific configuration files. These include a Cargo configuration for the Cortex-M7 target and probe-rs debugging, a build script to configure the FlexSPI runtime for 8MB of external QuadSPI flash, and a library defining the FlexSPI Configuration Block (FCB) to initialize the IS25WP flash chip for booting.

examples/mimxrt1062-evk · high confidence

Add NXP i.MX RT6 (MIMXRT685) example project

Introduces a new example project for the NXP i.MX RT6 series (specifically the MIMXRT685), providing a complete build configuration and a suite of demonstration applications. The project includes examples for GPIO (blinky, button), communication protocols (SPI, UART, DMA), and hardware features (CRC, RNG). It is configured for the thumbv8m.main-none-eabihf target and utilizes the embassy-imxrt HAL for asynchronous execution.

examples/mimxrt6 · high confidence

Add OPEN Alliance TC6 and generic SPI protocol support for ADIN1110

The ADIN1110 driver now supports two SPI communication protocols: the OPEN Alliance TC6 standard (enabled via the \tc6\ feature) and a generic SPI mode (enabled via the \generic-spi\ feature). This introduces a new \Adin1110Protocol\ trait that abstracts register and FIFO access, allowing the driver to handle the specific header formats, CRC/parity checks, and flow-control mechanisms required by each protocol. Users can select the appropriate implementation based on their hardware configuration. Also in this area: Documentation typo corrections across embassy HALs.

embassy-net-adin1110/src/protocol · high confidence

Add OSPI memory-mapped example for STM32H7B0

A new example demonstrating OctoSPI (OSPI) memory-mapped mode has been added for the STM32H7B0 microcontroller. The example configures the OCTOSPI1 peripheral to interface with a W25Q64 SPI flash chip, showcasing read/write operations and enabling memory-mapped access to read data directly from the flash address space (0x90000000). It includes necessary build configuration files (.cargo/config.toml, build.rs, memory.x) to target the Cortex-M7F core and link the application correctly.

examples/stm32h7b0 · high confidence

Add PKA cryptographic driver with ECDSA, ECDH, and RSA support

The PKA (Public Key Accelerator) peripheral driver is now available, providing hardware-accelerated public key cryptography for supported STM32 chips. Users can perform ECDSA signature generation and verification, ECDH key agreement, and RSA operations (including modular exponentiation and Montgomery multiplication) via both async and blocking APIs. The driver supports P-256 and P-384 curves, integrates with the \embassy-crypto\ ecosystem for standard curve arithmetic, and handles nonce generation securely using the system RNG. It also includes security features like RAM scrubbing after sensitive operations and support for multiple hardware revisions (v1a, v1b, v1c) with appropriate fallbacks for older silicon.

embassy-stm32/src/pka · high confidence

Add QSPI flash memory example for STM32H742

A new example application has been added for the STM32H742 microcontroller that demonstrates how to interact with QSPI flash memory (specifically the GD25Q64C). The example includes the necessary Cargo configuration and build scripts to target the ARM architecture, and provides a Rust implementation for common flash operations such as reading the device ID and UUID, erasing sectors/blocks/chips, and writing memory pages using the embassy-stm32 QSPI driver.

examples/stm32h742 · high confidence

Add ROM API bindings for flash, SPI, and secure boot on MCXA5xx

This change introduces Rust bindings for the NXP MCXA ROM API, enabling low-level access to internal bootloader services. The \flash\ module provides a standard \embedded\_storage\ interface for reading, erasing, and programming internal P-Flash. For MCXA5xx devices, the \flexspi\_nor\ and \spi\_flash\ modules expose drivers for external serial NOR and SPI flash memories, including configuration helpers for clock and mode settings. Additionally, the \kb\ (Key Boot) and \nboot\ modules implement the secure boot and authentication APIs, allowing applications to load, authenticate, and manage encrypted memory regions using the ROM's cryptographic engines.

embassy-mcxa/src/rom · high confidence

Add ROM-backed software floating-point intrinsics for RP235x

The embassy-rp float module now implements software floating-point operations (addition, subtraction, multiplication, division, comparison, conversion, and math functions like sqrt, sin, cos) by routing calls to the RP235x boot ROM routines. This change provides correct IEEE 754 handling for special values (NaN, infinity) and ensures compatibility with the RP235x hardware divider state, replacing previous software-only or missing implementations for these operations on the new chip.

embassy-rp/src/float · high confidence

Add RP firmware updater example application

The examples/boot/application/rp directory now includes a new firmware updater example (bin/a.rs) for the RP2040 platform. This application demonstrates how to use embassy-boot-rp to prepare, write, and mark a firmware update from a secondary binary (bin/b.rs) onto the device's flash memory, including watchdog management and LED status indication.

examples/boot/application/rp · high confidence

Add RP2040 bootloader example with watchdog-protected flash

A new bootloader example for the RP2040 platform has been added, demonstrating the use of embassy-boot-rp. The implementation initializes the system, creates a WatchdogFlash instance to protect flash operations with an 8-second timeout, and uses a BootLoaderConfig derived from a linker file to locate and load the active application image into flash memory.

examples/boot/bootloader/rp · high confidence

Add RP2040 example project with build configuration and driver demonstrations

This change introduces a new \examples/rp\ directory containing the build infrastructure and a comprehensive set of examples for the RP2040 microcontroller. A \build.rs\ script and \memory.x\ linker script are added to handle memory layout and linker arguments. The examples demonstrate core embassy-rp capabilities, including GPIO (blinky, button, async input), ADC with DMA support, flash memory operations, and various communication protocols such as SPI, I2C, UART, and PIO-based interfaces. It also includes network examples for the WIZnet W5500 Ethernet controller (TCP, UDP, ICMP) and examples for task orchestration and resource sharing.

examples/rp · high confidence

Add RP235x ROM data support

Users can now access RP235x bootrom functions and data through the embassy-rp rom\_data module. This change introduces a new rp235x.rs implementation that handles RP235x-specific ROM table lookups (including separate code and data lookup functions for ARM and RISC-V architectures) and exposes public ROM functions via the same interface as the existing RP2040 support.

_embassy-rp/src/rom\data · high confidence

Add RP235x example project with build configuration and diverse hardware demos

This change introduces a new \examples/rp235x\ directory containing a complete build setup and a wide range of examples for the RP235x microcontroller. The project includes a \.cargo/config.toml\ for probe-rs debugging, a \build.rs\ script to manage the linker script, and a \memory.x\ file defining memory layout for the RP2350 (including specific SRAM8/SRAM9 addresses). The examples cover basic I/O (blinky, button, bootsel), ADC with DMA, AON Timer async alarms, resource assignment patterns, and extensive networking capabilities including Wi-Fi (blinky\_wifi), Ethernet via W5500 (TCP/UDP/ICMP), and Ethernet via W6300 (UDP).

examples/rp235x · high confidence

Add RTC drivers for MCXA2xx and MCXA5xx series

New Real-Time Clock (RTC) drivers have been added for the MCXA2xx and MCXA5xx microcontroller series. These implementations provide date and time management capabilities, including conversion between Unix timestamps and structured date/time objects, alarm handling via interrupt flags, and configuration options for wakeup sources and compensation. The drivers are tailored to the specific register layouts of each series (e.g., \rtc2xx\ vs \rtc5xx\ PACs) and support standard Embassy HAL patterns for clock synchronization and alarm waiting.

embassy-mcxa/src/rtc · high confidence

Add Real-Time Clock (RTC) driver for RP2040/RP235x

Introduces a new RTC driver for RP2040 and RP235x microcontrollers, enabling users to set, read, and validate the current date and time. The driver supports scheduling hardware alarms with granular filters (year, month, day, day-of-week, hour, minute, second) via the \DateTimeFilter\ API and provides save/restore functionality to persist RTC state across resets. It includes a built-in \DateTime\ abstraction with optional \chrono\ crate integration for standard date/time handling and fixes a race condition in alarm handling by using an \AtomicBool\ flag.

embassy-rp/src/rtc · high confidence

Add S/PDIF receiver driver with ring-buffered DMA support

Introduces a new \Spdifrx\ driver for STM32 microcontrollers that receives S/PDIF audio data. The driver uses DMA to transfer audio samples into a configurable ring buffer, supporting stereo mode and left-aligned data formats. It allows users to configure control channel selection (A or B) for capturing channel status information and handles errors such as DMA overruns and channel synchronization failures.

embassy-stm32/src/spdifrx · high confidence

Add SGI cryptographic driver for MCXA

Introduces a new SGI (Secure Generic Interface) hardware driver for the MCXA platform, initially supporting SHA-384 and SHA-512 hashing. The driver provides both blocking and async execution modes, utilizing DMA for efficient data transfer in async operations. It includes context management with secure zeroization on drop and handles endianness conversion for input/output data.

embassy-mcxa/src/sgi · high confidence

Add SPI and UART drivers for i.MXRT Flexcomm peripherals

This change introduces new SPI and UART drivers for the i.MXRT series, located in the \embassy-imrt/src/flexcomm\ module. The \spi.rs\ file provides both blocking and async SPI implementations supporting standard modes (0-3) and various pin configurations (full, TX-only, RX-only, loopback). The \uart.rs\ file adds a UART driver with configurable baud rates, data bits, parity, and stop bits, also supporting both blocking and async modes. A shared \mod.rs\ file implements the low-level Flexcomm interface, handling clock selection and peripheral enablement for Flexcomm instances 0-7, 14, and 15.

embassy-imxrt/src/flexcomm · high confidence

This change introduces the \ll\_sys\ module, providing Rust wrappers for the STM32 WBA Link Layer IP's system-level functions. It includes critical section management (interrupt enable/disable), deep sleep mode handling with wake-up timers, general system interfaces (clocking, delays, RNG, radio event notifications), and BLE stack initialization logic. These shims bridge the embassy-stm32-wpan crate with the underlying ST Link Layer library, enabling proper hardware control and BLE stack integration.

_embassy-stm32-wpan/src/wba/ll\sys · high confidence

Add STM32 QSPI driver with multiple operational modes

Introduces a new QSPI driver for STM32 microcontrollers, enabling users to communicate with external flash memory. The driver supports Indirect Read/Write, AutoPolling, and Memory-Mapped modes, allowing for flexible access patterns including high-speed memory-mapped execution. It provides configuration options for dual-bank support, flash selection, address sizes (up to 32-bit), and GPIO speeds, while handling hardware-specific errata workarounds for STM32H7 series devices.

embassy-stm32/src/qspi · high confidence

Add STM32C0 example applications

New example applications are now available for the STM32C0 microcontroller, demonstrating core hardware capabilities. These include basic GPIO control (blinky, button), external interrupt handling (button\_exti), real-time clock usage (rtc), and analog-to-digital conversion (adc). The ADC examples specifically showcase both blocking reads and DMA-based ring-buffered sampling triggered by a timer, providing users with reference implementations for common embedded tasks on this chip family.

examples/stm32l1 · high confidence

Add STM32F105 USB serial example

A new USB serial (CDC-ACM) example has been added for the STM32F105 microcontroller, adapted from the existing STM32F4 implementation. This example demonstrates how to configure the USB OTG FS peripheral, set up the clock tree for 48 MHz USB clock, and implement a simple echo server using the Embassy framework. It includes necessary build configuration files for linking and debugging via probe-rs.

examples/stm32f105 · high confidence

Add STM32F107 Ethernet example

A new Ethernet example for the STM32F107 microcontroller has been added, demonstrating a TCP echo server. The example configures the hardware clock and Ethernet peripheral, initializes the network stack with DHCPv4, and listens on port 80 using the new listener API (AcceptToken) to handle incoming TCP connections.

examples/stm32f107 · high confidence

Add STM32F2 blinky and PLL configuration examples

New example applications for the STM32F2 microcontroller are now available, providing reference implementations for basic GPIO toggling and advanced clock configuration. The blinky example demonstrates a simple LED toggle loop using the embassy-time Timer, while the PLL example shows how to configure the system clock via the High-Speed External (HSE) oscillator and Phase-Locked Loop to achieve maximum performance on the NUCLEO-F207ZG board.

examples/stm32f2 · high confidence

Add STM32F334 example project with ADC, HRTIM, and OpAmp demos

A new example project for the STM32F334 microcontroller has been added, providing ready-to-run demonstrations for key hardware peripherals. The project includes specific binary examples for the ADC (reading VREFINT, temperature, and GPIO pins), the High-Resolution Timer (HRTIM) for generating advanced PWM waveforms, and the Operational Amplifier (OpAmp) for signal buffering. It also contains basic starter examples for GPIO output (button/LED) and a simple 'Hello World' loop, all configured with the necessary build scripts and cargo settings for the ARM Cortex-M target.

examples/stm32f334 · high confidence

Add STM32G4 example project with comprehensive peripheral demos

A new example project for the STM32G4 microcontroller is introduced, providing a complete build configuration (Cargo config, build script) and a suite of demonstration binaries. These examples cover ADC (including differential, DMA, oversampling, and injected/regular conversions), FDCAN (blocking and buffered modes), DAC (ring-buffered DMA waveform generation), I2C (master/slave), I2S, Input Capture, PWM, PLL configuration, USB Serial (CDC-ACM), USB-C Power Delivery, and basic GPIO/EXTI. This gives users a ready-to-run reference for integrating and testing these peripherals on STM32G4 hardware.

examples/stm32g4 · high confidence

Add STM32H5 example applications

This change introduces a new set of example applications for the STM32H5 microcontroller family. The examples cover a wide range of peripherals including ADC (blocking and DMA), backup SRAM, CAN (FDCAN), CORDIC, DTS (temperature sensor), Ethernet, I2C, MCO, RNG, SAI, SPI (slave mode), USART (blocking, DMA, and split), USB-C PD, USB Serial (CDC-ACM), and USB Audio (UAC1 Speaker). It also includes a cryptographic benchmark for P-256 operations and a simple blinky example, providing developers with reference implementations for these features on the STM32H5 platform.

examples/stm32c0 · high confidence

Add STM32H5 example project

This change introduces a new example project for the STM32H5 microcontroller family. It includes a Cargo configuration targeting the thumbv8m architecture and a build script for linking. The project provides a comprehensive set of demonstration binaries covering core peripherals: GPIO (blinky, button EXTI), ADC (blocking and DMA), backup SRAM, CAN (FDCAN), CORDIC, DTS (temperature sensor), Ethernet (with DHCP), I2C, MCO (clock output), RNG, SAI (audio), USART (blocking, DMA, and split), USB-C PD, USB Serial (CDC-ACM), USB Audio (UAC1 speaker), and Wi-Fi scanning (CYW43).

examples/stm32h5 · high confidence

Add STM32H745I-DISCO LCD display example

A new sample application has been added for the STM32H745I-DISCO board, demonstrating how to drive the LTDC LCD display using the Cortex-M7 core. The example initializes the display controller, sets up a 256-color lookup table to manage memory usage within the MCU's internal RAM, and animates a 'Ferris crab' bitmap across the screen while simultaneously blinking an LED in a separate async task. It includes specific configuration for the RK043FN48H display panel and provides instructions for disabling the CM4 core if needed.

examples/stm32h745cm7 · high confidence

Add STM32H747I-DISCO DSI display examples

This change introduces new example applications for the STM32H747I-DISCO board, specifically targeting the DSI-connected LCD panel. It adds a \display\ example using DSI in adapted command mode and a \display\_videomode\ example using DSI in video burst mode. These examples demonstrate driving the 480x800 NT35510-based display via the DSI host and LTDC, including SDRAM initialization for framebuffers, MPU configuration for cache coherency, and a text-based UI rendered using \ratatui\ and \mousefood\. The entry also includes the necessary build configuration (\.cargo/config.toml\, \build.rs\, \memory.x\) and shared library code (\src/lib.rs\, \src/glass.rs\, \src/framebuffer.rs\, \src/mpu.rs\) to support these display features.

examples/stm32h747cm7 · high confidence

Add STM32H755 CM4 blinky and intercore communication examples

New example binaries are added for the STM32H755 Cortex-M4 core, including a standard blinky demo and an intercore communication example that demonstrates shared-memory-based LED control between the CM7 and CM4 cores. The examples use a custom linker script to place shared data in SRAM4 (RAM\_D3) and rely on the embassy-stm32 secondary-core initialization API.

examples/stm32h755cm4 · high confidence

Add STM32L5 example project with USB and peripheral demos

A new example project for the STM32L5 microcontroller has been added, providing ready-to-run demonstrations for GPIO EXTI interrupts, hardware random number generation, and USB functionality (including CDC-ACM serial, HID mouse, and a combined USB-Ethernet CDC-NCM network stack). The project is configured to use probe-rs for flashing and debugging, sets the DEFMT\_LOG environment variable to trace level for detailed logging, and targets the thumbv8m.main-none-eabihf architecture.

examples/stm32l5 · high confidence

Add STM32N6 First Stage Boot Loader (FSBL) example

Introduces a new FSBL example for the STM32N6570-DK and NUCLEO-N657X0-Q boards that implements a two-stage boot process using embassy-boot. The FSBL initializes the XSPI2 peripheral to communicate with external Macronix NOR flash (MX66UW1G45G on DK, MX25UM51245G on Nucleo), handles debug port unlocking via BSEC registers, and configures the system clocks and RAM. It supports both development kit and Nucleo board variants through feature flags, enabling users to boot applications from external flash.

examples/stm32n6-flashboot/fsbl · high confidence

Add STM32N6 NPU driver with cache maintenance and EC binary loading

This change introduces the NPU (Neural-ART) driver for the STM32N6, enabling hardware-accelerated inference via the epoch controller model. It adds cache maintenance utilities in \cache.rs\ to handle coherence between the Cortex-M55 CPU and the NPU's CACHEAXI for external memory buffers, and an \ecloader.rs\ module to parse, load, and relocate ST Edge AI-generated Epoch Controller binaries. The main \mod.rs\ provides the async NPU driver, interrupt handling, and execution APIs (\run\_epoch\_blob\, \run\_network\) to orchestrate inference workloads.

embassy-stm32/src/npu · high confidence

Add STM32U0 example project with hardware demos

Introduces a new example project for the STM32U0 series (targeting the stm32u083mctx chip) that demonstrates the platform's hardware capabilities. The project includes runnable examples for GPIO (blinky, button, EXTI), analog peripherals (ADC, DAC), communication interfaces (SPI, I2C, USART, USB CDC-ACM), and system features (RTC, CRC, Flash, RNG, Watchdog, AES encryption).

examples/stm32u0 · high confidence

Add STM32WB USB DFU runtime example with WinUSB support

A new example application for the STM32WB platform has been added to demonstrate USB Device Firmware Upgrade (DFU) functionality using the Embassy framework. The example configures the device to automatically assign the WinUSB driver on Windows via MSOS descriptors, eliminating the need for manual driver installation tools like Zadig. It includes a configurable device interface GUID and implements the necessary firmware state management to handle DFU entry and reset operations.

examples/boot/application/stm32wb-dfu · high confidence

Add STM32WBA BLE stack integration with context switching and platform drivers

Introduces the core infrastructure for running the STM32WBA BLE stack within the Embassy async executor. This includes a custom context-switching mechanism (\context.rs\) that allows the C-based BLE sequencer to run on a separate stack and yield back to the Rust executor, a \Platform\ abstraction (\platform.rs\) that manages the runner task, event channels, and P-256 crypto requests, and platform adaptation layers (\linklayer\_plat.rs\, \ll\_sys\_if.rs\, \mac\_sys\_if.rs\) that bridge the BLE stack's hardware requirements (interrupts, timers, RNG, AES/CMAC via embassy-crypto) to the Embassy runtime. The \Controller\ (\controller.rs\) ties these components together, initializing the BLE stack and managing HCI event processing.

embassy-stm32-wpan/src/wba · high confidence

Add STM32WBA USB DFU bootloader example

A new bootloader example for the STM32WBA series is now available in the examples/boot/bootloader/stm32wba-dfu directory. It implements a USB Device Firmware Upgrade (DFU) interface using the embassy-usb-dfu crate, allowing users to update firmware over USB. The example includes configuration for the STM32WBA clock tree, flash layout parsing via embassy-boot-stm32, and optional firmware signature verification using Ed25519 (enabled via the 'verify' feature). It also integrates MSOS descriptors to ensure automatic WinUSB driver assignment on Windows hosts.

examples/boot/bootloader/stm32wba-dfu · high confidence

Add STM32WBA USB DFU runtime example

A new example application for the STM32WBA microcontroller has been added to demonstrate USB Device Firmware Upgrade (DFU) functionality. This example configures the device's USB OTG High-Speed peripheral and implements a runtime DFU handler that allows users to update firmware via USB. It includes specific configuration for Windows compatibility by adding MSOS descriptors to automatically assign the WinUSB driver, simplifying the update process for users on Windows without requiring manual driver installation tools.

examples/boot/application/stm32wba-dfu · high confidence

Add WASM executor example with DOM logging

A new WASM example has been added that demonstrates the embassy executor running in a browser environment. The example initializes a WASM logger, spawns a background task that increments a counter every second, and updates the page's DOM by appending list items to an element with the ID 'log'.

examples/wasm · high confidence

Add async and blocking flash partition support

Users can now divide a shared underlying flash storage into logical, offset-and-size-restricted partitions. The \embassy-embedded-hal\ crate introduces \Partition\ for asynchronous contexts and \BlockingPartition\ for synchronous contexts, both of which enforce read/write/erase alignment constraints and return an \OutOfBounds\ error if operations exceed the partition's defined range. This allows multiple independent flash regions to be managed safely within a single physical device.

embassy-embedded-hal/src/flash/partition · high confidence

Add asynchronous shared I2C and SPI bus implementations

Users can now share I2C and SPI peripherals among multiple devices using asynchronous drivers. The new \I2cDevice\ and \SpiDevice\ types provide async access to shared buses protected by a mutex, while \I2cDeviceWithConfig\ and \SpiDeviceWithConfig\ allow different devices on the same bus to apply their own communication settings at runtime. The SPI implementation also ensures the Chip Select (CS) pin is safely deasserted if a transaction is cancelled.

_embassy-embedded-hal/src/shared\bus/asynch · high confidence

Add blocking shared I2C and SPI bus implementations

Users can now share a single I2C or SPI peripheral among multiple devices using the new blocking \I2cDevice\ and \SpiDevice\ types in \embassy\_embedded\_hal::shared\_bus::blocking\. These types wrap the underlying hardware with a mutex to ensure thread-safe access, and \SpiDevice\ automatically handles chip-select assertion and deassertion around transactions. Additionally, \I2cDeviceWithConfig\ and \SpiDeviceWithConfig\ allow different devices on the same bus to apply their own communication settings (via \SetConfig\) before each operation, and runtime configuration changes are supported via \set\_config\.

_embassy-embedded-hal/src/shared\bus/blocking · high confidence

Add bootloader application examples for multiple platforms

Added bootloader application examples for nRF, Raspberry Pi (RP2040 and RP235x), and various STM32 families (F3, F7, H7, L0, L1, L4, and WB-DFU). These examples demonstrate how to structure an application binary to work with the embassy-boot system, including specific linker scripts (memory.x) that define regions for the bootloader, state, active application, and DFU updates, along with build scripts and configuration files to facilitate flashing and debugging.

examples · high confidence

Add buffered UART driver for MSPM0

Introduces a new buffered UART implementation for the MSPM0 series, providing \BufferedUart\, \BufferedUartTx\, and \BufferedUartRx\ structs that use ring buffers for asynchronous I/O. This driver supports configurable baud rates, data bits, parity, and flow control (RTS/CTS), and exposes async \read\/\write\ methods alongside blocking equivalents, enabling non-blocking serial communication on MSPM0 devices.

embassy-mspm0/src/uart · high confidence

Add changelog, README, and build configuration for embassy-boot-stm32

This change introduces the initial documentation and build infrastructure for the embassy-boot-stm32 crate. A CHANGELOG.md file has been added to track version history, including updates to embassy-sync, embassy-stm32, and embassy-boot dependencies. A README.md provides an overview of the crate's features, such as configuring bootloader partitions via linker scripts and loading applications from the active partition. Additionally, a build.rs script is included to conditionally define the armv6m configuration flag for Thumb-6M targets and register it for check-cfg validation.

embassy-boot-stm32 · high confidence

Add deep-sleep and shutdown support for MSPM0 families

The \embassy-mspm0\ crate now provides low-power capabilities for MSPM0 microcontrollers, allowing the system to enter deep-sleep modes (STOP0/1/2 and STANDBY0/1) or a full shutdown state. This implementation includes family-specific logic for C-series (C110x), H-series (H321x), and G/L-series chips, mapping a common \SleepLevel\ to the appropriate hardware registers while handling specific errata like prefetcher suspension. Users can now reduce power consumption significantly when the device is idle, with the ability to block specific sleep levels via \WakeGuard\ to ensure critical operations are not interrupted.

_embassy-mspm0/src/low\power · high confidence

Add embassy-boot example for RP2350

This change introduces a new example application for the RP2350 microcontroller that demonstrates firmware updates using the embassy-boot bootloader. The example includes two binaries: 'a', which waits five seconds and then writes binary 'b' to flash, and 'b', which blinks an LED at a speed that indicates whether it is a fresh boot or a post-update boot. The implementation relies on the \embassy\_boot\_rp\ crate for managing the update process and includes necessary configuration files such as \.cargo/config.toml\, \memory.x\ for memory layout, and a \build.rs\ script to handle linker scripts.

examples/boot/application/rp235x · high confidence

Add embassy-crypto-rand crate for OS-backed random number generation

A new \embassy-crypto-rand\ crate has been introduced to provide a random number generator implementation for \embassy-crypto\. It registers the operating system's secure random source (via the \getrandom\ crate) as the global RNG driver. Users can enable this by adding \embassy-crypto-rand\ as a dependency and including a dummy \use embassy\_crypto\rand as \;\ statement to ensure the driver is linked. The implementation is infallible, panicking if the OS random source fails to fill the buffer.

embassy-crypto-rand · high confidence

Add embassy-crypto-stub crate for placeholder crypto operations

A new \embassy-crypto-stub\ crate has been added to provide stub drivers for the \embassy-crypto\ ecosystem. This crate registers drivers for a wide range of cryptographic operations—including AES (ECB, CBC, CTR, GCM, CCM, CMAC), ChaCha stream and AEAD modes, SHA-2/3 and HMAC hash functions, Ed25519, X25519, and P-256/P-384 elliptic curve operations (arith, ECDH, ECDSA)—but every implementation panics at runtime via \unreachable!()\. It serves as a placeholder for builds where no real crypto backend (hardware, ASM, or RustCrypto) is available, allowing code linking against \embassy-crypto\ to compile and link successfully while ensuring that any actual crypto operation traps at runtime.

embassy-crypto-stub · high confidence

Add example projects for MSPM0C1104 and MSPM0G3507 MCUs

New example projects have been added for the MSPM0C1104 and MSPM0G3507 microcontrollers, providing ready-to-run demonstrations for key peripherals. These examples include GPIO control (blinky, button), ADC with thermistor reading, PWM for RGB LEDs, I2C (controller and target modes), UART (blocking and buffered), clock output, watchdog timer, and hardware-accelerated math operations. Each project includes the necessary build configuration, memory maps, and README instructions to help users get started quickly with these specific chip variants.

examples/mspm0g3507 · high confidence

Add full CRACEN and CryptoCell cryptographic accelerator drivers

This change introduces complete driver implementations for the nRF54L CRACEN and nRF52/nRF53/nRF91 CryptoCell cryptographic accelerators. It adds low-level modules for DMA descriptor chains and transfers, power management handles, and TRNG health-test configuration for CRACEN, alongside DMA paths and engine control for CryptoCell. High-level drivers are provided for the Public Key Accelerator (PKA), including elliptic curve arithmetic (P-192, P-224, P-256, P-384, P-521, secp256k1), ECDSA signing and verification, and RSA operations (modular exponentiation and CRT) for both hardware backends, exposing these capabilities through the embassy-crypto interface.

embassy-nrf/src/crypto · high confidence

Add nRF51 Blinky Example

A new blinky example has been added for nRF51 devices, demonstrating basic LED toggling using the embassy-nrf driver and embassy executor. This example serves as a starting point for users developing on nRF51 hardware within the embassy ecosystem.

examples/nrf51 · high confidence

Add nRF52840 EDF scheduler example

A new example application for the nRF52840 microcontroller has been added to demonstrate the Earliest Deadline First (EDF) scheduling capability. The example, located at \examples/nrf52840-edf\, includes the necessary build configuration (\.cargo/config.toml\, \build.rs\, \memory.x\) and a Rust source file (\src/bin/basic.rs\) that runs background load tasks alongside prioritized trial tasks to show how setting a deadline elevates a task's scheduling priority above non-prioritized background work.

examples/nrf52840-edf · high confidence

Add nRF9160 example with TCP modem connectivity

A new example project for the nRF9160 board has been added, demonstrating how to establish a TCP connection using the device's modem. The example configures a BufferedUarte for trace output, initializes the embassy-net-nrf91 driver to manage the modem context, and sets up an embassy-net stack to handle IP networking. It includes a control task to configure the APN and authentication, and a main loop that connects to a remote host to send periodic messages, providing a complete reference for integrating cellular connectivity with the Embassy RTOS.

examples/nrf9160 · high confidence

Add soft sQSPI driver for nRF54L

Introduces a new soft Quad Serial Peripheral Interface (sQSPI) driver for the nRF54L platform, implemented in firmware running on the VPR coprocessor. This driver exposes an API compatible with the existing hardware QSPI driver (including \read\, \write\, \erase\, and \embedded-storage\ traits) but requires the user to provide a firmware blob and a RAM buffer for the virtual register block. It supports standard SPI modes, multi-line addressing (dual/quad), and custom opcodes.

embassy-nrf/src/sqspi · high confidence

Add software cryptographic drivers for AES, ChaCha, Ed25519, X25519, and hashing

This change introduces a new software-backed implementation crate, embassy-crypto-rustcrypto, which provides drivers for a wide range of cryptographic algorithms using the RustCrypto ecosystem. Users can now enable features to use software implementations for AES (ECB, CBC, CTR, GCM, CCM, CMAC), ChaCha (ChaCha8/12/20 and ChaChaPoly1305), Ed25519 signatures, X25519 key exchange, and various hash functions (MD5, SHA-1, SHA-2 family) with HMAC support. The implementation also includes elliptic curve arithmetic, ECDH, and ECDSA for P-256 and P-384 curves, along with SEC1 point decompression support.

embassy-crypto-rustcrypto/src · high confidence

Add std examples for embassy-net and serial communication

The \examples/std\ directory now includes runnable examples demonstrating network and serial capabilities on standard hosts. New binaries include \net\ (TCP client), \tcp\_accept\ (single TCP listener), \tcp\_accept\_multi\ (concurrent TCP listener using a task pool), \net\_udp\ (UDP echo server), \net\_dns\ (DNS query), and \net\_ppp\ (PPP over serial). A \serial\ example demonstrates reading from a serial port using \async\_io\ and \embedded\_io\_adapters\. These examples rely on a \tap.sh\ script to configure a TAP interface and a \README.md\ for setup instructions.

examples/std · high confidence

Add support for Wiznet W5100S, W6100, and W6300 Ethernet chips

The embassy-net-wiznet driver now supports the Wiznet W5100S, W6100, and W6300 Ethernet controllers in addition to the existing W5500. This change introduces new chip-specific modules that define the unique register maps, SPI communication protocols, and buffer configurations required for each device, allowing users to initialize and communicate with these newer hardware variants.

embassy-net-wiznet/src/chip · high confidence

Added Blinky and UART examples for nRF9151 Non-Secure partition

New example applications have been added to the examples/nrf9151/ns directory, providing reference implementations for the nRF9151 Non-Secure (NS) partition. The Blinky example demonstrates basic GPIO control by toggling an LED, while the UART example showcases asynchronous serial communication using the UARTE peripheral with interrupt handling. These examples utilize the Embassy framework for async execution and defmt for logging, offering developers starting points for building applications on this specific hardware configuration.

examples/nrf9151/ns · high confidence

Added DHCPv4 client and server support

The network interface now supports automatic IP configuration via a DHCPv4 client and can act as a DHCPv4 server to hand out addresses to other devices. Users can enable the client using \Iface::set\_dhcpv4\ to obtain an IP lease and default route, or enable the server using \Iface::set\_dhcpv4\_server\ to lease addresses from a configured pool, specifying details like gateway and DNS servers. Lease information is accessible via \Iface::dhcpv4\_lease\ for clients and \Iface::dhcpv4\_server\_leases\ for servers.

embassy-net/src/iface · high confidence

Added Embassy-based examples for MSPM0L2228

New example applications for the MSPM0L2228 microcontroller have been added, demonstrating core hardware features using the Embassy async runtime. These include blinky and button input handling via GPIO, clock output configuration, true random number generation (TRNG), blocking UART communication, and windowed watchdog timer (WWDT) management.

examples/mspm0l2228 · high confidence

Added IEEE 802.15.4 radio driver

Users can now use the nRF radio for IEEE 802.15.4 (Zigbee/Thread) communication. A new \ieee802154\ module provides a \Radio\ driver that supports configuring the channel (11–26), Clear Channel Assessment (Carrier Sense or Energy Detection), transmission power, and the Start of Frame Delimiter. This driver is available on devices with the \nrf52811\, \nrf52820\, \nrf52833\, \nrf52840\, and \\_nrf5340-net\ features.

embassy-nrf/src/radio · high confidence

Added IWDG and WWDG watchdog drivers for STM32 microcontrollers

Users can now initialize and manage both Independent Watchdog (IWDG) and Window Watchdog (WWDG) peripherals on supported STM32 chips. The IWDG driver allows configuring a timeout in microseconds using the LSI clock, automatically selecting the appropriate prescaler and reload value, and provides methods to start (\unleash\) and refresh (\pet\) the watchdog. The WWDG driver supports configuring a total timeout and a 'closed window' duration, ensuring the watchdog is refreshed within the allowed time window to prevent unintended resets, with automatic prescaler selection to fit the timing requirements.

embassy-stm32/src/wdg · high confidence

Added NRF52810 blinky and SAADC lowpower examples

New example applications for the NRF52810 microcontroller have been added to demonstrate basic GPIO toggling and low-power SAADC sampling. The blinky example shows how to initialize the device and toggle an LED, while the SAADC lowpower example illustrates how to sample analog inputs while managing power consumption, specifically implementing a workaround for hardware anomaly 241 by resetting the SAADC peripheral in its Drop implementation.

examples/nrf52810 · high confidence

Added NVRAM configuration files and build tooling for CYW43 firmware

This change introduces new NVRAM (non-volatile RAM) configuration files for specific hardware variants, including \nvram\_rp2040.txt\, \nvram\_sterling\_lwb+.txt\, \nvram\_murata\_1yn.txt\, and \nvram\_murata\_2bc.txt\, alongside a Rust utility (\write\_nvrams.rs\) to compile these text-based configurations into binary blobs. It also adds the permissive binary license and a README documenting the firmware source and sync history. These files provide the necessary radio calibration and board-specific parameters for the CYW43 WiFi/Bluetooth driver to operate correctly on the supported platforms.

cyw43-firmware · high confidence

Added RTIC-based blinky example for nRF52840

A new blinky example has been added to the examples/nrf52840-rtic location, demonstrating how to use the Real-Time Interaction Toolkit (RTIC) framework with the embassy\_nrf HAL. The example configures a periodic task to toggle an LED on pin P0\_13 using the new Timer::after\_millis convenience method and the updated Peri type alias for peripheral references.

examples/nrf52840-rtic · high confidence

Added STM32U3 and STM32L5 low-power example projects

New example projects have been added for the STM32U3 and STM32L5 microcontroller families, providing reference implementations for common embedded tasks. The STM32U3 examples include blinky, button EXTI handling, MCO clock output, RTC timekeeping, and a USB CDC-ACM serial echo device. Additionally, a low-power example for the STM32L5 demonstrates entering Stop mode while maintaining debug connectivity via RTT.

examples/stm32u3 · high confidence

Added STM32WL firmware updater and blinker example applications

Two new example binaries are now available for the STM32WL platform: a firmware updater application (a.rs) that demonstrates updating firmware via an external button trigger using the embassy-boot library, and a simple LED blinker application (b.rs) that serves as the target firmware. These examples illustrate the integration of the bootloader with application code on this specific microcontroller family.

examples/boot/application/stm32wl · high confidence

Added VREFBUF driver for STM32 microcontrollers

Users can now configure the Voltage Reference Buffer (VREFBUF) on supported STM32 devices (including STM32U3, WBA, U5, H5, and H7 series) via the new \VoltageReferenceBuffer\ driver. The driver allows setting the voltage scale and impedance mode, automatically enabling the correct peripheral clock for each chip family, and includes a specific workaround for STM32WBA6 errata to ensure correct trim values are applied.

embassy-stm32/src/vrefbuf · high confidence

Added async and blocking test flash implementations for boot loader

The \embassy-boot\ crate now includes \AsyncTestFlash\ and \BlockingTestFlash\ types in the \test\_flash\ module, providing test-specific flash storage abstractions for the active, DFU, and state partitions. These implementations allow boot loader tests to simulate flash hardware using either asynchronous or blocking APIs, with built-in conversion between the two modes to support different testing scenarios.

_embassy-boot/src/test\flash · high confidence

Automated release tooling for dependency bumping and changelog updates

Added a new \bump-dependency.sh\ script to update specific crate versions in Cargo.toml files without modifying the crate's own version, and introduced a \release.toml\ configuration to automate pre-release replacements in the CHANGELOG.md, such as updating version placeholders and release dates.

release · high confidence

Blocking-mode EXTI support and group mask utilities

Users can now handle EXTI interrupts in blocking mode via the new \ExtiInput\<Blocking\>\ type and the \blocking\ module, which is useful for direct interrupt handling outside the async executor. The \blocking\ module introduces \ExtiGroupMask\, allowing multiple pins sharing an IRQ line to be cleared with a single register write for improved performance and reduced code verbosity in interrupt handlers. Additionally, low-level configuration functions for edge triggering and interrupt enabling have been exposed to support these blocking operations.

embassy-stm32/src/exti · high confidence

Bluetooth support added to the CYW43 driver

The driver now includes a new \bluetooth\ module that implements a Bluetooth HCI transport layer over the shared SDIO/SPI bus. This adds a \BtDriver\ for sending and receiving Bluetooth packets, a \BtRunner\ to manage the underlying bus transactions, and a \HostCtrl\ structure to handle shared-bus state and prevent radio corruption when both WiFi and Bluetooth are active. The module is gated behind the \bluetooth\ feature flag.

cyw43/src · high confidence

Compile-time configuration for USB interface and handler counts

Users can now configure the maximum number of USB interfaces and control handlers at compile time via Cargo features (e.g., \max-interface-count-8\) or environment variables (e.g., \EMBASSY\_USB\_MAX\_INTERFACE\_COUNT=8\). This replaces hardcoded defaults, allowing the USB device stack to scale to more complex composite devices without wasting memory on unused buffers. The configuration is managed by a new \build.rs\ script and \gen\_config.py\ tool that generate the appropriate constants.

embassy-usb · high confidence

Embassy project initialization and repository setup

This change establishes the Embassy embedded framework repository with its initial structure. It introduces the core documentation, including the README, API guidelines, and contributor guide, alongside the Apache-2.0 and MIT licenses. The repository is configured with \.gitattributes\ for line-ending and merge handling, \.gitignore\ for build artifacts, and \rust-toolchain.toml\ files defining stable (1.97) and nightly toolchains with specific embedded targets. CI automation is provided via \ci.sh\, \ci-nightly.sh\, and \ci-xtensa.sh\ scripts, along with formatting utilities (\fmtall.sh\, \fmtall.ps1\) and a release process document (\RELEASE.md\).

(repo-wide) · high confidence

GPDMA driver now supports linked-list and ring-buffer transfers

The GPDMA driver in embassy-stm32 has been expanded to support linked-list and ring-buffer transfer modes. Users can now configure circular linked lists for continuous, unattended data streaming via the new \ReadableRingBuffer\ and \WritableRingBuffer\ types, which handle buffer wrapping and synchronization automatically. The driver also introduces a \TwoDItem\ type for GPDMA channels that support 2D addressing, allowing for block-repeat transfers with per-burst and per-block address offsets. Additionally, the implementation includes a \RunMode\ enum to control whether linked lists run once or loop, and provides specific transfer-complete event modes (\EachBlock\, \EachLinkedListItem\, \LastLinkedListItem\) for finer control over interrupt generation.

embassy-stm32/src/dma/gpdma · high confidence

Initial DMA2D driver support for STM32

Added a new driver for the STM32 DMA2D (Chrom-ART Graphics Accelerator) hardware. This introduces types for managing 2D buffers and regions, supporting multiple pixel formats including ARGB8888, RGB888, RGB565, and various alpha/luminance modes. The driver enables hardware-accelerated graphics operations on compatible STM32 microcontrollers.

embassy-stm32/src/dma2d · high confidence

Initial ENC28J60 Ethernet driver implementation

This change introduces the initial implementation of the ENC28J60 Ethernet driver for the embassy-net ecosystem. The driver provides a complete hardware abstraction layer, including register definitions for all memory banks (Bank 0–3, Common, and PHY), a macro-based bit-field manipulation system for safe register access, and a logging framework that supports both \defmt\ and \log\ backends. It implements the core network interface functionality, such as MAC address configuration, buffer management (TX/RX), and packet transmission/reception, while also exposing the device's MAC address via a getter and handling hardware-specific errata like RX buffer reset on corruption.

embassy-net-enc28j60/src · high confidence

Initial FMAC driver with ADC integration support

Added a new Filter Math Accelerator (FMAC) driver for STM32 microcontrollers, exposing core configuration options such as output clamping modes (Wrapping/Saturating), access methods (Poll/Interrupt/DMA), and gain settings. The driver includes a dedicated \FromAdc\ module that enables binding an ADC peripheral to the FMAC via DMA for automated signal processing pipelines.

embassy-stm32/src/fmac · high confidence

Initial FlexCAN driver for MCXA with configurable RX filters and control modes

The \embassy-mcxa\ crate now includes a new FlexCAN driver for MCXA chips, providing the foundational interface for Classic CAN communication. This release introduces a \Control\ module for managing peripheral states (enable, disable, freeze) with configurable timeouts, and a \filter\ module that allows users to configure RX ID filters using standard or extended IDs, masked filters, or an 'accept all' mode via a compile-time validated macro. The driver also defines newtype wrappers for CAN identifiers to support \defmt\ formatting and establishes the trait-based instance and pin configuration system required to wire the peripheral to specific hardware pins.

embassy-mcxa/src/flexcan · high confidence

Initial LPC55 and i.MX RT1xxx HAL support

This change introduces the initial implementation of the embassy-nxp HAL, providing drivers for NXP LPC55 and i.MX RT1xxx microcontrollers. The diff adds new modules for GPIO, ADC, DMA, I2C, USART, SPI, PWM, SCT, PINT, and the HASHCRYPT cryptographic accelerator (supporting AES-ECB/CBC/CTR and SHA-1/256). It also includes a CASPER driver for hardware-accelerated big-integer arithmetic, chip-specific initialization logic for LPC55, MIMXRT1011, and MIMXRT1062, and a unified logging/formatting layer that supports both \log\ and \defmt\ backends.

embassy-nxp/src · high confidence

Initial LPTIM driver with multi-channel PWM support

Adds a new Low-Power Timer (LPTIM) driver to embassy-stm32, providing PWM functionality for STM32 microcontrollers. The implementation supports both single-output PWM (for older LPTIM versions) and dual-channel PWM (for LPTIM v2a, v2b, and N6 variants), allowing users to configure output pins with specific electrical settings and control duty cycles per channel.

embassy-stm32/src/lptim · high confidence

Initial MCXA HAL driver support

This release introduces the first set of hardware abstraction layer (HAL) drivers for NXP MCXA microcontrollers. The new drivers include ADC, Code Watchdog (CDOG), CLKOUT, CRC, DAC, DMA, GPIO, and FlexSPI, along with a custom executor for deep-sleep power management. This provides the foundational peripheral support needed to build applications on the MCXA platform.

embassy-mcxa/src · high confidence

Initial STM32 DSI Host driver support

This change introduces the DSI Host driver for STM32 microcontrollers, enabling users to connect and drive DSI-based LCD panels. The implementation includes configuration structures for video and command modes, PHY initialization logic, and a trait-based panel interface that allows specific display timings and initialization sequences to be defined. It supports conditional compilation for different STM32 series (v1 and u5) to handle hardware-specific register differences.

embassy-stm32/src/dsihost · high confidence

Initial STM32 HASH driver with async support and multiple algorithms

This change introduces the new \embassy-stm32/src/hash\ module, providing a hardware-accelerated hash driver for STM32 microcontrollers. It supports both blocking and asynchronous execution modes, with async operations enabled for hash\_v2, hash\_v3, and hash\_v4 configurations via DMA and interrupt handling. The driver implements several cryptographic algorithms including SHA-1, SHA-224, SHA-256, MD5 (on v1/v2/v4), and SHA-384/512 variants (on v3). It also includes HMAC functionality and is designed to integrate with the embassy ecosystem's async runtime.

embassy-stm32/src/hash · high confidence

Initial STM32C5 example suite

Adds a complete set of reference examples for the STM32C5 microcontroller, including basic peripherals (blinky, hello), ADC (blocking and DMA), AES and SAES encryption, CAN, EDATA, Ethernet, Flash, I2C, PWM, RNG, USART (blocking, DMA, and split), and USB serial. The location also includes the necessary Cargo configuration and build script to target the STM32C5 device.

examples/stm32c5 · high confidence

Initial STM32F1 example support with ADC, CAN, I2C, SPI, USB, and Timer demos

Developers can now run a comprehensive set of examples for the STM32F103 (Blue Pill) board, including ADC (with DMA ring buffering and timer triggers), CAN (blocking and async), I2C loopback, SPI with DMA, USB CDC-ACM serial, USB Audio Class (UAC) source, and various timer features like input capture and PWM input. The examples use the new \probe-rs\ runner and \defmt\ logging, providing a complete starting point for STM32F1 development.

examples/stm32f1 · high confidence

Initial STM32F767ZI support with comprehensive hardware examples

This release adds initial support for the STM32F767ZI microcontroller, providing a complete set of examples to demonstrate its capabilities. The new examples cover essential peripherals including ADC, GPIO (blinky, button, EXTI), CAN, CRYP (AES-GCM), Ethernet (with DHCP), Flash, HASH (SHA256/HMAC), PWM (including DMA ring buffer), QSPI, SDMMC, USART (with DMA), and USB (CDC-ACM serial). A build script is also included to configure the linker for the target.

examples/stm32f7 · high confidence

Initial STM32H7 example suite and build configuration

This change introduces a complete set of reference examples for the STM32H7 series, including blinky, ADC (blocking and DMA), CAN, DAC (blocking and DMA), Ethernet (RMII and MII), flash (blocking and async), FMC/SDRAM, I2C, and more. It also adds the necessary \build.rs\ script and \memory.x\ linker script to ensure correct memory layout and build behavior for these examples.

examples/stm32h7 · high confidence

Initial USB Audio Class (UAC) host support

Users can now interact with USB Audio Class devices via the embassy-usb host stack. This change introduces a new UAC handler module that parses device descriptors to identify audio control and streaming interfaces, registers the device, and manages isochronous pipes for audio output and feedback. It provides APIs for querying audio parameters (such as sampling frequency) and initiating audio streams, currently supporting PCM format devices.

embassy-usb/src/class/uac/host · high confidence

Initial USB device and host driver implementation for RP2040

This change introduces the foundational USB drivers for the RP2040 microcontroller, enabling both USB device and USB host modes. The \device.rs\ module implements the device-side driver, handling endpoint allocation, buffer management within the RP2040's DPRAM, and interrupt-driven data transfer. The \host.rs\ module provides a comprehensive USB host stack, featuring an EPX pipe arbiter for round-robin scheduling of concurrent transfers, support for control, bulk, and interrupt endpoints, and robust error handling for conditions like NAKs, stalls, and bus resets. The \mod.rs\ file ties these together, exposing the \Instance\ trait for peripheral abstraction and re-exporting the driver components.

embassy-rp/src/usb · high confidence

Initial example applications for nRF9151-S

Added initial example applications for the nRF9151-S variant, including a standard LED blinker, a demonstration of the CryptoCell hardware random number generator (RNG) using both async and sync APIs, and a basic example for reading data from non-volatile memory (NVMC).

examples/nrf9151/s · high confidence

Initial implementation of the MSPM0 time driver

This change introduces the core time driver implementation for the MSPM0 microcontroller series. It establishes the \time\_driver\ module structure, delegating to a \tim.rs\ backend that configures hardware timers (such as TIMG0/TIMG1 for low-power support) using the LFCLK source. The driver implements the \embassy\_time\_driver::Driver\ trait, managing timer initialization, interrupt handling for period and alarm events, and maintaining a monotonic time counter to ensure correct time progression even during overflow conditions.

_embassy-mspm0/src/time\driver · high confidence

Initial nRF5340 DK example support

Added a new set of examples for the nRF5340 DK board, including blinky, UART, GPIOTE channel, internal capacitor configuration, and CryptoCell RNG usage. The examples use the new \embassy-nrf\ API, \probe-rs\ for debugging, and \defmt\ for logging.

examples/nrf5340 · high confidence

Initial release of Embassy HAL for NXP MCX-A microcontrollers

This change introduces the \embassy-mcxa\ crate, providing a Hardware Abstraction Layer for the NXP MCX-A family of microcontrollers within the Embassy async framework. The HAL exposes safe, idiomatic Rust interfaces for key peripherals including GPIO, UART, and OSTIMER. It includes a build system that generates peripheral and interrupt implementations from NXP PAC metadata, supports DMA and clock/power configuration, and provides developer documentation and recovery instructions for FRDM boards.

embassy-mcxa · high confidence

Initial release of Embassy MSPM0 HAL

This entry introduces the \embassy-mspm0\ crate, providing a hardware abstraction layer for Texas Instruments MSPM0 and MSPS003 microcontrollers. The implementation covers core peripherals including GPIO, I2C (blocking and async with FIFO flush fixes), ADC, UART, DMA, Timers, Watchdog, TRNG, and MathACL. It supports a wide range of chip families (G, L, H, C series) and implements embedded-hal 1.0 traits for interoperability. The HAL uses a build-time code generation system to create singleton types and interrupt group handlers, and migrates GPIO wakers to use maitake-sync for improved synchronization.

embassy-mspm0 · high confidence

Initial release of Embassy Microchip HAL for MEC and CEC MCUs

This entry introduces the \embassy-microchip\ crate, providing safe, idiomatic Rust APIs for Microchip MEC and CEC family microcontrollers. The HAL supports both blocking and async operations across multiple peripherals, including GPIO, I2C, PWM, TACH (fan speed measurement), and UART. It handles interrupt management and low-power waiting automatically, allowing applications to focus on business logic. The implementation targets specific chip variants (e.g., mec1721n, mec1723n) via feature flags and includes a time driver based on the Input Capture and Compare Timer (CCT).

embassy-microchip · high confidence

Initial release of PPP network driver

This change introduces the \embassy-net-ppp\ crate, providing a Point-to-Point Protocol (PPP) driver for the embassy-net stack. Users can now establish PPP connections over a serial interface by running the provided \Runner\ in a background task. The driver handles packet transmission and reception, enforces the MTU by dropping oversized packets, and exposes an IPv4 configuration callback to notify users when the link is established. It also supports graceful termination and reconnection, returning a specific error if the peer terminates the PPP session.

embassy-net-ppp/src · high confidence

Initial release of embassy-boot-rp bootloader for RP2040

Introduces the embassy-boot-rp crate, an adaptation of embassy-boot for the RP2040 microcontroller. This bootloader allows applications to configure partitions based on a linker script and load from the active partition. The release includes version 0.10.0, which updates dependencies to embassy-sync 0.8.0, embassy-rp 0.10.0, and embassy-boot 0.7.0, and adds a build script to handle ARMv6m configuration checks.

embassy-boot-rp · high confidence

Initial release of embassy-executor-timer-queue crate

This change introduces the \embassy-executor-timer-queue\ crate, which decouples the timer queue item implementation from \embassy-executor\. It provides an opaque \TimerQueueItem\ type for executor-integrated timer queues, allowing HAL implementers to define custom item types with configurable sizes via Cargo features (4, 6, or 8 words). The crate exposes a \TimerQueueItemProvider\ unitrait for resolving the global provider implementation at link time, enabling queue implementations to access timer queue items associated with wakers.

embassy-executor-timer-queue · high confidence

Initial release of embassy-net-nrf91 LTE network driver

This change introduces the embassy-net-nrf91 crate, providing an embassy-net driver for nRF91 LTE modems. It includes a network driver implementation that manages shared memory and IPC, a context control API for configuring APN, authentication (PAP/CHAP), and SIM PINs, and support for DNS resolution. The driver also handles modem state management, including ensuring the modem is enabled and managing link states based on LTE connectivity.

embassy-net-nrf91/src · high confidence

Initial release of embassy-rp HAL for RP2040 and RP235x

This entry introduces the \embassy-rp\ crate, providing safe, idiomatic Rust APIs for Raspberry Pi RP2040 and RP235x microcontrollers. The HAL implements both blocking and async drivers for peripherals including GPIO, SPI, I2C, UART, PIO, USB, and TRNG, leveraging the Embassy executor for low-power interrupt handling. Key features include unified mode handling (\Blocking\/\Async\), support for RP235x-specific capabilities like multicore FPU and AON timers, and integration with \embassy-time\ for system clocking. The release also includes license files (Apache-2.0/MIT) crediting rp-rs, a build script for linker script generation, and a changelog documenting API stability and breaking changes.

embassy-rp · high confidence

Initial release of embassy-rp hardware abstraction layer

This change introduces the complete embassy-rp HAL, providing drivers for the RP2040 and RP235x microcontrollers. It adds support for GPIO, ADC, I2C, SPI, UART, PWM, DMA, Flash, and the Real-Time Clock (RTC), along with multicore executor support and clock configuration utilities.

embassy-rp/src · high confidence

Initial release of the ADIN1110 Ethernet PHY driver

This change introduces the \embassy-net-adin1110\ crate, providing an embassy-net driver for the Analog Devices ADIN1110 (and ADIN2111) Ethernet PHY. The implementation supports both the generic SPI protocol and the OPEN Alliance TC6 protocol (via the \tc6\ feature), enabling users to integrate these PHYs into their embedded network stacks. The driver includes CRC32 and CRC8 calculation utilities, MDIO bus support for Clause 22 and Clause 45 register access, and configurable logging via \defmt\ or \log\ features.

embassy-net-adin1110/src · high confidence

Initial structure for embassy-crypto crate

The embassy-crypto crate has been initialized with a basic project structure, including a placeholder README and an empty build script. This establishes the foundation for the crypto module, which is intended to consolidate embassy-crypto-driver and split software drivers into embassy-crypto-rustcrypto, though the actual cryptographic implementations are not yet present in this diff.

embassy-crypto · medium confidence

Initial support for Ambiq Apollo3 microcontrollers

The embassy-ambiq HAL is introduced, providing driver support for the Ambiq Apollo3 family (primarily targeting the SparkFun Artemis). This release adds GPIO, I2C master, and time driver capabilities, along with examples for async and synchronous LED blinking, button input, and I2C communication.

embassy-ambiq, examples/ambiq/sparkfun-artemis · high confidence

Initial support for MCXA2xx and MCXA5xx chip families

This change introduces the HAL initialization and clock configuration for the NXP MCXA2xx and MCXA5xx microcontroller families. It adds \mcxa2xx.rs\ and \mcxa5xx.rs\ modules that handle peripheral setup, including enabling GPIO ports (up to GPIO5 for MCXA5xx), configuring DMA, and setting NVIC interrupt priorities for RTC and GPIO. The MCXA5xx variant specifically corrects the RTC interrupt name to \RTC0\ and enables the additional PORT5/GPIO5 clocks. Both chips define their respective clock limits (Mid, Normal/Over Drive) to ensure safe CPU and bus clock frequencies.

embassy-mcxa/src/chips · high confidence

Initial support for MSPM0 microcontrollers

Embassy now supports the TI MSPM0 series, providing a comprehensive HAL with both blocking and async drivers for ADC, DMA, GPIO, I2C (controller and target), UART, timers, watchdog, and TRNG. The platform includes thread and interrupt mode executors with low-power sleep support, a MathACL driver for hardware-accelerated math, and a CLKOUT driver for clock output configuration.

embassy-mspm0/src · high confidence

Initial support for NXP i.MX RT600 series (mimxrt633s, mimxrt685s)

This release introduces the \embassy-imxrt\ HAL, providing driver support for the NXP i.MX RT600 series microcontrollers. The update includes implementations for core peripherals such as GPIO, DMA, CRC, and a True Random Number Generator (RNG), alongside comprehensive clock configuration and IO pad control. It also adds an RTC-based time driver for system timing and defines the chip-specific interrupt and peripheral mappings for the mimxrt633s and mimxrt685s variants.

embassy-imxrt/src · high confidence

Initial support for STM32 OSPI and OCTOSPIM peripherals

This change introduces a new OSPI driver module for STM32 microcontrollers, enabling communication with OctoSPI flash and RAM devices. It provides configuration structures for memory type, device size, and transfer parameters, along with support for various operating modes including indirect read/write, auto-polling, and memory-mapped access. The implementation also includes specific handling for HyperBus latency configuration and respects maximum DMA transfer sizes to ensure stable data transfers.

embassy-stm32/src/ospi · high confidence

Initial support for nRF51, nRF52805, nRF52810, nRF52811, nRF52820, nRF52832, nRF52833, nRF52840, nRF5340, nRF54L series, and nRF9120 chips

The embassy-nrf HAL now includes chip definition files for a wide range of Nordic Semiconductor microcontrollers, enabling developers to target these specific devices. This change adds support for the legacy nRF51 series, the nRF52 family (including nRF52805, nRF52810, nRF52811, nRF52820, nRF52832, nRF52833, and nRF52840), the dual-core nRF5340 (application and network cores), the nRF54L series (nRF54L05, nRF54L10, nRF54L15, and nRF54LM20), and the nRF9120 cellular IoT chip. Each chip file configures the available peripherals (such as GPIO, UART, SPI, I2C, PWM, SAADC, and radio), memory sizes, and interrupt mappings specific to that silicon variant, allowing the embassy framework to correctly interface with the hardware.

embassy-nrf/src/chips · high confidence

Internal HAL crate introduced with build-time configuration support

The new embassy-hal-internal crate provides internal implementation details for Embassy HALs (such as embassy-nrf, embassy-stm32, and embassy-rp) and is not intended for direct use. It includes a build script (build.rs) and shared build logic (build\_common.rs) that automatically declares and enables Rust target configuration flags (e.g., cortex\_m, armv6m, armv7m, has\_fpu) based on the compilation target, ensuring correct conditional compilation for ARM Cortex-M variants.

embassy-hal-internal · high confidence

Introduce Ethernet v2 driver with hardware timestamping and checksum offload

The embassy-stm32 Ethernet driver has been updated to version 2, introducing support for hardware timestamping (PTP) and full checksum offload for transmit and receive frames. This change adds new descriptor handling logic to manage DMA buffers and extract timestamps from hardware, while also implementing the embassy-net Device trait for the new driver. Users benefit from more accurate time synchronization and reduced CPU overhead for network packet processing.

embassy-stm32/src/eth/v2 · high confidence

Introduce LPSPI driver with DMA and unequal-length transfer support

Adds a new LPSPI controller driver for the MCXA series, enabling SPI communication in blocking, async, and DMA modes. The driver supports unequal-length SPI transfers and utilizes a DmaRequest enum for DMA configuration, improving reliability and flexibility for users interacting with SPI peripherals.

embassy-mcxa/src/spi · high confidence

Introduce PTP hardware clock abstraction with adjustable frequency

The embassy-ptp-driver crate now provides a common \Clock\ trait and \Timestamp\ type for PTP hardware clocks, allowing hardware implementations and synchronization engines to depend on a shared interface without coupling to each other or to \embassy-net\. Users can read the current clock time, step the clock for coarse corrections, and apply absolute frequency adjustments (in parts per million) to discipline the clock while it is being synchronized, keeping this distinct from the global executor time.

embassy-ptp-driver · high confidence

Introduce PubSubChannel for broadcast messaging

The embassy-sync library now includes a PubSubChannel, a broadcast channel that allows multiple publishers to send messages to multiple subscribers. Users can create typed or dynamic subscribers and publishers, choosing between blocking publish (waiting for queue space) or immediate publish (dropping oldest messages if full). The channel exposes capacity, length, and clear operations, and subscribers can poll for messages while handling lag conditions.

embassy-sync/src/pubsub · high confidence

Introduce Touch Sensing Controller (TSC) driver with async and blocking modes

The embassy-stm32 library now includes a new TSC driver that enables capacitive touch sensing on STM32 microcontrollers. The driver supports both blocking and asynchronous operation modes and handles TSC hardware versions v1, v2, and v3 (up to 8 pin groups). It provides a type-safe API for configuring pin groups with specific roles (Channel, Sample, Shield), creating acquisition banks for efficient repeated reads, and retrieving sensor readings. The implementation includes validation to ensure hardware constraints are met, such as allowing only one channel per group per acquisition.

embassy-stm32/src/tsc · high confidence

Introduce USB host driver traits and double-buffered endpoint allocation

The embassy-usb-driver crate now exposes a new host-side API via the \host\ module, providing traits and types (such as \UsbHostAllocator\, \UsbPipe\, and \SplitInfo\) that allow HAL implementations to support USB host mode and hub-connected devices. Additionally, the device driver trait \Driver\ now includes \alloc\_endpoint\_bulk\_in\_double\_buffered\ and \alloc\_endpoint\_bulk\_out\_double\_buffered\ methods, enabling higher throughput for bulk transfers on hardware that supports double buffering.

embassy-usb-driver · high confidence

Introduce XSPI driver with comprehensive configuration and transfer capabilities

This change introduces the XSPI (eXtended Serial Peripheral Interface) driver for STM32 microcontrollers, enabling support for high-speed external memory interfaces such as PSRAM and Flash. The driver provides a \Config\ struct for setting up peripheral parameters like FIFO thresholds, clock prescalers, and chip select timing, alongside a \TransferConfig\ struct that allows fine-grained control over instruction, address, alternate byte, and data phases, including support for multi-lane modes (up to Hexadeca-SPI) and Double Data Rate (DDR) transfers. It also includes specific handling for DMA transfer sizes and chip select switching, making it suitable for complex memory operations on devices like the STM32H7RS and STM32N6.

embassy-stm32/src/xspi · high confidence

Introduce comprehensive clock configuration and deep-sleep support for MCXA

The MCXA clock subsystem has been restructured to provide explicit configuration of system clocks, power domains, and low-power states. Users can now define a \ClocksConfig\ at startup to select voltage levels (VDD Core), oscillator sources (FIRC, SIRC, SOSC, SPLL), and main clock dividers. The new \WakeGuard\ mechanism automatically prevents deep-sleep entry when peripherals are active, and the \deep\_sleep\_if\_possible\ API allows safe entry into deep sleep with automatic clock recovery upon wake. Peripheral clock gating and reset handling are now centralized in the \gate\ module, ensuring safe enable/disable sequences for all peripherals.

embassy-mcxa/src/clocks · high confidence

Introduce embassy-boot firmware update and verification subsystem

This change introduces the core embassy-boot library, providing a bootloader framework that manages firmware updates across three flash partitions: active, DFU (Device Firmware Update), and state. Users can now configure the bootloader using \BootLoaderConfig\ (including a new \from\_linkerfile\_blocking\ helper) and perform staged firmware updates with cryptographic verification via the \FirmwareUpdater\ and \verify\_update\ APIs. The implementation supports both blocking and asynchronous flash operations, integrates with \embassy-crypto\ for signature verification (SHA-256, Ed25519, etc.), and includes a \flash-erase-zero\ feature to handle devices that erase to zero instead of one. A \MemFlash\ test implementation is also added to support unit testing of the bootloader logic.

embassy-boot/src · high confidence

Introduce embassy-crypto with support for AES, ChaCha, Ed25519, X25519, and NIST curves

The embassy-crypto library now provides a unified, driver-backed API for common cryptographic operations. Users can perform authenticated encryption using AES (ECB, CBC, CTR modes) and ChaCha (ChaCha8/12/20 and ChaCha20-Poly1305), manage key exchange via X25519 and NIST P-256/P-384 curves, and handle digital signatures with Ed25519 and ECDSA over P-256/P-384. The library also includes hash functions (MD5, SHA-1, SHA-2/3 families), HMAC, HKDF, and a global cryptographically secure RNG, all abstracted behind a driver interface that allows hardware or software implementations to be plugged in.

embassy-crypto/src · high confidence

Introduce embassy-crypto-test for known-answer crypto validation

Added the \embassy-crypto-test\ crate, which provides known-answer test suites for the \embassy-crypto\ public API. This library allows applications to verify their cryptographic drivers (whether software or hardware-backed) against standard vectors from Wycheproof and generated tables. It includes test runners for digests, HMAC/CMAC, HKDF, AEAD (GCM, CCM, ChaCha-Poly1305), block ciphers (CBC, ECB, CTR, ChaCha), RSA, and elliptic curve operations (ECDH, ECDSA, EdDSA, curve arithmetic), ensuring consistent validation across different backend implementations.

embassy-crypto-test/src · high confidence

Introduce embassy-crypto-test for known-answer test suites

A new \embassy-crypto-test\ crate has been added to provide known-answer test suites for \embassy-crypto\ drivers. It drives the public \embassy-crypto\ API to verify whichever driver the binary links, sourcing vectors from a pinned Wycheproof checkout and generating additional vectors at build time using RustCrypto crates for algorithms like plain digests, AES-ECB, AES-CTR, ChaCha, and curve arithmetic. The build process clones the Wycheproof repository into the output directory and includes vectors for raw RSA and specific curves (P-192, P-224, P-521, secp256k1) to assist HAL testing.

embassy-crypto-test · high confidence

Introduce embassy-executor-macros crate with architecture-specific entry points

The \embassy-executor-macros\ crate is introduced, providing procedural macros for defining async tasks and application entry points. The \\#\[task\]\ macro allows declaring async functions with optional pool sizes and an overrideable \embassy\_executor\ path, while the \\#\[main\]\ macro family now includes architecture-specific variants (\main\_avr\, \main\_cortex\_m\, \main\_aarch32\, \main\_spin\, \main\_riscv\, \main\_std\, \main\_wasm\) to handle platform-specific initialization and executor spawning. This change also adds support for AArch32 and AVR architectures, introduces an architecture-agnostic \main\_spin\ entry point, and allows users to specify a custom executor implementation via the \executor\ argument in the main macro.

embassy-executor-macros/src · high confidence

Introduce embassy-futures with blocking, joining, and selecting primitives

The \embassy-futures\ crate is introduced, providing core asynchronous primitives for systems without a full executor. It adds \block\_on\ and \poll\_once\ to run futures to completion or poll them once using a busy loop, \join\ (up to 5 futures) to wait for multiple futures to complete, and \select\ (up to 6 futures) to wait for the first of several futures to finish. The crate also includes \yield\_now\ for cooperative multitasking and a \fmt\ module supporting \defmt\ and \log\ features.

embassy-futures/src · high confidence

Introduce embassy-hal-internal with core HAL primitives

The \embassy-hal-internal\ crate is introduced to provide foundational building blocks for HAL implementations. It includes an atomic reusable ring buffer (\atomic\_ring\_buffer.rs\) supporting concurrent read/write access, a \Peri\ type for exclusive peripheral references that improves memory and code size efficiency over mutable references, and helper utilities like \OnDrop\ and \DropBomb\ for controlling drop behavior. The crate also provides macros for defining peripheral singletons and handling interrupts, along with formatting macros that support both \log\ and \defmt\ backends.

embassy-hal-internal/src · high confidence

Introduce embassy-net-driver-channel crate with split runner architecture

A new \embassy-net-driver-channel\ crate has been added, providing a channel-based abstraction for network drivers that decouples packet I/O from state management. The library exposes a \Runner\ struct that can be split into independent \StateRunner\, \RxRunner\, and \TxRunner\ components, allowing users to manage link state, hardware addresses, and multicast filters separately from packet transmission and reception. It integrates with the \xarxa\_driver\ for hardware address capabilities and uses \embassy\_sync\ channels for zero-copy packet buffering, supporting both \defmt\ and \log\ features via a unified \fmt\ module.

embassy-net-driver-channel/src · high confidence

Introduce embassy-stm32-neochrom driver for STM32 GPU2D

This change adds the embassy-stm32-neochrom crate, providing an Embassy-based driver for the ST NeoChrom (GPU2D) hardware via the NemaGFX middleware. It introduces a \NeoChrom\ context that supports batched rendering frames with both blocking (\end\_frame\) and async (\end\_frame\_async\) submission paths, handling CPU/GPU cache coherency and interrupt-driven completion. The driver includes a hardware bridge for real STM32 peripherals, a stub HAL for CI/link testing, and an optional \embedded-graphics\ \DrawTarget\ wrapper (\NeoChromTarget\) for GPU-accelerated 2D primitives.

embassy-stm32-neochrom · high confidence

Introduce embassy-sync as a dedicated synchronization primitive library

The \embassy-sync\ crate is introduced as a new, standalone library for asynchronous synchronization primitives, extracted from the broader \embassy-util\ crate. This location provides the core implementation for \Channel\ (MPMC message passing), \PriorityChannel\ (priority-based queuing), \Pipe\ (byte streams), \Mutex\, \RwLock\, \Semaphore\, \Signal\, \Watch\, \OnceLock\, and \LazyLock\. It also includes \RpcService\ for dispatching closures to a dedicated runner task and \DynamicSender\/\DynamicReceiver\ for type-erased channel access. The library supports configurable raw mutexes (e.g., \CriticalSectionRawMutex\, \NoopRawMutex\) to suit different concurrency contexts and integrates with \defmt\ and \log\ for debugging.

embassy-sync/src · high confidence

Introduce embassy-time-driver crate with configurable tick rates

The time driver has been split into a separate \embassy-time-driver\ crate, providing a global, linker-resolved interface for timekeeping via the \Driver\ trait and \time\_driver\_impl\ macro. This change allows hardware abstraction layers to register their own timer implementations without generic threading, ensuring consistent \Instant\ comparisons across the system. The driver supports a wide range of tick rates (from 1 Hz up to 133 MHz) via specific Cargo features (e.g., \tick-hz-133\_000\_000\), enabling precise configuration for various hardware clocks like the PR2040 or QEMU machines.

embassy-time-driver/src · high confidence

Introduce embassy-usb-dfu crate with DFU bootloader and runtime modes

Added the embassy-usb-dfu crate, providing an implementation of the USB DFU 1.1 protocol built on embassy-boot. The crate exposes two operational modes controlled by features: the \dfu\ feature enables the bootloader mode for receiving and writing firmware updates (with optional ed25519 signature verification via the \verify\ feature), while the \application\ feature enables runtime mode to expose the DFU capability to the host and handle detach/reset sequences. The implementation includes a platform-agnostic \Reset\ trait, re-exports necessary constants and handlers from embassy-usb, and ships with unit tests using the dfu-core crate to validate the download flow.

embassy-usb-dfu · high confidence

Introduce task metadata and configurable scheduling policies

The executor now supports task metadata, allowing tasks to have configurable names, priorities, and deadlines. Users can set these properties via the \MetadataRef\ API before or after spawning a task. Additionally, new Cargo features (\scheduler-priority\ and \scheduler-deadline\) enable priority-based and Earliest Deadline First (EDF) scheduling policies, respectively, allowing users to control task execution order based on priority levels or time-sensitive deadlines.

embassy-executor/src · high confidence

Introduces RP2040 bootloader with defmt/log routing and watchdog-integrated flash

The embassy-boot-rp crate now provides a functional bootloader for RP2040 devices, exposing the \BootLoader\ API to inspect state, prepare firmware swaps, and load applications. It includes a \WatchdogFlash\ wrapper that automatically feeds the hardware watchdog during flash operations and can be split back into separate flash and watchdog components. Debug output is unified via a new \fmt\ module that routes \panic\, \assert\, and logging macros to either \defmt\ or \log\ depending on enabled features, ensuring consistent debug information handling.

embassy-boot-rp/src · high confidence

Introduces blocking mutex primitives with configurable raw implementations

The \embassy-sync\ crate now provides a \blocking\_mutex\ module containing a generic \Mutex\ type backed by pluggable \RawMutex\ implementations. Users can choose between \CriticalSectionMutex\ for sharing data across threads and interrupts, \NoopMutex\ for single-executor task sharing, \PanicMutex\ which panics on re-entrant locking, and \ThreadModeMutex\ for single-executor global singletons. The module also exposes the underlying \RawMutex\ trait and specific implementations like \CriticalSectionRawMutex\ and \PanicRawMutex\, allowing low-level control over synchronization behavior. Atomic operations within these primitives can optionally use the \portable-atomic\ crate via a feature flag.

_embassy-sync/src/blocking\mutex · high confidence

Introduces internal logging macros and synchronization utilities for STM32 WPAN

The embassy-stm32-wpan crate now includes an internal \fmt\ module that provides unified logging and assertion macros (trace, debug, info, warn, error, assert, etc.) supporting both the \log\ and \defmt\ backends, with debug info collapsing enabled. Additionally, a new \util\ module exposes a \Flag\ type for asynchronous high/low state waiting and helper functions for parsing Bluetooth HCI command complete events, laying the groundwork for BLE and MAC subsystem integration.

embassy-stm32-wpan/src · high confidence

Introduces ring-buffered SPI receive mode for continuous background data capture

The SPI driver now supports a ring-buffered receive mode (\RingBufferedSpiRx\) that allows continuous, non-blocking data reception via DMA. Users can convert an existing SPI instance into this mode using \into\_ring\_buffered\, enabling the hardware to store incoming bytes in a circular buffer while the application reads them at its own pace. This prevents data loss during high-throughput or unpredictable slave transmissions, as the driver handles DMA interrupts and buffer management automatically, exposing methods to start, stop, clear, and read from the buffer.

embassy-stm32/src/spi · high confidence

Introduction of USB class module with device and host implementations

The \embassy-usb\ crate now exposes a \class\ module that organizes various USB class implementations. This module provides access to device-side classes including CDC-ACM, CDC-NCM, CMSIS-DAP v2, DFU, GUD (Generic USB Display), HID, MIDI, MSC, UAC, and WebUSB. It also exposes host-side classes for CCID, GIP, Hub, and VCP (Vendor-specific serial).

embassy-usb/src/class · high confidence

LPUART driver refactored into distinct blocking, buffered, DMA, and bbqueue modes

The LPUART driver in embassy-mcxa has been restructured from a single monolithic implementation into four separate, composable modes: blocking, buffered (interrupt-driven), DMA, and bbqueue (ring-buffered). Users can now select the mode that best fits their latency and throughput requirements. The blocking mode provides simple synchronous read/write operations. The buffered mode enables asynchronous, interrupt-driven I/O with user-provided ring buffers. The DMA mode supports high-throughput, scatter-gather transfers for both TX and RX, including a dedicated ring-buffered RX variant. The new bbqueue mode offers a flexible, high-performance buffered interface with configurable reception modes (Efficiency vs. MaxFrame) to handle varying baud rates and burst patterns. All modes support RTS/CTS flow control where applicable and ensure proper pin state management on drop.

embassy-mcxa/src/lpuart · high confidence

Mass Storage Class (MSC) host driver and shared transport layer

The embassy-usb MSC class now includes a host driver (embassy-usb/src/class/msc/host.rs) that implements the Bulk-Only Transport (BBB) protocol, allowing applications to enumerate USB mass storage devices, access logical units, and execute SCSI commands such as INQUIRY, READ/WRITE (6/10/12/16), and READ CAPACITY. This host implementation shares a new Bulk-Only Transport module (bot.rs) and SCSI command definitions (scsi.rs) with the existing device-side MSC class, providing a unified, type-safe interface for both host and device roles.

embassy-usb/src/class/msc · high confidence

New AON Timer driver for RP2350 with configurable wake modes and DateTime support

This change introduces the AON (Always-On) Timer driver for the RP2350 microcontroller, enabling millisecond-resolution timing and low-power wake capabilities. Users can now configure the timer with selectable clock sources (XOSC or LPOSC) and choose from multiple alarm wake modes: WFI/WFE interrupt-based wake, DORMANT hardware power-up wake, or both. The driver also includes a DateTime abstraction for setting and reading calendar time, allowing alarms to be scheduled at specific dates and times. This driver is part of the POWMAN peripheral integration and supports async alarm waiting via interrupts.

_embassy-rp/src/aon\timer · high confidence

New BLE API and configuration layer for STM32WBA

The \embassy-stm32-wpan\ Bluetooth module now exposes a comprehensive, high-level API for the STM32WBA series, replacing the previous low-level or incomplete implementation. This change introduces structured initialization via \GapInitParams\ (supporting public and random static addresses, roles, and security settings), a dedicated \BleError\ type for robust error handling, and a new \config\_data\ module that safely wraps ST's \ACI\_HAL\_WRITE\_CONFIG\_DATA\ and \ACI\_HAL\_READ\_CONFIG\_DATA\ commands. Users can now initialize the BLE stack with specific roles (including Observer for scanning), configure PHY preferences, and manage connections through a unified \HCI\ interface that integrates with \embassy-crypto\ for secure operations.

embassy-stm32-wpan/src/bluetooth · high confidence

New BLE Security Manager for pairing and bonding

Added a new Security Manager module that implements BLE pairing, bonding, and security features. Users can now configure IO capabilities (such as DisplayYesNo or KeyboardOnly), enable MITM protection, and manage bonded devices. The implementation supports Secure Connections (SC), passkey entry, numeric comparison, and address resolution (RPA) via direct calls to the STM32 HCI stack.

embassy-stm32-wpan/src/bluetooth/security · high confidence

New CDC-ACM and VCP host class drivers for USB serial communication

The embassy-usb library now includes host-side drivers for connecting to USB serial devices. A new CDC-ACM host driver (\embassy\_usb::class::cdc\_acm::host\) allows communication with standard virtual serial ports by automatically discovering interfaces and allocating pipes. Additionally, a new Virtual COM Port (VCP) host module (\embassy\_usb::class::vcp::host\) has been added, starting with a driver for Silicon Labs CP210x USB-to-UART bridges that supports both direct and divisor-based baud rate configuration.

_embassy-usb/src/class/cdc\acm · high confidence

New CORDIC driver with configurable precision, scale, and error handling

The embassy-stm32 crate now includes a new CORDIC (Coordinate Rotation Digital Computer) driver. This driver allows users to perform mathematical functions such as trigonometric (Sin, Cos, Phase), hyperbolic (Sinh, Cosh), and logarithmic (Ln, Sqrt) operations. The API supports configuration of function type, precision (number of iterations from 4 to 60), and scale factors. It includes comprehensive error handling for configuration mismatches, argument range violations, and buffer length issues, with support for defmt formatting. The driver is structured into separate modules for enums, errors, and core logic, providing a robust interface for embedded mathematical computations on STM32 microcontrollers.

embassy-stm32/src/cordic · high confidence

New Classic-mode FlexCAN driver with Async and Blocking APIs

This change introduces a new Classic-mode FlexCAN driver for the MCXA series, providing both asynchronous (interrupt-based) and blocking (polling) execution modes. Users can now send and receive CAN frames using \async\ methods or traditional blocking calls, with support for configurable bitrates, RX filters, and bus error handling. The driver includes a software RX queue for async reception, timeout-capable blocking operations, and detailed drop-count tracking for both the software queue and hardware FIFO to help diagnose high-load scenarios.

embassy-mcxa/src/flexcan/classic · high confidence

New DFSDM driver for STM32 peripherals

Added a complete Digital Filter and Sigma-Delta Modulator (DFSDM) driver. It provides a type-safe API for configuring pins, enabling regular and injected conversions, and reading data via DMA ring buffers or interrupts. The driver includes support for analog watchdogs, extremes detection, and clock output configuration, with compile-time checks for hardware capabilities like transceiver and filter counts.

embassy-stm32/src/dfsdm · high confidence

New DMA channel driver and support for variable word sizes

The DMA subsystem in embassy-stm32 now includes a new \Channel\ driver that allows users to create and manage DMA transfers directly. This change introduces a \Word\ trait and \WordSize\ enum, enabling DMA transfers with variable bit-widths (from 1 to 64 bits) rather than being limited to standard byte/halfword/word sizes. Additionally, a \ChannelAndRequest\ helper struct is provided to simplify binding a DMA channel to a specific request line, which is particularly useful for peripherals that require specific DMA request IDs.

embassy-stm32/src/dma · high confidence

New EGU, IEEE 802.15.4, and I2S drivers added to embassy-nrf

This update introduces three new peripheral drivers to the nRF HAL. The Event Generator Unit (EGU) driver provides a high-level API for triggering tasks and handling events via PPI, supporting up to 16 triggers with interrupt capabilities. An IEEE 802.15.4 network driver is added, implementing the embassy-net interface for the nRF radio to enable low-power wireless communication. Additionally, a full-duplex I2S driver is included, supporting configurable sample widths, alignment, formats, and multi-buffering for audio applications.

embassy-nrf/src · high confidence

New FDCAN driver implementation for STM32

The CAN FD peripheral driver for STM32 microcontrollers has been implemented from scratch, replacing the previous version. This new driver provides configuration structures for nominal and data bit timings (including transceiver delay compensation), a filter system supporting standard and extended IDs with various matching modes (range, bitmask, dedicated), and a unified peripheral interface for message transmission and reception. It also includes timestamp calculation logic and error handling specific to the FDCAN hardware variant.

embassy-stm32/src/can/fd · high confidence

New FDCAN message RAM register definitions and accessors

The FDCAN HAL now includes a new \message\_ram\ module that defines the hardware register layout for standard and extended filters, receive FIFOs, transmit buffers, and transmit events. This module provides typed readers and writers for all message RAM fields (such as ID, DLC, BRS, FDF, and filter configurations) and introduces a \DataLength\ enum to correctly handle the different length coding rules for Classic CAN (up to 8 bytes) versus FDCAN frames (up to 64 bytes).

_embassy-stm32/src/can/fd/message\ram · high confidence

New GAP implementation for STM32 WBA BLE stack

This change introduces a new GAP (Generic Access Profile) module for the STM32 WBA BLE stack, replacing the previous raw HCI approach with higher-level ACI (Application Command Interface) commands. It adds dedicated modules for advertising (supporting undirected, directed, and privacy-aware modes), scanning (using the Observer role and ACI\_GAP\_START\_OBSERVATION\_PROC), and connection management (including PHY selection, connection parameters, and disconnect reasons). The implementation handles advertising data construction, including local name, service UUIDs, and manufacturer-specific data, while ensuring compatibility with the ST host stack's requirements for advertising control.

embassy-stm32-wpan/src/bluetooth/gap · high confidence

New GUD (Generic USB Display) class implementation

Added a new USB device class driver for the Linux GUD (Generic USB Display) protocol, enabling microcontrollers to present themselves as USB displays to a host. The implementation supports streaming pixel data via bulk transfers to handle framebuffers larger than available RAM, and exposes standard GUD control requests for display configuration, connector status, and TV mode properties. The device is configured with a default Vendor ID of 0x1d50 and Product ID of 0x614d to ensure binding with the Linux GUD driver.

embassy-usb/src/class/gud · high confidence

New I2C async loopback test example for STM32F401

Added a new example in the stm32f401 folder that demonstrates asynchronous I2C communication using DMA. The i2c\_loopback\_test\_async.rs file configures I2C1 as a slave and I2C2 as a master on the same device to perform comprehensive loopback testing, covering write, read, and combined write-read transactions. This includes the necessary build configuration (.cargo/config.toml and build.rs) to target the STM32F401RE chip with defmt logging.

examples/stm32f401 · high confidence

New MCXA266 board examples for ADC, DMA, and peripherals

The examples/mcxa266 directory now includes a comprehensive set of new demonstration applications for the MCXA266 (MCXA276) board. These cover asynchronous and blocking ADC usage (including temperature sensing), GPIO toggling and interrupt handling, timer capture, code watchdog (CDOG), clock output (CLKOUT) and CPU clock configuration, CRC calculations, DAC output, and extensive DMA memory-to-memory and scatter-gather operations. Additional examples demonstrate Flash In-Application Programming (IAP) via the ROM API, FlexCAN Classic in both async and blocking modes, frequency measurement (FREQME), and cryptographic hashing (SGI).

examples/mcxa266, examples/mcxa577 · high confidence

New MCXA287 board examples for GPIO, ADC, CRC, DMA, and FlexSPI

The examples/mcxa287 directory now includes a comprehensive set of demonstration programs for the MCXA287 board. These cover basic GPIO toggling and button input (including async interrupt handling), ADC-based temperature sensing, hardware CRC verification against software baselines, and DMA operations such as memory-to-memory copies, buffer memset, and scatter-gather chaining. Additionally, extensive FlexSPI examples demonstrate NOR flash usage via blocking, interrupt-driven async, DMA-accelerated, and memory-mapped access modes, along with robust soak and cancellation-recovery tests to validate reliability under stress.

examples/mcxa287 · high confidence

New PIO instruction helpers and expanded FIFO/status configuration

The PIO driver now exposes direct instruction-level control via new methods on \StateMachine\ (such as \set\_x\, \get\_x\, \set\_y\, \get\_y\, \set\_pindir\, \set\_pin\, \set\_out\_pin\, \set\_out\_pindir\, and \exec\_jmp\), allowing users to execute specific PIO instructions programmatically. Additionally, the driver supports new FIFO join modes (\RxAsStatus\, \RxAsControl\, \PioScratch\) and a new \StatusSource\ option (\Irq\) for RP235x chips, enabling more flexible status checking and FIFO usage patterns.

embassy-rp/src/pio · high confidence

New PIO-backed peripheral drivers and clock divider utility

This change introduces a collection of new PIO programs and drivers for \embassy-rp\, including a clock generator, HD44780 LCD driver, I2S input/output, NEC IR receiver, OneWire, PWM, rotary encoder, SPI, and step/dir stepper motor control. It also adds a \clock\_divider\ utility module with a \calculate\_pio\_clock\_divider\ function to correctly scale PIO clock dividers based on the system clock frequency, which is used by the new drivers to ensure accurate timing.

_embassy-rp/src/pio\programs · high confidence

New SAES driver with hardware key support and async APIs

Added a new SAES (Secure Advanced Encryption Standard) driver for STM32 microcontrollers, providing hardware-accelerated AES operations with enhanced security features. Users can now utilize hardware-derived keys (DHUK, BHK) that are never exposed to software, support for key wrapping and sharing between peripherals, and both blocking and async APIs. The driver supports multiple cipher modes (ECB, CBC, CTR, GCM, GMAC, CCM) depending on the hardware revision (saes\_v1a, saes\_v1b, saes\_n6) and requires an RNG peripheral for countermeasures on certain chips.

embassy-stm32/src/saes · high confidence

New STM32 bootloader examples for single and dual-bank flash configurations

Added new bootloader example applications for STM32 microcontrollers, located in \examples/boot/bootloader/stm32\ (single-bank) and \examples/boot/bootloader/stm32-dual-bank\ (dual-bank). These examples demonstrate how to initialize the STM32 flash peripheral, configure the \embassy\_boot\_stm32\ bootloader using linker-file-based layouts, and load the active application from the correct flash region. The dual-bank example specifically shows how to manage separate flash regions for bank 1 and bank 2, enabling support for devices with dual-bank flash memory.

examples/boot/bootloader/stm32 · high confidence

New STM32F0 example suite for Nucleo-F091RC and Nucleo-F072RB

This location now provides a comprehensive set of examples for the STM32F0 series, targeting the Nucleo-F091RC and Nucleo-F072RB boards. The suite includes basic 'Hello World' and LED blinkers, as well as advanced demonstrations of the ADC with analog watchdog, I2C master and slave (both blocking and async with DMA), and multi-priority interrupt handling. Configuration is standardized via a new \.cargo/config.toml\ using \probe-rs\ for flashing and a \build.rs\ script for linker arguments.

examples/stm32f0 · high confidence

New STM32F3 example suite with USB and TSC support

This change introduces a complete set of examples for the STM32F3 family, including blinky, hello, button, button\_events, button\_exti, flash, multiprio, spi\_dma, usart\_dma, and usb\_serial. Notably, it adds support for the USB CDC-ACM class via the new embassy-usb integration and demonstrates the Touch Sensing Controller (TSC) with both single-pin and multi-pin acquisition examples. The examples use the new \embassy\_futures\ join mechanism and \probe-rs\ for debugging, replacing the previous \probe-run\ tooling.

examples/stm32f3 · high confidence

New STM32G0 example suite covering ADC, Flash, USB, and more

This change introduces a comprehensive set of new examples for the STM32G0 microcontroller family, providing reference implementations for a wide range of peripherals. The suite includes ADC examples demonstrating blocking reads, DMA-based sequence reads, oversampling for higher resolution, and ring-buffered timer-triggered sampling. It also adds examples for asynchronous and blocking Flash operations, PWM (including complementary outputs and input capture), I2C communication, RTC timekeeping, and GPIO interactions like button polling and EXTI interrupts. Furthermore, the examples cover USART in blocking, buffered, and DMA modes, as well as a 1-Wire DS18B20 temperature sensor driver. USB functionality is represented by both a device-mode CDC-ACM serial echo example and a host-mode HID keyboard reader, alongside SPI-based NeoPixel control.

examples/stm32g0 · high confidence

New STM32G474 example applications for comparator, flash, FMAC, HRTIM, and PWM input

The examples/stm32g474 directory now includes a complete set of demonstration applications for the STM32G474 microcontroller. Users can now run examples for the comparator peripheral (comp.rs), asynchronous flash memory operations (flash\_async.rs), FMAC with ADC integration (fmac\_w\_adc.rs), High-Resolution Timer PWM generation (hrtim.rs), HRTIM master/slave bridge control (hrtim\_master.rs), and asynchronous PWM input capture (pwm\_input\_async.rs). These examples are configured for the STM32G474RETx chip via probe-rs and demonstrate both blocking and async embassy patterns for these specific hardware features.

examples/stm32g474 · high confidence

New STM32H723 examples for SPDIFRX, SPI ring buffering, and synchronous USART

The STM32H723 example directory now includes four new demonstration applications alongside the standard build infrastructure. The new \spdifrx\ example bridges SPDIFRX input to SAI4 output, handling DMA buffers and clock synchronization. The \spi\_ring\_buffered\ example demonstrates a tx-only SPI master and an rx-only SPI slave using ring-buffered reception with deselect detection. Two new \usart\_synchronous\ examples showcase synchronous USART communication in master/slave mode, with one variant specifically illustrating the use of ring-buffered reception. These examples are supported by a new \.cargo/config.toml\, \build.rs\, and \memory.x\ file tailored for the STM32H723ZGTx device.

examples/stm32h723 · high confidence

New STM32H735 examples for LTDC, HyperRAM, and OCTOSPI NOR flash

The examples/stm32h735 location now provides standalone, buildable examples for the STM32H735G-DK board, including an LTDC display driver using internal AXI SRAM, a HyperRAM memory-mapped example, an OCTOSPI memory-mapped NOR flash example, and an OCTOSPIM unusual pinout demo. These examples demonstrate how to configure and use the LTDC peripheral for RGB565 and L8 pixel formats, how to interface with external HyperRAM via OCTOSPI2 in memory-mapped mode, and how to use OCTOSPI1 for octal-DTR NOR flash operations. The LTDC example also shows how to drive panel enable and backlight control pins separately from the LTDC signal interface.

examples/stm32h735 · high confidence

New STM32H755CM7 examples and DFSDM driver demonstrations

This update adds a complete set of new example applications for the STM32H755CM7 microcontroller, including a blinky demo and a comprehensive suite for the DFSDM (Digital Filter for Sigma-Delta Modulators) peripheral. The DFSDM examples cover polling, interrupt-driven, and DMA-based data transfers (including MDMA mem2mem and ring buffers), as well as specific hardware features like short-circuit detection, clock-absence detection, and parallel ADC input. These examples demonstrate how to configure the DFSDM for various use cases, such as reading PDM microphone data, processing audio signals with beat detection, and interfacing with internal ADCs.

examples/stm32h755cm7 · high confidence

New STM32H7RS example suite with hardware-specific configurations

The examples/stm32h7rs directory now provides a comprehensive set of reference applications for the STM32H7RS series, including blinky, button EXTI, CAN, cryptographic acceleration (AES-GCM via CRYP), Ethernet networking, I2C, MCO clock output, multi-priority task execution, RNG, RTC, SPI (blocking and DMA), USART (blocking, DMA, and split), USB serial (CDC-ACM), and high-speed XSPI memory-mapped access. These examples include necessary build configurations (Cargo config, linker scripts) and demonstrate hardware-specific features such as HSLV mode and compensation cells for XSPI, USBPHYC clock configuration, and DMA-based peripheral communication.

examples/stm32h7rs · high confidence

New STM32L0 example suite with low-power and USB support

This change introduces a complete set of examples for the STM32L0 family, including blinky, button, EXTI, ADC, flash, EEPROM, SPI, I2C (low-power slave), USART (DMA and IRQ), TSC (touch sensing in async, blocking, and multipin modes), DDS, and a new USB CDC-ACM serial example. The examples are configured to use the \embassy-stm32\ driver, the \embassy\_executor\, and \probe-rs\ for flashing, with a \build.rs\ handling linker arguments and a \.cargo/config.toml\ targeting \thumbv6m-none-eabi\.

examples/stm32l0 · high confidence

New STM32L4 example applications and RTIC integration

This change introduces a comprehensive set of new example applications for the STM32L4 family, covering peripherals such as ADC (with DMA), DAC (with DMA), SPI, I2C, CAN, RTC, RNG, MCO, and the Touch Sensing Controller (TSC) in both blocking and async modes. It also adds a dedicated \examples/stm32l4-rtic\ directory demonstrating how to integrate Embassy with the RTIC framework, including software and hardware task examples for blinking, timer interrupts, and EXTI handling. These examples provide reference implementations for common embedded tasks on STM32L4 microcontrollers.

examples/stm32l4 · high confidence

New STM32L432 QSPI memory-mapped example

Added a new example for the STM32L432 family demonstrating QSPI peripheral usage in both indirect and memory-mapped modes. The example includes a \FlashMemory\ abstraction for common flash operations (read ID, sector erase, write enable) and utilizes the \TransferConfig\ structure for transaction setup. Supporting files include a \.cargo/config.toml\ configured for the STM32L432KCUx chip via probe-rs, a \build.rs\ for linker arguments, and a \README.md\ with setup instructions for the NUCLEO-L432KC board.

examples/stm32l432 · high confidence

New STM32N6 example applications and documentation

This change introduces a comprehensive suite of standalone examples for the STM32N6570-DK and NUCLEO-N657X0-Q boards, including a NeoChrom (NemaGFX) graphics demo, a camera-to-SD capture application, an Ethernet speed test with a companion PC utility, and hardware-accelerated JPEG encode/decode routines. It also adds a memory map configuration file and a README that documents the examples' usage, specifically noting the requirement to configure the external SMPS supply for the development kit.

examples/stm32n6 · high confidence

New STM32U5 peripheral examples

Added a comprehensive set of reference examples for the STM32U5 family, covering ADC (blocking and async reads), CAN (classic, FD, and split TX/RX tasks), DAC (blocking and DMA-triggered), HSPI (memory-mapped flash mode), I2C, LTDC (LCD display with double buffering), PDM microphone capture, RNG, SPI (blocking and DMA), TSC (touch sensing), and USB (HS and FS serial with VBUS detection/override).

examples/stm32u5 · high confidence

New STM32WB USB DFU bootloader example with Windows WinUSB support

A new bootloader example for the STM32WB series has been added, enabling firmware updates via USB Device Firmware Upgrade (DFU). This implementation automatically configures MSOS descriptors to assign the WinUSB driver on Windows, eliminating the need for manual driver installation tools like Zadig. It also supports optional firmware signature verification via an ed25519 public key and includes a warning to customize the device interface GUID for production use.

examples/boot/bootloader/stm32wb-dfu · high confidence

New STM32WB coprocessor transport layer and firmware upgrade support

This change introduces the core \embassy-stm32-wpan/src/wb\ module, implementing the Transport Layer (TL) and System Host Controller Interface (SHCI) for communicating with the STM32WB coprocessor. It adds the \FirmwareUpgrader\ component to handle FUS and wireless stack upgrades via the flash download area, defines the \TlMbox\ interface for initializing IPCC channels and shared memory tables, and provides the low-level packet structures (\CmdPacket\, \EvtPacket\) and channel constants required for BLE, Thread, and MAC 802.15.4 subsystems.

embassy-stm32-wpan/src/wb · high confidence

New STM32WB example applications for BLE, 802.15.4, and system services

The examples/stm32wb directory now includes a comprehensive suite of reference applications for the STM32WB series, demonstrating both Bluetooth Low Energy (BLE) and IEEE 802.15.4 (WPAN) capabilities. BLE examples include a GATT server, an Eddystone beacon, and low-level TL\_Mbox communication. WPAN examples cover MAC-level operations for both Full Function Devices (FFD) and Reduced Function Devices (RFD), as well as a complete network stack example using UDP over IPv6. Additional examples demonstrate the Firmware Upgrade Service (FUS) and basic GPIO/EXTI functionality, all utilizing the embassy framework and the new TlMbox interface for coprocessor communication.

examples/stm32wb · high confidence

New STM32WBA example applications for ADC, AES, and BLE

The examples/stm32wba directory now includes a comprehensive set of reference applications for the STM32WBA platform. Users can now explore hardware capabilities through dedicated examples for ADC4 (including analog watchdogs and ring-buffered DMA sampling with temperature calibration), cryptographic operations via the AES and SAES peripherals (demonstrating ECB, CBC, CTR, CCM, GCM, and GMAC modes), and a Phase 1 BLE stack implementation featuring advertiser, central, and DTM runtime roles. These examples are configured for the STM32WBA55 Nucleo board and provide concrete usage patterns for the underlying embassy-stm32 drivers.

examples/stm32wba · high confidence

New STM32WBA6 examples for ADC, AES, and audio streaming

The examples/stm32wba6 directory now includes a comprehensive set of demonstration applications. New ADC examples cover analog watchdog monitoring with overscaling, standard blocking/async reads, and ring-buffered DMA sampling (both continuous and timer-triggered via TIM1 TRGO2) with factory-calibrated temperature and voltage readings. Cryptographic capabilities are demonstrated through AES examples for ECB, CBC, CTR, CCM, GCM, and GMAC modes, including multi-block streaming and NIST test vector validation. Additionally, an SD-to-SAI audio streaming example allows playing raw PCM files from an SD card, supported by Python and shell scripts to convert WAV files to the required 48 kHz unsigned 16-bit format. A new .cargo/config.toml and build.rs configure the project for the STM32WBA65RI chip.

examples/stm32wba6 · high confidence

New STM32WL example project with multi-peripheral demos

A new example project for the STM32WL series has been added, providing a complete build configuration (Cargo, linker script, memory map) and a suite of demonstration applications. The examples cover core embedded functionalities including GPIO (blinky, button), analog-to-digital conversion (ADC), flash memory read/erase/write operations, real-time clock (RTC) with LSE configuration, hardware random number generation (RNG), and asynchronous UART communication with DMA support. The project also includes an EXTI-based button interrupt example, showcasing the platform's interrupt handling capabilities.

examples/stm32wl · high confidence

New STM32WL55CM0P low-power examples with inter-core communication

Added new example projects for the STM32WL55CM0P (Cortex-M0+) target, including a blinky demo and an inter-core communication sample. The inter-core example demonstrates using the IPCC peripheral to exchange state between the M0+ and the main core, utilizing shared RAM for data synchronization and defmt for logging.

examples/stm32wl55cm0p-lp · high confidence

New STM32WL55CM4-LP example with inter-core communication and low-power support

Added a new example project for the STM32WL55CM4-LP board that demonstrates dual-core (Cortex-M7 and Cortex-M4) operation using Embassy. The example includes a blinky binary for basic LED control and an intercore binary that showcases reliable communication between cores via shared memory and the IPCC peripheral. It also configures the system for low-power stop2 modes, allowing users to observe minimal current consumption, and supports defmt logging via RTT or serial UART.

examples/stm32wl55cm4-lp · high confidence

New USB MIDI 1.0 class implementation for device and host roles

The embassy-usb library now includes a complete USB MIDI 1.0 class implementation, restructured from a single file into a dedicated module with separate device and host support. Users can now create USB MIDI devices using \MidiClass\, configuring input/output jacks, interface names, and packet sizes via \MidiClassConfig\. The implementation provides low-level packet handling through \MidiPacket\ for encoding and decoding MIDI events, including support for System Exclusive (SysEx) messages, with strict and relaxed encoding options (\try\_encode\_exact\ and \try\_encode\). A \MidiPacketWriter\ facilitates building bulk transfer buffers, enabling direct, low-overhead USB MIDI communication without intermediate buffering.

embassy-usb/src/class/midi · high confidence

New USB MIDI 1.0 host class driver

The embassy-usb library now includes a host-side driver for USB MIDI 1.0 devices. This change introduces a high-level \MidiHost\ API that automatically discovers MIDI ports and virtual cables from device descriptors, allowing users to send and receive MIDI messages via logical input and output ports. It also provides a \raw\ module for low-level access to MIDI streaming interfaces and bulk endpoint pipes, supporting advanced topologies and direct pipe management.

embassy-usb/src/class/midi/host · high confidence

New USB device and host class drivers added

This release adds several new USB class implementations to the embassy-usb library. On the device side, it introduces CDC-NCM for Ethernet-over-USB with embassy-net integration, CMSIS-DAP v2 for debug probes, WebUSB for browser-based device control, and a complete USB DFU implementation split into runtime (app\_mode) and bootloader (dfu\_mode) modes. On the host side, it adds support for CCID smart-card readers and the Gaming Input Protocol (GIP) for Xbox controllers.

(repo-wide) · high confidence

New USB driver support for nRF54LM20A

The embassy-nrf USB driver now includes support for the nRF54LM20A microcontroller. This adds a new high-speed USB (USBHS) implementation in \usbhs.rs\ that leverages the Synopsys OTG core, featuring a larger RX FIFO to handle high-speed wire maximums. The change also introduces a new \VbusDetect\ trait and specific implementations to handle VBUS power detection via the VREGUSB peripheral, which is distinct from the method used on other nRF series like nRF53.

embassy-nrf/src/usb · high confidence

New USB host stack infrastructure in embassy-usb

The \embassy-usb\ crate now includes a complete USB host stack implementation within the \src/host\ module. This adds support for device enumeration, descriptor parsing, and control request handling, allowing applications to interact with connected USB devices. The new code introduces modules for control pipe operations (\control.rs\), descriptor parsing (\descriptor.rs\), and enumeration helpers (\handler.rs\), along with the main host state management (\mod.rs\). This represents a significant expansion of the library's capabilities from device-only to host-mode support.

embassy-usb/src/host · high confidence

New USB hub host driver implementation

Added a new host driver for USB hubs in embassy-usb, enabling the enumeration and management of connected hub devices. The implementation handles deferred bus resets, port state and speed detection, and port debouncing in accordance with the USB 2.0 specification. It supports interrupt IN pipes for monitoring port status changes, manages device address allocation and deallocation for connected devices, and provides events for device detection and removal.

embassy-usb/src/class/hub · high confidence

New async adapters for embedded-hal v1.0 traits

The embassy-embedded-hal library now provides two new adapter wrappers, \BlockingAsync\ and \YieldingAsync\, to bridge blocking embedded-hal v1.0 implementations with async drivers. \BlockingAsync\ wraps a blocking peripheral driver to expose it via async traits, allowing users to use blocking drivers in async contexts. \YieldingAsync\ wraps an existing async driver to insert explicit yields between operations, which helps prevent blocking the executor during long-running I/O or flash erase operations. Both adapters support I2C, SPI, and NOR flash interfaces, and implement the \SetConfig\ trait to propagate configuration changes to the underlying hardware.

embassy-embedded-hal/src/adapter · high confidence

New async block device abstraction and caching adapter for USB Mass Storage

The USB Mass Storage class now uses an \AsyncBlockDevice\ trait instead of the previous synchronous \BlockDevice\ trait, allowing storage operations to run without blocking the executor. To support existing synchronous storage drivers, a \BlockDeviceAdapter\ is provided to wrap them. Additionally, a \SectorCache\ wrapper is introduced to aggregate writes and reduce read-erase-write cycles on flash storage, improving performance and endurance for devices with large physical block sizes.

embassy-usb/src/class/msc/device · high confidence

New asynchronous and blocking firmware updater APIs

The \embassy-boot\ firmware updater now exposes dedicated \FirmwareUpdater\ (async) and \BlockingFirmwareUpdater\ (blocking) structs, allowing applications to interact with the bootloader without risking internal state corruption. These APIs provide methods to verify firmware signatures (supporting both \ed25519-dalek\ and \ed25519-salty\ features), hash updates, and manage boot states (marking updates, triggering swaps, or confirming successful boots). Configuration can be derived directly from linker-defined flash partition symbols via \from\_linkerfile\ or \from\_linkerfile\_blocking\, simplifying setup for devices using single or multiple flash regions.

_embassy-boot/src/firmware\updater · high confidence

New blocking I3C controller driver for STM32N6, H5, and U3

Added a new blocking-mode I3C controller driver for STM32N6, STM32H5, and STM32U3 microcontrollers. This driver exposes configuration options for bus timing and controller behavior, and provides methods for direct CCC read/write, private transfers, broadcast CCC commands, and dynamic address assignment (ENTDAA).

embassy-stm32/src/i3c · high confidence

New buffered UART driver with split RX/TX handles

The RP UART driver now includes a new \BufferedUart\ implementation that uses internal ring buffers for asynchronous RX and TX operations. This allows users to perform non-blocking serial communication with automatic interrupt-driven buffering. The driver supports splitting the UART into separate \BufferedUartRx\ and \BufferedUartTx\ handles, enabling independent use of receive and transmit channels. It also provides methods for reading/writing with backpressure, checking read readiness, and handling line breaks.

embassy-rp/src/uart · high confidence

New dedicated SMA peripheral for Ethernet Station Management

Users can now access a standalone Station Management Agent (SMA/MDIO/SMI) peripheral via embassy-stm32/src/eth/sma, providing explicit smi\_read and smi\_write capabilities for interacting with Ethernet PHYs. The implementation is split into version-specific drivers (v1.rs for eth\_v1a/b/c and v2.rs for eth\_v2/a/b) that handle register access (MACMIIAR/MACMIIDR vs MACMDIOAR/MACMDIODR) and MDC clock configuration based on HCLK frequency, abstracting away the previous tight coupling where the Ethernet MAC driver managed Station Management internally.

embassy-stm32/src/eth/sma · high confidence

New embassy-net-tuntap crate for TUN/TAP networking

A new \embassy-net-tuntap\ crate has been added, providing an async TUN/TAP network driver for Unix-like systems. It implements the \xarxa\ network driver interface, allowing users to create virtual network interfaces (TAP/TUN) and exchange packets asynchronously. The \TunTapDevice\ struct manages the file descriptor and includes a configurable hardware (MAC) address, defaulting to a fixed value that can be overridden via \set\_hardware\_address\.

embassy-net-tuntap/src · high confidence

New firmware updater examples for STM32L1 and STM32L4

Added new bootloader application examples for the STM32L1 and STM32L4 series. These examples demonstrate how to use the \embassy\_boot\_stm32\ \FirmwareUpdater\ to write and mark firmware updates via a button press, alongside a simple application binary that blinks an LED.

examples/boot/application/stm32l1, examples/boot/application/stm32l4 · high confidence

New flash utilities: ConcatFlash and MemFlash

This change introduces two new components in the embassy-embedded-hal flash module. First, it adds a \ConcatFlash\ type that allows users to combine two consecutive flash devices into a single logical flash region, supporting both synchronous and asynchronous read, write, and erase operations across the combined capacity. Second, it adds a \MemFlash\ type, a memory-backed flash implementation primarily intended for testing, which simulates flash behavior in RAM. These utilities are exported via the flash module's public API.

embassy-embedded-hal/src/flash · high confidence

New generic and integrated timer queue implementations

The \embassy-time-queue-utils\ crate now provides two distinct timer queue backends: a generic queue backed by \heapless::Vec\ with configurable capacity (8, 16, 32, 64, or 128 via features) and an integrated queue that stores timer items directly within task structures. Users can select the backend via feature flags, with the generic queue becoming the default when \\_generic-queue\ is enabled, allowing for more flexible memory management and capacity control compared to the previous integrated-only approach.

embassy-time-queue-utils/src · high confidence

New high-resolution power conversion drivers for HRTIM

The HRTIM module now includes dedicated drivers for power electronics: \BridgeConverter\ for fixed-frequency synchronous buck/boost topologies, \FullBridgeConverter\ for fixed-frequency full-bridge applications, and \ResonantConverter\ for variable-frequency half/full-bridge resonant converters. These drivers manage timer configuration, dead-time insertion, and duty-cycle control, while the module also exposes \AdvancedPwm\ for splitting the timer into individual channels and provides an optional adapter for the \stm32-hrtim\ crate.

embassy-stm32/src/hrtim · high confidence

New interrupt-driven buffered and DMA-backed ring-buffered UART drivers

The USART driver now provides two new asynchronous reception modes: \BufferedUart\ and \RingBufferedUartRx\. \BufferedUart\ uses an interrupt-driven ring buffer to allow continuous background reception and transmission, supporting half-duplex readback and eager-read configurations. \RingBufferedUartRx\ leverages DMA with a ring buffer for high-throughput, low-CPU-overhead reception, offering configurable 'eager reads' to reduce latency for intermittent senders. Both modes integrate with the existing \Uart\ API via conversion methods (e.g., \into\_ring\_buffered\) and support reconfiguration via \SetConfig\.

embassy-stm32/src/usart · high confidence

New lockless AtomicWaker and TurboWaker support for improved wake latency

The embassy-sync waitqueue module now includes a new \AtomicWaker\ type that uses a lockless atomic state machine to coordinate waker registration and waking, avoiding critical sections on the wake path to reduce jitter and improve latency for time-critical async drivers. Additionally, a \turbowakers\ feature flag enables a specialized \AtomicWaker\ implementation using turbo-waker pointers for even faster registration and waking. The module also exposes \CriticalSectionWaker\ as a fallback for targets without 32-bit atomic support and includes \MultiWakerRegistration\ for waking multiple tasks and \WakerRegistration\ with \will\_wake\ checks to avoid unnecessary clones and wakes.

embassy-sync/src/waitqueue · high confidence

New low-power STM32WBA and STM32WBA6 example projects with STOP mode support

Added new example projects for the STM32WBA-LP and STM32WBA6-LP boards that demonstrate low-power STOP mode integration with the Embassy executor. These examples include blinky, button EXTI, PWM, and BLE advertiser applications that automatically enter STOP mode during idle periods to minimize current consumption (down to \~1 µA). The projects feature a MEASURE\_POWER configuration flag to switch between a debug-friendly profile (higher sleep current, debug enabled) and a measurement profile (lowest leakage, debug disabled). The STM32WBA6-LP examples also include a USB bulk reader/writer implementation and a low-power BLE advertiser that integrates the BLE stack with the low-power executor.

examples/stm32wba6-lp · high confidence

New low-power examples for STM32WLEx family

Added a new set of low-power examples for the STM32WLEx family (targeting the LoRa-E5 Dev Board), including blinky, button\_exti, adc, and i2c. These examples demonstrate deep sleep capabilities (STOP1/STOP2 modes with microamp-level current draw), utilize DMA for I2C transfers, and configure the system clock and debug settings to optimize power consumption during sleep.

examples/stm32wle5-lp · high confidence

New low-power timer (LPTIM) driver with STM32N6 support

This change introduces a new low-level timer driver for STM32 devices, supporting LPTIM v1, v2, and the new STM32N6 variant. Users can now configure timer frequency, enable single or continuous modes, and set up external triggers with configurable sources, edge detection, and digital filtering. The driver also exposes channel management capabilities, allowing users to enable/disable channels, set compare values, and configure channel direction (PWM output or input capture). The implementation handles register differences across LPTIM versions, particularly for the STM32N6 which uses different register layouts and bit fields.

embassy-stm32/src/lptim/timer · high confidence

New nRF bootloader application examples with firmware update and revert detection

Added two new example applications (a.rs and b.rs) for the nRF bootloader. Example 'a' demonstrates a firmware updater that writes new firmware, handles watchdog configuration to prevent boot loops, and detects revert states via GPIO LEDs, supporting both nRF54 and other nRF series devices. Example 'b' is a simple LED blinker used as the target firmware to be updated by 'a'.

examples/boot/application/nrf · high confidence

New nRF52840 example project with comprehensive peripheral demos

A new example project for the nRF52840 board has been added, providing a complete set of demonstrations for the Embassy framework. The project includes configuration for the \probe-rs\ debugger, linker scripts, and memory layout. It features examples covering GPIO (blinky), asynchronous buffered UART, inter-task communication (channels, mutexes), and multi-priority executors. Hardware-accelerated capabilities are demonstrated via the CryptoCell (SHA-256, AES-CCM, ChaCha20, ECDSA, ECDH) and PKA drivers. Connectivity examples include IEEE 802.15.4 radio, NFC Type 4A with ISO-DEP, and Ethernet via the ENC28J60 driver. Audio and sensor peripherals are covered with I2S (waveform generation, monitoring, effects) and PDM microphone input. Additional examples showcase GPIOTE channels and ports, EGU with PPI, and manual executor creation.

examples/nrf52840 · high confidence

New nRF54L15 application core examples and coprocessor support

This change introduces a new \examples/nrf54l15-app\ crate providing a comprehensive set of examples for the nRF54L15 application core, including GPIO, UART, SPI, I2C, PWM, ADC, temperature, watchdog, and crypto (CRACEN) demos. It also adds support for the nRF54L15's FLPR coprocessor (VPR) with examples for loading and running firmware on the secondary core, as well as hardware-accelerated sQSPI communication via the coprocessor. Users can now build and run these examples using the provided Cargo configuration and linker scripts.

examples/nrf54l15-app · high confidence

New nRF54LM20 example applications

Added a suite of new example applications for the nRF54LM20 microcontroller, including blinky, GPIO, GPIOTE, timer, RNG, and GRTC demos. The update also introduces USB support with examples for HID keyboard and mouse devices, as well as USB serial communication (including a multitask variant and a Windows-compatible WinUSB variant).

examples/nrf54lm20 · high confidence

New peripheral drivers and low-level utilities for STM32

This release adds several new peripheral drivers and low-level utilities to the embassy-stm32 HAL. Users can now use the Audio Digital Filter (ADF) driver for PDM microphone capture, the AXI Cache (CACHEAXI) driver for performance monitoring, and the Backup SRAM driver for persistent storage across resets. The Analog Comparator (COMP) driver has been expanded to support multiple IP versions (comp\_u5, comp\_v1, comp\_v2, comp\_u0) with configurable power modes, hysteresis, and blanking sources. Additionally, the HAL now includes a Multicore utility (CPU) for identifying core IDs on dual-core chips, atomic register modification helpers for safe bit manipulation, and a consolidated cryptographic driver interface supporting AES, SAES, and CRYP peripherals with various cipher modes.

embassy-stm32/src · high confidence

New timer driver modules for complementary PWM, input capture, and quadrature decoding

The timer subsystem now includes dedicated drivers for complementary PWM (supporting independent idle states and break inputs), input capture (with configurable filters and prescalers), quadrature encoder decoding (with index event support), Hall sensor interfaces, one-pulse mode, PWM input measurement, and DMA ring-buffered PWM channels. These modules provide a unified, low-level timer abstraction that exposes advanced STM32 timer features such as center-aligned counting modes, output compare modes, and break/disarm controls.

embassy-stm32/src/timer · high confidence

STM32 Ethernet v1 driver adds PTP support and new construction APIs

The Ethernet driver in embassy-stm32/src/eth/v1 now supports IEEE 1588 PTP (Precision Time Protocol) for hardware timestamping. This includes a new ptp module exposing PtpClock and PtpTimeProvider for reading and adjusting MAC timestamps, and updated receive descriptors (RDes) that extract PTP timestamps from incoming packets when the 'ptp' feature is enabled. Additionally, the driver introduces new construction methods (new\_with\_phy, new\_mii\_with\_phy) allowing users to supply custom PHY instances, and consolidates the driver implementation across v1a, v1b, and v1c hardware variants.

embassy-stm32/src/eth/v1 · high confidence

STM32 bootloader implementation with unified logging and panic handling

The embassy-boot-stm32 crate now provides a concrete bootloader implementation for STM32 devices, exposing a \BootLoader\ struct with \prepare\ and \load\ methods to manage firmware state and jump to the application. To ensure consistent debugging and error reporting, the crate introduces a \fmt\ module that routes all logging (via \log\ or \defmt\ features) and panic/assertion macros to the selected backend, while also adding \\#\[collapse\_debuginfo(yes)\]\ to improve debug symbol quality.

embassy-boot-stm32/src · high confidence

STM32N6 application supports DFU via UART and two-stage boot from external NOR flash

The application example for STM32N6 now implements a two-stage boot process where the app runs from memory-mapped external NOR flash via XSPI2. It includes a DFU receiver over UART (XMODEM-CRC) that writes firmware to a dedicated DFU partition, with a maximum firmware size bound enforced to prevent overflow. The memory layout defines separate regions for the bootloader, bootloader state, and DFU data. Hardware support covers both DK and Nucleo boards, with adjusted LED polarity and button behavior for each. Flash operations are implemented in RAM to avoid conflicts with memory-mapped execution.

examples/stm32n6-flashboot · high confidence

STM32WBA BLE API expansion and extended memory support

The embassy-stm32-wpan crate now exposes additional BLE capabilities for the STM32WBA series, including full AdvData payload support (manufacturer data, 128-bit UUIDs, service data, flags/TX power), directed advertising, RSSI reading, radio activity masking, passkey input, and GATT descriptor management. To support the extended BLE stack, the package introduces scatter memory files (tl\_mbox.x.in) that configure shared RAM sections for mailbox interfaces, with specific layouts for STM32WB1 and STM32WBx5 variants, and a build script that selects the appropriate linker script based on the enabled Cargo features.

embassy-stm32-wpan · high confidence

Support for both esp-hosted-fg and esp-hosted-mcu coprocessor firmware variants

The RPC layer now supports two distinct coprocessor firmware dialects: the legacy 'mcu' protocol and the newer 'fg' (firmware gateway) protocol. This change introduces a unified \RpcBackend\ trait that abstracts the differences in ioctl encoding, message parsing, and interface type mapping between the two variants. Users can now select the appropriate backend via Cargo features (\esp-hosted-fg\ or \esp-hosted-mcu\), or enable both to allow automatic detection of the connected firmware variant at runtime based on serial data signatures. The implementation includes specific handling for each dialect's message formats (e.g., \ctrlResp\ vs \RPCRsp\) and ensures that operations like Wi-Fi initialization, scanning, and connection are correctly translated to the underlying firmware's expected commands.

embassy-net-esp-hosted/src/rpc · high confidence

Unified ADC driver with DMA ring buffering, injected conversions, and internal channel support

The ADC driver has been refactored into a single, unified API that abstracts away the differences between the three STM32 ADC hardware generations (v1, v2, and v3). Users now get a consistent interface across all supported families, including new capabilities such as DMA-based ring-buffered reads for continuous sampling, support for injected conversion sequences (available on v1 and v3 hardware), and dedicated methods to enable and read internal channels like VREFINT, temperature sensors, and VBAT. The driver also introduces a \ConfiguredSequence\ type to optimize repeated DMA reads by programming the channel sequence only once, and adds analog watchdog monitoring with configurable thresholds.

embassy-stm32/src/adc · high confidence

Unified AES driver with GCM/CCM support across STM32 hardware revisions

The AES driver has been consolidated into a register-agnostic common layer that supports multiple hardware revisions (aes\_v1, aes\_v2, aes\_f7, aes\_v3a, aes\_v3b) with a consistent blocking API. Users can now use GCM, GMAC, and CCM authenticated encryption modes on compatible chips (aes\_v2, aes\_f7, aes\_v3a/b), whereas aes\_v1 remains limited to ECB, CBC, and CTR. The driver provides both blocking and interrupt-driven async APIs, with DMA support available for aes\_v3b parts. Key sizes are limited to 128-bit and 256-bit (192-bit is not supported), and intermediate payload chunks must be block-aligned (16 bytes) except for the final chunk.

embassy-stm32/src/aes · high confidence

Unified CAN API with FDCAN support and buffered I/O

The CAN driver now provides a unified API that supports both Classic (BXCAN) and CAN FD (FDCAN) controllers, allowing users to write code that works across different STM32 families. A new buffered mode is introduced, offering async \BufferedSender\ and \BufferedReceiver\ types that use internal channels for frame transmission and reception, simplifying interrupt handling and improving throughput. The driver also implements automatic reference counting for CAN instances, ensuring that hardware resources like RCC clocks and pins are automatically released when the last user is dropped, and adds support for automatic bus-off recovery.

embassy-stm32/src/can · high confidence

Unified STM32 USB driver with host mode support

The STM32 USB HAL has been restructured into a single module that consolidates device, OTG, and host capabilities. It now provides a unified initialization path for USB clock and power across diverse STM32 families (including specific handling for H7RS, N6, U5, and WBA chips) and introduces a new USB host implementation for v4 peripherals, enabling device enumeration and pipe-based communication alongside existing device/OTG functionality.

embassy-stm32/src/usb · high confidence

Unified async and blocking flash driver with region splitting

The flash driver has been refactored into a unified implementation that supports both blocking and asynchronous modes. Users can now create a flash driver in either mode and split it into independent drivers for each flash memory region (banks or groups of equally sized sectors) using \into\_blocking\_regions\ or \into\_regions\. The driver automatically handles cache maintenance (disabling and flushing caches like ART, ICACHE, and Cortex-M L1 caches) during program and erase operations to ensure data integrity across all supported STM32 families.

embassy-stm32/src/flash · high confidence

Removals

Removal of deprecated embassy utility modules

The \embassy/src/util\ module has been removed, eliminating several internal utility components including \DropBomb\, \Portal\, \Signal\, \WakerStore\, and associated macros (\depanic\, \deassert\) and traits (\Dewrap\). This cleanup removes legacy synchronization and error-handling primitives that were previously exposed through the \embassy::util\ namespace, simplifying the public API and reducing the crate's footprint.

embassy/src/util · high confidence

Removal of embassy::io::util module

The \embassy/src/io/util\ module has been completely removed, deleting all associated utility types and extension traits. This includes the \AsyncBufReadExt\ and \AsyncWriteExt\ traits, as well as specific async futures such as \Read\, \ReadBuf\, \ReadByte\, \ReadExact\, \ReadToEnd\, \ReadWhile\, \SkipWhile\, \Write\, \WriteAll\, \WriteByte\, and \CopyBuf\. Additionally, the \split\ function for separating read/write halves and the \read\_line\ helper are no longer available in this location.

embassy/src/io/util · high confidence

Removal of internal flash and util modules

The internal \flash\ trait and the \util\ module have been removed from the embassy crate. This cleanup eliminates legacy internal abstractions that are no longer part of the public API, simplifying the crate's surface area.

embassy/src · high confidence

Architecture

Refactored MSC host driver into modular source files

The USB Mass Storage Class (MSC) host driver implementation has been reorganized into separate modules: \lun.rs\ now contains the \MscLun\ struct and per-LUN SCSI command logic (including inquiry, capacity probing, and block I/O), \transport.rs\ handles the Bulk-Only Transport (BBB) command cycles and stall recovery, and \mod.rs\ exposes the public \MscDevice\ API. This change improves code maintainability and separation of concerns without altering the external API or behavior for users of the embassy-usb library.

embassy-usb/src/class/msc/host · high confidence

Behavioural changes

Add shared bus error types for I2C and SPI

The \embassy-embedded-hal\ crate now exposes \I2cDeviceError\ and \SpiDeviceError\ enums in the \shared\_bus\ module. These types wrap underlying bus errors and implement \embedded\_hal\_1\ error traits, \core::error::Error\, and \fmt::Display\, allowing users to handle and display I2C and SPI device errors consistently with the updated embedded-hal 1.0 API.

_embassy-embedded-hal/src/shared\bus · high confidence

Added I2C async loopback test for STM32F072

The I2C async loopback test example has been moved to the stm32f072 folder, including the necessary Cargo configuration and build script for the STM32F072RB target. This example demonstrates comprehensive async I2C master and slave testing on the NUCLEO-F072RB board using I2C1 as the slave and I2C2 as the master.

examples/stm32f072 · medium confidence

BXCAN driver overhaul with new filter API and reliability fixes

The BXCAN driver has been refactored to improve reliability and usability. A new filter API (filter.rs) allows precise configuration of CAN message filtering using list and mask modes for standard and extended IDs, including support for remote frames. The driver now correctly handles automatic retransmission logic and ensures bus errors are forwarded only once to prevent infinite interrupt loops. Additionally, the implementation includes sleep/wakeup handling, reference counting for senders/receivers to prevent premature shutdown, and optional FIFO scheduling for outgoing frames to prioritize transmission order.

embassy-stm32/src/can/bxcan · high confidence

Complete rewrite of STM32 DAC driver with ring-buffered DMA and multi-channel support

The DAC driver has been completely rewritten to support all STM32 families, introducing a new API that allows independent use of channel 1 and channel 2. A new \RingBufferedDacChannel\ type enables continuous waveform streaming via DMA ring buffers, supporting 8-bit and 12-bit modes with features like immediate writing, exact asynchronous writes, and pause/resume capabilities. The driver now uses a \Mode\ enum to configure channel behavior (buffered/unbuffered, external/internal) and includes specific support for hardware-generated waveforms like sawtooth on STM32G4. Internal changes include a shared state mechanism to manage channel enable/disable counts, ensuring the DAC peripheral clock is only disabled when all channels are dropped, and the removal of the \OptionalPin\ abstraction in favor of explicit pin configuration.

embassy-stm32/src/dac · high confidence

Default timer queue behavior changes with new feature flags

Enabling a \generic-queue-\*\ feature now disables integrated timers by default, though users can re-enable them by explicitly adding the \integrated-timers\ feature. Additionally, both integrated and generic queue implementations are now available independently of their respective features, and a new \schedule\_wake\_queue\_item\ method has been added to support storing timer queue items outside of embassy executor tasks.

embassy-time-queue-utils · high confidence

Embassy-time library split and driver architecture overhaul

The embassy-time crate has been restructured to separate the core time abstractions (Duration, Instant, Timer, Ticker) from the hardware-specific driver implementations. New dedicated drivers are introduced for the ARM CMSDK timer, the standard library (std), and WebAssembly (wasm), alongside a MockDriver for testing. The core library now implements embedded-hal 1.0 and 0.2 delay traits via the new Delay type, and provides panic-free variants for blocking and timeout operations (try\_block\_for, try\_with\_timeout). The std driver implementation has been fixed to prevent deadlocks between the alarm thread and schedule\_wake calls, and the timer queue logic has been refactored to be reentrancy-safe.

embassy-time/src · high confidence

Executor platform implementations now use \`unitrait\` and relaxed memory ordering

The platform-specific executor implementations (cortex\_m, aarch32, riscv, avr, std, wasm, spin) have been refactored to use the \unitrait\ crate for trait definitions and to apply relaxed memory ordering where safe (e.g., RISC-V pender signals). This change standardizes the underlying trait mechanics across all supported architectures without altering the high-level executor API or behavior for users.

embassy-executor/src/platform · medium confidence

I2C driver restructured with version-specific implementations and unified configuration

The I2C driver has been refactored to support distinct hardware versions (v1 and v2/v3) via separate implementation modules (\v1.rs\ and \v2.rs\), selected at compile time. A new \config.rs\ module introduces a unified \Config\ struct and \Address\ type that handle both 7-bit and 10-bit addressing, along with slave address masking (\AddrMask\) and optional internal pull-up configuration. This change aligns the driver with \embedded-hal-1.0\ traits and introduces frame-based operations to control start/stop conditions, improving reliability for both master and slave modes across different STM32 families.

embassy-stm32/src/i2c · high confidence

Introduce configurable USB logger with custom styling and input handling

The embassy-usb-logger now supports custom log formatting via a new \with\_custom\_style\ method and allows processing incoming USB data through a pluggable \ReceiverHandler\ trait. This enables users to tailor the appearance of log messages and handle commands sent from the host, moving beyond the previous simple pass-through logging behavior.

embassy-usb-logger · high confidence

Introduce embassy-net v2 with xarxa backend and new public API

The embassy-net crate has been rewritten as a major version update, replacing the underlying networking stack with \xarxa\ and exposing a new public API. This change introduces new modules for DNS (\dns.rs\), neighbor caching (\neighbor.rs\), routing (\route.rs\), and raw sockets (\raw.rs\), while refactoring TCP (\tcp.rs\) and UDP (\udp.rs\) implementations to use \xarxa\'s handles and error types. The public API now uses \embassy\_time\ for time conversions instead of \xarxa\'s internal types, and the stack initialization requires explicit \StackStorage\ allocation. Feature flags have been updated to gate functionality such as \dns\, \tcp\, \udp\, \raw-ip\, \raw-ethernet\, and \iface-bind\.

embassy-net/src · high confidence

Introduce runtime configuration traits for peripheral drivers

The embassy-embedded-hal library now exposes the SetConfig and GetConfig traits, allowing peripheral drivers (such as SPI and I2C) to change their communication settings at runtime. This enables shared bus implementations like SpiDeviceWithConfig and I2cDeviceWithConfig to dynamically adjust configurations for different devices on the same bus, rather than relying on static compile-time settings.

embassy-embedded-hal/src · high confidence

Introduces new embassy-usb source structure with control, descriptor, and type modules

The embassy-usb crate has been restructured into distinct modules: control.rs defines USB control request types (RequestType, Recipient, Request) and response enums (OutResponse, InResponse); descriptor.rs provides utilities for writing USB descriptors including configuration, interface association, and endpoint descriptors; types.rs introduces type-safe handles for InterfaceNumber and StringIndex; and fmt.rs consolidates logging macros supporting both defmt and log features. This refactoring centralizes control logic, improves descriptor building APIs, and adds type safety for interface and string indexing.

embassy-usb/src · high confidence

LPC55 peripheral drivers and codegen migration

The embassy-nxp crate now generates peripheral implementations from nxp-pac metadata, moving the LPC55S69 chip from lpc55-pac to nxp-pac. This update introduces blocking SPI, simple PWM, and asynchronous USART with DMA support for the LPC55 series, while also adding GPIO and time drivers for MIMXRT1011 and MIMXRT1062 chips.

embassy-nxp · high confidence

Major API overhaul and new USB host mode support

This release introduces a significant breaking change to the driver's API: the internal state structures (\State\, \HostState\, \OtgState\, etc.) are now type-erased and non-generic, requiring users to construct static storage via \StateStorage::new()\ and \HostStateStorage::new()\ before obtaining references. The previous const-generic parameters for endpoint and channel counts have been removed from the driver instances and interrupt handlers. Additionally, the driver now supports USB host mode (via the \host\ feature), allowing up to 16 host channels, and \embassy-time\ is now an optional feature for device mode to enable remote wakeup. Several bugs are fixed, including endpoint halt reset behavior, IN endpoint stalling issues, and periodic transfer parking.

embassy-usb-synopsys-otg · high confidence

New SAI driver with DMA ring-buffer support and hardware fixes

The embassy-stm32 SAI (Serial Audio Interface) driver has been rewritten to support both transmit and receive operations using DMA ring buffers, replacing the previous limited implementation. This update introduces robust FIFO flushing on initialization and disable to prevent data corruption, corrects master clock divider (MCKDIV) calculations for SAI v3/v4 and STM32WB chips, and enables external SAI synchronization for L5 and H7 families. Users can now configure frame lengths up to 256, handle ring-buffer overrun errors, and utilize mute status checks, ensuring reliable audio data transfer across a wider range of STM32 devices.

embassy-stm32/src/sai · high confidence

New USB device stack implementation in embassy-usb

The USB device stack has been reorganized into a dedicated \device/\ module, introducing a new builder-based API for configuring USB devices (including vendor/product IDs, speed, and descriptors) and a new descriptor reader for parsing USB descriptors. The update also adds support for Microsoft OS 2.0 descriptors via a new \msos\ module and includes validation for endpoint control requests to improve robustness.

embassy-usb/src/device · high confidence

PIO-driven SPI for cyw43 now selects programs based on core clock speed

The cyw43-pio driver now automatically chooses between low, high, and overclock PIO programs depending on the effective PIO clock frequency derived from the system core clock. This allows the driver to support higher SPI speeds (up to 75MHz GSPI on RP2350 and 66.5MHz on RP2040) when the core clock is sufficiently high, while falling back to slower, more stable programs for lower clock configurations or specific variants like the RM2.

cyw43-pio/src · high confidence

RCC module refactored with new family-specific config structs and backup domain module

The RCC module has been restructured to use a unified, family-specific configuration API. A new \rcc/bd.rs\ module centralizes low-speed clock (LSE/LSI) and backup domain management, introducing \LsConfig\ for RTC and peripheral clocking settings. Each supported STM32 family (C0, C5, F013, F247, G0, G4, H, etc.) now provides its own \rcc/\<family\>.rs\ file containing a dedicated \Config\ struct and \init\ function, replacing the previous monolithic or macro-driven approach. This change allows users to configure clocks with type-safe, const-friendly structs specific to their chip's capabilities (e.g., PLL dividers, HSE modes, voltage scaling), while the underlying initialization logic is now more explicit and easier to maintain.

embassy-stm32/src/rcc · high confidence

RTC driver refactored with new DateTime API and low-power wakeup support

The RTC driver has been restructured to introduce a new \DateTime\ struct for date and time handling, replacing previous internal representations and adding support for microsecond precision. This change includes a new \RtcTimeProvider\ for immutable time access and implements low-power wakeup alarm capabilities (\start\_wakeup\_alarm\, \stop\_wakeup\_alarm\) that allow the system to wake from stop modes using the RTC. The driver now supports multiple RTC hardware versions (v1, v2, v3) with specific implementations for each, including proper handling of backup registers and EXTI lines for wakeup events across various STM32 families.

embassy-stm32/src/rtc · high confidence

Raw executor implementation with deadline-aware scheduling and task tracing

The raw executor module has been rewritten to support Earliest Deadline First (EDF) scheduling when the \scheduler-deadline\ feature is enabled, allowing tasks to be prioritized by their deadline metadata. This change introduces a new \Deadline\ type for managing task deadlines and updates the run queue to sort tasks by deadline (or priority) when applicable. Additionally, the executor now provides a comprehensive tracing API (\Trace\ trait) that exposes detailed lifecycle events for both tasks and executors, including new trace points for task name, priority, and deadline changes, as well as executor idle states.

embassy-executor/src/raw · high confidence

Refactored Ethernet driver with generic PHY support and hardware offloads

The Ethernet implementation has been refactored to support a generic SMI PHY abstraction (GenericPhy) that allows automatic PHY address detection and configurable polling intervals, replacing previous hard-coded PHY drivers. The driver now integrates with the xarxa network stack and exposes hardware capabilities such as IPv4/TCP/UDP/ICMP checksum offloading and PTP packet timestamping (when enabled). Descriptor rings are consolidated into a shared ring module, and packet queues are initialized with typed writes to improve safety and performance.

embassy-stm32/src/eth · high confidence

Refactored PPI driver with DPPI support and safer channel management

The PPI driver has been restructured to support both standard PPI (nRF51/52) and Distributed PPI (DPPI, nRF53/91) hardware variants through a unified \Ppi\ struct that tracks event and task counts. DPPI channels now enforce that tasks and events are not already in use by panicking if a register is non-zero, preventing accidental double-subscription. The driver introduces a \persist()\ method for static configurations, offering a safer alternative to \mem::forget\ by preventing peripheral reuse. Additionally, \PpiGroup\ operations for adding or removing channels now use atomic subscribe-based updates to avoid race conditions during group configuration changes.

embassy-nrf/src/ppi · high confidence

Refactored STM32 WB sub-system with dedicated BLE, MAC, and Thread drivers

The embassy-stm32-wpan sub-system has been restructured into distinct modules (ble, mac, mm, sys, thread) to improve modularity and support multiple wireless stacks. The BLE module now provides a \Ble\ guard and a \ControllerAdapter\ for sending commands and ACL data to CPU2, while the MAC module implements an 802.15.4 \ControllerAdapter\ that parses MLME/MCPS confirmations and indications. A new Thread module exposes a \Runner\ for the OpenThread stack and C-compatible hooks (\Pre\_OtCmdProcessing\, \THREAD\_Get\_OTCmdPayloadBuffer\, etc.) for command transfer. The refactoring also introduces a dedicated \MemoryManager\ module for handling event packet buffers and introduces feature flags (\wb-ble\, \wb-mac\, \wb-thread\) to conditionally compile these sub-systems.

embassy-stm32-wpan/src/wb/sub · high confidence

Refactored USB Audio Class 1.0 device implementation

The USB Audio Class 1.0 device implementation has been restructured into a modular architecture within embassy-usb. The shared audio function logic (descriptors, feature unit handling, and sampling frequency control) is now centralized in a new \function\ module, while distinct device profiles are exposed as \Speaker\ (host-to-device playback with feedback) and \AudioSource\ (device-to-host capture). The API now uses owned vectors for feature unit controls and bitflags for channel control capabilities (mute/volume), and includes a fix to filter out unsupported controls before indexing channel data to prevent errors on targets without 32-bit atomic operations.

embassy-usb/src/class/uac/device · high confidence

Refactored buffered UART driver with hardware-specific implementations

The buffered UART driver has been restructured to separate version-specific logic into distinct modules (v1.rs and v2.rs) selected via feature flags. The v2 implementation, targeting nRF54L devices, replaces the previous byte-counting mechanism with a DMA amount register read to accurately determine received data sizes, addressing issues where the generic approach failed due to hardware buffering. The v1 implementation retains the original logic for other nRF variants. Both versions now use thiserror for error handling and align with updated embedded-io and PAC APIs, ensuring consistent behavior and preventing buffer overruns or deadlocks in interrupt handlers.

_embassy-nrf/src/buffered\uarte · high confidence

Refactored time driver into LPTIM and general-timer implementations with 32-bit support

The time driver implementation has been restructured into a modular directory structure, separating the logic for Low-Power Timers (LPTIM) and general-purpose timers (TIM). The new LPTIM driver (\lptim.rs\) adds support for LPTIM v2a/v2b variants found on STM32WBA, STM32U5, and STM32U3 chips, handling register differences such as DIER vs IER and indexed compare registers. It also improves low-power reliability by atomically reading the period and counter, clearing the CMPOK flag before updates, and ensuring proper EXTI routing for wake-from-stop on STM32WL. The general-timer driver (\tim.rs\) now supports 32-bit timers via a new \time\_driver\_32bit\ feature gate, using a dual-period counting mechanism to maintain accurate timekeeping across overflows. A common \LPTimeDriver\ trait and \AlarmState\ struct are shared between both implementations to standardize low-power pause/resume behavior.

_embassy-stm32/src/time\driver · high confidence

Removal of default embedded build configuration

The default build configuration for embedded targets has been removed from the project. Previously, the \.cargo/config\ file automatically set the compilation target to \thumbv7em-none-eabihf\ (Cortex-M4F/M7F with FPU) and configured the runner to use \probe-run\ with an nRF52840 chip. This change means users must now explicitly specify their target architecture and debugging runner settings, likely via \cargo build\ flags or a \config.toml\ in the workspace root, rather than relying on these hardcoded defaults.

.cargo · high confidence

Replace embassy::io with embedded\_io

The embassy I/O module has been removed and replaced with the \embedded\_io\ crate. This change updates the underlying traits and error types used for asynchronous reading and writing, meaning users must now depend on and use \embedded\_io\ for I/O operations instead of the previous embassy-specific implementation.

embassy/src/io · high confidence

Restructured HID class with dedicated host-side drivers and report parsing

The HID class implementation has been reorganized to separate device and host functionalities. The device side now provides a refactored \HidReaderWriter\ API for sending and receiving reports. A new host-side driver has been added, featuring a boot-protocol keyboard handler (\KbdHandler\) for standard keyboard input and a mouse report parser. Additionally, a heap-less HID report descriptor parser (\hid\_report\) is now available for host applications to interpret complex device capabilities and extract typed field values from raw report buffers.

embassy-usb/src/class/hid · high confidence

SDMMC driver refactored with UHS-I support and new storage abstractions

The SDMMC driver has been significantly refactored to support high-speed UHS-I modes (SDR50, SDR104) on compatible STM32 chips (e.g., STM32N6), including the addition of a DLYB tuning module for signal integrity. The driver now exposes new public types like \DataBlock\ and \CmdBlock\ for DMA-compatible memory handling and introduces a \StorageDevice\ abstraction for managing SD and eMMC cards. While the previous \embedded-sdmmc\ integration was removed, the driver now relies on the \sdio\ and \sdio\_host\ crates for protocol handling, providing a more robust and flexible interface for SD/SDIO/eMMC operations.

embassy-stm32/src/sdmmc · high confidence

STM32F4 examples migrated to embassy-executor and updated build configuration

The STM32F4 example applications have been restructured to use the new embassy-executor framework, replacing the previous executor model. This includes updating the entry points to use the \\#\[embassy\_executor::main\]\ macro and adopting the \embassy\_executor::Spawner\ API. A new \build.rs\ script has been added to configure linker arguments (\--nmagic\, \link.x\, \defmt.x\). The examples now demonstrate modern patterns such as ring-buffered ADC with DMA, async I2C slave operations, and updated network stack usage with embassy-net.

examples/stm32f4 · high confidence

STM32F7 and STM32H7 bootloader examples now use BlockingFirmwareUpdater

The bootloader application examples for STM32F7 and STM32H7 have been updated to use the \BlockingFirmwareUpdater\ from \embassy\_boot\_stm32\. These examples now demonstrate a workflow where a firmware update is triggered by a button press (EXTI), writing a binary payload to flash using a blocking flash interface, and marking the update as ready before resetting the device.

examples/boot/application/stm32f7, examples/boot/application/stm32h7 · high confidence

Split time driver into a separate embassy-time-driver crate

The time driver implementation has been extracted from the main embassy-time crate into a new, standalone embassy-time-driver crate. This separation allows hardware-specific driver implementations to depend only on the driver trait, ensuring they remain compatible with future major versions of embassy-time as long as the trait interface remains stable. The crate includes a build script and a code generation tool (gen\_tick.py) to manage tick rate features across both embassy-time and embassy-time-driver, and introduces a new Driver trait method (schedule\_wake) while removing older alarm management functions (allocate\_alarm, set\_alarm\_callback, set\_alarm).

embassy-time-driver · high confidence

Updated STM32F3 and STM32L0 firmware updater examples

The firmware updater examples for STM32F3 and STM32L0 have been updated to align with recent Embassy framework changes. The application binaries now use the new \Timer::after\_millis\ convenience methods for timing, and the bootloader application (\a.rs\) has been refactored to use the \Flash\ type with \BlockingAsync\ and \Mutex\ wrappers for thread-safe access. Additionally, the examples now correctly configure EXTI interrupts using the updated \bind\_interrupts\ macro and handle firmware updates via the \FirmwareUpdater\ API, ensuring compatibility with the split \embassy-executor\ and \embassy-time\ crates.

examples/boot/application/stm32f3 · high confidence

WPAN network stack refactored to use xarxa and a trait-based controller interface

The \embassy-stm32-wpan\ network module has been rewritten to replace the previous smoltcp-based implementation with the \xarxa\ library for IEEE 802.15.4 frame handling. This change introduces a new trait-based architecture where the radio hardware implements a \Controller\ trait, decoupling the MAC logic from specific chip drivers. The module now exposes a \Control\ API for management commands (such as joining networks and setting PIB attributes) and a \Runner\ for asynchronous data transmission, providing a more flexible and hardware-agnostic network stack for 802.15.4 devices.

embassy-stm32-wpan/src/net · high confidence

Watchdog support and panic routing in nRF bootloader

The nRF bootloader now includes a \WatchdogFlash\ wrapper that feeds the hardware watchdog during flash operations to prevent timeouts, and introduces a \fmt.rs\ module that routes panics and logging through \defmt\ or \log\ features with debug info collapsing. This ensures reliable boot processes on devices with active watchdogs and consistent debug output across different logging backends.

embassy-boot-nrf/src · high confidence

The embassy-net-wiznet driver now checks the hardware version during initialization and returns an \InvalidChipVersion\ error if the detected chip does not match the expected version, preventing operation on unsupported hardware. Additionally, the driver actively monitors the physical link state, updating the network stack with \LinkState::Up\ or \LinkState::Down\ events when the cable is plugged or unplugged.

embassy-net-wiznet/src · high confidence

embassy-executor v0.10.0 release notes and build infrastructure

This change introduces the changelog for embassy-executor v0.10.0, documenting significant updates including a new task metadata API, optional highest-priority and earliest-deadline-first (EDF) scheduling, and the migration of ARM Cortex-A/R support to the \aarch32-cpu\ crate under the \platform-aarch32\ feature. It also adds \run\_until\ for graceful shutdown, fallible \from\_waker\ getters, and static task pool allocation on stable Rust. Additionally, the entry includes the initial \build.rs\ and \build\_common.rs\ files, which handle target configuration detection and \rustc-check-cfg\ emission to ensure build correctness across supported architectures.

embassy-executor · high confidence

embassy-stm32 v0.3.0 release with major API and peripheral updates

This release introduces a comprehensive set of API changes and new features across the STM32 HAL. Key behavioral changes include renaming GPIO level methods (e.g., \get\_level\ to \level\), unifying the ADC driver into a single implementation with a new constructor API, and reordering arguments in USART constructors. New capabilities include configurable RNG initialization policies, 32-bit timer support for the time driver, and optional erase parallelism for flash operations. The release also adds support for new chip families (STM32U3, U5, N6, WBA) and peripherals (OSPI HyperBus, SDMMC UHS-I), while fixing critical issues in DMA, I2C, and clock configuration.

embassy-stm32 · high confidence

embassy-sync v0.8.0 release with lockless AtomicWaker and Pipe improvements

The embassy-sync crate has been updated to version 0.8.0, introducing several key changes for users. The AtomicWaker is now lockless, using an atomic state machine instead of critical sections for register and wake operations, which improves performance but requires callers to re-register the waker on every poll() call to adhere to the Future::poll contract. A new CriticalSectionWaker wrapper is provided for those needing the previous critical-section-based semantics. The Pipe::Writer now includes a write\_all method for convenient byte stream writing, and Pipe::try\_write\_all is also available. FairSemaphore now correctly wakes the next waiter when a queued acquire future is dropped, fixing a bug where tasks remained pending. Signal::poll\_wait, Subscriber::poll\_next\_message, and watch::Receiver::poll\_changed are now public. Additionally, channel error types implement core::error::Error, and the Sized trait bound has been removed from MutexGuard::map. The crate also updates to embedded-io-async 0.7.0 and implements futures\_sink::Sink for Channel and Sender.

embassy-sync · high confidence

Test coverage

Added HIL tests for RP2040/RP2350 hardware peripherals; Added HIL tests for nRF54, Buffered UARTE, and crypto engines; Added UI tests for embassy-executor task constraints; Added UI tests to verify Sync/Send safety constraints; Added comprehensive unit and UI tests for the executor; Added empty test binary for RISC-V; Added hardware validation tests for DMA and UART on MSPM0; Added hardware-in-the-loop tests for MCXA2xx peripherals; Added network performance client test suite; Added performance server test harness with TLS and IPv6 support; Added serial port saturation utility for testing; Added test suite for embassy-crypto-rustcrypto drivers; Expanded hardware test coverage for STM32 peripherals; Standardized test infrastructure for Cortex-M and RISC-V targets.

Dependencies

Update stm32-metapac dependency

The stm32-metapac dependency has been updated to the latest version, ensuring that the generated peripheral access code and metadata for STM32 microcontrollers are current.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 67 → 68 (+1.1)

Lenses

  • Code Health 87 → 87 (+0.1)
  • Architecture 95 → 95 (-0.3)
  • Maturity 74 → 77 (+2.9)
  • Readiness 50 → 51 (+0.9)
  • Security 85 → 85 (+0.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 100 → 100 (+0.0)

Resolved (144)

  • Banned license: atdf2svd
  • ClassTooLong: MscClass (embassy-usb/src/class/msc/device/mod.rs)
  • Duplicated block (10 lines × 2) (embassy-stm32/src/flash/c.rs)
  • Duplicated block (10 lines × 2) (embassy-stm32/src/flash/c5.rs)
  • Duplicated block (10 lines × 2) (embassy-stm32/src/flash/f4.rs)
  • Duplicated block (10 lines × 2) (embassy-stm32/src/flash/h7.rs)
  • Duplicated block (10 lines × 2) (embassy-stm32/src/flash/u3.rs)
  • Duplicated block (10–11 lines × 2) (embassy-stm32/src/spi/mod.rs)
  • Duplicated block (11 lines × 2) (embassy-mspm0/src/uart/buffered.rs)
  • Duplicated block (11 lines × 2) (embassy-stm32/src/flash/g.rs)
  • Duplicated block (11 lines × 2) (embassy-stm32/src/flash/u3.rs)
  • Duplicated block (11 lines × 3) (embassy-stm32/src/flash/f7.rs)
  • Duplicated block (11 lines × 4) (embassy-stm32/src/flash/c.rs)
  • Duplicated block (11–17 lines × 2) (embassy-stm32/src/sdmmc/mod.rs)
  • Duplicated block (12 lines × 2) (embassy-imxrt/src/time_driver.rs)
  • Duplicated block (12 lines × 2) (embassy-stm32/src/flash/f2.rs)
  • Duplicated block (12 lines × 2) (embassy-usb/src/class/msc/host.rs)
  • Duplicated block (12 lines × 3) (embassy-stm32/src/flash/h5.rs)
  • Duplicated block (13 lines × 2) (embassy-stm32/src/dma/ringbuffer/mod.rs)
  • Duplicated block (13 lines × 2) (embassy-stm32/src/flash/h7.rs)
  • …and 124 more

New (156)

  • BtRunner::handle_irq (cognitive 17) (cyw43/src/bluetooth.rs)
  • Change coupling: low_power.rs ↔ low_power.rs (embassy-stm32/src/low_power.rs)
  • Duplicated block (10 lines × 2) (embassy-stm32/src/adc/v3.rs)
  • Duplicated block (10 lines × 2) (embassy-stm32/src/adc/v3.rs)
  • Duplicated block (10 lines × 2) (embassy-stm32/src/adc/v3.rs)
  • Duplicated block (10 lines × 2) (embassy-usb/src/class/msc/device/transfer.rs)
  • Duplicated block (10 lines × 5) (embassy-nxp/src/hashcrypt/lpc55.rs)
  • Duplicated block (10 lines × 5) (embassy-nxp/src/hashcrypt/lpc55.rs)
  • Duplicated block (10–11 lines × 2) (embassy-rp/src/pio_programs/ir_nec.rs)
  • Duplicated block (10–11 lines × 2) (embassy-stm32/src/spi/mod.rs)
  • Duplicated block (11 lines × 2) (embassy-stm32/src/adc/v3.rs)
  • Duplicated block (11 lines × 2) (embassy-stm32/src/adc/v3.rs)
  • Duplicated block (11 lines × 2) (embassy-stm32/src/adc/v3.rs)
  • Duplicated block (11–12 lines × 2) (embassy-stm32/src/eth/sma/v2.rs)
  • Duplicated block (12 lines × 2) (embassy-nxp/src/hashcrypt/lpc55.rs)
  • Duplicated block (12 lines × 2) (embassy-nxp/src/hashcrypt/lpc55.rs)
  • Duplicated block (12 lines × 2) (embassy-stm32/src/adc/v3.rs)
  • Duplicated block (13 lines × 2) (embassy-nxp/src/hashcrypt/lpc55.rs)
  • Duplicated block (13 lines × 2) (embassy-nxp/src/hashcrypt/lpc55.rs)
  • Duplicated block (13 lines × 2) (embassy-stm32/src/dma/ringbuffer.rs)
  • …and 136 more

Changes since last survey

  • 300 commits — 240 feature/other, 60 fixes

By area

  • (repo) — 80 commits
  • embassy-nxp/src — 53 commits
  • embassy-stm32/src — 16 commits
  • examples/lpc55s69 — 15 commits
  • embassy-mcxa/src — 14 commits
  • embassy-stm32/CHANGELOG.md — 14 commits
  • embassy-nrf/src — 6 commits
  • examples/rp — 6 commits
  • cyw43/src — 5 commits
  • embassy-stm32-wpan/src — 5 commits
  • embassy-stm32/Cargo.toml — 5 commits
  • embassy-boot/src — 4 commits
  • embassy-net-nrf91/src — 4 commits
  • examples/boot — 4 commits
  • examples/mcxa287 — 4 commits
  • tests/stm32 — 4 commits
  • (root) — 3 commits
  • embassy-mcxa/Cargo.toml — 3 commits
  • embassy-net-esp-hosted/src — 3 commits
  • embassy-rp/src — 3 commits

Notable commits

  • fix: Fix TRNG bug caused by stale entropy
  • fix: Fix more variables
  • fix: Merge branch 'main' into fix/stm32-eth-c5-checksum-offload
  • fix: Merge branch 'main' into rp235x-i2c-fixes
  • fix: Merge pull request #7233 from sean0407/codex/fix-bxcan-classic-dlc-length
  • fix: Merge pull request #7240 from cryptographix/rp235x-i2c-fixes
  • fix: Merge pull request #7268 from cedrivard/fix/cyw43-rx-pool-size
  • fix: Merge pull request #7273 from felipebalbi/fix/lptmr-wait-cell
  • fix: Merge pull request #7280 from Abrahamh08/fix/stm32-eth-bounded-init
  • fix: Merge pull request #7282 from rockboynton/rockboynton/fix-uart-early-flush-return
  • fix: Merge pull request #7289 from Abrahamh08/fix/stm32-eth-drop-dma-stop
  • fix: Merge pull request #7292 from kumbung01/fix-grtc-channel-reservation
  • fix: Merge pull request #7299 from BIOS9/fix-wiznet-busy-tx
  • fix: Merge pull request #7306 from ThoFrank/fix/tuntap_waker_registration
  • fix: Merge pull request #7321 from embassy-rs/rp-linker-script-fix
  • fix: Merge pull request #7324 from felipebalbi/ostimer-fixes
  • fix: Merge pull request #7338 from embassy-rs/rp-fixes
  • fix: Merge pull request #7340 from Abrahamh08/fix/stm32-eth-c5-checksum-offload
  • fix: Merge pull request #7341 from Abrahamh08/fix/stm32-eth-v1-rx-valid
  • fix: Merge pull request #7361 from embassy-rs/revert-7344-stm32-adc-c5-prescaler
  • …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

embassy-rs/embassy was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 27 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit c287925f1fe61f811a9b0ceb85a7c68ba173a86b — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.34+preprod-c12eef3a1477.