embassy-rs/embassy

Embassy is an asynchronous embedded framework for Rust that provides a unified runtime and hardware abstraction layers for a wide variety of microcontrollers. It enables developers to write non-blocking, concurrent applications by managing async executors, timers, and shared peripheral buses across diverse silicon families. The system also includes specialized crates for secure firmware updates, cryptographic operations, and network connectivity over Ethernet, cellular, and wireless protocols.

86 changes.

This period established the Embassy embedded framework repository and initiated the development of hardware abstraction layers for STM32, nRF, and RP2040 microcontrollers. The work focused on building comprehensive peripheral drivers, refactoring core infrastructure like networking and synchronization primitives, and providing extensive example suites to validate the new APIs.

89 changes.

The project significantly broadened its hardware support by adding HALs and examples for new microcontroller families, including NXP LPC55/i.MX RT, STM32H7RS/N6, and nRF53/54 series. Concurrently, it established a robust firmware update ecosystem by introducing the embassy-boot framework with swap/revert capabilities and dedicated USB DFU implementations for STM32, RP2040, and nRF platforms.

121 changes.

This period focused on significantly expanding hardware support by introducing initial HALs for new microcontroller families including MSPM0, MCXA, i.MX RT6, and Ambiq Apollo3, alongside extensive driver updates for STM32, nRF, and RP235x. Concurrently, the project consolidated its cryptographic capabilities by launching the embassy-crypto crate, which unified hardware and software backends for secure operations across the ecosystem.

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

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

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

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

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

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

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

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

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

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.

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

New example projects are provided for the MSPM0G3519 and MSPM0L2228 microcontrollers, demonstrating the Embassy framework's support for these chips. Each example directory includes configuration for the \embassy-mspm0\ driver and source code for blinky, button, clock output (ClkOut), UART, and window watchdog (WWDT) applications. The MSPM0L2228 examples additionally include a True Random Number Generator (TRNG) demo. These examples serve as reference implementations for initializing peripherals and running async tasks on the respective hardware.

examples/mspm0l2228 · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

Introduces a new example project for the MSPM0L1306 microcontroller, providing ready-to-run demonstrations for ADC (thermistor reading), GPIO (blinky, button), I2C (blocking and async master, target mode), UART (blocking echo), clock output, and the window watchdog timer. The project includes the necessary build configuration, memory map, and README instructions to help users get started with these peripherals on the LP-MSPM0L1306 board.

examples/mspm0l1306, examples/stm32wl · high confidence

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

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

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

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.

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

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

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

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

A new example located in examples/qemu-virt-riscv64 demonstrates the platform-riscv64 thread executor on a QEMU virt machine. It includes a hello.rs binary, linker scripts (memory.x, no-unwind.x) to handle high-address RAM and discard unwind tables, and a cargo runner configuration for semihosting. A test script verifies the example against multiple QEMU CPU profiles (rv64, sifive-u54, sifive-e51, thead-c906, veyron-v1, max) for both riscv64imac and riscv64gc targets.

examples/qemu-virt-riscv64 · high confidence

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

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

Introduces a new example demonstrating the embassy-boot-rp bootloader on the Raspberry Pi Pico (RP2040). The example includes two application binaries: 'a' which waits 5 seconds and then writes the 'b' binary to flash before marking it as updated, and 'b' which simply blinks an LED. The setup uses a custom linker script to define memory regions for the bootloader state and DFU, and configures the build to use probe-rs for flashing.

examples/boot/application/rp · high confidence

A new bootloader example for the RP2040 microcontroller has been added to the examples/boot/bootloader/rp directory. This implementation uses the embassy-boot library to manage flash memory, featuring a WatchdogFlash component to ensure reliability during updates. The example includes specific linker scripts and memory layouts defining regions for the bootloader state, active application, and DFU, along with configuration for flashing and debugging via probe-rs.

examples/boot/bootloader/rp · high confidence

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

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

A new bootloader example for the RP235x series has been added to the examples directory. This example utilizes the embassy-boot library to manage firmware updates, defining specific memory layouts for the bootloader state, active application, and DFU (Device Firmware Update) regions via a linker script. It includes the necessary build configuration and source code to initialize the flash and watchdog, load the active firmware, and handle system resets.

examples/boot/bootloader/rp235x, examples/boot/bootloader/stm32 · high confidence

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

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

A new example application has been added to the examples/nrf52840-rtic directory, demonstrating how to use the Real-Time Interaction Toolkit (RTIC) with the embassy\_nrf HAL on the nRF52840 microcontroller. The example includes a blinky binary that initializes the device, configures a GPIO pin, and toggles an LED using RTIC tasks and embassy\_time timers. Supporting files include a Cargo configuration for probe-rs debugging, a build script to handle memory layout, and a memory.x linker script defining flash and RAM regions for the nRF52840.

examples/nrf52840-rtic · high confidence

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

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

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

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

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

A new bootloader example for STM32 devices with dual-bank flash memory (targeting STM32H747XI) has been added. It uses embassy-boot to manage flash partitions, with bootloader state and active application code anchored in bank 1, and DFU storage in bank 2. Users must configure the memory layout in the provided memory.x file to match their specific device.

examples/boot/bootloader/stm32-dual-bank · high confidence

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

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

New blinky and PLL example applications are now available for the STM32F2 microcontroller. The blinky example demonstrates basic GPIO toggling and timing using the embassy framework, while the PLL example configures the system clock for maximum performance on NUCLEO-F207ZG boards. Both examples use probe-rs for flashing and defmt for logging.

examples/stm32f2 · high confidence

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

A new example project for the STM32F401 microcontroller has been added to demonstrate low-power STOP mode operation. The example configures unused GPIO pins to Analog mode to minimize leakage current and automatically enters STOP mode during idle periods longer than 300ms, waking via external interrupt or timer timeout. It includes specific build configurations for the thumbv7em-none-eabi target and debugging instructions for probe-rs.

examples/stm32f4-lp · high confidence

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

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.

(repo-wide) · high confidence

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

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

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

New bootloader application examples have been added for the STM32L1 (STM32L151CBxxA) and STM32L4 (STM32L475VG) microcontrollers. These examples demonstrate a Device Firmware Update (DFU) workflow where application 'a' writes a secondary binary 'b' to flash and triggers a reset, while application 'b' serves as the updated firmware. The implementation uses \embassy-boot-stm32\ for the update logic, \probe-rs\ for flashing, and includes specific linker scripts (\memory.x\) to define memory regions for the bootloader, state, and DFU data.

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

A new example project for the STM32L151CBxxA microcontroller has been added, providing reference implementations for GPIO (blinky), EEPROM, Flash, SPI, USART, and USB CDC-ACM serial communication. The project includes a build configuration that uses probe-rs for flashing and defmt for logging, and demonstrates the new blocking Flash API with automatic lock/unlock handling.

examples/stm32l1 · high confidence

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

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

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

Introduces a new two-stage boot example for the STM32N6, featuring a First Stage Boot Loader (FSBL) that initializes external NOR flash and an application firmware with DFU capabilities. The example supports both the STM32N6570-DK and NUCLEO-N657X0-Q boards, allowing firmware updates via UART (XMODEM-CRC) or debug probe, and includes build scripts, memory layouts, and documentation to guide users through the flashing and signing process.

examples/stm32n6-flashboot · high confidence

This location introduces a new bootloader example for STM32WB55 devices using embassy-boot and embassy-usb-dfu. It provides a complete implementation including memory layout (memory.x), build configuration (build.rs), and source code (src/main.rs) that enables firmware updates via USB DFU. Key capabilities include optional ed25519 signature verification for update binaries (controlled by the 'verify' feature flag) and automatic Windows driver assignment via MSOS/WinUSB descriptors, eliminating the need for manual driver installation tools like Zadig. The example also includes documentation (README.md) detailing usage, flashing procedures, and key management for secure updates.

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

A new example application for STM32WB microcontrollers has been added to demonstrate USB Device Firmware Upgrade (DFU) functionality. The example configures the device to accept firmware updates via USB, utilizing WinUSB drivers on Windows through MSOS descriptors and a customizable interface GUID. It includes a linker script defining memory regions for the bootloader, state, and DFU storage, along with a build configuration for flashing via probe-rs.

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

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

A new bootloader example for STM32WBA devices has been added to the examples/boot/bootloader/stm32wba-dfu directory. This implementation uses embassy-boot and embassy-usb-dfu to manage firmware updates via USB DFU. It includes configuration for flashing via probe-rs, linker scripts defining memory layout for the bootloader, active firmware, and DFU state, and source code that initializes the USB stack with WinUSB support for Windows. The example supports optional ed25519-based signature verification for firmware updates when the 'verify' feature is enabled.

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

Added a new example demonstrating the bootloader workflow for the STM32WL series, consisting of two binaries: 'a' (the application that triggers a DFU update via a button press) and 'b' (the updated firmware image). The example includes necessary build configuration (build.rs, memory.x) to handle shared RAM and linker sections, and uses the embassy-boot-stm32 crate to write and mark the firmware update.

examples/boot/application/stm32wl · high confidence

Users can now connect and communicate with Silicon Labs CP210x USB-to-serial bridge chips via the \embassy-usb-host\ library. This new vendor-class driver (\Cp210xDevice\ and \Cp210xPort\) supports single- and multi-port configurations, allowing applications to configure line coding (baud rate, parity, stop bits), manage flow control, and read/write data over bulk pipes. It handles the specific vendor control requests defined in AN571 and automatically detects the supported baud-rate API flavor (direct or divisor-based) for compatibility across different CP210x firmware versions.

embassy-usb-host/src · high confidence

Added a new example for the SparkFun Artemis board (Ambiq Apollo3 MCU) that demonstrates Embassy runtime usage, including async blinky and button-waiting patterns. The example includes a custom memory map configured to boot from address 0x10000 to accommodate the SparkFun SVL bootloader, along with build scripts and a Python/Shell toolchain to flash binaries over UART via the SVL protocol.

examples/ambiq · high confidence

Introduces a new UAC host class handler in embassy-usb-host that enables enumeration, control, and isochronous audio streaming for USB Audio Class 2.0 devices. The implementation parses audio interface collections (control and streaming interfaces), allocates control, output, and feedback pipes, and supports PCM format audio output with sampling frequency control, while restricting support to UAC 2.0 devices.

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

The \embassy-usb\ crate now includes a new \uac1\ module implementing the USB Audio Class 1.0 specification. This adds two primary device profiles: a \Speaker\ class for host-to-device audio streaming (with configurable sample rates, resolutions, and channel layouts) and an \AudioSource\ class for device-to-host streaming (such as microphone input). The implementation includes full descriptor generation for audio control and streaming interfaces, support for mute and volume controls via feature units, and terminal type definitions for various input and output devices.

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

A new WASM example has been added to the examples/wasm directory, providing a runnable demonstration of the embassy executor and timer functionality in a web environment. The example includes an HTML page that loads the compiled WebAssembly module and displays a log of ticker events, along with a Rust library source file that sets up an async task to periodically update the DOM. Users can build and run this example using wasm-pack and a local web server to see the embassy framework in action within a browser.

examples/wasm · high confidence

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

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

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

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

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

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

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

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

Users can now use the CDC-NCM USB class as a network interface with the embassy-net stack. This change introduces an \embassy\_net\ module within the CDC-NCM class, providing a \Runner\ for background operation and a \Device\ type that implements the embassy-net driver interface. By calling \into\_embassy\_net\_device\ on a \CdcNcmClass\ instance, users obtain the necessary runner and device to integrate USB Ethernet connectivity directly into their network stack.

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

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

Users can now run a basic LED blinky example on nRF51 hardware (specifically the nRF51422\_xxAA variant) using the embassy-nrf framework. This new example includes the necessary build configuration (Cargo config, build script, and memory layout for 128K flash/16K RAM) and source code to initialize the device and toggle an LED on pin P0\_21.

examples/nrf51 · high confidence

New example projects for the nRF52810 microcontroller have been added, including a basic blinky application and a low-power SAADC example that demonstrates a workaround for hardware anomaly 241. These examples provide the necessary build configuration, memory layout, and source code to run Embassy OS-based applications on this specific chip.

examples/nrf52810 · high confidence

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

A new example project for the nRF54LM20A microcontroller has been added, providing a complete build configuration (Cargo, linker, and memory layout) and a suite of demonstration binaries. The examples cover basic GPIO and timer operations, GPIOTE input handling, and hardware random number generation. Crucially, the project includes full USB support, featuring HID keyboard and mouse examples as well as CDC-ACM serial communication examples (including a multitask variant and a Windows-specific WinUSB variant).

examples/nrf54lm20 · high confidence

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

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

The embassy-usb crate now includes a standalone, internal implementation of the USB DFU 1.1 class protocol, split into two distinct modes: \app\_mode\ for runtime devices (handling detach requests and state transitions to enter DFU) and \dfu\_mode\ for bootloader devices (handling firmware downloads, block management, and manifest phases). This new implementation provides dedicated handler traits for both modes, allowing applications to integrate DFU functionality without relying on external crates, and includes fixes for state transitions (such as \ManifestWaitReset\) and control response handling to ensure correct behavior with the USB core.

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

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

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

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

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

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

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

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

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

The embassy-usb-host library now includes a new USB MIDI 1.0 class driver located in \embassy-usb-host/src/class/midi\. This addition introduces descriptor parsing for MIDIStreaming interfaces (including headers, IN/OUT jacks, and endpoint associations) and implements bulk endpoint transport for sending and receiving four-byte USB-MIDI event packets. The module exposes both a high-level API for standard MIDI messages and a \raw\ submodule for advanced descriptor and endpoint-level access, enabling the host to communicate with USB MIDI devices.

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

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

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

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

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

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

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

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

The Synopsys DWC2 OTG driver has been extracted into its own crate (\embassy-usb-synopsys-otg\), introducing a new \host\ module that implements USB host mode capabilities (including enumeration and pipe management) alongside the existing device mode. The driver now provides a dedicated \fmt\ module with logging macros that support both \defmt\ and \log\ backends, and includes updated register definitions in \otg\_v1.rs\ to reflect the core's hardware interface.

embassy-usb-synopsys-otg/src · high confidence

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

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

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

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

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

This change introduces the initial implementation of the embassy-nxp HAL for NXP microcontrollers, specifically targeting the LPC55 and i.MX RT (MIMXRT1011/1062) families. It adds new drivers for Analog-to-Digital Conversion (ADC), Direct Memory Access (DMA), General Purpose Input/Output (GPIO), Inter-Integrated Circuit (I2C), Pin Interrupts (PINT), Pulse-Width Modulation (PWM), and the CASPER cryptographic accelerator. The implementation includes chip-specific configurations, interrupt handling, and hardware initialization routines, establishing the foundational peripheral support for these NXP devices.

embassy-nxp/src · high confidence

This change introduces the Low-Power Timer (LPTIM) driver for STM32 microcontrollers, providing PWM and timer capabilities. The driver supports both LPTIM v1 (basic) and v2/v2a/v2b/N6 variants, with v2+ devices offering multi-channel PWM (Ch1/Ch2) and configurable pin settings (output type, speed, pull), while v1 devices provide single-output PWM. It includes channel management, duty cycle control, and frequency configuration, along with compatibility shims for PAC register values on devices like STM32N6.

embassy-stm32/src/hash, embassy-stm32/src/lptim · high confidence

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

Added a new example project for the MCXA5xx series (targeting MCXA577) that provides a comprehensive set of hardware demonstrations. The project includes configuration for the Cortex-M33 target, a build script to generate memory layout (2 MB Flash, 640 KB RAM), and a runner configuration for SWD debugging. It features examples for GPIO (blinky variants using FIRC, SOSC, and SPLL clock sources, button input, and async GPIO interrupts), ADC (async, blocking, and temperature sensing), CRC (verifying CCITT, Maxim, Kermit, ISO HDLC, and POSIX algorithms), Code Watchdog (CDOG), and Timer Capture. Additionally, it introduces DMA capabilities with memory-to-memory transfers, a scatter-gather builder API, and a comprehensive stress test, alongside Flash IAP using ROM APIs, FlexCAN Classic (async and blocking), and CLKOUT generation.

examples/mcxa5xx · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

This change introduces the embassy-mspm0 hardware abstraction layer, providing safe, idiomatic access to MSPM0 and MSPS003 microcontrollers. The HAL implements embedded-hal 1.0, embedded-hal-async, embedded-io, and embedded-io-async traits. Key features include drivers for I2C (blocking and async), ADC, Window Watchdog, TRNG, DMA, Timers, and UART (with inherent async methods for read, write, flush, etc.). It supports multiple chip families (MSPM0C1105/6, MSPM0G5187, MSPM0H3216, etc.) and includes a build system that generates chip-specific code and interrupt group handlers. The release also includes examples for tested MCUs like mspm0l1306 and mspm0g3507.

embassy-microchip, embassy-mspm0 · high confidence

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

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

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

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

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

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

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

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

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

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

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

Added initial support for the nRF9151 SoC by introducing new example projects for both the secure (s) and non-secure (ns) execution environments. The secure example includes a standard memory layout and build configuration for flashing directly to the device. The non-secure example is configured to run alongside a Trusted Firmware-M (TF-M) instance, including a reference TF-M binary, a helper script to flash it, and documentation explaining the required setup sequence.

examples/nrf9151 · high confidence

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

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

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

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

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

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

The \embassy-usb-driver\ crate now exposes a new \host\ module containing the foundational traits and data types for USB host mode. This includes the \UsbHostController\ trait for bus-level operations (such as waiting for device events and performing bus resets), the \UsbHostAllocator\ trait for managing pipe allocation, and supporting types like \SplitInfo\ for handling split transactions with low/full-speed devices behind hubs. Users can now implement these traits in their HALs to enable host functionality, distinct from the existing device-mode \Driver\ trait.

embassy-usb-driver/src · high confidence

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

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

The embassy-boot module now provides a complete bootloader implementation for managing firmware updates via Device Firmware Update (DFU). It introduces a BootLoader that manages three flash partitions (active, DFU, and state) and supports swapping the active firmware with a DFU image, as well as reverting to the previous version if the update fails. The bootloader state is persisted in flash using magic values (BOOT\_MAGIC, SWAP\_MAGIC, REVERT\_MAGIC) and includes a flash-erase-zero feature to handle different flash erase behaviors. Additionally, digest adapters for SHA-512 are provided via optional features (ed25519-dalek, salty) to support firmware verification. The module also includes a memory-backed flash implementation (MemFlash) for testing purposes.

embassy-boot/src · high confidence

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

This release adds the \embassy-crypto-rustcrypto\ crate, providing a software-based implementation of the \embassy-crypto\ driver interface built on the RustCrypto ecosystem. Users can enable specific cryptographic operations via Cargo features (e.g., \embassy-crypto-sha256\, \embassy-crypto-aes128-gcm\, \embassy-crypto-ed25519\) to register these drivers globally. The crate supports a wide range of algorithms including SHA-2 family hashes, HMAC, AES in ECB/CBC/CTR/GCM/CCM modes, ChaCha8/12/20 stream ciphers and Poly1305 AEAD, Ed25519 signatures, X25519 key exchange, and P-256/P-384 elliptic curve operations (ECDSA, ECDH, and arithmetic). It also includes tests for HKDF-SHA256 and HKDF-SHA384.

embassy-crypto-rustcrypto · high confidence

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

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

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

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

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

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

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

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

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

The new embassy-usb-dfu crate provides a standalone implementation of the USB Device Firmware Upgrade (DFU) 1.1 protocol, allowing devices to enter a bootloader mode via USB for firmware updates. It introduces a \FirmwareHandler\ that writes incoming USB chunks to a specified DFU flash partition using \BlockingFirmwareUpdater\, and triggers a system reset upon successful completion. The crate supports optional ed25519 signature verification (controlled by the \\_verify\ feature) and allows customization of the USB function descriptor via a closure. It exposes a \Reset\ trait with immediate reset implementations for Cortex-M and ESP32C3, and separates bootloader (\dfu\) and application (\application\) logic via features to support dual-bank or single-bank update strategies.

embassy-usb-dfu/src · high confidence

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

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

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

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

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

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

The \embassy-usb\ crate now includes a new MIDI class implementation located in \src/class/midi\. This addition allows users to configure USB MIDI devices with customizable input/output jacks, interface names, and packet sizes via the \MidiClassConfig\ struct. The implementation supports both basic packet-level access and named jack configurations, enabling integration of USB MIDI functionality into embedded devices built with embassy-usb.

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

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

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

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

Added a new example for the STM32U575 Bristlemouth dev kit that demonstrates 10BASE-T1L networking using the ADIN2111 PHY in OPEN Alliance TC6 mode. The example derives a stable node identity (node ID, MAC, and IPv6 address) from the factory chip UID, serves an HTTP page displaying temperature data from the on-board BME280 sensor, and discovers neighboring nodes via UDP multicast beacons. It also includes basic examples for GPIO (blinky), flash, and RNG.

examples/stm32u575 · high confidence

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

This change introduces the underlying hardware drivers for the nRF54L (CRACEN) and nRF52/53/91 (CryptoCell) cryptographic accelerators. It adds the low-level implementations for DMA transfers, power management, and the Public Key Accelerator (PKA) engine, including elliptic curve arithmetic and ECDSA support. These drivers form the foundation that enables the \embassy-crypto\ integration features to offload symmetric, hash, and public-key operations to the respective hardware engines.

embassy-nrf/src/crypto · high confidence

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

Introduces a new \ReadableDmaRingBuffer\ and \WritableDmaRingBuffer\ in \embassy-stm32/src/dma/ringbuffer\ to manage DMA transfers with hardware synchronization. This change adds support for frame alignment (critical for protocols like I2S to discard partial frames after overruns), automatic overrun recovery, and timing-safe TX frame alignment via exposed write position tracking. It also refines the internal DMA index synchronization logic to prevent position jumps during hardware wrap-arounds.

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

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

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

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

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

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

The \examples/mcxa2xx\ directory now provides a comprehensive set of reference applications for the MCXA2xx series, including async and blocking ADC, GPIO, button, capture, CRC, DAC, and flash IAP demos. A new DMA subsystem is introduced with examples for memory-to-memory transfers, a builder-based scatter-gather API, and a comprehensive stress test. The suite also demonstrates advanced clock configuration via CLKOUT and CPU clocks, as well as SGI hashing and Code Watchdog (CDOG) usage.

examples/mcxa2xx · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The \embassy-stm32-wpan/src/wb\ module has been restructured to provide a complete transport layer for the STM32WB coprocessor. This includes new definitions for IPCC communication channels, command and event packet structures, and shared reference tables required for BLE, Thread, and MAC subsystems. Additionally, a \FirmwareUpgrader\ component has been added to handle Over-The-Air (OTA) updates via the Wireless Firmware Update System (FUS), and a local HCI interface (\lhci\) now exposes device information such as UID and package type.

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

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

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

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

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

The \embassy-usb/src/class\ module now includes implementations for several new USB device classes: CDC-ACM (serial over USB), CMSIS-DAP v2 (debug probes), WebUSB (browser-based device access), and HID (Human Interface Devices). These additions expand the library's capability to support diverse USB peripherals, allowing users to implement serial communication, debugging interfaces, web-integrated devices, and standard input devices directly within their firmware.

embassy-usb/src/class · high confidence

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

The \embassy-usb-host/src/class\ module now provides a comprehensive set of host-side class drivers, enabling support for a wide range of USB peripherals. This includes HID (Human Interface Devices) with boot-protocol keyboard and mouse support plus a full report descriptor parser, CDC ACM for virtual serial ports, MSC (Mass Storage Class) implementing the Bulk-Only Transport for flash drives and card readers, and a USB Hub handler for managing multi-port expansion. Additionally, new drivers are available for CCID (smart card readers), GIP (Microsoft Gaming Input Protocol for Xbox controllers), UAC (USB Audio Class), MIDI, and VCP (Virtual COM Port). These drivers handle device enumeration, pipe allocation, and protocol-specific communication, allowing applications to interact with these standard USB devices directly.

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

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

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

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

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

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

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

Introduces a new \embassy-usb-logger\ crate that implements a \log::Log\ backend over a USB CDC-ACM interface. Users can now route log messages to a USB serial connection with support for custom formatting styles via \with\_custom\_style\ and handle incoming commands from the host using the \ReceiverHandler\ trait. The logger manages its own USB device lifecycle or can be attached to an existing class instance, buffering output in a configurable pipe to prevent data loss.

embassy-usb-logger/src · high confidence

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

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

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

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

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

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

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

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

Added example applications for nRF devices (nRF52, nRF91, and nRF54) demonstrating the embassy-boot bootloader workflow. The 'a' binary acts as a firmware updater that writes a secondary binary ('b') via DFU when a button is pressed, while 'b' is the updated application. The examples include memory layout linker scripts for different targets, a build script to handle memory definitions, and logic to detect and signal bootloader revert states via LEDs if the watchdog is not serviced after an update.

examples/boot/application/nrf · high confidence

Added a new bootloader example for nRF microcontrollers located in examples/boot/bootloader/nrf. This example utilizes embassy-boot to manage flash memory, featuring specific linker scripts (memory.x, memory-s140.x, memory-bm.x) that define memory layouts for the bootloader state, active application, and DFU regions. The implementation includes main.rs with watchdog-integrated flash access (WatchdogFlash) and supports both standard nRF52 devices and the nRF54 series via conditional compilation.

examples/boot/bootloader/nrf · high confidence

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

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

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

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

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

The flash driver has been refactored to support both blocking and asynchronous operations, with the async mode enabled by default. This introduces a new \Flash\ struct that can be instantiated in either mode, along with corresponding \write\ and \erase\ methods that work with offsets from the flash start. The driver now covers a significantly wider range of STM32 families, including F0, F1, F2, F3, F4, F7, G0, G4, H5, H7, L0, L1, L4, L5, U3, U5, and C0/C5, with specific implementations for each. Key features include automatic flash locking/unlocking, support for dual-bank configurations, data cache management for errata workarounds, and optional erase parallelism for F2/F4/F7/H7 families. The driver also adds support for EDATA and EEPROM regions on supported chips, implementing the embedded-storage traits for both blocking and async modes.

embassy-stm32/src/flash · high confidence

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

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

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

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

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

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

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

The QSPI flash example, the UART communication example, and the shared example common module (which provided defmt logging and error-handling helpers) have been removed from the examples directory. This eliminates the ability to run these specific hardware interaction demos and removes the shared utility code previously used by them.

examples/src · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The embassy-usb library has been restructured to improve usability and correctness. The builder API has been renamed from \UsbDeviceBuilder\ to \Builder\, and the configuration now defaults to \composite\_with\_iads\ for better compatibility with host operating systems. Control request handling has been centralized into a new \control\ module, allowing handlers to be associated with specific interfaces and automatically routing requests. The library now supports custom string descriptors, Microsoft OS descriptors (MS OS 2.0), and configurable USB versions (2.0 and 2.1). Additionally, the \Config\ struct has been constified, and the \susependable\ field has been added to support device suspend/resume states.

embassy-usb/src · high confidence

The DMA subsystem has been refactored into a unified driver that consolidates support for standard DMA, BDMA, and MDMA controllers, along with DMAMUX configuration. This change introduces a new \Channel\ driver and \TransferOptions\ struct, allowing users to configure burst sizes, flow control, FIFO thresholds, priority, circular mode, and half-transfer interrupts. The update also adds a \ChannelAndRequest\ helper for peripheral drivers and a \Word\ trait that supports arbitrary bit-widths (1–64 bits) for flexible memory-to-peripheral and memory-to-memory transfers.

embassy-stm32/src/dma · high confidence

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

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

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

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

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

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 property-based state-machine tests for DMA ringbuffer reader and writer; Added serial port saturation utility for testing; Added unit tests for DMA ring buffer index synchronization and wrap-around logic; Added unit tests for USB DFU functionality; Expanded hardware test coverage for STM32 peripherals; Standardized test infrastructure for Cortex-M and RISC-V targets.

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.

• CAI 65 → 66 (+1.4)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 80 → 80 (+0.1)
• Architecture 100 → 94 (-5.7)
• Maturity 75 → 75 (+0.0)
• Readiness 43 → 48 (+5.6)
• Security 97 → 85 (-12.5)
• Event Sourcing 100 → 100 (+0.0)
• Performance 100 (new)

• AesDriver::apply_keystream (cognitive 26) (embassy-stm32/src/aes/driver.rs)
• AesDriver::apply_keystream (cognitive 26) (embassy-stm32/src/aes/driver.rs)
• AesDriver::apply_keystream (cognitive 26) (embassy-stm32/src/cryp/driver.rs)
• AesDriver::apply_keystream (cognitive 26) (embassy-stm32/src/cryp/driver.rs)
• Change coupling: low_power.rs ↔ low_power.rs (embassy-stm32/src/low_power.rs)
• ClassTooLong: AesDriver (embassy-stm32/src/aes/driver.rs)
• ClassTooLong: AesDriver (embassy-stm32/src/cryp/driver.rs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (embassy-net-esp-hosted/README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (embassy-mcxa/src/spi/controller.rs)
• Duplicated block (10 lines × 2) (embassy-net/src/raw.rs)
• Duplicated block (10 lines × 2) (embassy-net/src/raw.rs)
• Duplicated block (10 lines × 2) (embassy-stm32-wpan/src/wba/linklayer_plat.rs)
• Duplicated block (10 lines × 3) (embassy-net/src/raw.rs)
• Duplicated block (10 lines × 3) (embassy-stm32/src/flash/f2.rs)
• Duplicated block (10 lines × 4) (embassy-stm32/src/aes/driver.rs)
• Duplicated block (10 lines × 4) (embassy-stm32/src/aes/driver.rs)
• Duplicated block (10 lines × 4) (embassy-stm32/src/cryp/driver.rs)
• Duplicated block (10 lines × 7) (embassy-stm32/src/cryp/mod.rs)
• …and 144 more

• AesDriver::apply_keystream (cognitive 26) (embassy-stm32/src/crypto_driver.rs)
• AesDriver::apply_keystream (cognitive 26) (embassy-stm32/src/crypto_driver.rs)
• Change coupling: aci_gap.rs ↔ mod.rs (embassy-stm32-wpan/src/bluetooth/gap/aci_gap.rs)
• ClassTooLong: AesDriver (embassy-stm32/src/crypto_driver.rs)
• ClassTooLong: NeoChrom (embassy-stm32-neochrom/src/driver.rs)
• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Duplicated block (10 lines × 2) (embassy-mcxa/src/spi/controller.rs)
• Duplicated block (10 lines × 2) (embassy-stm32-wpan/src/bluetooth/mod.rs)
• Duplicated block (10 lines × 2) (embassy-stm32/src/spi/mod.rs)
• Duplicated block (10 lines × 4) (embassy-mcxa/src/spi/controller.rs)
• Duplicated block (10 lines × 4) (embassy-stm32/src/cryp/mod.rs)
• Duplicated block (10 lines × 4) (embassy-stm32/src/crypto_driver.rs)
• Duplicated block (11 lines × 2) (embassy-nxp/src/i2c/lpc55.rs)
• Duplicated block (11 lines × 2) (embassy-nxp/src/i2c/lpc55.rs)
• Duplicated block (11 lines × 2) (embassy-nxp/src/i2c/lpc55.rs)
• Duplicated block (11 lines × 3) (embassy-stm32-wpan/src/bluetooth/security/mod.rs)
• Duplicated block (11 lines × 4) (embassy-stm32/src/crypto_driver.rs)
• Duplicated block (11–12 lines × 3) (embassy-stm32/src/spi/ringbuffered.rs)
• Duplicated block (12 lines × 3) (embassy-mcxa/src/spi/controller.rs)
• Duplicated block (12 lines × 4) (embassy-nxp/src/casper/lpc55.rs)
• …and 136 more

• 296 commits — 242 feature/other, 54 fixes

• (repo) — 101 commits
• embassy-stm32/src — 46 commits
• embassy-mcxa/src — 28 commits
• embassy-nxp/src — 14 commits
• embassy-usb/src — 11 commits
• embassy-rp/src — 9 commits
• tests/rp — 8 commits
• embassy-stm32-wpan/src — 7 commits
• examples/stm32n6 — 6 commits
• embassy-stm32/Cargo.toml — 5 commits
• (root) — 4 commits
• cyw43/src — 4 commits
• embassy-net/src — 4 commits
• embassy-mspm0/CHANGELOG.md — 3 commits
• examples/mcxa2xx — 3 commits
• examples/rp — 3 commits
• examples/stm32wba6 — 3 commits
• .github/ci — 2 commits
• embassy-executor/CHANGELOG.md — 2 commits
• embassy-net-adin1110/Cargo.toml — 2 commits

• fix: Add fix for set_alarm()
• fix: Fix RCC MCO cfg for rcc_h7rm0468
• fix: Fix i2c Naks
• fix: Fix load FW from ELF - addrs realigned with examples
• fix: Fix peripheral helper and add config to constructor
• fix: Merge branch 'main' into fix/h7-psize-cleanup
• fix: Merge pull request #7000 from xoviat/rng-fix
• fix: Merge pull request #7001 from embassy-rs/stm32-adc-fixes
• fix: Merge pull request #7005 from leftger/fix/wba6-adc-ring-buffer-trigger
• fix: Merge pull request #7007 from nponsard/fix/bootloader-readme-time-driver
• fix: Merge pull request #7009 from embassy-rs/fix-boot
• fix: Merge pull request #7010 from cedrivard/fix/cyw43-bluetooth-shared-bus
• fix: Merge pull request #7011 from leftger/feat/wba-ble-stack-fixes
• fix: Merge pull request #7030 from ShangYJQ/fix/usb-host-disconnect-retry
• fix: Merge pull request #7036 from raghav2005/fix/cyw43-invalid-passphrase
• fix: Merge pull request #7046 from MRNIU/fix/h7-psize-cleanup
• fix: Merge pull request #7047 from felipebalbi/mcxa-clock-fixes
• fix: Merge pull request #7048 from quartiq/fix/eth-v2-tail-main
• fix: Merge pull request #7056 from leftger/feat/wba-ble-stack-fixes-rebased
• fix: Merge pull request #7072 from leftger/feat/fix-n6-examples
• …and 276 more

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

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.