206 files changed, 23136 insertions, 2546 deletions

diff --git a/README.md b/README.md
index de6b3bb59..950d19a6d 100644
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@ Rust's [async/await](https://rust-lang.github.io/async-book/) allows for unprece
   No more messing with hardware timers. [embassy_time](https://docs.embassy.dev/embassy-time) provides Instant, Duration, and Timer types that are globally available and never overflow.
 
 - **Real-time ready** -
-  Tasks on the same async executor run cooperatively, but you can create multiple executors with different priorities so that higher priority tasks preempt lower priority ones. See the [example](https://github.com/embassy-rs/embassy/blob/master/examples/nrf52840/src/bin/multiprio.rs).
+  Tasks on the same async executor run cooperatively, but you can create multiple executors with different priorities so that higher priority tasks preempt lower priority ones. See the [example](https://github.com/embassy-rs/embassy/blob/main/examples/nrf52840/src/bin/multiprio.rs).
 
 - **Low-power ready** -
   Easily build devices with years of battery life. The async executor automatically puts the core to sleep when there's no work to do. Tasks are woken by interrupts, there is no busy-loop polling while waiting.
@@ -49,7 +49,7 @@ Rust's [async/await](https://rust-lang.github.io/async-book/) allows for unprece
   [embassy-usb](https://docs.embassy.dev/embassy-usb/) implements a device-side USB stack. Implementations for common classes such as USB serial (CDC ACM) and USB HID are available, and a rich builder API allows building your own.
 
 - **Bootloader and DFU** -
-  [embassy-boot](https://github.com/embassy-rs/embassy/tree/master/embassy-boot) is a lightweight bootloader supporting firmware application upgrades in a power-fail-safe way, with trial boots and rollbacks.
+  [embassy-boot](https://github.com/embassy-rs/embassy/tree/main/embassy-boot) is a lightweight bootloader supporting firmware application upgrades in a power-fail-safe way, with trial boots and rollbacks.
 
 ## Sneak peek
 
diff --git a/cyw43-pio/CHANGELOG.md b/cyw43-pio/CHANGELOG.md
index ec38989e3..c2d18919c 100644
--- a/cyw43-pio/CHANGELOG.md
+++ b/cyw43-pio/CHANGELOG.md
@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- Select pio program based on core clock speed #4792
+
 ## 0.8.0 - 2025-08-28
 
 - Bump cyw43 version
diff --git a/cyw43-pio/src/lib.rs b/cyw43-pio/src/lib.rs
index 41ac6816d..c8715e662 100644
--- a/cyw43-pio/src/lib.rs
+++ b/cyw43-pio/src/lib.rs
@@ -7,6 +7,7 @@ use core::slice;
 
 use cyw43::SpiBusCyw43;
 use embassy_rp::Peri;
+use embassy_rp::clocks::clk_sys_freq;
 use embassy_rp::dma::Channel;
 use embassy_rp::gpio::{Drive, Level, Output, Pull, SlewRate};
 use embassy_rp::pio::program::pio_asm;
@@ -23,23 +24,24 @@ pub struct PioSpi<'d, PIO: Instance, const SM: usize, DMA: Channel> {
     wrap_target: u8,
 }
 
-/// The default clock divider that works for Pico 1 and 2 W. As well as the RM2 on rp2040 devices.
-/// same speed as pico-sdk, 62.5Mhz
-/// This is actually the fastest we can go without overclocking.
-/// According to data sheet, the theoretical maximum is 100Mhz Pio => 50Mhz SPI Freq.
-/// However, the PIO uses a fractional divider, which works by introducing jitter when
-/// the divider is not an integer. It does some clocks at 125mhz and others at 62.5mhz
-/// so that it averages out to the desired frequency of 100mhz. The 125mhz clock cycles
-/// violate the maximum from the data sheet.
+/// Clock divider used for most applications
+/// With default core clock configuration:
+/// RP2350: 150Mhz / 2 = 75Mhz pio clock -> 37.5Mhz GSPI clock
+/// RP2040: 133Mhz / 2 = 66.5Mhz pio clock -> 33.25Mhz GSPI clock
 pub const DEFAULT_CLOCK_DIVIDER: FixedU32<U8> = FixedU32::from_bits(0x0200);
 
-/// The overclock clock divider for the Pico 1 W. Does not work on any known RM2 devices.
-/// 125mhz Pio => 62.5Mhz SPI Freq. 25% higher than theoretical maximum according to
-/// data sheet, but seems to work fine.
+/// Clock divider used to overclock the cyw43
+/// With default core clock configuration:
+/// RP2350: 150Mhz / 1 = 150Mhz pio clock -> 75Mhz GSPI clock (50% greater that manufacturer
+/// recommended 50Mhz)
+/// RP2040: 133Mhz / 1 = 133Mhz pio clock -> 66.5Mhz GSPI clock (33% greater that manufacturer
+/// recommended 50Mhz)
 pub const OVERCLOCK_CLOCK_DIVIDER: FixedU32<U8> = FixedU32::from_bits(0x0100);
 
-/// The clock divider for the RM2 module. Found to be needed for the Pimoroni Pico Plus 2 W,
-/// Pico Plus 2 Non w with the RM2 breakout module, and the Pico 2 with the RM2 breakout module.
+/// Clock divider used with the RM2
+/// With default core clock configuration:
+/// RP2350: 150Mhz / 3 = 50Mhz pio clock -> 25Mhz GSPI clock
+/// RP2040: 133Mhz / 3 = 44.33Mhz pio clock -> 22.16Mhz GSPI clock
 pub const RM2_CLOCK_DIVIDER: FixedU32<U8> = FixedU32::from_bits(0x0300);
 
 impl<'d, PIO, const SM: usize, DMA> PioSpi<'d, PIO, SM, DMA>
@@ -58,7 +60,40 @@ where
         clk: Peri<'d, impl PioPin>,
         dma: Peri<'d, DMA>,
     ) -> Self {
-        let loaded_program = if clock_divider < DEFAULT_CLOCK_DIVIDER {
+        let effective_pio_frequency = (clk_sys_freq() as f32 / clock_divider.to_num::<f32>()) as u32;
+
+        #[cfg(feature = "defmt")]
+        defmt::trace!("Effective pio frequency: {}Hz", effective_pio_frequency);
+
+        // Non-integer pio clock dividers are achieved by introducing clock jitter resulting in a
+        // combination of long and short cycles. The long and short cycles average to achieve the
+        // requested clock speed.
+        // This can be a problem for peripherals that expect a consistent clock / have a clock
+        // speed upper bound that is violated by the short cycles. The cyw43 seems to handle the
+        // jitter well, but we emit a warning to recommend an integer divider anyway.
+        if clock_divider.frac() != FixedU32::<U8>::ZERO {
+            #[cfg(feature = "defmt")]
+            defmt::trace!(
+                "Configured clock divider is not a whole number. Some clock cycles may violate the maximum recommended GSPI speed. Use at your own risk."
+            );
+        }
+
+        // Different pio programs must be used for different pio clock speeds.
+        // The programs used below are based on the pico SDK: https://github.com/raspberrypi/pico-sdk/blob/master/src/rp2_common/pico_cyw43_driver/cyw43_bus_pio_spi.pio
+        // The clock speed cutoff for each program has been determined experimentally:
+        // > 100Mhz -> Overclock program
+        // [75Mhz, 100Mhz] -> High speed program
+        // [0, 75Mhz) -> Low speed program
+        let loaded_program = if effective_pio_frequency > 100_000_000 {
+            // Any frequency > 100Mhz is overclocking the chip (manufacturer recommends max 50Mhz GSPI
+            // clock)
+            // Example:
+            // * RP2040 @ 133Mhz (stock) with OVERCLOCK_CLOCK_DIVIDER (133MHz)
+            #[cfg(feature = "defmt")]
+            defmt::trace!(
+                "Configured clock divider results in a GSPI frequency greater than the manufacturer recommendation (50Mhz). Use at your own risk."
+            );
+
             let overclock_program = pio_asm!(
                 ".side_set 1"
 
@@ -69,7 +104,7 @@ where
                 "jmp x-- lp     side 1"
                 // switch directions
                 "set pindirs, 0 side 0"
-                "nop            side 1"  // necessary for clkdiv=1.
+                "nop            side 1"
                 "nop            side 0"
                 // read in y-1 bits
                 "lp2:"
@@ -83,8 +118,47 @@ where
                 ".wrap"
             );
             common.load_program(&overclock_program.program)
+        } else if effective_pio_frequency >= 75_000_000 {
+            // Experimentally determined cutoff.
+            // Notably includes the stock RP2350 configured with clk_div of 2 (150Mhz base clock / 2 = 75Mhz)
+            // but does not include stock RP2040 configured with clk_div of 2 (133Mhz base clock / 2 = 66.5Mhz)
+            // Example:
+            // * RP2350 @ 150Mhz (stock) with DEFAULT_CLOCK_DIVIDER (75Mhz)
+            // * RP2XXX @ 200Mhz with DEFAULT_CLOCK_DIVIDER (100Mhz)
+            #[cfg(feature = "defmt")]
+            defmt::trace!("Using high speed pio program.");
+            let high_speed_program = pio_asm!(
+                ".side_set 1"
+
+                ".wrap_target"
+                // write out x-1 bits
+                "lp:"
+                "out pins, 1    side 0"
+                "jmp x-- lp     side 1"
+                // switch directions
+                "set pindirs, 0 side 0"
+                "nop            side 1"
+                // read in y-1 bits
+                "lp2:"
+                "in pins, 1     side 0"
+                "jmp y-- lp2    side 1"
+
+                // wait for event and irq host
+                "wait 1 pin 0   side 0"
+                "irq 0          side 0"
+
+                ".wrap"
+            );
+            common.load_program(&high_speed_program.program)
         } else {
-            let default_program = pio_asm!(
+            // Low speed
+            // Examples:
+            // * RP2040 @ 133Mhz (stock) with DEFAULT_CLOCK_DIVIDER (66.5Mhz)
+            // * RP2040 @ 133Mhz (stock) with RM2_CLOCK_DIVIDER (44.3Mhz)
+            // * RP2350 @ 150Mhz (stock) with RM2_CLOCK_DIVIDER (50Mhz)
+            #[cfg(feature = "defmt")]
+            defmt::trace!("Using low speed pio program.");
+            let low_speed_program = pio_asm!(
                 ".side_set 1"
 
                 ".wrap_target"
@@ -106,7 +180,7 @@ where
 
                 ".wrap"
             );
-            common.load_program(&default_program.program)
+            common.load_program(&low_speed_program.program)
         };
 
         let mut pin_io: embassy_rp::pio::Pin<PIO> = common.make_pio_pin(dio);
diff --git a/docs/examples/basic/Cargo.toml b/docs/examples/basic/Cargo.toml
index b90180853..fadda102b 100644
--- a/docs/examples/basic/Cargo.toml
+++ b/docs/examples/basic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 authors = ["Dario Nieuwenhuis <[email protected]>"]
-edition = "2018"
+edition = "2024"
 name = "embassy-basic-example"
 version = "0.1.0"
 license = "MIT OR Apache-2.0"
diff --git a/docs/examples/basic/src/main.rs b/docs/examples/basic/src/main.rs
index 6e274bacb..42797612c 100644
--- a/docs/examples/basic/src/main.rs
+++ b/docs/examples/basic/src/main.rs
@@ -3,24 +3,41 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_nrf::gpio::{Level, Output, OutputDrive};
-use embassy_time::{Duration, Timer};
-use {defmt_rtt as _, panic_probe as _}; // global logger
+use embassy_nrf::Peri;
+use embassy_nrf::gpio::{AnyPin, Input, Level, Output, OutputDrive, Pull};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
 
+// Declare async tasks
 #[embassy_executor::task]
-async fn blinker(mut led: Output<'static>, interval: Duration) {
+async fn blink(pin: Peri<'static, AnyPin>) {
+    let mut led = Output::new(pin, Level::Low, OutputDrive::Standard);
+
     loop {
+        // Timekeeping is globally available, no need to mess with hardware timers.
         led.set_high();
-        Timer::after(interval).await;
+        Timer::after_millis(150).await;
         led.set_low();
-        Timer::after(interval).await;
+        Timer::after_millis(150).await;
     }
 }
 
+// Main is itself an async task as well.
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
+    // Initialize the embassy-nrf HAL.
     let p = embassy_nrf::init(Default::default());
 
-    let led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);
-    spawner.spawn(unwrap!(blinker(led, Duration::from_millis(300))));
+    // Spawned tasks run in the background, concurrently.
+    spawner.spawn(blink(p.P0_13.into()).unwrap());
+
+    let mut button = Input::new(p.P0_11, Pull::Up);
+    loop {
+        // Asynchronously wait for GPIO events, allowing other tasks
+        // to run, or the core to sleep.
+        button.wait_for_low().await;
+        info!("Button pressed!");
+        button.wait_for_high().await;
+        info!("Button released!");
+    }
 }
diff --git a/docs/pages/embassy_in_the_wild.adoc b/docs/pages/embassy_in_the_wild.adoc
index 3b58bb9b4..0792130eb 100644
--- a/docs/pages/embassy_in_the_wild.adoc
+++ b/docs/pages/embassy_in_the_wild.adoc
@@ -4,6 +4,10 @@ Here are known examples of real-world projects which make use of Embassy. Feel f
 
 _newer entries at the top_
 
+* link:https://github.com/thataquarel/protovolt[ProtoV MINI: A USB-C mini lab power supply]
+** A dual-channel USB PD powered breadboard power supply based on the RP2040, running embedded graphics. Open-source schematics and firmware.
+* link:https://github.com/Dawson-HEP/opentrig/[Opentrig: A particle physics trigger and data acquisition system]
+** Digital event trigger with threshold, data acquisition system designed to interface with AIDA-2020 TLU systems, tested at the DESY II Test Beam Facility. Based on the RP2040, and Embassy's async event handling.
 * link:https://github.com/1-rafael-1/air-quality-monitor[Air Quality Monitor]
 ** Air Quality Monitor based on rp2350 board, ens160 and aht21 sensors and ssd1306 display. Code and 3D printable enclosure included.
 * link:https://github.com/CarlKCarlK/clock[Embassy Clock: Layered, modular bare-metal clock with emulation]
diff --git a/embassy-executor/CHANGELOG.md b/embassy-executor/CHANGELOG.md
index 47a8ae995..5fbb8cf13 100644
--- a/embassy-executor/CHANGELOG.md
+++ b/embassy-executor/CHANGELOG.md
@@ -13,7 +13,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Upgraded rtos-trace
 - Added optional "highest priority" scheduling
 - Added optional "earliest deadline first" EDF scheduling
-- Bump `cortex-ar` to v0.3
+- Migrate `cortex-ar` to `aarch32-cpu`. The feature name `arch-cortex-ar` remains the same and
+  legacy ARM architectures are not supported.
 
 ## 0.9.1 - 2025-08-31
 
diff --git a/embassy-executor/Cargo.toml b/embassy-executor/Cargo.toml
index ecc4b6338..d3e5b241a 100644
--- a/embassy-executor/Cargo.toml
+++ b/embassy-executor/Cargo.toml
@@ -30,6 +30,7 @@ build = [
     {target = "thumbv7em-none-eabi", features = ["arch-cortex-m", "executor-interrupt", "executor-thread", "embassy-time-driver", "scheduler-deadline"]},
     {target = "thumbv7em-none-eabi", features = ["arch-cortex-m", "executor-interrupt", "executor-thread", "scheduler-priority", "scheduler-deadline"]},
     {target = "thumbv7em-none-eabi", features = ["arch-cortex-m", "executor-interrupt", "executor-thread", "scheduler-deadline"]},
+    {target = "thumbv7em-none-eabi", features = ["arch-cortex-m", "executor-interrupt", "executor-thread", "embassy-time-driver", "scheduler-priority", "scheduler-deadline", "trace"]},
     {target = "thumbv7em-none-eabi", features = ["arch-spin"]},
     {target = "thumbv7em-none-eabi", features = ["arch-spin", "scheduler-deadline"]},
     {target = "armv7a-none-eabi", features = ["arch-cortex-ar", "executor-thread"]},
@@ -37,6 +38,7 @@ build = [
     {target = "armv7r-none-eabihf", features = ["arch-cortex-ar", "executor-thread"]},
     {target = "riscv32imac-unknown-none-elf", features = ["arch-riscv32"]},
     {target = "riscv32imac-unknown-none-elf", features = ["arch-riscv32", "executor-thread"]},
+    {target = "riscv32imac-unknown-none-elf", features = ["arch-riscv32", "executor-thread", "trace"]},
     # Nightly builds
     {group = "nightly", target = "thumbv7em-none-eabi", features = ["nightly"]},
     {group = "nightly", target = "thumbv7em-none-eabi", features = ["nightly", "log"]},
@@ -100,7 +102,7 @@ portable-atomic = { version = "1.5", optional = true }
 cortex-m = { version = "0.7.6", optional = true }
 
 # arch-cortex-ar dependencies
-cortex-ar = { version = "0.3", optional = true }
+aarch32-cpu = { version = "0.1", optional = true }
 
 # arch-wasm dependencies
 wasm-bindgen = { version = "0.2.82", optional = true }
@@ -128,7 +130,7 @@ nightly = ["embassy-executor-macros/nightly"]
 ## Enable defmt logging
 defmt = ["dep:defmt"]
 
-## Enable log logging  
+## Enable log logging
 log = ["dep:log"]
 
 # Enables turbo wakers, which requires patching core. Not surfaced in the docs by default due to
@@ -143,7 +145,7 @@ arch-std = ["_arch"]
 ## Cortex-M
 arch-cortex-m = ["_arch", "dep:cortex-m"]
 ## Cortex-A/R
-arch-cortex-ar = ["_arch", "dep:cortex-ar"]
+arch-cortex-ar = ["_arch", "dep:aarch32-cpu", "dep:arm-targets"]
 ## RISC-V 32
 arch-riscv32 = ["_arch"]
 ## WASM
@@ -180,3 +182,6 @@ scheduler-priority = []
 ## Enable the embassy_time_driver dependency.
 ## This can unlock extra APIs, for example for the `sheduler-deadline`
 embassy-time-driver = ["dep:embassy-time-driver"]
+
+[build-dependencies]
+arm-targets = { version = "0.4", optional = true }
diff --git a/embassy-executor/build.rs b/embassy-executor/build.rs
index 37becde3e..36e23a632 100644
--- a/embassy-executor/build.rs
+++ b/embassy-executor/build.rs
@@ -4,4 +4,9 @@ mod common;
 fn main() {
     let mut rustc_cfgs = common::CfgSet::new();
     common::set_target_cfgs(&mut rustc_cfgs);
+
+    // This is used to exclude legacy architecture support. The raw executor needs to be used for
+    // those architectures because SEV/WFE are not supported.
+    #[cfg(feature = "arch-cortex-ar")]
+    arm_targets::process();
 }
diff --git a/embassy-executor/src/arch/cortex_ar.rs b/embassy-executor/src/arch/cortex_ar.rs
index a9be3d323..ce572738a 100644
--- a/embassy-executor/src/arch/cortex_ar.rs
+++ b/embassy-executor/src/arch/cortex_ar.rs
@@ -1,3 +1,6 @@
+#[cfg(arm_profile = "legacy")]
+compile_error!("`arch-cortex-ar` does not support the legacy ARM profile, WFE/SEV are not available.");
+
 #[cfg(feature = "executor-interrupt")]
 compile_error!("`executor-interrupt` is not supported with `arch-cortex-ar`.");
 
@@ -10,7 +13,7 @@ fn __pender(context: *mut ()) {
     #[cfg(feature = "executor-thread")]
     // Try to make Rust optimize the branching away if we only use thread mode.
     if !cfg!(feature = "executor-interrupt") || context == THREAD_PENDER {
-        cortex_ar::asm::sev();
+        aarch32_cpu::asm::sev();
         return;
     }
 }
@@ -23,7 +26,7 @@ mod thread {
 
     use core::marker::PhantomData;
 
-    use cortex_ar::asm::wfe;
+    use aarch32_cpu::asm::wfe;
     pub use embassy_executor_macros::main_cortex_ar as main;
 
     use crate::{Spawner, raw};
diff --git a/embassy-executor/src/raw/trace.rs b/embassy-executor/src/raw/trace.rs
index 74519b927..830162039 100644
--- a/embassy-executor/src/raw/trace.rs
+++ b/embassy-executor/src/raw/trace.rs
@@ -169,7 +169,7 @@ impl TaskTracker {
 }
 
 #[cfg(feature = "trace")]
-extern "Rust" {
+unsafe extern "Rust" {
     /// This callback is called when the executor begins polling. This will always
     /// be paired with a later call to `_embassy_trace_executor_idle`.
     ///
diff --git a/embassy-mspm0/CHANGELOG.md b/embassy-mspm0/CHANGELOG.md
index 948f0205d..f0b5868f4 100644
--- a/embassy-mspm0/CHANGELOG.md
+++ b/embassy-mspm0/CHANGELOG.md
@@ -7,7 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- next-header -->
 ## Unreleased - ReleaseDate
- 
+
 - feat: Add I2C Controller (blocking & async) + examples for mspm0l1306, mspm0g3507 (tested MCUs) (#4435)
 - fix gpio interrupt not being set for mspm0l110x
 - feat: Add window watchdog implementation based on WWDT0, WWDT1 peripherals (#4574)
@@ -16,3 +16,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - fix: gpio OutputOpenDrain config (#4735)
 - fix: add MSPM0C1106 to build test matrix
 - feat: add MSPM0H3216 support
+- feat: Add i2c target implementation (#4605)
+- fix: group irq handlers must check for NO_INTR (#4785)
+- feat: Add read_reset_cause function
diff --git a/embassy-mspm0/Cargo.toml b/embassy-mspm0/Cargo.toml
index df6176ff6..b76bc7e41 100644
--- a/embassy-mspm0/Cargo.toml
+++ b/embassy-mspm0/Cargo.toml
@@ -72,7 +72,7 @@ cortex-m = "0.7.6"
 critical-section = "1.2.0"
 
 # mspm0-metapac = { version = "" }
-mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-e7de4103a0713772695ffcad52c3c2f07414dc29" }
+mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-8542f260cc89645a983b7f1a874c87b21822279e" }
 
 [build-dependencies]
 proc-macro2 = "1.0.94"
@@ -80,7 +80,7 @@ quote = "1.0.40"
 cfg_aliases = "0.2.1"
 
 # mspm0-metapac = { version = "", default-features = false, features = ["metadata"] }
-mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-e7de4103a0713772695ffcad52c3c2f07414dc29", default-features = false, features = ["metadata"] }
+mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-8542f260cc89645a983b7f1a874c87b21822279e", default-features = false, features = ["metadata"] }
 
 [features]
 default = ["rt"]
diff --git a/embassy-mspm0/build.rs b/embassy-mspm0/build.rs
index 1d118ad66..4942364aa 100644
--- a/embassy-mspm0/build.rs
+++ b/embassy-mspm0/build.rs
@@ -194,8 +194,15 @@ fn generate_groups() -> TokenStream {
                 use crate::pac::#group_enum;
 
                 let group = crate::pac::CPUSS.int_group(#group_number);
-                // MUST subtract by 1 since 0 is NO_INTR
-                let iidx = group.iidx().read().stat().to_bits() - 1;
+                let stat = group.iidx().read().stat();
+
+                // check for spurious interrupts
+                if stat == crate::pac::cpuss::vals::Iidx::NO_INTR {
+                    return;
+                }
+
+                // MUST subtract by 1 because NO_INTR offsets IIDX values.
+                let iidx = stat.to_bits() - 1;
 
                 let Ok(group) = #group_enum::try_from(iidx as u8) else {
                     return;
diff --git a/embassy-mspm0/src/i2c.rs b/embassy-mspm0/src/i2c.rs
index 192527dd2..3067f4833 100644
--- a/embassy-mspm0/src/i2c.rs
+++ b/embassy-mspm0/src/i2c.rs
@@ -56,7 +56,7 @@ pub enum ClockDiv {
 }
 
 impl ClockDiv {
-    fn into(self) -> vals::Ratio {
+    pub(crate) fn into(self) -> vals::Ratio {
         match self {
             Self::DivBy1 => vals::Ratio::DIV_BY_1,
             Self::DivBy2 => vals::Ratio::DIV_BY_2,
@@ -133,6 +133,11 @@ pub enum ConfigError {
     ///
     /// The clock soure is not enabled is SYSCTL.
     ClockSourceNotEnabled,
+
+    /// Invalid target address.
+    ///
+    /// The target address is not 7-bit.
+    InvalidTargetAddress,
 }
 
 #[non_exhaustive]
@@ -140,7 +145,7 @@ pub enum ConfigError {
 /// Config
 pub struct Config {
     /// I2C clock source.
-    clock_source: ClockSel,
+    pub(crate) clock_source: ClockSel,
 
     /// I2C clock divider.
     pub clock_div: ClockDiv,
@@ -196,7 +201,7 @@ impl Config {
     }
 
     #[cfg(any(mspm0c110x, mspm0c1105_c1106))]
-    fn calculate_clock_source(&self) -> u32 {
+    pub(crate) fn calculate_clock_source(&self) -> u32 {
         // Assume that BusClk has default value.
         // TODO: calculate BusClk more precisely.
         match self.clock_source {
@@ -209,7 +214,7 @@ impl Config {
         mspm0g110x, mspm0g150x, mspm0g151x, mspm0g310x, mspm0g350x, mspm0g351x, mspm0h321x, mspm0l110x, mspm0l122x,
         mspm0l130x, mspm0l134x, mspm0l222x
     ))]
-    fn calculate_clock_source(&self) -> u32 {
+    pub(crate) fn calculate_clock_source(&self) -> u32 {
         // Assume that BusClk has default value.
         // TODO: calculate BusClk more precisely.
         match self.clock_source {
diff --git a/embassy-mspm0/src/i2c_target.rs b/embassy-mspm0/src/i2c_target.rs
new file mode 100644
index 000000000..86be91415
--- /dev/null
+++ b/embassy-mspm0/src/i2c_target.rs
@@ -0,0 +1,509 @@
+//! Inter-Integrated-Circuit (I2C) Target
+// The following code is modified from embassy-stm32 and embassy-rp
+// https://github.com/embassy-rs/embassy/tree/main/embassy-stm32
+// https://github.com/embassy-rs/embassy/tree/main/embassy-rp
+
+use core::future::poll_fn;
+use core::marker::PhantomData;
+use core::sync::atomic::Ordering;
+use core::task::Poll;
+
+use embassy_embedded_hal::SetConfig;
+use mspm0_metapac::i2c::vals::CpuIntIidxStat;
+
+use crate::gpio::{AnyPin, SealedPin};
+use crate::interrupt::InterruptExt;
+use crate::mode::{Async, Blocking, Mode};
+use crate::pac::{self, i2c::vals};
+use crate::{i2c, i2c_target, interrupt, Peri};
+// Re-use I2c controller types
+use crate::i2c::{ClockSel, ConfigError, Info, Instance, InterruptHandler, SclPin, SdaPin, State};
+
+#[non_exhaustive]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+/// Config
+pub struct Config {
+    /// 7-bit Target Address
+    pub target_addr: u8,
+
+    /// Control if the target should ack to and report general calls.
+    pub general_call: bool,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            target_addr: 0x48,
+            general_call: false,
+        }
+    }
+}
+
+/// I2C error
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum Error {
+    /// User passed in a response buffer that was 0 length
+    InvalidResponseBufferLength,
+    /// The response buffer length was too short to contain the message
+    ///
+    /// The length parameter will always be the length of the buffer, and is
+    /// provided as a convenience for matching alongside `Command::Write`.
+    PartialWrite(usize),
+    /// The response buffer length was too short to contain the message
+    ///
+    /// The length parameter will always be the length of the buffer, and is
+    /// provided as a convenience for matching alongside `Command::GeneralCall`.
+    PartialGeneralCall(usize),
+}
+
+/// Received command from the controller.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Command {
+    /// General Call Write: Controller sent the General Call address (0x00) followed by data.
+    /// Contains the number of bytes written by the controller.
+    GeneralCall(usize),
+    /// Read: Controller wants to read data from the target.
+    Read,
+    /// Write: Controller sent the target's address followed by data.
+    /// Contains the number of bytes written by the controller.
+    Write(usize),
+    /// Write followed by Read (Repeated Start): Controller wrote data, then issued a repeated
+    /// start and wants to read data. Contains the number of bytes written before the read.
+    WriteRead(usize),
+}
+
+/// Status after responding to a controller read request.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum ReadStatus {
+    /// Transaction completed successfully. The controller either NACKed the last byte
+    /// or sent a STOP condition.
+    Done,
+    /// Transaction incomplete, controller trying to read more bytes than were provided
+    NeedMoreBytes,
+    /// Transaction complete, but controller stopped reading bytes before we ran out
+    LeftoverBytes(u16),
+}
+
+/// I2C Target driver.
+// Use the same Instance, SclPin, SdaPin traits as the controller
+pub struct I2cTarget<'d, M: Mode> {
+    info: &'static Info,
+    state: &'static State,
+    scl: Option<Peri<'d, AnyPin>>,
+    sda: Option<Peri<'d, AnyPin>>,
+    config: i2c::Config,
+    target_config: i2c_target::Config,
+    _phantom: PhantomData<M>,
+}
+
+impl<'d> SetConfig for I2cTarget<'d, Async> {
+    type Config = (i2c::Config, i2c_target::Config);
+    type ConfigError = ConfigError;
+
+    fn set_config(&mut self, config: &Self::Config) -> Result<(), Self::ConfigError> {
+        self.info.interrupt.disable();
+
+        if let Some(ref sda) = self.sda {
+            sda.update_pf(config.0.sda_pf());
+        }
+
+        if let Some(ref scl) = self.scl {
+            scl.update_pf(config.0.scl_pf());
+        }
+
+        self.config = config.0.clone();
+        self.target_config = config.1.clone();
+
+        self.reset()
+    }
+}
+
+impl<'d> SetConfig for I2cTarget<'d, Blocking> {
+    type Config = (i2c::Config, i2c_target::Config);
+    type ConfigError = ConfigError;
+
+    fn set_config(&mut self, config: &Self::Config) -> Result<(), Self::ConfigError> {
+        if let Some(ref sda) = self.sda {
+            sda.update_pf(config.0.sda_pf());
+        }
+
+        if let Some(ref scl) = self.scl {
+            scl.update_pf(config.0.scl_pf());
+        }
+
+        self.config = config.0.clone();
+        self.target_config = config.1.clone();
+
+        self.reset()
+    }
+}
+
+impl<'d> I2cTarget<'d, Async> {
+    /// Create a new asynchronous I2C target driver using interrupts
+    /// The `config` reuses the i2c controller config to setup the clock while `target_config`
+    /// configures i2c target specific parameters.
+    pub fn new<T: Instance>(
+        peri: Peri<'d, T>,
+        scl: Peri<'d, impl SclPin<T>>,
+        sda: Peri<'d, impl SdaPin<T>>,
+        _irq: impl interrupt::typelevel::Binding<T::Interrupt, InterruptHandler<T>> + 'd,
+        config: i2c::Config,
+        target_config: i2c_target::Config,
+    ) -> Result<Self, ConfigError> {
+        let mut this = Self::new_inner(
+            peri,
+            new_pin!(scl, config.scl_pf()),
+            new_pin!(sda, config.sda_pf()),
+            config,
+            target_config,
+        );
+        this.reset()?;
+        Ok(this)
+    }
+
+    /// Reset the i2c peripheral. If you cancel a respond_to_read, you may stall the bus.
+    /// You can recover the bus by calling this function, but doing so will almost certainly cause
+    /// an i/o error in the controller.
+    pub fn reset(&mut self) -> Result<(), ConfigError> {
+        self.init()?;
+        unsafe { self.info.interrupt.enable() };
+        Ok(())
+    }
+}
+
+impl<'d> I2cTarget<'d, Blocking> {
+    /// Create a new blocking I2C target driver.
+    /// The `config` reuses the i2c controller config to setup the clock while `target_config`
+    /// configures i2c target specific parameters.
+    pub fn new_blocking<T: Instance>(
+        peri: Peri<'d, T>,
+        scl: Peri<'d, impl SclPin<T>>,
+        sda: Peri<'d, impl SdaPin<T>>,
+        config: i2c::Config,
+        target_config: i2c_target::Config,
+    ) -> Result<Self, ConfigError> {
+        let mut this = Self::new_inner(
+            peri,
+            new_pin!(scl, config.scl_pf()),
+            new_pin!(sda, config.sda_pf()),
+            config,
+            target_config,
+        );
+        this.reset()?;
+        Ok(this)
+    }
+
+    /// Reset the i2c peripheral. If you cancel a respond_to_read, you may stall the bus.
+    /// You can recover the bus by calling this function, but doing so will almost certainly cause
+    /// an i/o error in the controller.
+    pub fn reset(&mut self) -> Result<(), ConfigError> {
+        self.init()?;
+        Ok(())
+    }
+}
+
+impl<'d, M: Mode> I2cTarget<'d, M> {
+    fn new_inner<T: Instance>(
+        _peri: Peri<'d, T>,
+        scl: Option<Peri<'d, AnyPin>>,
+        sda: Option<Peri<'d, AnyPin>>,
+        config: i2c::Config,
+        target_config: i2c_target::Config,
+    ) -> Self {
+        if let Some(ref scl) = scl {
+            let pincm = pac::IOMUX.pincm(scl._pin_cm() as usize);
+            pincm.modify(|w| {
+                w.set_hiz1(true);
+            });
+        }
+        if let Some(ref sda) = sda {
+            let pincm = pac::IOMUX.pincm(sda._pin_cm() as usize);
+            pincm.modify(|w| {
+                w.set_hiz1(true);
+            });
+        }
+
+        Self {
+            info: T::info(),
+            state: T::state(),
+            scl,
+            sda,
+            config,
+            target_config,
+            _phantom: PhantomData,
+        }
+    }
+
+    fn init(&mut self) -> Result<(), ConfigError> {
+        let mut config = self.config;
+        let target_config = self.target_config;
+        let regs = self.info.regs;
+
+        config.check_config()?;
+        // Target address must be 7-bit
+        if !(target_config.target_addr < 0x80) {
+            return Err(ConfigError::InvalidTargetAddress);
+        }
+
+        regs.target(0).tctr().modify(|w| {
+            w.set_active(false);
+        });
+
+        // Init power for I2C
+        regs.gprcm(0).rstctl().write(|w| {
+            w.set_resetstkyclr(true);
+            w.set_resetassert(true);
+            w.set_key(vals::ResetKey::KEY);
+        });
+
+        regs.gprcm(0).pwren().write(|w| {
+            w.set_enable(true);
+            w.set_key(vals::PwrenKey::KEY);
+        });
+
+        self.info.interrupt.disable();
+
+        // Init delay from the M0 examples by TI in CCStudio (16 cycles)
+        cortex_m::asm::delay(16);
+
+        // Select and configure the I2C clock using the CLKSEL and CLKDIV registers
+        regs.clksel().write(|w| match config.clock_source {
+            ClockSel::BusClk => {
+                w.set_mfclk_sel(false);
+                w.set_busclk_sel(true);
+            }
+            ClockSel::MfClk => {
+                w.set_mfclk_sel(true);
+                w.set_busclk_sel(false);
+            }
+        });
+        regs.clkdiv().write(|w| w.set_ratio(config.clock_div.into()));
+
+        // Configure at least one target address by writing the 7-bit address to I2Cx.SOAR register. The additional
+        // target address can be enabled and configured by using I2Cx.TOAR2 register.
+        regs.target(0).toar().modify(|w| {
+            w.set_oaren(true);
+            w.set_oar(target_config.target_addr as u16);
+        });
+
+        self.state
+            .clock
+            .store(config.calculate_clock_source(), Ordering::Relaxed);
+
+        regs.target(0).tctr().modify(|w| {
+            w.set_gencall(target_config.general_call);
+            w.set_tclkstretch(true);
+            // Disable target wakeup, follow TI example. (TI note: Workaround for errata I2C_ERR_04.)
+            w.set_twuen(false);
+            w.set_txempty_on_treq(true);
+        });
+
+        // Enable the I2C target mode by setting the ACTIVE bit in I2Cx.TCTR register.
+        regs.target(0).tctr().modify(|w| {
+            w.set_active(true);
+        });
+
+        Ok(())
+    }
+
+    #[inline(always)]
+    fn drain_fifo(&mut self, buffer: &mut [u8], offset: &mut usize) {
+        let regs = self.info.regs;
+
+        for b in &mut buffer[*offset..] {
+            if regs.target(0).tfifosr().read().rxfifocnt() == 0 {
+                break;
+            }
+
+            *b = regs.target(0).trxdata().read().value();
+            *offset += 1;
+        }
+    }
+
+    /// Blocking function to empty the tx fifo
+    ///
+    /// This function can be used to empty the transmit FIFO if data remains after handling a 'read' command (LeftoverBytes).
+    pub fn flush_tx_fifo(&mut self) {
+        self.info.regs.target(0).tfifoctl().modify(|w| {
+            w.set_txflush(true);
+        });
+        while self.info.regs.target(0).tfifosr().read().txfifocnt() as usize != self.info.fifo_size {}
+        self.info.regs.target(0).tfifoctl().modify(|w| {
+            w.set_txflush(false);
+        });
+    }
+}
+
+impl<'d> I2cTarget<'d, Async> {
+    /// Wait asynchronously for commands from an I2C controller.
+    /// `buffer` is provided in case controller does a 'write', 'write read', or 'general call' and is unused for 'read'.
+    pub async fn listen(&mut self, buffer: &mut [u8]) -> Result<Command, Error> {
+        let regs = self.info.regs;
+
+        let mut len = 0;
+
+        // Set the rx fifo interrupt to avoid a fifo overflow
+        regs.target(0).tfifoctl().modify(|r| {
+            r.set_rxtrig(vals::TfifoctlRxtrig::LEVEL_6);
+        });
+
+        self.wait_on(
+            |me| {
+                // Check if address matches the General Call address (0x00)
+                let is_gencall = regs.target(0).tsr().read().addrmatch() == 0;
+
+                if regs.target(0).tfifosr().read().rxfifocnt() > 0 {
+                    me.drain_fifo(buffer, &mut len);
+                }
+
+                if buffer.len() == len && regs.target(0).tfifosr().read().rxfifocnt() > 0 {
+                    if is_gencall {
+                        return Poll::Ready(Err(Error::PartialGeneralCall(buffer.len())));
+                    } else {
+                        return Poll::Ready(Err(Error::PartialWrite(buffer.len())));
+                    }
+                }
+
+                let iidx = regs.cpu_int(0).iidx().read().stat();
+                trace!("ls:{} len:{}", iidx as u8, len);
+                let result = match iidx {
+                    CpuIntIidxStat::TTXEMPTY => match len {
+                        0 => Poll::Ready(Ok(Command::Read)),
+                        w => Poll::Ready(Ok(Command::WriteRead(w))),
+                    },
+                    CpuIntIidxStat::TSTOPFG => match (is_gencall, len) {
+                        (_, 0) => Poll::Pending,
+                        (true, w) => Poll::Ready(Ok(Command::GeneralCall(w))),
+                        (false, w) => Poll::Ready(Ok(Command::Write(w))),
+                    },
+                    _ => Poll::Pending,
+                };
+                if !result.is_pending() {
+                    regs.cpu_int(0).imask().write(|_| {});
+                }
+                result
+            },
+            |_me| {
+                regs.cpu_int(0).imask().write(|_| {});
+                regs.cpu_int(0).imask().modify(|w| {
+                    w.set_tgencall(true);
+                    w.set_trxfifotrg(true);
+                    w.set_tstop(true);
+                    w.set_ttxempty(true);
+                });
+            },
+        )
+        .await
+    }
+
+    /// Respond to an I2C controller 'read' command, asynchronously.
+    pub async fn respond_to_read(&mut self, buffer: &[u8]) -> Result<ReadStatus, Error> {
+        if buffer.is_empty() {
+            return Err(Error::InvalidResponseBufferLength);
+        }
+
+        let regs = self.info.regs;
+        let fifo_size = self.info.fifo_size;
+        let mut chunks = buffer.chunks(self.info.fifo_size);
+
+        self.wait_on(
+            |_me| {
+                if let Some(chunk) = chunks.next() {
+                    for byte in chunk {
+                        regs.target(0).ttxdata().write(|w| w.set_value(*byte));
+                    }
+
+                    return Poll::Pending;
+                }
+
+                let iidx = regs.cpu_int(0).iidx().read().stat();
+                let fifo_bytes = fifo_size - regs.target(0).tfifosr().read().txfifocnt() as usize;
+                trace!("rs:{}, fifo:{}", iidx as u8, fifo_bytes);
+
+                let result = match iidx {
+                    CpuIntIidxStat::TTXEMPTY => Poll::Ready(Ok(ReadStatus::NeedMoreBytes)),
+                    CpuIntIidxStat::TSTOPFG => match fifo_bytes {
+                        0 => Poll::Ready(Ok(ReadStatus::Done)),
+                        w => Poll::Ready(Ok(ReadStatus::LeftoverBytes(w as u16))),
+                    },
+                    _ => Poll::Pending,
+                };
+                if !result.is_pending() {
+                    regs.cpu_int(0).imask().write(|_| {});
+                }
+                result
+            },
+            |_me| {
+                regs.cpu_int(0).imask().write(|_| {});
+                regs.cpu_int(0).imask().modify(|w| {
+                    w.set_ttxempty(true);
+                    w.set_tstop(true);
+                });
+            },
+        )
+        .await
+    }
+
+    /// Respond to reads with the fill byte until the controller stops asking
+    pub async fn respond_till_stop(&mut self, fill: u8) -> Result<(), Error> {
+        // The buffer size could be increased to reduce interrupt noise but has higher probability
+        // of LeftoverBytes
+        let buff = [fill];
+        loop {
+            match self.respond_to_read(&buff).await {
+                Ok(ReadStatus::NeedMoreBytes) => (),
+                Ok(_) => break Ok(()),
+                Err(e) => break Err(e),
+            }
+        }
+    }
+
+    /// Respond to a controller read, then fill any remaining read bytes with `fill`
+    pub async fn respond_and_fill(&mut self, buffer: &[u8], fill: u8) -> Result<ReadStatus, Error> {
+        let resp_stat = self.respond_to_read(buffer).await?;
+
+        if resp_stat == ReadStatus::NeedMoreBytes {
+            self.respond_till_stop(fill).await?;
+            Ok(ReadStatus::Done)
+        } else {
+            Ok(resp_stat)
+        }
+    }
+
+    /// Calls `f` to check if we are ready or not.
+    /// If not, `g` is called once(to eg enable the required interrupts).
+    /// The waker will always be registered prior to calling `f`.
+    #[inline(always)]
+    async fn wait_on<F, U, G>(&mut self, mut f: F, mut g: G) -> U
+    where
+        F: FnMut(&mut Self) -> Poll<U>,
+        G: FnMut(&mut Self),
+    {
+        poll_fn(|cx| {
+            // Register prior to checking the condition
+            self.state.waker.register(cx.waker());
+            let r = f(self);
+
+            if r.is_pending() {
+                g(self);
+            }
+
+            r
+        })
+        .await
+    }
+}
+
+impl<'d, M: Mode> Drop for I2cTarget<'d, M> {
+    fn drop(&mut self) {
+        // Ensure peripheral is disabled and pins are reset
+        self.info.regs.target(0).tctr().modify(|w| w.set_active(false));
+
+        self.scl.as_ref().map(|x| x.set_as_disconnected());
+        self.sda.as_ref().map(|x| x.set_as_disconnected());
+    }
+}
diff --git a/embassy-mspm0/src/lib.rs b/embassy-mspm0/src/lib.rs
index 55f3f9381..9f3e4d5e8 100644
--- a/embassy-mspm0/src/lib.rs
+++ b/embassy-mspm0/src/lib.rs
@@ -18,6 +18,7 @@ pub mod adc;
 pub mod dma;
 pub mod gpio;
 pub mod i2c;
+pub mod i2c_target;
 pub mod timer;
 pub mod uart;
 pub mod wwdt;
@@ -233,3 +234,114 @@ impl Iterator for BitIter {
         }
     }
 }
+
+/// Reset cause values from SYSCTL.RSTCAUSE register.
+/// Based on MSPM0 L-series Technical Reference Manual Table 2-9 and
+/// MSPM0 G-series Technical Reference Manual Table 2-12.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum ResetCause {
+    /// No reset since last read
+    NoReset,
+    /// VDD < POR- violation, PMU trim parity fault, or SHUTDNSTOREx parity fault
+    PorHwFailure,
+    /// NRST pin reset (>1s)
+    PorExternalNrst,
+    /// Software-triggered POR
+    PorSwTriggered,
+    /// VDD < BOR- violation
+    BorSupplyFailure,
+    /// Wake from SHUTDOWN
+    BorWakeFromShutdown,
+    /// Non-PMU trim parity fault
+    #[cfg(not(any(
+        mspm0c110x,
+        mspm0c1105_c1106,
+        mspm0g110x,
+        mspm0g150x,
+        mspm0g151x,
+        mspm0g310x,
+        mspm0g350x,
+        mspm0g351x
+    )))]
+    BootrstNonPmuParityFault,
+    /// Fatal clock fault
+    BootrstClockFault,
+    /// Software-triggered BOOTRST
+    BootrstSwTriggered,
+    /// NRST pin reset (<1s)
+    BootrstExternalNrst,
+    /// WWDT0 violation
+    BootrstWwdt0Violation,
+    /// WWDT1 violation (G-series only)
+    #[cfg(any(mspm0g110x, mspm0g150x, mspm0g151x, mspm0g310x, mspm0g350x, mspm0g351x))]
+    SysrstWwdt1Violation,
+    /// BSL exit (if present)
+    SysrstBslExit,
+    /// BSL entry (if present)
+    SysrstBslEntry,
+    /// Uncorrectable flash ECC error (if present)
+    #[cfg(not(any(mspm0c110x, mspm0c1105_c1106, mspm0g351x, mspm0g151x)))]
+    SysrstFlashEccError,
+    /// CPU lockup violation
+    SysrstCpuLockupViolation,
+    /// Debug-triggered SYSRST
+    SysrstDebugTriggered,
+    /// Software-triggered SYSRST
+    SysrstSwTriggered,
+    /// Debug-triggered CPURST
+    CpurstDebugTriggered,
+    /// Software-triggered CPURST
+    CpurstSwTriggered,
+}
+
+/// Read the reset cause from the SYSCTL.RSTCAUSE register.
+///
+/// This function reads the reset cause register which indicates why the last
+/// system reset occurred. The register is automatically cleared after being read,
+/// so this should be called only once per application startup.
+///
+/// If the reset cause is not recognized, an `Err` containing the raw value is returned.
+#[must_use = "Reading reset cause will clear it"]
+pub fn read_reset_cause() -> Result<ResetCause, u8> {
+    let cause_raw = pac::SYSCTL.rstcause().read().id();
+
+    use ResetCause::*;
+    use pac::sysctl::vals::Id;
+
+    match cause_raw {
+        Id::NORST => Ok(NoReset),
+        Id::PORHWFAIL => Ok(PorHwFailure),
+        Id::POREXNRST => Ok(PorExternalNrst),
+        Id::PORSW => Ok(PorSwTriggered),
+        Id::BORSUPPLY => Ok(BorSupplyFailure),
+        Id::BORWAKESHUTDN => Ok(BorWakeFromShutdown),
+        #[cfg(not(any(
+            mspm0c110x,
+            mspm0c1105_c1106,
+            mspm0g110x,
+            mspm0g150x,
+            mspm0g151x,
+            mspm0g310x,
+            mspm0g350x,
+            mspm0g351x
+        )))]
+        Id::BOOTNONPMUPARITY => Ok(BootrstNonPmuParityFault),
+        Id::BOOTCLKFAIL => Ok(BootrstClockFault),
+        Id::BOOTSW => Ok(BootrstSwTriggered),
+        Id::BOOTEXNRST => Ok(BootrstExternalNrst),
+        Id::BOOTWWDT0 => Ok(BootrstWwdt0Violation),
+        Id::SYSBSLEXIT => Ok(SysrstBslExit),
+        Id::SYSBSLENTRY => Ok(SysrstBslEntry),
+        #[cfg(any(mspm0g110x, mspm0g150x, mspm0g151x, mspm0g310x, mspm0g350x, mspm0g351x))]
+        Id::SYSWWDT1 => Ok(SysrstWwdt1Violation),
+        #[cfg(not(any(mspm0c110x, mspm0c1105_c1106, mspm0g351x, mspm0g151x)))]
+        Id::SYSFLASHECC => Ok(SysrstFlashEccError),
+        Id::SYSCPULOCK => Ok(SysrstCpuLockupViolation),
+        Id::SYSDBG => Ok(SysrstDebugTriggered),
+        Id::SYSSW => Ok(SysrstSwTriggered),
+        Id::CPUDBG => Ok(CpurstDebugTriggered),
+        Id::CPUSW => Ok(CpurstSwTriggered),
+        other => Err(other as u8),
+    }
+}
diff --git a/embassy-net-esp-hosted/CHANGELOG.md b/embassy-net-esp-hosted/CHANGELOG.md
index 5153e3799..d8b912295 100644
--- a/embassy-net-esp-hosted/CHANGELOG.md
+++ b/embassy-net-esp-hosted/CHANGELOG.md
@@ -8,6 +8,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- Add an `Interface` trait to allow using other interface transports.
+- Switch to `micropb` for protobuf.
+- Update protos to latest `esp-hosted-fg`.
+
 ## 0.2.1 - 2025-08-26
 
 - First release with changelog.
diff --git a/embassy-net-esp-hosted/Cargo.toml b/embassy-net-esp-hosted/Cargo.toml
index f148f4762..81096b024 100644
--- a/embassy-net-esp-hosted/Cargo.toml
+++ b/embassy-net-esp-hosted/Cargo.toml
@@ -25,7 +25,7 @@ embassy-net-driver-channel = { version = "0.3.2", path = "../embassy-net-driver-
 embedded-hal = { version = "1.0" }
 embedded-hal-async = { version = "1.0" }
 
-noproto = "0.1.0"
+micropb = { version = "0.4.0", default-features = false, features = ["container-heapless", "encode", "decode"] }
 heapless = "0.8"
 
 [package.metadata.embassy_docs]
diff --git a/embassy-net-esp-hosted/src/control.rs b/embassy-net-esp-hosted/src/control.rs
index cbc194877..38ec648b4 100644
--- a/embassy-net-esp-hosted/src/control.rs
+++ b/embassy-net-esp-hosted/src/control.rs
@@ -1,6 +1,7 @@
 use embassy_net_driver_channel as ch;
 use embassy_net_driver_channel::driver::{HardwareAddress, LinkState};
 use heapless::String;
+use micropb::{MessageDecode, MessageEncode, PbEncoder};
 
 use crate::ioctl::Shared;
 use crate::proto::{self, CtrlMsg};
@@ -38,7 +39,7 @@ enum WifiMode {
     ApSta = 3,
 }
 
-pub use proto::CtrlWifiSecProt as Security;
+pub use proto::Ctrl_WifiSecProt as Security;
 
 /// WiFi status.
 #[derive(Clone, Debug)]
@@ -59,18 +60,20 @@ pub struct Status {
 macro_rules! ioctl {
     ($self:ident, $req_variant:ident, $resp_variant:ident, $req:ident, $resp:ident) => {
         let mut msg = proto::CtrlMsg {
-            msg_id: proto::CtrlMsgId::$req_variant as _,
-            msg_type: proto::CtrlMsgType::Req as _,
-            payload: Some(proto::CtrlMsgPayload::$req_variant($req)),
+            msg_id: proto::CtrlMsgId::$req_variant,
+            msg_type: proto::CtrlMsgType::Req,
+            payload: Some(proto::CtrlMsg_::Payload::$req_variant($req)),
+            req_resp_type: 0,
+            uid: 0,
         };
         $self.ioctl(&mut msg).await?;
         #[allow(unused_mut)]
-        let Some(proto::CtrlMsgPayload::$resp_variant(mut $resp)) = msg.payload else {
+        let Some(proto::CtrlMsg_::Payload::$resp_variant(mut $resp)) = msg.payload else {
             warn!("unexpected response variant");
             return Err(Error::Internal);
         };
         if $resp.resp != 0 {
-            return Err(Error::Failed($resp.resp));
+            return Err(Error::Failed($resp.resp as u32));
         }
     };
 }
@@ -100,35 +103,44 @@ impl<'a> Control<'a> {
 
     /// Get the current status.
     pub async fn get_status(&mut self) -> Result<Status, Error> {
-        let req = proto::CtrlMsgReqGetApConfig {};
+        let req = proto::CtrlMsg_Req_GetAPConfig {};
         ioctl!(self, ReqGetApConfig, RespGetApConfig, req, resp);
-        trim_nulls(&mut resp.ssid);
+        let ssid = core::str::from_utf8(&resp.ssid).map_err(|_| Error::Internal)?;
+        let ssid = String::try_from(ssid.trim_end_matches('\0')).map_err(|_| Error::Internal)?;
+        let bssid_str = core::str::from_utf8(&resp.bssid).map_err(|_| Error::Internal)?;
         Ok(Status {
-            ssid: resp.ssid,
-            bssid: parse_mac(&resp.bssid)?,
+            ssid,
+            bssid: parse_mac(bssid_str)?,
             rssi: resp.rssi as _,
-            channel: resp.chnl,
+            channel: resp.chnl as u32,
             security: resp.sec_prot,
         })
     }
 
     /// Connect to the network identified by ssid using the provided password.
     pub async fn connect(&mut self, ssid: &str, password: &str) -> Result<(), Error> {
-        let req = proto::CtrlMsgReqConnectAp {
+        const WIFI_BAND_MODE_AUTO: i32 = 3; // 2.4GHz + 5GHz
+
+        let req = proto::CtrlMsg_Req_ConnectAP {
             ssid: unwrap!(String::try_from(ssid)),
             pwd: unwrap!(String::try_from(password)),
             bssid: String::new(),
             listen_interval: 3,
             is_wpa3_supported: true,
+            band_mode: WIFI_BAND_MODE_AUTO,
         };
         ioctl!(self, ReqConnectAp, RespConnectAp, req, resp);
+
+        // TODO: in newer esp-hosted firmwares that added EventStationConnectedToAp
+        // the connect ioctl seems to be async, so we shouldn't immediately set LinkState::Up here.
         self.state_ch.set_link_state(LinkState::Up);
+
         Ok(())
     }
 
     /// Disconnect from any currently connected network.
     pub async fn disconnect(&mut self) -> Result<(), Error> {
-        let req = proto::CtrlMsgReqGetStatus {};
+        let req = proto::CtrlMsg_Req_GetStatus {};
         ioctl!(self, ReqDisconnectAp, RespDisconnectAp, req, resp);
         self.state_ch.set_link_state(LinkState::Down);
         Ok(())
@@ -136,21 +148,25 @@ impl<'a> Control<'a> {
 
     /// duration in seconds, clamped to [10, 3600]
     async fn set_heartbeat(&mut self, duration: u32) -> Result<(), Error> {
-        let req = proto::CtrlMsgReqConfigHeartbeat { enable: true, duration };
+        let req = proto::CtrlMsg_Req_ConfigHeartbeat {
+            enable: true,
+            duration: duration as i32,
+        };
         ioctl!(self, ReqConfigHeartbeat, RespConfigHeartbeat, req, resp);
         Ok(())
     }
 
     async fn get_mac_addr(&mut self) -> Result<[u8; 6], Error> {
-        let req = proto::CtrlMsgReqGetMacAddress {
+        let req = proto::CtrlMsg_Req_GetMacAddress {
             mode: WifiMode::Sta as _,
         };
         ioctl!(self, ReqGetMacAddress, RespGetMacAddress, req, resp);
-        parse_mac(&resp.mac)
+        let mac_str = core::str::from_utf8(&resp.mac).map_err(|_| Error::Internal)?;
+        parse_mac(mac_str)
     }
 
     async fn set_wifi_mode(&mut self, mode: u32) -> Result<(), Error> {
-        let req = proto::CtrlMsgReqSetMode { mode };
+        let req = proto::CtrlMsg_Req_SetMode { mode: mode as i32 };
         ioctl!(self, ReqSetWifiMode, RespSetWifiMode, req, resp);
 
         Ok(())
@@ -160,11 +176,15 @@ impl<'a> Control<'a> {
         debug!("ioctl req: {:?}", &msg);
 
         let mut buf = [0u8; 128];
+        let buf_len = buf.len();
 
-        let req_len = noproto::write(msg, &mut buf).map_err(|_| {
+        let mut encoder = PbEncoder::new(&mut buf[..]);
+        msg.encode(&mut encoder).map_err(|_| {
             warn!("failed to serialize control request");
             Error::Internal
         })?;
+        let remaining = encoder.into_writer();
+        let req_len = buf_len - remaining.len();
 
         struct CancelOnDrop<'a>(&'a Shared);
 
@@ -186,8 +206,8 @@ impl<'a> Control<'a> {
 
         ioctl.defuse();
 
-        *msg = noproto::read(&buf[..resp_len]).map_err(|_| {
-            warn!("failed to serialize control request");
+        msg.decode_from_bytes(&buf[..resp_len]).map_err(|_| {
+            warn!("failed to deserialize control response");
             Error::Internal
         })?;
         debug!("ioctl resp: {:?}", msg);
@@ -221,9 +241,3 @@ fn parse_mac(mac: &str) -> Result<[u8; 6], Error> {
     }
     Ok(res)
 }
-
-fn trim_nulls<const N: usize>(s: &mut String<N>) {
-    while s.chars().rev().next() == Some(0 as char) {
-        s.pop();
-    }
-}
diff --git a/embassy-net-esp-hosted/src/esp_hosted_config.proto b/embassy-net-esp-hosted/src/esp_hosted_config.proto
index aa1bfde64..7d626207e 100644
--- a/embassy-net-esp-hosted/src/esp_hosted_config.proto
+++ b/embassy-net-esp-hosted/src/esp_hosted_config.proto
@@ -1,3 +1,6 @@
+/* Copyright (C) 2015-2025 Espressif Systems (Shanghai) PTE LTD */
+/* SPDX-License-Identifier: GPL-2.0-only OR Apache-2.0 */
+
 syntax = "proto3";
 
 /* Enums similar to ESP IDF */
@@ -28,9 +31,10 @@ enum Ctrl_WifiBw {
 }
 
 enum Ctrl_WifiPowerSave {
-    PS_Invalid = 0;
+    NO_PS = 0;
     MIN_MODEM = 1;
     MAX_MODEM = 2;
+    PS_Invalid = 3;
 }
 
 enum Ctrl_WifiSecProt {
@@ -96,9 +100,16 @@ enum CtrlMsgId {
     Req_GetWifiCurrTxPower = 120;
 
     Req_ConfigHeartbeat = 121;
+    Req_EnableDisable = 122;
+    Req_GetFwVersion = 123;
+    Req_SetCountryCode = 124;
+    Req_GetCountryCode = 125;
+    Req_SetDhcpDnsStatus = 126;
+    Req_GetDhcpDnsStatus = 127;
+    Req_Custom_RPC_Unserialised_Msg = 128;
     /* Add new control path command response before Req_Max
      * and update Req_Max */
-    Req_Max = 122;
+    Req_Max = 129;
 
     /** Response Msgs **/
     Resp_Base = 200;
@@ -130,9 +141,16 @@ enum CtrlMsgId {
     Resp_GetWifiCurrTxPower = 220;
 
     Resp_ConfigHeartbeat = 221;
+    Resp_EnableDisable = 222;
+    Resp_GetFwVersion = 223;
+    Resp_SetCountryCode = 224;
+    Resp_GetCountryCode = 225;
+    Resp_SetDhcpDnsStatus = 226;
+    Resp_GetDhcpDnsStatus = 227;
+    Resp_Custom_RPC_Unserialised_Msg = 228;
     /* Add new control path command response before Resp_Max
      * and update Resp_Max */
-    Resp_Max = 222;
+    Resp_Max = 229;
 
     /** Event Msgs **/
     Event_Base = 300;
@@ -140,9 +158,22 @@ enum CtrlMsgId {
     Event_Heartbeat = 302;
     Event_StationDisconnectFromAP = 303;
     Event_StationDisconnectFromESPSoftAP = 304;
+    Event_StationConnectedToAP = 305;
+    Event_StationConnectedToESPSoftAP = 306;
+    Event_SetDhcpDnsStatus = 307;
+    Event_Custom_RPC_Unserialised_Msg = 308;
     /* Add new control path command notification before Event_Max
      * and update Event_Max */
-    Event_Max = 305;
+    Event_Max = 309;
+}
+
+enum HostedFeature {
+    Hosted_InvalidFeature = 0;
+    Hosted_Wifi = 1;
+    Hosted_Bluetooth = 2;
+    Hosted_Is_Network_Split_On = 3;
+
+    /* Add your new features here and re-build prot using build_proto.sh */
 }
 
 /* internal supporting structures for CtrlMsg */
@@ -213,6 +244,7 @@ message CtrlMsg_Resp_GetAPConfig {
     int32 chnl = 4;
     Ctrl_WifiSecProt sec_prot = 5;
     int32 resp = 6;
+    int32 band_mode = 7;
 }
 
 message CtrlMsg_Req_ConnectAP {
@@ -221,11 +253,13 @@ message CtrlMsg_Req_ConnectAP {
     string bssid = 3;
     bool is_wpa3_supported = 4;
     int32 listen_interval = 5;
+    int32 band_mode = 6;
 }
 
 message  CtrlMsg_Resp_ConnectAP {
     int32 resp = 1;
     bytes mac = 2;
+    int32 band_mode = 3;
 }
 
 message CtrlMsg_Req_GetSoftAPConfig {
@@ -240,6 +274,7 @@ message CtrlMsg_Resp_GetSoftAPConfig {
     bool ssid_hidden = 6;
     int32 bw = 7;
     int32 resp = 8;
+    int32 band_mode = 9;
 }
 
 message CtrlMsg_Req_StartSoftAP {
@@ -250,11 +285,13 @@ message CtrlMsg_Req_StartSoftAP {
     int32 max_conn = 5;
     bool ssid_hidden = 6;
     int32 bw = 7;
+    int32 band_mode = 8;
 }
 
 message CtrlMsg_Resp_StartSoftAP {
     int32 resp = 1;
     bytes mac = 2;
+    int32 band_mode = 3;
 }
 
 message CtrlMsg_Req_ScanResult {
@@ -302,7 +339,7 @@ message CtrlMsg_Req_VendorIEData {
     int32 length = 2;
     bytes vendor_oui = 3;
     int32 vendor_oui_type = 4;
-    bytes payload = 5; 
+    bytes payload = 5;
 }
 
 message CtrlMsg_Req_SetSoftAPVendorSpecificIE {
@@ -341,6 +378,81 @@ message CtrlMsg_Resp_ConfigHeartbeat {
     int32 resp = 1;
 }
 
+message CtrlMsg_Req_EnableDisable {
+    uint32 feature = 1;
+    bool enable = 2;
+}
+
+message CtrlMsg_Resp_EnableDisable {
+    int32 resp = 1;
+}
+
+message CtrlMsg_Req_GetFwVersion {
+}
+
+message CtrlMsg_Resp_GetFwVersion {
+    int32 resp = 1;
+    string name = 2;
+    uint32 major1 = 3;
+    uint32 major2 = 4;
+    uint32 minor = 5;
+    uint32 rev_patch1 = 6;
+    uint32 rev_patch2 = 7;
+}
+
+message CtrlMsg_Req_SetCountryCode {
+    bytes country = 1;
+    bool ieee80211d_enabled = 2;
+}
+
+message CtrlMsg_Resp_SetCountryCode {
+    int32 resp = 1;
+}
+
+message CtrlMsg_Req_GetCountryCode {
+}
+
+message CtrlMsg_Resp_GetCountryCode {
+    int32 resp = 1;
+    bytes country = 2;
+}
+
+message CtrlMsg_Req_SetDhcpDnsStatus {
+      int32 iface = 1;
+      int32 net_link_up = 2;
+
+      int32 dhcp_up = 3;
+      bytes dhcp_ip = 4;
+      bytes dhcp_nm = 5;
+      bytes dhcp_gw = 6;
+
+      int32 dns_up = 7;
+      bytes dns_ip = 8;
+      int32 dns_type = 9;
+}
+
+message CtrlMsg_Resp_SetDhcpDnsStatus {
+      int32 resp = 1;
+}
+
+message CtrlMsg_Req_GetDhcpDnsStatus {
+}
+
+message CtrlMsg_Resp_GetDhcpDnsStatus {
+      int32 resp = 1;
+      int32 iface = 2;
+      int32 net_link_up = 3;
+
+      int32 dhcp_up = 4;
+      bytes dhcp_ip = 5;
+      bytes dhcp_nm = 6;
+      bytes dhcp_gw = 7;
+
+      int32 dns_up = 8;
+      bytes dns_ip = 9;
+      int32 dns_type = 10;
+}
+
 /** Event structure **/
 message CtrlMsg_Event_ESPInit {
     bytes init_data = 1;
@@ -352,11 +464,70 @@ message CtrlMsg_Event_Heartbeat {
 
 message CtrlMsg_Event_StationDisconnectFromAP {
     int32 resp = 1;
+    bytes ssid = 2;
+    uint32 ssid_len = 3;
+    bytes bssid = 4;
+    uint32 reason = 5;
+    int32 rssi = 6;
 }
 
+message CtrlMsg_Event_StationConnectedToAP {
+    int32 resp = 1;
+    bytes ssid = 2;
+    uint32 ssid_len = 3;
+    bytes bssid = 4;
+    uint32 channel = 5;
+    int32 authmode = 6;
+    int32 aid = 7;
+}
+
+
 message CtrlMsg_Event_StationDisconnectFromESPSoftAP {
     int32 resp = 1;
     bytes mac = 2;
+    uint32 aid = 3;
+    bool is_mesh_child = 4;
+    uint32 reason = 5;
+}
+
+message CtrlMsg_Event_StationConnectedToESPSoftAP {
+    int32 resp = 1;
+    bytes mac = 2;
+    uint32 aid = 3;
+    bool is_mesh_child = 4;
+}
+
+message CtrlMsg_Event_SetDhcpDnsStatus {
+      int32 iface = 1;
+      int32 net_link_up = 2;
+
+      int32 dhcp_up = 3;
+      bytes dhcp_ip = 4;
+      bytes dhcp_nm = 5;
+      bytes dhcp_gw = 6;
+
+      int32 dns_up = 7;
+      bytes dns_ip = 8;
+      int32 dns_type = 9;
+      int32 resp = 10;
+}
+
+/* Add Custom RPC message structures after existing message structures to make it easily notice */
+message CtrlMsg_Req_CustomRpcUnserialisedMsg {
+    uint32 custom_msg_id = 1;
+    bytes data = 2;
+}
+
+message CtrlMsg_Resp_CustomRpcUnserialisedMsg {
+    int32 resp = 1;
+    uint32 custom_msg_id = 2;
+    bytes data = 3;
+}
+
+message CtrlMsg_Event_CustomRpcUnserialisedMsg {
+    int32 resp = 1;
+    uint32 custom_evt_id = 2;
+    bytes data = 3;
 }
 
 message CtrlMsg {
@@ -366,6 +537,12 @@ message CtrlMsg {
     /* msg id */
     CtrlMsgId msg_id = 2;
 
+    /* UID of message */
+    int32 uid = 3;
+
+    /* Request/response type: sync or async */
+    uint32 req_resp_type = 4;
+
     /* union of all msg ids */
     oneof payload {
         /** Requests **/
@@ -395,6 +572,13 @@ message CtrlMsg {
         CtrlMsg_Req_SetWifiMaxTxPower req_set_wifi_max_tx_power = 119;
         CtrlMsg_Req_GetWifiCurrTxPower req_get_wifi_curr_tx_power = 120;
         CtrlMsg_Req_ConfigHeartbeat req_config_heartbeat = 121;
+        CtrlMsg_Req_EnableDisable req_enable_disable_feat = 122;
+        CtrlMsg_Req_GetFwVersion req_get_fw_version = 123;
+        CtrlMsg_Req_SetCountryCode req_set_country_code = 124;
+        CtrlMsg_Req_GetCountryCode req_get_country_code = 125;
+        CtrlMsg_Req_SetDhcpDnsStatus req_set_dhcp_dns_status = 126;
+        CtrlMsg_Req_GetDhcpDnsStatus req_get_dhcp_dns_status = 127;
+        CtrlMsg_Req_CustomRpcUnserialisedMsg req_custom_rpc_unserialised_msg = 128;
 
         /** Responses **/
         CtrlMsg_Resp_GetMacAddress resp_get_mac_address = 201;
@@ -422,11 +606,22 @@ message CtrlMsg {
         CtrlMsg_Resp_SetWifiMaxTxPower resp_set_wifi_max_tx_power = 219;
         CtrlMsg_Resp_GetWifiCurrTxPower resp_get_wifi_curr_tx_power = 220;
         CtrlMsg_Resp_ConfigHeartbeat resp_config_heartbeat = 221;
+        CtrlMsg_Resp_EnableDisable resp_enable_disable_feat = 222;
+        CtrlMsg_Resp_GetFwVersion resp_get_fw_version = 223;
+        CtrlMsg_Resp_SetCountryCode resp_set_country_code = 224;
+        CtrlMsg_Resp_GetCountryCode resp_get_country_code = 225;
+        CtrlMsg_Resp_SetDhcpDnsStatus resp_set_dhcp_dns_status = 226;
+        CtrlMsg_Resp_GetDhcpDnsStatus resp_get_dhcp_dns_status = 227;
+        CtrlMsg_Resp_CustomRpcUnserialisedMsg resp_custom_rpc_unserialised_msg = 228;
 
         /** Notifications **/
         CtrlMsg_Event_ESPInit event_esp_init = 301;
         CtrlMsg_Event_Heartbeat event_heartbeat = 302;
         CtrlMsg_Event_StationDisconnectFromAP event_station_disconnect_from_AP = 303;
         CtrlMsg_Event_StationDisconnectFromESPSoftAP event_station_disconnect_from_ESP_SoftAP = 304;
+        CtrlMsg_Event_StationConnectedToAP event_station_connected_to_AP = 305;
+        CtrlMsg_Event_StationConnectedToESPSoftAP event_station_connected_to_ESP_SoftAP = 306;
+        CtrlMsg_Event_SetDhcpDnsStatus event_set_dhcp_dns_status = 307;
+        CtrlMsg_Event_CustomRpcUnserialisedMsg event_custom_rpc_unserialised_msg = 308;
     }
 }
diff --git a/embassy-net-esp-hosted/src/iface.rs b/embassy-net-esp-hosted/src/iface.rs
new file mode 100644
index 000000000..1f57851e0
--- /dev/null
+++ b/embassy-net-esp-hosted/src/iface.rs
@@ -0,0 +1,62 @@
+use embassy_time::Timer;
+use embedded_hal::digital::InputPin;
+use embedded_hal_async::digital::Wait;
+use embedded_hal_async::spi::SpiDevice;
+
+/// Physical interface trait for communicating with the ESP chip.
+pub trait Interface {
+    /// Wait for the HANDSHAKE signal indicating the ESP is ready for a new transaction.
+    async fn wait_for_handshake(&mut self);
+
+    /// Wait for the READY signal indicating the ESP has data to send.
+    async fn wait_for_ready(&mut self);
+
+    /// Perform a SPI transfer, exchanging data with the ESP chip.
+    async fn transfer(&mut self, rx: &mut [u8], tx: &[u8]);
+}
+
+/// Standard SPI interface.
+///
+/// This interface is what's implemented in the upstream `esp-hosted-fg` firmware. It uses:
+/// - An `SpiDevice` for SPI communication (CS is handled by the device)
+/// - A handshake pin that signals when the ESP is ready for a new transaction
+/// - A ready pin that indicates when the ESP has data to send
+pub struct SpiInterface<SPI, IN> {
+    spi: SPI,
+    handshake: IN,
+    ready: IN,
+}
+
+impl<SPI, IN> SpiInterface<SPI, IN>
+where
+    SPI: SpiDevice,
+    IN: InputPin + Wait,
+{
+    /// Create a new SpiInterface.
+    pub fn new(spi: SPI, handshake: IN, ready: IN) -> Self {
+        Self { spi, handshake, ready }
+    }
+}
+
+impl<SPI, IN> Interface for SpiInterface<SPI, IN>
+where
+    SPI: SpiDevice,
+    IN: InputPin + Wait,
+{
+    async fn wait_for_handshake(&mut self) {
+        self.handshake.wait_for_high().await.unwrap();
+    }
+
+    async fn wait_for_ready(&mut self) {
+        self.ready.wait_for_high().await.unwrap();
+    }
+
+    async fn transfer(&mut self, rx: &mut [u8], tx: &[u8]) {
+        self.spi.transfer(rx, tx).await.unwrap();
+
+        // The esp-hosted firmware deasserts the HANDSHAKE pin a few us AFTER ending the SPI transfer
+        // If we check it again too fast, we'll see it's high from the previous transfer, and if we send it
+        // data it will get lost.
+        Timer::after_micros(100).await;
+    }
+}
diff --git a/embassy-net-esp-hosted/src/lib.rs b/embassy-net-esp-hosted/src/lib.rs
index 4405d9f77..d882af8cf 100644
--- a/embassy-net-esp-hosted/src/lib.rs
+++ b/embassy-net-esp-hosted/src/lib.rs
@@ -1,27 +1,34 @@
 #![no_std]
 #![doc = include_str!("../README.md")]
 #![warn(missing_docs)]
+#![allow(async_fn_in_trait)]
 
 use embassy_futures::select::{Either4, select4};
 use embassy_net_driver_channel as ch;
 use embassy_net_driver_channel::driver::LinkState;
 use embassy_time::{Duration, Instant, Timer};
-use embedded_hal::digital::{InputPin, OutputPin};
-use embedded_hal_async::digital::Wait;
-use embedded_hal_async::spi::SpiDevice;
+use embedded_hal::digital::OutputPin;
 
 use crate::ioctl::{PendingIoctl, Shared};
-use crate::proto::{CtrlMsg, CtrlMsgPayload};
+use crate::proto::{CtrlMsg, CtrlMsg_};
 
+#[allow(unused)]
+#[allow(non_snake_case)]
+#[allow(non_camel_case_types)]
+#[allow(non_upper_case_globals)]
+#[allow(missing_docs)]
+#[allow(clippy::all)]
 mod proto;
 
 // must be first
 mod fmt;
 
 mod control;
+mod iface;
 mod ioctl;
 
 pub use control::*;
+pub use iface::*;
 
 const MTU: usize = 1514;
 
@@ -118,20 +125,17 @@ impl State {
 /// Type alias for network driver.
 pub type NetDriver<'a> = ch::Device<'a, MTU>;
 
-/// Create a new esp-hosted driver using the provided state, SPI peripheral and pins.
+/// Create a new esp-hosted driver using the provided state, interface, and reset pin.
 ///
 /// Returns a device handle for interfacing with embassy-net, a control handle for
 /// interacting with the driver, and a runner for communicating with the WiFi device.
-pub async fn new<'a, SPI, IN, OUT>(
+pub async fn new<'a, I, OUT>(
     state: &'a mut State,
-    spi: SPI,
-    handshake: IN,
-    ready: IN,
+    iface: I,
     reset: OUT,
-) -> (NetDriver<'a>, Control<'a>, Runner<'a, SPI, IN, OUT>)
+) -> (NetDriver<'a>, Control<'a>, Runner<'a, I, OUT>)
 where
-    SPI: SpiDevice,
-    IN: InputPin + Wait,
+    I: Interface,
     OUT: OutputPin,
 {
     let (ch_runner, device) = ch::new(&mut state.ch, ch::driver::HardwareAddress::Ethernet([0; 6]));
@@ -142,10 +146,8 @@ where
         state_ch,
         shared: &state.shared,
         next_seq: 1,
-        handshake,
-        ready,
         reset,
-        spi,
+        iface,
         heartbeat_deadline: Instant::now() + HEARTBEAT_MAX_GAP,
     };
 
@@ -153,7 +155,7 @@ where
 }
 
 /// Runner for communicating with the WiFi device.
-pub struct Runner<'a, SPI, IN, OUT> {
+pub struct Runner<'a, I, OUT> {
     ch: ch::Runner<'a, MTU>,
     state_ch: ch::StateRunner<'a>,
     shared: &'a Shared,
@@ -161,16 +163,13 @@ pub struct Runner<'a, SPI, IN, OUT> {
     next_seq: u16,
     heartbeat_deadline: Instant,
 
-    spi: SPI,
-    handshake: IN,
-    ready: IN,
+    iface: I,
     reset: OUT,
 }
 
-impl<'a, SPI, IN, OUT> Runner<'a, SPI, IN, OUT>
+impl<'a, I, OUT> Runner<'a, I, OUT>
 where
-    SPI: SpiDevice,
-    IN: InputPin + Wait,
+    I: Interface,
     OUT: OutputPin,
 {
     /// Run the packet processing.
@@ -185,11 +184,11 @@ where
         let mut rx_buf = [0u8; MAX_SPI_BUFFER_SIZE];
 
         loop {
-            self.handshake.wait_for_high().await.unwrap();
+            self.iface.wait_for_handshake().await;
 
             let ioctl = self.shared.ioctl_wait_pending();
             let tx = self.ch.tx_buf();
-            let ev = async { self.ready.wait_for_high().await.unwrap() };
+            let ev = async { self.iface.wait_for_ready().await };
             let hb = Timer::at(self.heartbeat_deadline);
 
             match select4(ioctl, tx, ev, hb).await {
@@ -243,15 +242,9 @@ where
                 trace!("tx: {:02x}", &tx_buf[..40]);
             }
 
-            self.spi.transfer(&mut rx_buf, &tx_buf).await.unwrap();
+            self.iface.transfer(&mut rx_buf, &tx_buf).await;
 
-            // The esp-hosted firmware deasserts the HANSHAKE pin a few us AFTER ending the SPI transfer
-            // If we check it again too fast, we'll see it's high from the previous transfer, and if we send it
-            // data it will get lost.
-            // Make sure we check it after 100us at minimum.
-            let delay_until = Instant::now() + Duration::from_micros(100);
             self.handle_rx(&mut rx_buf);
-            Timer::at(delay_until).await;
         }
     }
 
@@ -326,10 +319,12 @@ where
     }
 
     fn handle_event(&mut self, data: &[u8]) {
-        let Ok(event) = noproto::read::<CtrlMsg>(data) else {
+        use micropb::MessageDecode;
+        let mut event = CtrlMsg::default();
+        if event.decode_from_bytes(data).is_err() {
             warn!("failed to parse event");
             return;
-        };
+        }
 
         debug!("event: {:?}", &event);
 
@@ -339,9 +334,13 @@ where
         };
 
         match payload {
-            CtrlMsgPayload::EventEspInit(_) => self.shared.init_done(),
-            CtrlMsgPayload::EventHeartbeat(_) => self.heartbeat_deadline = Instant::now() + HEARTBEAT_MAX_GAP,
-            CtrlMsgPayload::EventStationDisconnectFromAp(e) => {
+            CtrlMsg_::Payload::EventEspInit(_) => self.shared.init_done(),
+            CtrlMsg_::Payload::EventHeartbeat(_) => self.heartbeat_deadline = Instant::now() + HEARTBEAT_MAX_GAP,
+            CtrlMsg_::Payload::EventStationConnectedToAp(e) => {
+                info!("connected, code {}", e.resp);
+                self.state_ch.set_link_state(LinkState::Up);
+            }
+            CtrlMsg_::Payload::EventStationDisconnectFromAp(e) => {
                 info!("disconnected, code {}", e.resp);
                 self.state_ch.set_link_state(LinkState::Down);
             }
diff --git a/embassy-net-esp-hosted/src/proto.rs b/embassy-net-esp-hosted/src/proto.rs
index 089ded677..74c67bd61 100644
--- a/embassy-net-esp-hosted/src/proto.rs
+++ b/embassy-net-esp-hosted/src/proto.rs
@@ -1,656 +1,13764 @@
-#![allow(unused)]
+/*
+Generated with the following snippet.
+Switch to a proper script when https://github.com/YuhanLiin/micropb/issues/30 is done
 
-use heapless::{String, Vec};
+    let mut g = micropb_gen::Generator::new();
+    g.use_container_heapless();
 
-/// internal supporting structures for CtrlMsg
+    g.configure(
+        ".",
+        micropb_gen::Config::new()
+            .max_bytes(32) // For ssid, mac, etc - strings
+            .max_len(16) // For repeated fields
+            .type_attributes("#[cfg_attr(feature = \"defmt\", derive(defmt::Format))]"),
+    );
 
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct ScanResult {
-    #[noproto(tag = "1")]
-    pub ssid: String<32>,
-    #[noproto(tag = "2")]
-    pub chnl: u32,
-    #[noproto(tag = "3")]
-    pub rssi: u32,
-    #[noproto(tag = "4")]
-    pub bssid: String<32>,
-    #[noproto(tag = "5")]
-    pub sec_prot: CtrlWifiSecProt,
-}
+    // Special config for things that need to be larger
+    g.configure(
+        ".CtrlMsg_Req_OTAWrite.ota_data",
+        micropb_gen::Config::new().max_bytes(1024),
+    );
+    g.configure(
+        ".CtrlMsg_Event_ESPInit.init_data",
+        micropb_gen::Config::new().max_bytes(64),
+    );
+    g.configure(
+        ".CtrlMsg_Req_VendorIEData.payload",
+        micropb_gen::Config::new().max_bytes(64),
+    );
+
+    g.compile_protos(&["src/esp_hosted_config.proto"], format!("{}/proto.rs", out_dir))
+        .unwrap();
+
+*/
 
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct ConnectedStaList {
-    #[noproto(tag = "1")]
-    pub mac: String<32>,
-    #[noproto(tag = "2")]
-    pub rssi: u32,
+pub struct ScanResult {
+    pub r#ssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#chnl: u32,
+    pub r#rssi: i32,
+    pub r#bssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#sec_prot: Ctrl_WifiSecProt,
 }
-/// * Req/Resp structure *
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ScanResult {
+    ///Return a reference to `ssid`
+    #[inline]
+    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#ssid
+    }
+    ///Return a mutable reference to `ssid`
+    #[inline]
+    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#ssid
+    }
+    ///Set the value of `ssid`
+    #[inline]
+    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Return a reference to `chnl`
+    #[inline]
+    pub fn r#chnl(&self) -> &u32 {
+        &self.r#chnl
+    }
+    ///Return a mutable reference to `chnl`
+    #[inline]
+    pub fn mut_chnl(&mut self) -> &mut u32 {
+        &mut self.r#chnl
+    }
+    ///Set the value of `chnl`
+    #[inline]
+    pub fn set_chnl(&mut self, value: u32) -> &mut Self {
+        self.r#chnl = value.into();
+        self
+    }
+    ///Builder method that sets the value of `chnl`. Useful for initializing the message.
+    #[inline]
+    pub fn init_chnl(mut self, value: u32) -> Self {
+        self.r#chnl = value.into();
+        self
+    }
+    ///Return a reference to `rssi`
+    #[inline]
+    pub fn r#rssi(&self) -> &i32 {
+        &self.r#rssi
+    }
+    ///Return a mutable reference to `rssi`
+    #[inline]
+    pub fn mut_rssi(&mut self) -> &mut i32 {
+        &mut self.r#rssi
+    }
+    ///Set the value of `rssi`
+    #[inline]
+    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
+        self.r#rssi = value.into();
+        self
+    }
+    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
+    #[inline]
+    pub fn init_rssi(mut self, value: i32) -> Self {
+        self.r#rssi = value.into();
+        self
+    }
+    ///Return a reference to `bssid`
+    #[inline]
+    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#bssid
+    }
+    ///Return a mutable reference to `bssid`
+    #[inline]
+    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#bssid
+    }
+    ///Set the value of `bssid`
+    #[inline]
+    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Return a reference to `sec_prot`
+    #[inline]
+    pub fn r#sec_prot(&self) -> &Ctrl_WifiSecProt {
+        &self.r#sec_prot
+    }
+    ///Return a mutable reference to `sec_prot`
+    #[inline]
+    pub fn mut_sec_prot(&mut self) -> &mut Ctrl_WifiSecProt {
+        &mut self.r#sec_prot
+    }
+    ///Set the value of `sec_prot`
+    #[inline]
+    pub fn set_sec_prot(&mut self, value: Ctrl_WifiSecProt) -> &mut Self {
+        self.r#sec_prot = value.into();
+        self
+    }
+    ///Builder method that sets the value of `sec_prot`. Useful for initializing the message.
+    #[inline]
+    pub fn init_sec_prot(mut self, value: Ctrl_WifiSecProt) -> Self {
+        self.r#sec_prot = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for ScanResult {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#ssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#chnl;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#rssi;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#bssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#sec_prot;
+                    {
+                        let val = decoder.decode_int32().map(|n| Ctrl_WifiSecProt(n as _))?;
+                        let val_ref = &val;
+                        if val_ref.0 != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for ScanResult {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(Ctrl_WifiSecProt::_MAX_SIZE), |size| size
+                + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#chnl;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#rssi;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(34u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#sec_prot;
+            if val_ref.0 != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_int32(val_ref.0 as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#chnl;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#rssi;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#sec_prot;
+            if val_ref.0 != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqGetMacAddress {
-    #[noproto(tag = "1")]
-    pub mode: u32,
+pub struct ConnectedSTAList {
+    pub r#mac: ::micropb::heapless::Vec<u8, 32>,
+    pub r#rssi: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ConnectedSTAList {
+    ///Return a reference to `mac`
+    #[inline]
+    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#mac
+    }
+    ///Return a mutable reference to `mac`
+    #[inline]
+    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#mac
+    }
+    ///Set the value of `mac`
+    #[inline]
+    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mac`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Return a reference to `rssi`
+    #[inline]
+    pub fn r#rssi(&self) -> &i32 {
+        &self.r#rssi
+    }
+    ///Return a mutable reference to `rssi`
+    #[inline]
+    pub fn mut_rssi(&mut self) -> &mut i32 {
+        &mut self.r#rssi
+    }
+    ///Set the value of `rssi`
+    #[inline]
+    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
+        self.r#rssi = value.into();
+        self
+    }
+    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
+    #[inline]
+    pub fn init_rssi(mut self, value: i32) -> Self {
+        self.r#rssi = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for ConnectedSTAList {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#mac;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#rssi;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for ConnectedSTAList {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#rssi;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#rssi;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespGetMacAddress {
-    #[noproto(tag = "1")]
-    pub mac: String<32>,
-    #[noproto(tag = "2")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_GetMacAddress {
+    pub r#mode: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Req_GetMacAddress {
+    ///Return a reference to `mode`
+    #[inline]
+    pub fn r#mode(&self) -> &i32 {
+        &self.r#mode
+    }
+    ///Return a mutable reference to `mode`
+    #[inline]
+    pub fn mut_mode(&mut self) -> &mut i32 {
+        &mut self.r#mode
+    }
+    ///Set the value of `mode`
+    #[inline]
+    pub fn set_mode(&mut self, value: i32) -> &mut Self {
+        self.r#mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mode(mut self, value: i32) -> Self {
+        self.r#mode = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetMacAddress {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetMacAddress {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqGetMode {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+pub struct CtrlMsg_Resp_GetMacAddress {
+    pub r#mac: ::micropb::heapless::Vec<u8, 32>,
+    pub r#resp: i32,
+}
+impl CtrlMsg_Resp_GetMacAddress {
+    ///Return a reference to `mac`
+    #[inline]
+    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#mac
+    }
+    ///Return a mutable reference to `mac`
+    #[inline]
+    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#mac
+    }
+    ///Set the value of `mac`
+    #[inline]
+    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mac`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetMacAddress {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#mac;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetMacAddress {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespGetMode {
-    #[noproto(tag = "1")]
-    pub mode: u32,
-    #[noproto(tag = "2")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_GetMode {}
+impl CtrlMsg_Req_GetMode {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetMode {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetMode {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqSetMode {
-    #[noproto(tag = "1")]
-    pub mode: u32,
+pub struct CtrlMsg_Resp_GetMode {
+    pub r#mode: i32,
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Resp_GetMode {
+    ///Return a reference to `mode`
+    #[inline]
+    pub fn r#mode(&self) -> &i32 {
+        &self.r#mode
+    }
+    ///Return a mutable reference to `mode`
+    #[inline]
+    pub fn mut_mode(&mut self) -> &mut i32 {
+        &mut self.r#mode
+    }
+    ///Set the value of `mode`
+    #[inline]
+    pub fn set_mode(&mut self, value: i32) -> &mut Self {
+        self.r#mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mode(mut self, value: i32) -> Self {
+        self.r#mode = value.into();
+        self
+    }
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetMode {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetMode {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespSetMode {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_SetMode {
+    pub r#mode: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Req_SetMode {
+    ///Return a reference to `mode`
+    #[inline]
+    pub fn r#mode(&self) -> &i32 {
+        &self.r#mode
+    }
+    ///Return a mutable reference to `mode`
+    #[inline]
+    pub fn mut_mode(&mut self) -> &mut i32 {
+        &mut self.r#mode
+    }
+    ///Set the value of `mode`
+    #[inline]
+    pub fn set_mode(&mut self, value: i32) -> &mut Self {
+        self.r#mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mode(mut self, value: i32) -> Self {
+        self.r#mode = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_SetMode {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_SetMode {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqGetStatus {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+pub struct CtrlMsg_Resp_SetMode {
+    pub r#resp: i32,
+}
+impl CtrlMsg_Resp_SetMode {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_SetMode {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_SetMode {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespGetStatus {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_GetStatus {}
+impl CtrlMsg_Req_GetStatus {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetStatus {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetStatus {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqSetMacAddress {
-    #[noproto(tag = "1")]
-    pub mac: String<32>,
-    #[noproto(tag = "2")]
-    pub mode: u32,
+pub struct CtrlMsg_Resp_GetStatus {
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Resp_GetStatus {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetStatus {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetStatus {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespSetMacAddress {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_SetMacAddress {
+    pub r#mac: ::micropb::heapless::Vec<u8, 32>,
+    pub r#mode: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Req_SetMacAddress {
+    ///Return a reference to `mac`
+    #[inline]
+    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#mac
+    }
+    ///Return a mutable reference to `mac`
+    #[inline]
+    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#mac
+    }
+    ///Set the value of `mac`
+    #[inline]
+    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mac`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Return a reference to `mode`
+    #[inline]
+    pub fn r#mode(&self) -> &i32 {
+        &self.r#mode
+    }
+    ///Return a mutable reference to `mode`
+    #[inline]
+    pub fn mut_mode(&mut self) -> &mut i32 {
+        &mut self.r#mode
+    }
+    ///Set the value of `mode`
+    #[inline]
+    pub fn set_mode(&mut self, value: i32) -> &mut Self {
+        self.r#mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mode(mut self, value: i32) -> Self {
+        self.r#mode = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_SetMacAddress {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#mac;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_SetMacAddress {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqGetApConfig {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespGetApConfig {
-    #[noproto(tag = "1")]
-    pub ssid: String<32>,
-    #[noproto(tag = "2")]
-    pub bssid: String<32>,
-    #[noproto(tag = "3")]
-    pub rssi: u32,
-    #[noproto(tag = "4")]
-    pub chnl: u32,
-    #[noproto(tag = "5")]
-    pub sec_prot: CtrlWifiSecProt,
-    #[noproto(tag = "6")]
-    pub resp: u32,
+pub struct CtrlMsg_Resp_SetMacAddress {
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqConnectAp {
-    #[noproto(tag = "1")]
-    pub ssid: String<32>,
-    #[noproto(tag = "2")]
-    pub pwd: String<32>,
-    #[noproto(tag = "3")]
-    pub bssid: String<32>,
-    #[noproto(tag = "4")]
-    pub is_wpa3_supported: bool,
-    #[noproto(tag = "5")]
-    pub listen_interval: u32,
+impl CtrlMsg_Resp_SetMacAddress {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageDecode for CtrlMsg_Resp_SetMacAddress {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_SetMacAddress {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespConnectAp {
-    #[noproto(tag = "1")]
-    pub resp: u32,
-    #[noproto(tag = "2")]
-    pub mac: String<32>,
+pub struct CtrlMsg_Req_GetAPConfig {}
+impl CtrlMsg_Req_GetAPConfig {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetAPConfig {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetAPConfig {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqGetSoftApConfig {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespGetSoftApConfig {
-    #[noproto(tag = "1")]
-    pub ssid: String<32>,
-    #[noproto(tag = "2")]
-    pub pwd: String<32>,
-    #[noproto(tag = "3")]
-    pub chnl: u32,
-    #[noproto(tag = "4")]
-    pub sec_prot: CtrlWifiSecProt,
-    #[noproto(tag = "5")]
-    pub max_conn: u32,
-    #[noproto(tag = "6")]
-    pub ssid_hidden: bool,
-    #[noproto(tag = "7")]
-    pub bw: u32,
-    #[noproto(tag = "8")]
-    pub resp: u32,
+pub struct CtrlMsg_Resp_GetAPConfig {
+    pub r#ssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#bssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#rssi: i32,
+    pub r#chnl: i32,
+    pub r#sec_prot: Ctrl_WifiSecProt,
+    pub r#resp: i32,
+    pub r#band_mode: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqStartSoftAp {
-    #[noproto(tag = "1")]
-    pub ssid: String<32>,
-    #[noproto(tag = "2")]
-    pub pwd: String<32>,
-    #[noproto(tag = "3")]
-    pub chnl: u32,
-    #[noproto(tag = "4")]
-    pub sec_prot: CtrlWifiSecProt,
-    #[noproto(tag = "5")]
-    pub max_conn: u32,
-    #[noproto(tag = "6")]
-    pub ssid_hidden: bool,
-    #[noproto(tag = "7")]
-    pub bw: u32,
+impl CtrlMsg_Resp_GetAPConfig {
+    ///Return a reference to `ssid`
+    #[inline]
+    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#ssid
+    }
+    ///Return a mutable reference to `ssid`
+    #[inline]
+    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#ssid
+    }
+    ///Set the value of `ssid`
+    #[inline]
+    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Return a reference to `bssid`
+    #[inline]
+    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#bssid
+    }
+    ///Return a mutable reference to `bssid`
+    #[inline]
+    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#bssid
+    }
+    ///Set the value of `bssid`
+    #[inline]
+    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Return a reference to `rssi`
+    #[inline]
+    pub fn r#rssi(&self) -> &i32 {
+        &self.r#rssi
+    }
+    ///Return a mutable reference to `rssi`
+    #[inline]
+    pub fn mut_rssi(&mut self) -> &mut i32 {
+        &mut self.r#rssi
+    }
+    ///Set the value of `rssi`
+    #[inline]
+    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
+        self.r#rssi = value.into();
+        self
+    }
+    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
+    #[inline]
+    pub fn init_rssi(mut self, value: i32) -> Self {
+        self.r#rssi = value.into();
+        self
+    }
+    ///Return a reference to `chnl`
+    #[inline]
+    pub fn r#chnl(&self) -> &i32 {
+        &self.r#chnl
+    }
+    ///Return a mutable reference to `chnl`
+    #[inline]
+    pub fn mut_chnl(&mut self) -> &mut i32 {
+        &mut self.r#chnl
+    }
+    ///Set the value of `chnl`
+    #[inline]
+    pub fn set_chnl(&mut self, value: i32) -> &mut Self {
+        self.r#chnl = value.into();
+        self
+    }
+    ///Builder method that sets the value of `chnl`. Useful for initializing the message.
+    #[inline]
+    pub fn init_chnl(mut self, value: i32) -> Self {
+        self.r#chnl = value.into();
+        self
+    }
+    ///Return a reference to `sec_prot`
+    #[inline]
+    pub fn r#sec_prot(&self) -> &Ctrl_WifiSecProt {
+        &self.r#sec_prot
+    }
+    ///Return a mutable reference to `sec_prot`
+    #[inline]
+    pub fn mut_sec_prot(&mut self) -> &mut Ctrl_WifiSecProt {
+        &mut self.r#sec_prot
+    }
+    ///Set the value of `sec_prot`
+    #[inline]
+    pub fn set_sec_prot(&mut self, value: Ctrl_WifiSecProt) -> &mut Self {
+        self.r#sec_prot = value.into();
+        self
+    }
+    ///Builder method that sets the value of `sec_prot`. Useful for initializing the message.
+    #[inline]
+    pub fn init_sec_prot(mut self, value: Ctrl_WifiSecProt) -> Self {
+        self.r#sec_prot = value.into();
+        self
+    }
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `band_mode`
+    #[inline]
+    pub fn r#band_mode(&self) -> &i32 {
+        &self.r#band_mode
+    }
+    ///Return a mutable reference to `band_mode`
+    #[inline]
+    pub fn mut_band_mode(&mut self) -> &mut i32 {
+        &mut self.r#band_mode
+    }
+    ///Set the value of `band_mode`
+    #[inline]
+    pub fn set_band_mode(&mut self, value: i32) -> &mut Self {
+        self.r#band_mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `band_mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_band_mode(mut self, value: i32) -> Self {
+        self.r#band_mode = value.into();
+        self
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetAPConfig {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#ssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#bssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#rssi;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#chnl;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#sec_prot;
+                    {
+                        let val = decoder.decode_int32().map(|n| Ctrl_WifiSecProt(n as _))?;
+                        let val_ref = &val;
+                        if val_ref.0 != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                7u32 => {
+                    let mut_ref = &mut self.r#band_mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetAPConfig {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(Ctrl_WifiSecProt::_MAX_SIZE), |size| size
+                + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#rssi;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#chnl;
+            if *val_ref != 0 {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#sec_prot;
+            if val_ref.0 != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_int32(val_ref.0 as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(48u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(56u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#rssi;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#chnl;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#sec_prot;
+            if val_ref.0 != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespStartSoftAp {
-    #[noproto(tag = "1")]
-    pub resp: u32,
-    #[noproto(tag = "2")]
-    pub mac: String<32>,
+pub struct CtrlMsg_Req_ConnectAP {
+    pub r#ssid: ::micropb::heapless::String<32>,
+    pub r#pwd: ::micropb::heapless::String<32>,
+    pub r#bssid: ::micropb::heapless::String<32>,
+    pub r#is_wpa3_supported: bool,
+    pub r#listen_interval: i32,
+    pub r#band_mode: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Req_ConnectAP {
+    ///Return a reference to `ssid`
+    #[inline]
+    pub fn r#ssid(&self) -> &::micropb::heapless::String<32> {
+        &self.r#ssid
+    }
+    ///Return a mutable reference to `ssid`
+    #[inline]
+    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::String<32> {
+        &mut self.r#ssid
+    }
+    ///Set the value of `ssid`
+    #[inline]
+    pub fn set_ssid(&mut self, value: ::micropb::heapless::String<32>) -> &mut Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid(mut self, value: ::micropb::heapless::String<32>) -> Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Return a reference to `pwd`
+    #[inline]
+    pub fn r#pwd(&self) -> &::micropb::heapless::String<32> {
+        &self.r#pwd
+    }
+    ///Return a mutable reference to `pwd`
+    #[inline]
+    pub fn mut_pwd(&mut self) -> &mut ::micropb::heapless::String<32> {
+        &mut self.r#pwd
+    }
+    ///Set the value of `pwd`
+    #[inline]
+    pub fn set_pwd(&mut self, value: ::micropb::heapless::String<32>) -> &mut Self {
+        self.r#pwd = value.into();
+        self
+    }
+    ///Builder method that sets the value of `pwd`. Useful for initializing the message.
+    #[inline]
+    pub fn init_pwd(mut self, value: ::micropb::heapless::String<32>) -> Self {
+        self.r#pwd = value.into();
+        self
+    }
+    ///Return a reference to `bssid`
+    #[inline]
+    pub fn r#bssid(&self) -> &::micropb::heapless::String<32> {
+        &self.r#bssid
+    }
+    ///Return a mutable reference to `bssid`
+    #[inline]
+    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::String<32> {
+        &mut self.r#bssid
+    }
+    ///Set the value of `bssid`
+    #[inline]
+    pub fn set_bssid(&mut self, value: ::micropb::heapless::String<32>) -> &mut Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_bssid(mut self, value: ::micropb::heapless::String<32>) -> Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Return a reference to `is_wpa3_supported`
+    #[inline]
+    pub fn r#is_wpa3_supported(&self) -> &bool {
+        &self.r#is_wpa3_supported
+    }
+    ///Return a mutable reference to `is_wpa3_supported`
+    #[inline]
+    pub fn mut_is_wpa3_supported(&mut self) -> &mut bool {
+        &mut self.r#is_wpa3_supported
+    }
+    ///Set the value of `is_wpa3_supported`
+    #[inline]
+    pub fn set_is_wpa3_supported(&mut self, value: bool) -> &mut Self {
+        self.r#is_wpa3_supported = value.into();
+        self
+    }
+    ///Builder method that sets the value of `is_wpa3_supported`. Useful for initializing the message.
+    #[inline]
+    pub fn init_is_wpa3_supported(mut self, value: bool) -> Self {
+        self.r#is_wpa3_supported = value.into();
+        self
+    }
+    ///Return a reference to `listen_interval`
+    #[inline]
+    pub fn r#listen_interval(&self) -> &i32 {
+        &self.r#listen_interval
+    }
+    ///Return a mutable reference to `listen_interval`
+    #[inline]
+    pub fn mut_listen_interval(&mut self) -> &mut i32 {
+        &mut self.r#listen_interval
+    }
+    ///Set the value of `listen_interval`
+    #[inline]
+    pub fn set_listen_interval(&mut self, value: i32) -> &mut Self {
+        self.r#listen_interval = value.into();
+        self
+    }
+    ///Builder method that sets the value of `listen_interval`. Useful for initializing the message.
+    #[inline]
+    pub fn init_listen_interval(mut self, value: i32) -> Self {
+        self.r#listen_interval = value.into();
+        self
+    }
+    ///Return a reference to `band_mode`
+    #[inline]
+    pub fn r#band_mode(&self) -> &i32 {
+        &self.r#band_mode
+    }
+    ///Return a mutable reference to `band_mode`
+    #[inline]
+    pub fn mut_band_mode(&mut self) -> &mut i32 {
+        &mut self.r#band_mode
+    }
+    ///Set the value of `band_mode`
+    #[inline]
+    pub fn set_band_mode(&mut self, value: i32) -> &mut Self {
+        self.r#band_mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `band_mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_band_mode(mut self, value: i32) -> Self {
+        self.r#band_mode = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_ConnectAP {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#ssid;
+                    {
+                        decoder.decode_string(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#pwd;
+                    {
+                        decoder.decode_string(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#bssid;
+                    {
+                        decoder.decode_string(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#is_wpa3_supported;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#listen_interval;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#band_mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_ConnectAP {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_string(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#pwd;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_string(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(26u32)?;
+                encoder.encode_string(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#is_wpa3_supported;
+            if *val_ref {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#listen_interval;
+            if *val_ref != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(48u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#pwd;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#is_wpa3_supported;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        {
+            let val_ref = &self.r#listen_interval;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqScanResult {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+pub struct CtrlMsg_Resp_ConnectAP {
+    pub r#resp: i32,
+    pub r#mac: ::micropb::heapless::Vec<u8, 32>,
+    pub r#band_mode: i32,
+}
+impl CtrlMsg_Resp_ConnectAP {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `mac`
+    #[inline]
+    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#mac
+    }
+    ///Return a mutable reference to `mac`
+    #[inline]
+    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#mac
+    }
+    ///Set the value of `mac`
+    #[inline]
+    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mac`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Return a reference to `band_mode`
+    #[inline]
+    pub fn r#band_mode(&self) -> &i32 {
+        &self.r#band_mode
+    }
+    ///Return a mutable reference to `band_mode`
+    #[inline]
+    pub fn mut_band_mode(&mut self) -> &mut i32 {
+        &mut self.r#band_mode
+    }
+    ///Set the value of `band_mode`
+    #[inline]
+    pub fn set_band_mode(&mut self, value: i32) -> &mut Self {
+        self.r#band_mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `band_mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_band_mode(mut self, value: i32) -> Self {
+        self.r#band_mode = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_ConnectAP {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#mac;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#band_mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_ConnectAP {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespScanResult {
-    #[noproto(tag = "1")]
-    pub count: u32,
-    #[noproto(repeated, tag = "2")]
-    pub entries: Vec<ScanResult, 16>,
-    #[noproto(tag = "3")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_GetSoftAPConfig {}
+impl CtrlMsg_Req_GetSoftAPConfig {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetSoftAPConfig {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetSoftAPConfig {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqSoftApConnectedSta {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+pub struct CtrlMsg_Resp_GetSoftAPConfig {
+    pub r#ssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#pwd: ::micropb::heapless::Vec<u8, 32>,
+    pub r#chnl: i32,
+    pub r#sec_prot: Ctrl_WifiSecProt,
+    pub r#max_conn: i32,
+    pub r#ssid_hidden: bool,
+    pub r#bw: i32,
+    pub r#resp: i32,
+    pub r#band_mode: i32,
+}
+impl CtrlMsg_Resp_GetSoftAPConfig {
+    ///Return a reference to `ssid`
+    #[inline]
+    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#ssid
+    }
+    ///Return a mutable reference to `ssid`
+    #[inline]
+    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#ssid
+    }
+    ///Set the value of `ssid`
+    #[inline]
+    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Return a reference to `pwd`
+    #[inline]
+    pub fn r#pwd(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#pwd
+    }
+    ///Return a mutable reference to `pwd`
+    #[inline]
+    pub fn mut_pwd(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#pwd
+    }
+    ///Set the value of `pwd`
+    #[inline]
+    pub fn set_pwd(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#pwd = value.into();
+        self
+    }
+    ///Builder method that sets the value of `pwd`. Useful for initializing the message.
+    #[inline]
+    pub fn init_pwd(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#pwd = value.into();
+        self
+    }
+    ///Return a reference to `chnl`
+    #[inline]
+    pub fn r#chnl(&self) -> &i32 {
+        &self.r#chnl
+    }
+    ///Return a mutable reference to `chnl`
+    #[inline]
+    pub fn mut_chnl(&mut self) -> &mut i32 {
+        &mut self.r#chnl
+    }
+    ///Set the value of `chnl`
+    #[inline]
+    pub fn set_chnl(&mut self, value: i32) -> &mut Self {
+        self.r#chnl = value.into();
+        self
+    }
+    ///Builder method that sets the value of `chnl`. Useful for initializing the message.
+    #[inline]
+    pub fn init_chnl(mut self, value: i32) -> Self {
+        self.r#chnl = value.into();
+        self
+    }
+    ///Return a reference to `sec_prot`
+    #[inline]
+    pub fn r#sec_prot(&self) -> &Ctrl_WifiSecProt {
+        &self.r#sec_prot
+    }
+    ///Return a mutable reference to `sec_prot`
+    #[inline]
+    pub fn mut_sec_prot(&mut self) -> &mut Ctrl_WifiSecProt {
+        &mut self.r#sec_prot
+    }
+    ///Set the value of `sec_prot`
+    #[inline]
+    pub fn set_sec_prot(&mut self, value: Ctrl_WifiSecProt) -> &mut Self {
+        self.r#sec_prot = value.into();
+        self
+    }
+    ///Builder method that sets the value of `sec_prot`. Useful for initializing the message.
+    #[inline]
+    pub fn init_sec_prot(mut self, value: Ctrl_WifiSecProt) -> Self {
+        self.r#sec_prot = value.into();
+        self
+    }
+    ///Return a reference to `max_conn`
+    #[inline]
+    pub fn r#max_conn(&self) -> &i32 {
+        &self.r#max_conn
+    }
+    ///Return a mutable reference to `max_conn`
+    #[inline]
+    pub fn mut_max_conn(&mut self) -> &mut i32 {
+        &mut self.r#max_conn
+    }
+    ///Set the value of `max_conn`
+    #[inline]
+    pub fn set_max_conn(&mut self, value: i32) -> &mut Self {
+        self.r#max_conn = value.into();
+        self
+    }
+    ///Builder method that sets the value of `max_conn`. Useful for initializing the message.
+    #[inline]
+    pub fn init_max_conn(mut self, value: i32) -> Self {
+        self.r#max_conn = value.into();
+        self
+    }
+    ///Return a reference to `ssid_hidden`
+    #[inline]
+    pub fn r#ssid_hidden(&self) -> &bool {
+        &self.r#ssid_hidden
+    }
+    ///Return a mutable reference to `ssid_hidden`
+    #[inline]
+    pub fn mut_ssid_hidden(&mut self) -> &mut bool {
+        &mut self.r#ssid_hidden
+    }
+    ///Set the value of `ssid_hidden`
+    #[inline]
+    pub fn set_ssid_hidden(&mut self, value: bool) -> &mut Self {
+        self.r#ssid_hidden = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid_hidden`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid_hidden(mut self, value: bool) -> Self {
+        self.r#ssid_hidden = value.into();
+        self
+    }
+    ///Return a reference to `bw`
+    #[inline]
+    pub fn r#bw(&self) -> &i32 {
+        &self.r#bw
+    }
+    ///Return a mutable reference to `bw`
+    #[inline]
+    pub fn mut_bw(&mut self) -> &mut i32 {
+        &mut self.r#bw
+    }
+    ///Set the value of `bw`
+    #[inline]
+    pub fn set_bw(&mut self, value: i32) -> &mut Self {
+        self.r#bw = value.into();
+        self
+    }
+    ///Builder method that sets the value of `bw`. Useful for initializing the message.
+    #[inline]
+    pub fn init_bw(mut self, value: i32) -> Self {
+        self.r#bw = value.into();
+        self
+    }
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `band_mode`
+    #[inline]
+    pub fn r#band_mode(&self) -> &i32 {
+        &self.r#band_mode
+    }
+    ///Return a mutable reference to `band_mode`
+    #[inline]
+    pub fn mut_band_mode(&mut self) -> &mut i32 {
+        &mut self.r#band_mode
+    }
+    ///Set the value of `band_mode`
+    #[inline]
+    pub fn set_band_mode(&mut self, value: i32) -> &mut Self {
+        self.r#band_mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `band_mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_band_mode(mut self, value: i32) -> Self {
+        self.r#band_mode = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetSoftAPConfig {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#ssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#pwd;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#chnl;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#sec_prot;
+                    {
+                        let val = decoder.decode_int32().map(|n| Ctrl_WifiSecProt(n as _))?;
+                        let val_ref = &val;
+                        if val_ref.0 != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#max_conn;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#ssid_hidden;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                7u32 => {
+                    let mut_ref = &mut self.r#bw;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                8u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                9u32 => {
+                    let mut_ref = &mut self.r#band_mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetSoftAPConfig {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(Ctrl_WifiSecProt::_MAX_SIZE), |size| size
+                + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#pwd;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#chnl;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#sec_prot;
+            if val_ref.0 != 0 {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_int32(val_ref.0 as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#max_conn;
+            if *val_ref != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#ssid_hidden;
+            if *val_ref {
+                encoder.encode_varint32(48u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#bw;
+            if *val_ref != 0 {
+                encoder.encode_varint32(56u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(64u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(72u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#pwd;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#chnl;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#sec_prot;
+            if val_ref.0 != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
+            }
+        }
+        {
+            let val_ref = &self.r#max_conn;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#ssid_hidden;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        {
+            let val_ref = &self.r#bw;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespSoftApConnectedSta {
-    #[noproto(tag = "1")]
-    pub num: u32,
-    #[noproto(repeated, tag = "2")]
-    pub stations: Vec<ConnectedStaList, 16>,
-    #[noproto(tag = "3")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_StartSoftAP {
+    pub r#ssid: ::micropb::heapless::String<32>,
+    pub r#pwd: ::micropb::heapless::String<32>,
+    pub r#chnl: i32,
+    pub r#sec_prot: Ctrl_WifiSecProt,
+    pub r#max_conn: i32,
+    pub r#ssid_hidden: bool,
+    pub r#bw: i32,
+    pub r#band_mode: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Req_StartSoftAP {
+    ///Return a reference to `ssid`
+    #[inline]
+    pub fn r#ssid(&self) -> &::micropb::heapless::String<32> {
+        &self.r#ssid
+    }
+    ///Return a mutable reference to `ssid`
+    #[inline]
+    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::String<32> {
+        &mut self.r#ssid
+    }
+    ///Set the value of `ssid`
+    #[inline]
+    pub fn set_ssid(&mut self, value: ::micropb::heapless::String<32>) -> &mut Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid(mut self, value: ::micropb::heapless::String<32>) -> Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Return a reference to `pwd`
+    #[inline]
+    pub fn r#pwd(&self) -> &::micropb::heapless::String<32> {
+        &self.r#pwd
+    }
+    ///Return a mutable reference to `pwd`
+    #[inline]
+    pub fn mut_pwd(&mut self) -> &mut ::micropb::heapless::String<32> {
+        &mut self.r#pwd
+    }
+    ///Set the value of `pwd`
+    #[inline]
+    pub fn set_pwd(&mut self, value: ::micropb::heapless::String<32>) -> &mut Self {
+        self.r#pwd = value.into();
+        self
+    }
+    ///Builder method that sets the value of `pwd`. Useful for initializing the message.
+    #[inline]
+    pub fn init_pwd(mut self, value: ::micropb::heapless::String<32>) -> Self {
+        self.r#pwd = value.into();
+        self
+    }
+    ///Return a reference to `chnl`
+    #[inline]
+    pub fn r#chnl(&self) -> &i32 {
+        &self.r#chnl
+    }
+    ///Return a mutable reference to `chnl`
+    #[inline]
+    pub fn mut_chnl(&mut self) -> &mut i32 {
+        &mut self.r#chnl
+    }
+    ///Set the value of `chnl`
+    #[inline]
+    pub fn set_chnl(&mut self, value: i32) -> &mut Self {
+        self.r#chnl = value.into();
+        self
+    }
+    ///Builder method that sets the value of `chnl`. Useful for initializing the message.
+    #[inline]
+    pub fn init_chnl(mut self, value: i32) -> Self {
+        self.r#chnl = value.into();
+        self
+    }
+    ///Return a reference to `sec_prot`
+    #[inline]
+    pub fn r#sec_prot(&self) -> &Ctrl_WifiSecProt {
+        &self.r#sec_prot
+    }
+    ///Return a mutable reference to `sec_prot`
+    #[inline]
+    pub fn mut_sec_prot(&mut self) -> &mut Ctrl_WifiSecProt {
+        &mut self.r#sec_prot
+    }
+    ///Set the value of `sec_prot`
+    #[inline]
+    pub fn set_sec_prot(&mut self, value: Ctrl_WifiSecProt) -> &mut Self {
+        self.r#sec_prot = value.into();
+        self
+    }
+    ///Builder method that sets the value of `sec_prot`. Useful for initializing the message.
+    #[inline]
+    pub fn init_sec_prot(mut self, value: Ctrl_WifiSecProt) -> Self {
+        self.r#sec_prot = value.into();
+        self
+    }
+    ///Return a reference to `max_conn`
+    #[inline]
+    pub fn r#max_conn(&self) -> &i32 {
+        &self.r#max_conn
+    }
+    ///Return a mutable reference to `max_conn`
+    #[inline]
+    pub fn mut_max_conn(&mut self) -> &mut i32 {
+        &mut self.r#max_conn
+    }
+    ///Set the value of `max_conn`
+    #[inline]
+    pub fn set_max_conn(&mut self, value: i32) -> &mut Self {
+        self.r#max_conn = value.into();
+        self
+    }
+    ///Builder method that sets the value of `max_conn`. Useful for initializing the message.
+    #[inline]
+    pub fn init_max_conn(mut self, value: i32) -> Self {
+        self.r#max_conn = value.into();
+        self
+    }
+    ///Return a reference to `ssid_hidden`
+    #[inline]
+    pub fn r#ssid_hidden(&self) -> &bool {
+        &self.r#ssid_hidden
+    }
+    ///Return a mutable reference to `ssid_hidden`
+    #[inline]
+    pub fn mut_ssid_hidden(&mut self) -> &mut bool {
+        &mut self.r#ssid_hidden
+    }
+    ///Set the value of `ssid_hidden`
+    #[inline]
+    pub fn set_ssid_hidden(&mut self, value: bool) -> &mut Self {
+        self.r#ssid_hidden = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid_hidden`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid_hidden(mut self, value: bool) -> Self {
+        self.r#ssid_hidden = value.into();
+        self
+    }
+    ///Return a reference to `bw`
+    #[inline]
+    pub fn r#bw(&self) -> &i32 {
+        &self.r#bw
+    }
+    ///Return a mutable reference to `bw`
+    #[inline]
+    pub fn mut_bw(&mut self) -> &mut i32 {
+        &mut self.r#bw
+    }
+    ///Set the value of `bw`
+    #[inline]
+    pub fn set_bw(&mut self, value: i32) -> &mut Self {
+        self.r#bw = value.into();
+        self
+    }
+    ///Builder method that sets the value of `bw`. Useful for initializing the message.
+    #[inline]
+    pub fn init_bw(mut self, value: i32) -> Self {
+        self.r#bw = value.into();
+        self
+    }
+    ///Return a reference to `band_mode`
+    #[inline]
+    pub fn r#band_mode(&self) -> &i32 {
+        &self.r#band_mode
+    }
+    ///Return a mutable reference to `band_mode`
+    #[inline]
+    pub fn mut_band_mode(&mut self) -> &mut i32 {
+        &mut self.r#band_mode
+    }
+    ///Set the value of `band_mode`
+    #[inline]
+    pub fn set_band_mode(&mut self, value: i32) -> &mut Self {
+        self.r#band_mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `band_mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_band_mode(mut self, value: i32) -> Self {
+        self.r#band_mode = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_StartSoftAP {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#ssid;
+                    {
+                        decoder.decode_string(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#pwd;
+                    {
+                        decoder.decode_string(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#chnl;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#sec_prot;
+                    {
+                        let val = decoder.decode_int32().map(|n| Ctrl_WifiSecProt(n as _))?;
+                        let val_ref = &val;
+                        if val_ref.0 != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#max_conn;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#ssid_hidden;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                7u32 => {
+                    let mut_ref = &mut self.r#bw;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                8u32 => {
+                    let mut_ref = &mut self.r#band_mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_StartSoftAP {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(Ctrl_WifiSecProt::_MAX_SIZE), |size| size
+                + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_string(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#pwd;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_string(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#chnl;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#sec_prot;
+            if val_ref.0 != 0 {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_int32(val_ref.0 as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#max_conn;
+            if *val_ref != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#ssid_hidden;
+            if *val_ref {
+                encoder.encode_varint32(48u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#bw;
+            if *val_ref != 0 {
+                encoder.encode_varint32(56u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(64u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#pwd;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#chnl;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#sec_prot;
+            if val_ref.0 != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
+            }
+        }
+        {
+            let val_ref = &self.r#max_conn;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#ssid_hidden;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        {
+            let val_ref = &self.r#bw;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqOtaBegin {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+pub struct CtrlMsg_Resp_StartSoftAP {
+    pub r#resp: i32,
+    pub r#mac: ::micropb::heapless::Vec<u8, 32>,
+    pub r#band_mode: i32,
+}
+impl CtrlMsg_Resp_StartSoftAP {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `mac`
+    #[inline]
+    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#mac
+    }
+    ///Return a mutable reference to `mac`
+    #[inline]
+    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#mac
+    }
+    ///Set the value of `mac`
+    #[inline]
+    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mac`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Return a reference to `band_mode`
+    #[inline]
+    pub fn r#band_mode(&self) -> &i32 {
+        &self.r#band_mode
+    }
+    ///Return a mutable reference to `band_mode`
+    #[inline]
+    pub fn mut_band_mode(&mut self) -> &mut i32 {
+        &mut self.r#band_mode
+    }
+    ///Set the value of `band_mode`
+    #[inline]
+    pub fn set_band_mode(&mut self, value: i32) -> &mut Self {
+        self.r#band_mode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `band_mode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_band_mode(mut self, value: i32) -> Self {
+        self.r#band_mode = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_StartSoftAP {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#mac;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#band_mode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_StartSoftAP {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#band_mode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespOtaBegin {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_ScanResult {}
+impl CtrlMsg_Req_ScanResult {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_ScanResult {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageEncode for CtrlMsg_Req_ScanResult {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqOtaWrite {
-    #[noproto(tag = "1")]
-    pub ota_data: Vec<u8, 1024>,
+pub struct CtrlMsg_Resp_ScanResult {
+    pub r#count: u32,
+    pub r#entries: ::micropb::heapless::Vec<ScanResult, 16>,
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Resp_ScanResult {
+    ///Return a reference to `count`
+    #[inline]
+    pub fn r#count(&self) -> &u32 {
+        &self.r#count
+    }
+    ///Return a mutable reference to `count`
+    #[inline]
+    pub fn mut_count(&mut self) -> &mut u32 {
+        &mut self.r#count
+    }
+    ///Set the value of `count`
+    #[inline]
+    pub fn set_count(&mut self, value: u32) -> &mut Self {
+        self.r#count = value.into();
+        self
+    }
+    ///Builder method that sets the value of `count`. Useful for initializing the message.
+    #[inline]
+    pub fn init_count(mut self, value: u32) -> Self {
+        self.r#count = value.into();
+        self
+    }
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_ScanResult {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#count;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut val: ScanResult = ::core::default::Default::default();
+                    let mut_ref = &mut val;
+                    {
+                        mut_ref.decode_len_delimited(decoder)?;
+                    };
+                    if let (Err(_), false) = (self.r#entries.pb_push(val), decoder.ignore_repeated_cap_err) {
+                        return Err(::micropb::DecodeError::Capacity);
+                    }
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_ScanResult {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+            ::micropb::const_map!(<ScanResult as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                ::micropb::size::sizeof_len_record(size)
+            }),
+            |size| (size + 1usize) * 16usize
+        ) {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#count;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            for val_ref in self.r#entries.iter() {
+                encoder.encode_varint32(18u32)?;
+                val_ref.encode_len_delimited(encoder)?;
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#count;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            for val_ref in self.r#entries.iter() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespOtaWrite {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_SoftAPConnectedSTA {}
+impl CtrlMsg_Req_SoftAPConnectedSTA {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_SoftAPConnectedSTA {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageEncode for CtrlMsg_Req_SoftAPConnectedSTA {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqOtaEnd {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+pub struct CtrlMsg_Resp_SoftAPConnectedSTA {
+    pub r#num: u32,
+    pub r#stations: ::micropb::heapless::Vec<ConnectedSTAList, 16>,
+    pub r#resp: i32,
+}
+impl CtrlMsg_Resp_SoftAPConnectedSTA {
+    ///Return a reference to `num`
+    #[inline]
+    pub fn r#num(&self) -> &u32 {
+        &self.r#num
+    }
+    ///Return a mutable reference to `num`
+    #[inline]
+    pub fn mut_num(&mut self) -> &mut u32 {
+        &mut self.r#num
+    }
+    ///Set the value of `num`
+    #[inline]
+    pub fn set_num(&mut self, value: u32) -> &mut Self {
+        self.r#num = value.into();
+        self
+    }
+    ///Builder method that sets the value of `num`. Useful for initializing the message.
+    #[inline]
+    pub fn init_num(mut self, value: u32) -> Self {
+        self.r#num = value.into();
+        self
+    }
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_SoftAPConnectedSTA {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#num;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut val: ConnectedSTAList = ::core::default::Default::default();
+                    let mut_ref = &mut val;
+                    {
+                        mut_ref.decode_len_delimited(decoder)?;
+                    };
+                    if let (Err(_), false) = (self.r#stations.pb_push(val), decoder.ignore_repeated_cap_err) {
+                        return Err(::micropb::DecodeError::Capacity);
+                    }
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_SoftAPConnectedSTA {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+            ::micropb::const_map!(<ConnectedSTAList as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                ::micropb::size::sizeof_len_record(size)
+            }),
+            |size| (size + 1usize) * 16usize
+        ) {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#num;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            for val_ref in self.r#stations.iter() {
+                encoder.encode_varint32(18u32)?;
+                val_ref.encode_len_delimited(encoder)?;
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#num;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            for val_ref in self.r#stations.iter() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespOtaEnd {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_OTABegin {}
+impl CtrlMsg_Req_OTABegin {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_OTABegin {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqVendorIeData {
-    #[noproto(tag = "1")]
-    pub element_id: u32,
-    #[noproto(tag = "2")]
-    pub length: u32,
-    #[noproto(tag = "3")]
-    pub vendor_oui: Vec<u8, 8>,
-    #[noproto(tag = "4")]
-    pub vendor_oui_type: u32,
-    #[noproto(tag = "5")]
-    pub payload: Vec<u8, 64>,
+impl ::micropb::MessageEncode for CtrlMsg_Req_OTABegin {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqSetSoftApVendorSpecificIe {
-    #[noproto(tag = "1")]
-    pub enable: bool,
-    #[noproto(tag = "2")]
-    pub r#type: CtrlVendorIeType,
-    #[noproto(tag = "3")]
-    pub idx: CtrlVendorIeid,
-    #[noproto(optional, tag = "4")]
-    pub vendor_ie_data: Option<CtrlMsgReqVendorIeData>,
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Resp_OTABegin {
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Resp_OTABegin {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_OTABegin {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_OTABegin {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespSetSoftApVendorSpecificIe {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_OTAWrite {
+    pub r#ota_data: ::micropb::heapless::Vec<u8, 1024>,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Req_OTAWrite {
+    ///Return a reference to `ota_data`
+    #[inline]
+    pub fn r#ota_data(&self) -> &::micropb::heapless::Vec<u8, 1024> {
+        &self.r#ota_data
+    }
+    ///Return a mutable reference to `ota_data`
+    #[inline]
+    pub fn mut_ota_data(&mut self) -> &mut ::micropb::heapless::Vec<u8, 1024> {
+        &mut self.r#ota_data
+    }
+    ///Set the value of `ota_data`
+    #[inline]
+    pub fn set_ota_data(&mut self, value: ::micropb::heapless::Vec<u8, 1024>) -> &mut Self {
+        self.r#ota_data = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ota_data`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ota_data(mut self, value: ::micropb::heapless::Vec<u8, 1024>) -> Self {
+        self.r#ota_data = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_OTAWrite {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#ota_data;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_OTAWrite {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1026usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#ota_data;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#ota_data;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqSetWifiMaxTxPower {
-    #[noproto(tag = "1")]
-    pub wifi_max_tx_power: u32,
+pub struct CtrlMsg_Resp_OTAWrite {
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Resp_OTAWrite {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_OTAWrite {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_OTAWrite {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespSetWifiMaxTxPower {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_OTAEnd {}
+impl CtrlMsg_Req_OTAEnd {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_OTAEnd {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageEncode for CtrlMsg_Req_OTAEnd {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqGetWifiCurrTxPower {}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+pub struct CtrlMsg_Resp_OTAEnd {
+    pub r#resp: i32,
+}
+impl CtrlMsg_Resp_OTAEnd {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_OTAEnd {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_OTAEnd {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespGetWifiCurrTxPower {
-    #[noproto(tag = "1")]
-    pub wifi_curr_tx_power: u32,
-    #[noproto(tag = "2")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_VendorIEData {
+    pub r#element_id: i32,
+    pub r#length: i32,
+    pub r#vendor_oui: ::micropb::heapless::Vec<u8, 32>,
+    pub r#vendor_oui_type: i32,
+    pub r#payload: ::micropb::heapless::Vec<u8, 64>,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Req_VendorIEData {
+    ///Return a reference to `element_id`
+    #[inline]
+    pub fn r#element_id(&self) -> &i32 {
+        &self.r#element_id
+    }
+    ///Return a mutable reference to `element_id`
+    #[inline]
+    pub fn mut_element_id(&mut self) -> &mut i32 {
+        &mut self.r#element_id
+    }
+    ///Set the value of `element_id`
+    #[inline]
+    pub fn set_element_id(&mut self, value: i32) -> &mut Self {
+        self.r#element_id = value.into();
+        self
+    }
+    ///Builder method that sets the value of `element_id`. Useful for initializing the message.
+    #[inline]
+    pub fn init_element_id(mut self, value: i32) -> Self {
+        self.r#element_id = value.into();
+        self
+    }
+    ///Return a reference to `length`
+    #[inline]
+    pub fn r#length(&self) -> &i32 {
+        &self.r#length
+    }
+    ///Return a mutable reference to `length`
+    #[inline]
+    pub fn mut_length(&mut self) -> &mut i32 {
+        &mut self.r#length
+    }
+    ///Set the value of `length`
+    #[inline]
+    pub fn set_length(&mut self, value: i32) -> &mut Self {
+        self.r#length = value.into();
+        self
+    }
+    ///Builder method that sets the value of `length`. Useful for initializing the message.
+    #[inline]
+    pub fn init_length(mut self, value: i32) -> Self {
+        self.r#length = value.into();
+        self
+    }
+    ///Return a reference to `vendor_oui`
+    #[inline]
+    pub fn r#vendor_oui(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#vendor_oui
+    }
+    ///Return a mutable reference to `vendor_oui`
+    #[inline]
+    pub fn mut_vendor_oui(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#vendor_oui
+    }
+    ///Set the value of `vendor_oui`
+    #[inline]
+    pub fn set_vendor_oui(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#vendor_oui = value.into();
+        self
+    }
+    ///Builder method that sets the value of `vendor_oui`. Useful for initializing the message.
+    #[inline]
+    pub fn init_vendor_oui(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#vendor_oui = value.into();
+        self
+    }
+    ///Return a reference to `vendor_oui_type`
+    #[inline]
+    pub fn r#vendor_oui_type(&self) -> &i32 {
+        &self.r#vendor_oui_type
+    }
+    ///Return a mutable reference to `vendor_oui_type`
+    #[inline]
+    pub fn mut_vendor_oui_type(&mut self) -> &mut i32 {
+        &mut self.r#vendor_oui_type
+    }
+    ///Set the value of `vendor_oui_type`
+    #[inline]
+    pub fn set_vendor_oui_type(&mut self, value: i32) -> &mut Self {
+        self.r#vendor_oui_type = value.into();
+        self
+    }
+    ///Builder method that sets the value of `vendor_oui_type`. Useful for initializing the message.
+    #[inline]
+    pub fn init_vendor_oui_type(mut self, value: i32) -> Self {
+        self.r#vendor_oui_type = value.into();
+        self
+    }
+    ///Return a reference to `payload`
+    #[inline]
+    pub fn r#payload(&self) -> &::micropb::heapless::Vec<u8, 64> {
+        &self.r#payload
+    }
+    ///Return a mutable reference to `payload`
+    #[inline]
+    pub fn mut_payload(&mut self) -> &mut ::micropb::heapless::Vec<u8, 64> {
+        &mut self.r#payload
+    }
+    ///Set the value of `payload`
+    #[inline]
+    pub fn set_payload(&mut self, value: ::micropb::heapless::Vec<u8, 64>) -> &mut Self {
+        self.r#payload = value.into();
+        self
+    }
+    ///Builder method that sets the value of `payload`. Useful for initializing the message.
+    #[inline]
+    pub fn init_payload(mut self, value: ::micropb::heapless::Vec<u8, 64>) -> Self {
+        self.r#payload = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_VendorIEData {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#element_id;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#length;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#vendor_oui;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#vendor_oui_type;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#payload;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_VendorIEData {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(65usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#element_id;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#length;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#vendor_oui;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(26u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#vendor_oui_type;
+            if *val_ref != 0 {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#payload;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(42u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#element_id;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#length;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#vendor_oui;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#vendor_oui_type;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#payload;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        size
+    }
+}
+pub mod CtrlMsg_Req_SetSoftAPVendorSpecificIE_ {
+    #[derive(Debug, Default, PartialEq, Clone)]
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    pub struct _Hazzer([u8; 1]);
+    impl _Hazzer {
+        ///New hazzer with all fields set to off
+        #[inline]
+        pub const fn _new() -> Self {
+            Self([0; 1])
+        }
+        ///Query presence of `vendor_ie_data`
+        #[inline]
+        pub const fn r#vendor_ie_data(&self) -> bool {
+            (self.0[0] & 1) != 0
+        }
+        ///Set presence of `vendor_ie_data`
+        #[inline]
+        pub const fn set_vendor_ie_data(&mut self) -> &mut Self {
+            let elem = &mut self.0[0];
+            *elem |= 1;
+            self
+        }
+        ///Clear presence of `vendor_ie_data`
+        #[inline]
+        pub const fn clear_vendor_ie_data(&mut self) -> &mut Self {
+            let elem = &mut self.0[0];
+            *elem &= !1;
+            self
+        }
+        ///Builder method that sets the presence of `vendor_ie_data`. Useful for initializing the Hazzer.
+        #[inline]
+        pub const fn init_vendor_ie_data(mut self) -> Self {
+            self.set_vendor_ie_data();
+            self
+        }
+    }
+}
+#[derive(Debug, Default, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgReqConfigHeartbeat {
-    #[noproto(tag = "1")]
-    pub enable: bool,
-    #[noproto(tag = "2")]
-    pub duration: u32,
+pub struct CtrlMsg_Req_SetSoftAPVendorSpecificIE {
+    pub r#enable: bool,
+    pub r#type: Ctrl_VendorIEType,
+    pub r#idx: Ctrl_VendorIEID,
+    pub r#vendor_ie_data: CtrlMsg_Req_VendorIEData,
+    pub _has: CtrlMsg_Req_SetSoftAPVendorSpecificIE_::_Hazzer,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::core::cmp::PartialEq for CtrlMsg_Req_SetSoftAPVendorSpecificIE {
+    fn eq(&self, other: &Self) -> bool {
+        let mut ret = true;
+        ret &= (self.r#enable == other.r#enable);
+        ret &= (self.r#type == other.r#type);
+        ret &= (self.r#idx == other.r#idx);
+        ret &= (self.r#vendor_ie_data() == other.r#vendor_ie_data());
+        ret
+    }
+}
+impl CtrlMsg_Req_SetSoftAPVendorSpecificIE {
+    ///Return a reference to `enable`
+    #[inline]
+    pub fn r#enable(&self) -> &bool {
+        &self.r#enable
+    }
+    ///Return a mutable reference to `enable`
+    #[inline]
+    pub fn mut_enable(&mut self) -> &mut bool {
+        &mut self.r#enable
+    }
+    ///Set the value of `enable`
+    #[inline]
+    pub fn set_enable(&mut self, value: bool) -> &mut Self {
+        self.r#enable = value.into();
+        self
+    }
+    ///Builder method that sets the value of `enable`. Useful for initializing the message.
+    #[inline]
+    pub fn init_enable(mut self, value: bool) -> Self {
+        self.r#enable = value.into();
+        self
+    }
+    ///Return a reference to `type`
+    #[inline]
+    pub fn r#type(&self) -> &Ctrl_VendorIEType {
+        &self.r#type
+    }
+    ///Return a mutable reference to `type`
+    #[inline]
+    pub fn mut_type(&mut self) -> &mut Ctrl_VendorIEType {
+        &mut self.r#type
+    }
+    ///Set the value of `type`
+    #[inline]
+    pub fn set_type(&mut self, value: Ctrl_VendorIEType) -> &mut Self {
+        self.r#type = value.into();
+        self
+    }
+    ///Builder method that sets the value of `type`. Useful for initializing the message.
+    #[inline]
+    pub fn init_type(mut self, value: Ctrl_VendorIEType) -> Self {
+        self.r#type = value.into();
+        self
+    }
+    ///Return a reference to `idx`
+    #[inline]
+    pub fn r#idx(&self) -> &Ctrl_VendorIEID {
+        &self.r#idx
+    }
+    ///Return a mutable reference to `idx`
+    #[inline]
+    pub fn mut_idx(&mut self) -> &mut Ctrl_VendorIEID {
+        &mut self.r#idx
+    }
+    ///Set the value of `idx`
+    #[inline]
+    pub fn set_idx(&mut self, value: Ctrl_VendorIEID) -> &mut Self {
+        self.r#idx = value.into();
+        self
+    }
+    ///Builder method that sets the value of `idx`. Useful for initializing the message.
+    #[inline]
+    pub fn init_idx(mut self, value: Ctrl_VendorIEID) -> Self {
+        self.r#idx = value.into();
+        self
+    }
+    ///Return a reference to `vendor_ie_data` as an `Option`
+    #[inline]
+    pub fn r#vendor_ie_data(&self) -> ::core::option::Option<&CtrlMsg_Req_VendorIEData> {
+        self._has.r#vendor_ie_data().then_some(&self.r#vendor_ie_data)
+    }
+    ///Set the value and presence of `vendor_ie_data`
+    #[inline]
+    pub fn set_vendor_ie_data(&mut self, value: CtrlMsg_Req_VendorIEData) -> &mut Self {
+        self._has.set_vendor_ie_data();
+        self.r#vendor_ie_data = value.into();
+        self
+    }
+    ///Return a mutable reference to `vendor_ie_data` as an `Option`
+    #[inline]
+    pub fn mut_vendor_ie_data(&mut self) -> ::core::option::Option<&mut CtrlMsg_Req_VendorIEData> {
+        self._has.r#vendor_ie_data().then_some(&mut self.r#vendor_ie_data)
+    }
+    ///Clear the presence of `vendor_ie_data`
+    #[inline]
+    pub fn clear_vendor_ie_data(&mut self) -> &mut Self {
+        self._has.clear_vendor_ie_data();
+        self
+    }
+    ///Take the value of `vendor_ie_data` and clear its presence
+    #[inline]
+    pub fn take_vendor_ie_data(&mut self) -> ::core::option::Option<CtrlMsg_Req_VendorIEData> {
+        let val = self
+            ._has
+            .r#vendor_ie_data()
+            .then(|| ::core::mem::take(&mut self.r#vendor_ie_data));
+        self._has.clear_vendor_ie_data();
+        val
+    }
+    ///Builder method that sets the value of `vendor_ie_data`. Useful for initializing the message.
+    #[inline]
+    pub fn init_vendor_ie_data(mut self, value: CtrlMsg_Req_VendorIEData) -> Self {
+        self.set_vendor_ie_data(value);
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_SetSoftAPVendorSpecificIE {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#enable;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#type;
+                    {
+                        let val = decoder.decode_int32().map(|n| Ctrl_VendorIEType(n as _))?;
+                        let val_ref = &val;
+                        if val_ref.0 != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#idx;
+                    {
+                        let val = decoder.decode_int32().map(|n| Ctrl_VendorIEID(n as _))?;
+                        let val_ref = &val;
+                        if val_ref.0 != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#vendor_ie_data;
+                    {
+                        mut_ref.decode_len_delimited(decoder)?;
+                    };
+                    self._has.set_vendor_ie_data();
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_SetSoftAPVendorSpecificIE {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(Ctrl_VendorIEType::_MAX_SIZE), |size| size
+                + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(Ctrl_VendorIEID::_MAX_SIZE), |size| size
+                + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+            ::micropb::const_map!(
+                <CtrlMsg_Req_VendorIEData as ::micropb::MessageEncode>::MAX_SIZE,
+                |size| ::micropb::size::sizeof_len_record(size)
+            ),
+            |size| size + 1usize
+        ) {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#enable;
+            if *val_ref {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#type;
+            if val_ref.0 != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(val_ref.0 as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#idx;
+            if val_ref.0 != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(val_ref.0 as _)?;
+            }
+        }
+        {
+            if let ::core::option::Option::Some(val_ref) = self.r#vendor_ie_data() {
+                encoder.encode_varint32(34u32)?;
+                val_ref.encode_len_delimited(encoder)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#enable;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        {
+            let val_ref = &self.r#type;
+            if val_ref.0 != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
+            }
+        }
+        {
+            let val_ref = &self.r#idx;
+            if val_ref.0 != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
+            }
+        }
+        {
+            if let ::core::option::Option::Some(val_ref) = self.r#vendor_ie_data() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgRespConfigHeartbeat {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Resp_SetSoftAPVendorSpecificIE {
+    pub r#resp: i32,
 }
-/// * Event structure *
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Resp_SetSoftAPVendorSpecificIE {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_SetSoftAPVendorSpecificIE {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_SetSoftAPVendorSpecificIE {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgEventEspInit {
-    #[noproto(tag = "1")]
-    pub init_data: Vec<u8, 64>,
+pub struct CtrlMsg_Req_SetWifiMaxTxPower {
+    pub r#wifi_max_tx_power: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Req_SetWifiMaxTxPower {
+    ///Return a reference to `wifi_max_tx_power`
+    #[inline]
+    pub fn r#wifi_max_tx_power(&self) -> &i32 {
+        &self.r#wifi_max_tx_power
+    }
+    ///Return a mutable reference to `wifi_max_tx_power`
+    #[inline]
+    pub fn mut_wifi_max_tx_power(&mut self) -> &mut i32 {
+        &mut self.r#wifi_max_tx_power
+    }
+    ///Set the value of `wifi_max_tx_power`
+    #[inline]
+    pub fn set_wifi_max_tx_power(&mut self, value: i32) -> &mut Self {
+        self.r#wifi_max_tx_power = value.into();
+        self
+    }
+    ///Builder method that sets the value of `wifi_max_tx_power`. Useful for initializing the message.
+    #[inline]
+    pub fn init_wifi_max_tx_power(mut self, value: i32) -> Self {
+        self.r#wifi_max_tx_power = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_SetWifiMaxTxPower {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#wifi_max_tx_power;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_SetWifiMaxTxPower {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#wifi_max_tx_power;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#wifi_max_tx_power;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgEventHeartbeat {
-    #[noproto(tag = "1")]
-    pub hb_num: u32,
+pub struct CtrlMsg_Resp_SetWifiMaxTxPower {
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl CtrlMsg_Resp_SetWifiMaxTxPower {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_SetWifiMaxTxPower {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_SetWifiMaxTxPower {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgEventStationDisconnectFromAp {
-    #[noproto(tag = "1")]
-    pub resp: u32,
+pub struct CtrlMsg_Req_GetWifiCurrTxPower {}
+impl CtrlMsg_Req_GetWifiCurrTxPower {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetWifiCurrTxPower {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetWifiCurrTxPower {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsgEventStationDisconnectFromEspSoftAp {
-    #[noproto(tag = "1")]
-    pub resp: u32,
-    #[noproto(tag = "2")]
-    pub mac: String<32>,
+pub struct CtrlMsg_Resp_GetWifiCurrTxPower {
+    pub r#wifi_curr_tx_power: i32,
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Eq, PartialEq, noproto::Message)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) struct CtrlMsg {
-    /// msg_type could be req, resp or Event
-    #[noproto(tag = "1")]
-    pub msg_type: CtrlMsgType,
-    /// msg id
-    #[noproto(tag = "2")]
-    pub msg_id: CtrlMsgId,
-    /// union of all msg ids
-    #[noproto(
-        oneof,
-        tags = "101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 301, 302, 303, 304"
-    )]
-    pub payload: Option<CtrlMsgPayload>,
+impl CtrlMsg_Resp_GetWifiCurrTxPower {
+    ///Return a reference to `wifi_curr_tx_power`
+    #[inline]
+    pub fn r#wifi_curr_tx_power(&self) -> &i32 {
+        &self.r#wifi_curr_tx_power
+    }
+    ///Return a mutable reference to `wifi_curr_tx_power`
+    #[inline]
+    pub fn mut_wifi_curr_tx_power(&mut self) -> &mut i32 {
+        &mut self.r#wifi_curr_tx_power
+    }
+    ///Set the value of `wifi_curr_tx_power`
+    #[inline]
+    pub fn set_wifi_curr_tx_power(&mut self, value: i32) -> &mut Self {
+        self.r#wifi_curr_tx_power = value.into();
+        self
+    }
+    ///Builder method that sets the value of `wifi_curr_tx_power`. Useful for initializing the message.
+    #[inline]
+    pub fn init_wifi_curr_tx_power(mut self, value: i32) -> Self {
+        self.r#wifi_curr_tx_power = value.into();
+        self
+    }
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
 }
-
-/// union of all msg ids
-#[derive(Debug, Clone, Eq, PartialEq, noproto::Oneof)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlMsgPayload {
-    /// * Requests *
-    #[noproto(tag = "101")]
-    ReqGetMacAddress(CtrlMsgReqGetMacAddress),
-    #[noproto(tag = "102")]
-    ReqSetMacAddress(CtrlMsgReqSetMacAddress),
-    #[noproto(tag = "103")]
-    ReqGetWifiMode(CtrlMsgReqGetMode),
-    #[noproto(tag = "104")]
-    ReqSetWifiMode(CtrlMsgReqSetMode),
-    #[noproto(tag = "105")]
-    ReqScanApList(CtrlMsgReqScanResult),
-    #[noproto(tag = "106")]
-    ReqGetApConfig(CtrlMsgReqGetApConfig),
-    #[noproto(tag = "107")]
-    ReqConnectAp(CtrlMsgReqConnectAp),
-    #[noproto(tag = "108")]
-    ReqDisconnectAp(CtrlMsgReqGetStatus),
-    #[noproto(tag = "109")]
-    ReqGetSoftapConfig(CtrlMsgReqGetSoftApConfig),
-    #[noproto(tag = "110")]
-    ReqSetSoftapVendorSpecificIe(CtrlMsgReqSetSoftApVendorSpecificIe),
-    #[noproto(tag = "111")]
-    ReqStartSoftap(CtrlMsgReqStartSoftAp),
-    #[noproto(tag = "112")]
-    ReqSoftapConnectedStasList(CtrlMsgReqSoftApConnectedSta),
-    #[noproto(tag = "113")]
-    ReqStopSoftap(CtrlMsgReqGetStatus),
-    #[noproto(tag = "114")]
-    ReqSetPowerSaveMode(CtrlMsgReqSetMode),
-    #[noproto(tag = "115")]
-    ReqGetPowerSaveMode(CtrlMsgReqGetMode),
-    #[noproto(tag = "116")]
-    ReqOtaBegin(CtrlMsgReqOtaBegin),
-    #[noproto(tag = "117")]
-    ReqOtaWrite(CtrlMsgReqOtaWrite),
-    #[noproto(tag = "118")]
-    ReqOtaEnd(CtrlMsgReqOtaEnd),
-    #[noproto(tag = "119")]
-    ReqSetWifiMaxTxPower(CtrlMsgReqSetWifiMaxTxPower),
-    #[noproto(tag = "120")]
-    ReqGetWifiCurrTxPower(CtrlMsgReqGetWifiCurrTxPower),
-    #[noproto(tag = "121")]
-    ReqConfigHeartbeat(CtrlMsgReqConfigHeartbeat),
-    /// * Responses *
-    #[noproto(tag = "201")]
-    RespGetMacAddress(CtrlMsgRespGetMacAddress),
-    #[noproto(tag = "202")]
-    RespSetMacAddress(CtrlMsgRespSetMacAddress),
-    #[noproto(tag = "203")]
-    RespGetWifiMode(CtrlMsgRespGetMode),
-    #[noproto(tag = "204")]
-    RespSetWifiMode(CtrlMsgRespSetMode),
-    #[noproto(tag = "205")]
-    RespScanApList(CtrlMsgRespScanResult),
-    #[noproto(tag = "206")]
-    RespGetApConfig(CtrlMsgRespGetApConfig),
-    #[noproto(tag = "207")]
-    RespConnectAp(CtrlMsgRespConnectAp),
-    #[noproto(tag = "208")]
-    RespDisconnectAp(CtrlMsgRespGetStatus),
-    #[noproto(tag = "209")]
-    RespGetSoftapConfig(CtrlMsgRespGetSoftApConfig),
-    #[noproto(tag = "210")]
-    RespSetSoftapVendorSpecificIe(CtrlMsgRespSetSoftApVendorSpecificIe),
-    #[noproto(tag = "211")]
-    RespStartSoftap(CtrlMsgRespStartSoftAp),
-    #[noproto(tag = "212")]
-    RespSoftapConnectedStasList(CtrlMsgRespSoftApConnectedSta),
-    #[noproto(tag = "213")]
-    RespStopSoftap(CtrlMsgRespGetStatus),
-    #[noproto(tag = "214")]
-    RespSetPowerSaveMode(CtrlMsgRespSetMode),
-    #[noproto(tag = "215")]
-    RespGetPowerSaveMode(CtrlMsgRespGetMode),
-    #[noproto(tag = "216")]
-    RespOtaBegin(CtrlMsgRespOtaBegin),
-    #[noproto(tag = "217")]
-    RespOtaWrite(CtrlMsgRespOtaWrite),
-    #[noproto(tag = "218")]
-    RespOtaEnd(CtrlMsgRespOtaEnd),
-    #[noproto(tag = "219")]
-    RespSetWifiMaxTxPower(CtrlMsgRespSetWifiMaxTxPower),
-    #[noproto(tag = "220")]
-    RespGetWifiCurrTxPower(CtrlMsgRespGetWifiCurrTxPower),
-    #[noproto(tag = "221")]
-    RespConfigHeartbeat(CtrlMsgRespConfigHeartbeat),
-    /// * Notifications *
-    #[noproto(tag = "301")]
-    EventEspInit(CtrlMsgEventEspInit),
-    #[noproto(tag = "302")]
-    EventHeartbeat(CtrlMsgEventHeartbeat),
-    #[noproto(tag = "303")]
-    EventStationDisconnectFromAp(CtrlMsgEventStationDisconnectFromAp),
-    #[noproto(tag = "304")]
-    EventStationDisconnectFromEspSoftAp(CtrlMsgEventStationDisconnectFromEspSoftAp),
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetWifiCurrTxPower {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#wifi_curr_tx_power;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-/// Enums similar to ESP IDF
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlVendorIeType {
-    #[default]
-    Beacon = 0,
-    ProbeReq = 1,
-    ProbeResp = 2,
-    AssocReq = 3,
-    AssocResp = 4,
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetWifiCurrTxPower {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#wifi_curr_tx_power;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#wifi_curr_tx_power;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
 }
-
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlVendorIeid {
-    #[default]
-    Id0 = 0,
-    Id1 = 1,
+pub struct CtrlMsg_Req_ConfigHeartbeat {
+    pub r#enable: bool,
+    pub r#duration: i32,
 }
-
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
+impl CtrlMsg_Req_ConfigHeartbeat {
+    ///Return a reference to `enable`
+    #[inline]
+    pub fn r#enable(&self) -> &bool {
+        &self.r#enable
+    }
+    ///Return a mutable reference to `enable`
+    #[inline]
+    pub fn mut_enable(&mut self) -> &mut bool {
+        &mut self.r#enable
+    }
+    ///Set the value of `enable`
+    #[inline]
+    pub fn set_enable(&mut self, value: bool) -> &mut Self {
+        self.r#enable = value.into();
+        self
+    }
+    ///Builder method that sets the value of `enable`. Useful for initializing the message.
+    #[inline]
+    pub fn init_enable(mut self, value: bool) -> Self {
+        self.r#enable = value.into();
+        self
+    }
+    ///Return a reference to `duration`
+    #[inline]
+    pub fn r#duration(&self) -> &i32 {
+        &self.r#duration
+    }
+    ///Return a mutable reference to `duration`
+    #[inline]
+    pub fn mut_duration(&mut self) -> &mut i32 {
+        &mut self.r#duration
+    }
+    ///Set the value of `duration`
+    #[inline]
+    pub fn set_duration(&mut self, value: i32) -> &mut Self {
+        self.r#duration = value.into();
+        self
+    }
+    ///Builder method that sets the value of `duration`. Useful for initializing the message.
+    #[inline]
+    pub fn init_duration(mut self, value: i32) -> Self {
+        self.r#duration = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_ConfigHeartbeat {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#enable;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#duration;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_ConfigHeartbeat {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#enable;
+            if *val_ref {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#duration;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#enable;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        {
+            let val_ref = &self.r#duration;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlWifiMode {
-    #[default]
-    None = 0,
-    Sta = 1,
-    Ap = 2,
-    Apsta = 3,
+pub struct CtrlMsg_Resp_ConfigHeartbeat {
+    pub r#resp: i32,
 }
-
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
+impl CtrlMsg_Resp_ConfigHeartbeat {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_ConfigHeartbeat {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_ConfigHeartbeat {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlWifiBw {
-    #[default]
-    BwInvalid = 0,
-    Ht20 = 1,
-    Ht40 = 2,
+pub struct CtrlMsg_Req_EnableDisable {
+    pub r#feature: u32,
+    pub r#enable: bool,
 }
-
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
+impl CtrlMsg_Req_EnableDisable {
+    ///Return a reference to `feature`
+    #[inline]
+    pub fn r#feature(&self) -> &u32 {
+        &self.r#feature
+    }
+    ///Return a mutable reference to `feature`
+    #[inline]
+    pub fn mut_feature(&mut self) -> &mut u32 {
+        &mut self.r#feature
+    }
+    ///Set the value of `feature`
+    #[inline]
+    pub fn set_feature(&mut self, value: u32) -> &mut Self {
+        self.r#feature = value.into();
+        self
+    }
+    ///Builder method that sets the value of `feature`. Useful for initializing the message.
+    #[inline]
+    pub fn init_feature(mut self, value: u32) -> Self {
+        self.r#feature = value.into();
+        self
+    }
+    ///Return a reference to `enable`
+    #[inline]
+    pub fn r#enable(&self) -> &bool {
+        &self.r#enable
+    }
+    ///Return a mutable reference to `enable`
+    #[inline]
+    pub fn mut_enable(&mut self) -> &mut bool {
+        &mut self.r#enable
+    }
+    ///Set the value of `enable`
+    #[inline]
+    pub fn set_enable(&mut self, value: bool) -> &mut Self {
+        self.r#enable = value.into();
+        self
+    }
+    ///Builder method that sets the value of `enable`. Useful for initializing the message.
+    #[inline]
+    pub fn init_enable(mut self, value: bool) -> Self {
+        self.r#enable = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_EnableDisable {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#feature;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#enable;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_EnableDisable {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#feature;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#enable;
+            if *val_ref {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#feature;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#enable;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlWifiPowerSave {
-    #[default]
-    PsInvalid = 0,
-    MinModem = 1,
-    MaxModem = 2,
+pub struct CtrlMsg_Resp_EnableDisable {
+    pub r#resp: i32,
 }
-
-/// Wifi Security Settings
-#[allow(missing_docs)]
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub enum CtrlWifiSecProt {
-    #[default]
-    Open = 0,
-    Wep = 1,
-    WpaPsk = 2,
-    Wpa2Psk = 3,
-    WpaWpa2Psk = 4,
-    Wpa2Enterprise = 5,
-    Wpa3Psk = 6,
-    Wpa2Wpa3Psk = 7,
+impl CtrlMsg_Resp_EnableDisable {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
 }
-
-/// enums for Control path
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlStatus {
-    #[default]
-    Connected = 0,
-    NotConnected = 1,
-    NoApFound = 2,
-    ConnectionFail = 3,
-    InvalidArgument = 4,
-    OutOfRange = 5,
+impl ::micropb::MessageDecode for CtrlMsg_Resp_EnableDisable {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
+impl ::micropb::MessageEncode for CtrlMsg_Resp_EnableDisable {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlMsgType {
-    #[default]
-    MsgTypeInvalid = 0,
-    Req = 1,
-    Resp = 2,
-    Event = 3,
-    MsgTypeMax = 4,
+pub struct CtrlMsg_Req_GetFwVersion {}
+impl CtrlMsg_Req_GetFwVersion {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetFwVersion {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
 }
-
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash, PartialOrd, Ord, noproto::Enumeration)]
-#[repr(u32)]
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub(crate) enum CtrlMsgId {
-    #[default]
-    MsgIdInvalid = 0,
-    /// * Request Msgs *
-    ReqBase = 100,
-    ReqGetMacAddress = 101,
-    ReqSetMacAddress = 102,
-    ReqGetWifiMode = 103,
-    ReqSetWifiMode = 104,
-    ReqGetApScanList = 105,
-    ReqGetApConfig = 106,
-    ReqConnectAp = 107,
-    ReqDisconnectAp = 108,
-    ReqGetSoftApConfig = 109,
-    ReqSetSoftApVendorSpecificIe = 110,
-    ReqStartSoftAp = 111,
-    ReqGetSoftApConnectedStaList = 112,
-    ReqStopSoftAp = 113,
-    ReqSetPowerSaveMode = 114,
-    ReqGetPowerSaveMode = 115,
-    ReqOtaBegin = 116,
-    ReqOtaWrite = 117,
-    ReqOtaEnd = 118,
-    ReqSetWifiMaxTxPower = 119,
-    ReqGetWifiCurrTxPower = 120,
-    ReqConfigHeartbeat = 121,
-    /// Add new control path command response before Req_Max
-    /// and update Req_Max
-    ReqMax = 122,
-    /// * Response Msgs *
-    RespBase = 200,
-    RespGetMacAddress = 201,
-    RespSetMacAddress = 202,
-    RespGetWifiMode = 203,
-    RespSetWifiMode = 204,
-    RespGetApScanList = 205,
-    RespGetApConfig = 206,
-    RespConnectAp = 207,
-    RespDisconnectAp = 208,
-    RespGetSoftApConfig = 209,
-    RespSetSoftApVendorSpecificIe = 210,
-    RespStartSoftAp = 211,
-    RespGetSoftApConnectedStaList = 212,
-    RespStopSoftAp = 213,
-    RespSetPowerSaveMode = 214,
-    RespGetPowerSaveMode = 215,
-    RespOtaBegin = 216,
-    RespOtaWrite = 217,
-    RespOtaEnd = 218,
-    RespSetWifiMaxTxPower = 219,
-    RespGetWifiCurrTxPower = 220,
-    RespConfigHeartbeat = 221,
-    /// Add new control path command response before Resp_Max
-    /// and update Resp_Max
-    RespMax = 222,
-    /// * Event Msgs *
-    EventBase = 300,
-    EventEspInit = 301,
-    EventHeartbeat = 302,
-    EventStationDisconnectFromAp = 303,
-    EventStationDisconnectFromEspSoftAp = 304,
-    /// Add new control path command notification before Event_Max
-    /// and update Event_Max
-    EventMax = 305,
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetFwVersion {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Resp_GetFwVersion {
+    pub r#resp: i32,
+    pub r#name: ::micropb::heapless::String<32>,
+    pub r#major1: u32,
+    pub r#major2: u32,
+    pub r#minor: u32,
+    pub r#rev_patch1: u32,
+    pub r#rev_patch2: u32,
+}
+impl CtrlMsg_Resp_GetFwVersion {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `name`
+    #[inline]
+    pub fn r#name(&self) -> &::micropb::heapless::String<32> {
+        &self.r#name
+    }
+    ///Return a mutable reference to `name`
+    #[inline]
+    pub fn mut_name(&mut self) -> &mut ::micropb::heapless::String<32> {
+        &mut self.r#name
+    }
+    ///Set the value of `name`
+    #[inline]
+    pub fn set_name(&mut self, value: ::micropb::heapless::String<32>) -> &mut Self {
+        self.r#name = value.into();
+        self
+    }
+    ///Builder method that sets the value of `name`. Useful for initializing the message.
+    #[inline]
+    pub fn init_name(mut self, value: ::micropb::heapless::String<32>) -> Self {
+        self.r#name = value.into();
+        self
+    }
+    ///Return a reference to `major1`
+    #[inline]
+    pub fn r#major1(&self) -> &u32 {
+        &self.r#major1
+    }
+    ///Return a mutable reference to `major1`
+    #[inline]
+    pub fn mut_major1(&mut self) -> &mut u32 {
+        &mut self.r#major1
+    }
+    ///Set the value of `major1`
+    #[inline]
+    pub fn set_major1(&mut self, value: u32) -> &mut Self {
+        self.r#major1 = value.into();
+        self
+    }
+    ///Builder method that sets the value of `major1`. Useful for initializing the message.
+    #[inline]
+    pub fn init_major1(mut self, value: u32) -> Self {
+        self.r#major1 = value.into();
+        self
+    }
+    ///Return a reference to `major2`
+    #[inline]
+    pub fn r#major2(&self) -> &u32 {
+        &self.r#major2
+    }
+    ///Return a mutable reference to `major2`
+    #[inline]
+    pub fn mut_major2(&mut self) -> &mut u32 {
+        &mut self.r#major2
+    }
+    ///Set the value of `major2`
+    #[inline]
+    pub fn set_major2(&mut self, value: u32) -> &mut Self {
+        self.r#major2 = value.into();
+        self
+    }
+    ///Builder method that sets the value of `major2`. Useful for initializing the message.
+    #[inline]
+    pub fn init_major2(mut self, value: u32) -> Self {
+        self.r#major2 = value.into();
+        self
+    }
+    ///Return a reference to `minor`
+    #[inline]
+    pub fn r#minor(&self) -> &u32 {
+        &self.r#minor
+    }
+    ///Return a mutable reference to `minor`
+    #[inline]
+    pub fn mut_minor(&mut self) -> &mut u32 {
+        &mut self.r#minor
+    }
+    ///Set the value of `minor`
+    #[inline]
+    pub fn set_minor(&mut self, value: u32) -> &mut Self {
+        self.r#minor = value.into();
+        self
+    }
+    ///Builder method that sets the value of `minor`. Useful for initializing the message.
+    #[inline]
+    pub fn init_minor(mut self, value: u32) -> Self {
+        self.r#minor = value.into();
+        self
+    }
+    ///Return a reference to `rev_patch1`
+    #[inline]
+    pub fn r#rev_patch1(&self) -> &u32 {
+        &self.r#rev_patch1
+    }
+    ///Return a mutable reference to `rev_patch1`
+    #[inline]
+    pub fn mut_rev_patch1(&mut self) -> &mut u32 {
+        &mut self.r#rev_patch1
+    }
+    ///Set the value of `rev_patch1`
+    #[inline]
+    pub fn set_rev_patch1(&mut self, value: u32) -> &mut Self {
+        self.r#rev_patch1 = value.into();
+        self
+    }
+    ///Builder method that sets the value of `rev_patch1`. Useful for initializing the message.
+    #[inline]
+    pub fn init_rev_patch1(mut self, value: u32) -> Self {
+        self.r#rev_patch1 = value.into();
+        self
+    }
+    ///Return a reference to `rev_patch2`
+    #[inline]
+    pub fn r#rev_patch2(&self) -> &u32 {
+        &self.r#rev_patch2
+    }
+    ///Return a mutable reference to `rev_patch2`
+    #[inline]
+    pub fn mut_rev_patch2(&mut self) -> &mut u32 {
+        &mut self.r#rev_patch2
+    }
+    ///Set the value of `rev_patch2`
+    #[inline]
+    pub fn set_rev_patch2(&mut self, value: u32) -> &mut Self {
+        self.r#rev_patch2 = value.into();
+        self
+    }
+    ///Builder method that sets the value of `rev_patch2`. Useful for initializing the message.
+    #[inline]
+    pub fn init_rev_patch2(mut self, value: u32) -> Self {
+        self.r#rev_patch2 = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetFwVersion {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#name;
+                    {
+                        decoder.decode_string(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#major1;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#major2;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#minor;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#rev_patch1;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                7u32 => {
+                    let mut_ref = &mut self.r#rev_patch2;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetFwVersion {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#name;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_string(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#major1;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#major2;
+            if *val_ref != 0 {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#minor;
+            if *val_ref != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#rev_patch1;
+            if *val_ref != 0 {
+                encoder.encode_varint32(48u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#rev_patch2;
+            if *val_ref != 0 {
+                encoder.encode_varint32(56u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#name;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#major1;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#major2;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#minor;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#rev_patch1;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#rev_patch2;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Req_SetCountryCode {
+    pub r#country: ::micropb::heapless::Vec<u8, 32>,
+    pub r#ieee80211d_enabled: bool,
+}
+impl CtrlMsg_Req_SetCountryCode {
+    ///Return a reference to `country`
+    #[inline]
+    pub fn r#country(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#country
+    }
+    ///Return a mutable reference to `country`
+    #[inline]
+    pub fn mut_country(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#country
+    }
+    ///Set the value of `country`
+    #[inline]
+    pub fn set_country(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#country = value.into();
+        self
+    }
+    ///Builder method that sets the value of `country`. Useful for initializing the message.
+    #[inline]
+    pub fn init_country(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#country = value.into();
+        self
+    }
+    ///Return a reference to `ieee80211d_enabled`
+    #[inline]
+    pub fn r#ieee80211d_enabled(&self) -> &bool {
+        &self.r#ieee80211d_enabled
+    }
+    ///Return a mutable reference to `ieee80211d_enabled`
+    #[inline]
+    pub fn mut_ieee80211d_enabled(&mut self) -> &mut bool {
+        &mut self.r#ieee80211d_enabled
+    }
+    ///Set the value of `ieee80211d_enabled`
+    #[inline]
+    pub fn set_ieee80211d_enabled(&mut self, value: bool) -> &mut Self {
+        self.r#ieee80211d_enabled = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ieee80211d_enabled`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ieee80211d_enabled(mut self, value: bool) -> Self {
+        self.r#ieee80211d_enabled = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_SetCountryCode {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#country;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#ieee80211d_enabled;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_SetCountryCode {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#country;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#ieee80211d_enabled;
+            if *val_ref {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#country;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#ieee80211d_enabled;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Resp_SetCountryCode {
+    pub r#resp: i32,
+}
+impl CtrlMsg_Resp_SetCountryCode {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_SetCountryCode {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_SetCountryCode {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Req_GetCountryCode {}
+impl CtrlMsg_Req_GetCountryCode {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetCountryCode {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetCountryCode {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Resp_GetCountryCode {
+    pub r#resp: i32,
+    pub r#country: ::micropb::heapless::Vec<u8, 32>,
+}
+impl CtrlMsg_Resp_GetCountryCode {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `country`
+    #[inline]
+    pub fn r#country(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#country
+    }
+    ///Return a mutable reference to `country`
+    #[inline]
+    pub fn mut_country(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#country
+    }
+    ///Set the value of `country`
+    #[inline]
+    pub fn set_country(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#country = value.into();
+        self
+    }
+    ///Builder method that sets the value of `country`. Useful for initializing the message.
+    #[inline]
+    pub fn init_country(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#country = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetCountryCode {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#country;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetCountryCode {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#country;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#country;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Req_SetDhcpDnsStatus {
+    pub r#iface: i32,
+    pub r#net_link_up: i32,
+    pub r#dhcp_up: i32,
+    pub r#dhcp_ip: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dhcp_nm: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dhcp_gw: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dns_up: i32,
+    pub r#dns_ip: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dns_type: i32,
+}
+impl CtrlMsg_Req_SetDhcpDnsStatus {
+    ///Return a reference to `iface`
+    #[inline]
+    pub fn r#iface(&self) -> &i32 {
+        &self.r#iface
+    }
+    ///Return a mutable reference to `iface`
+    #[inline]
+    pub fn mut_iface(&mut self) -> &mut i32 {
+        &mut self.r#iface
+    }
+    ///Set the value of `iface`
+    #[inline]
+    pub fn set_iface(&mut self, value: i32) -> &mut Self {
+        self.r#iface = value.into();
+        self
+    }
+    ///Builder method that sets the value of `iface`. Useful for initializing the message.
+    #[inline]
+    pub fn init_iface(mut self, value: i32) -> Self {
+        self.r#iface = value.into();
+        self
+    }
+    ///Return a reference to `net_link_up`
+    #[inline]
+    pub fn r#net_link_up(&self) -> &i32 {
+        &self.r#net_link_up
+    }
+    ///Return a mutable reference to `net_link_up`
+    #[inline]
+    pub fn mut_net_link_up(&mut self) -> &mut i32 {
+        &mut self.r#net_link_up
+    }
+    ///Set the value of `net_link_up`
+    #[inline]
+    pub fn set_net_link_up(&mut self, value: i32) -> &mut Self {
+        self.r#net_link_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `net_link_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_net_link_up(mut self, value: i32) -> Self {
+        self.r#net_link_up = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_up`
+    #[inline]
+    pub fn r#dhcp_up(&self) -> &i32 {
+        &self.r#dhcp_up
+    }
+    ///Return a mutable reference to `dhcp_up`
+    #[inline]
+    pub fn mut_dhcp_up(&mut self) -> &mut i32 {
+        &mut self.r#dhcp_up
+    }
+    ///Set the value of `dhcp_up`
+    #[inline]
+    pub fn set_dhcp_up(&mut self, value: i32) -> &mut Self {
+        self.r#dhcp_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_up(mut self, value: i32) -> Self {
+        self.r#dhcp_up = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_ip`
+    #[inline]
+    pub fn r#dhcp_ip(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_ip
+    }
+    ///Return a mutable reference to `dhcp_ip`
+    #[inline]
+    pub fn mut_dhcp_ip(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_ip
+    }
+    ///Set the value of `dhcp_ip`
+    #[inline]
+    pub fn set_dhcp_ip(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_ip = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_ip`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_ip(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_ip = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_nm`
+    #[inline]
+    pub fn r#dhcp_nm(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_nm
+    }
+    ///Return a mutable reference to `dhcp_nm`
+    #[inline]
+    pub fn mut_dhcp_nm(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_nm
+    }
+    ///Set the value of `dhcp_nm`
+    #[inline]
+    pub fn set_dhcp_nm(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_nm = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_nm`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_nm(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_nm = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_gw`
+    #[inline]
+    pub fn r#dhcp_gw(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_gw
+    }
+    ///Return a mutable reference to `dhcp_gw`
+    #[inline]
+    pub fn mut_dhcp_gw(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_gw
+    }
+    ///Set the value of `dhcp_gw`
+    #[inline]
+    pub fn set_dhcp_gw(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_gw = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_gw`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_gw(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_gw = value.into();
+        self
+    }
+    ///Return a reference to `dns_up`
+    #[inline]
+    pub fn r#dns_up(&self) -> &i32 {
+        &self.r#dns_up
+    }
+    ///Return a mutable reference to `dns_up`
+    #[inline]
+    pub fn mut_dns_up(&mut self) -> &mut i32 {
+        &mut self.r#dns_up
+    }
+    ///Set the value of `dns_up`
+    #[inline]
+    pub fn set_dns_up(&mut self, value: i32) -> &mut Self {
+        self.r#dns_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_up(mut self, value: i32) -> Self {
+        self.r#dns_up = value.into();
+        self
+    }
+    ///Return a reference to `dns_ip`
+    #[inline]
+    pub fn r#dns_ip(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dns_ip
+    }
+    ///Return a mutable reference to `dns_ip`
+    #[inline]
+    pub fn mut_dns_ip(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dns_ip
+    }
+    ///Set the value of `dns_ip`
+    #[inline]
+    pub fn set_dns_ip(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dns_ip = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_ip`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_ip(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dns_ip = value.into();
+        self
+    }
+    ///Return a reference to `dns_type`
+    #[inline]
+    pub fn r#dns_type(&self) -> &i32 {
+        &self.r#dns_type
+    }
+    ///Return a mutable reference to `dns_type`
+    #[inline]
+    pub fn mut_dns_type(&mut self) -> &mut i32 {
+        &mut self.r#dns_type
+    }
+    ///Set the value of `dns_type`
+    #[inline]
+    pub fn set_dns_type(&mut self, value: i32) -> &mut Self {
+        self.r#dns_type = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_type`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_type(mut self, value: i32) -> Self {
+        self.r#dns_type = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_SetDhcpDnsStatus {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#iface;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#net_link_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#dhcp_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#dhcp_ip;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#dhcp_nm;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#dhcp_gw;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                7u32 => {
+                    let mut_ref = &mut self.r#dns_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                8u32 => {
+                    let mut_ref = &mut self.r#dns_ip;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                9u32 => {
+                    let mut_ref = &mut self.r#dns_type;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_SetDhcpDnsStatus {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#iface;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#net_link_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_ip;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(34u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_nm;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(42u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_gw;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(50u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(56u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_ip;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(66u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_type;
+            if *val_ref != 0 {
+                encoder.encode_varint32(72u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#iface;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#net_link_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_ip;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_nm;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_gw;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dns_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dns_ip;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dns_type;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Resp_SetDhcpDnsStatus {
+    pub r#resp: i32,
+}
+impl CtrlMsg_Resp_SetDhcpDnsStatus {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_SetDhcpDnsStatus {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_SetDhcpDnsStatus {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Req_GetDhcpDnsStatus {}
+impl CtrlMsg_Req_GetDhcpDnsStatus {}
+impl ::micropb::MessageDecode for CtrlMsg_Req_GetDhcpDnsStatus {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_GetDhcpDnsStatus {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Resp_GetDhcpDnsStatus {
+    pub r#resp: i32,
+    pub r#iface: i32,
+    pub r#net_link_up: i32,
+    pub r#dhcp_up: i32,
+    pub r#dhcp_ip: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dhcp_nm: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dhcp_gw: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dns_up: i32,
+    pub r#dns_ip: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dns_type: i32,
+}
+impl CtrlMsg_Resp_GetDhcpDnsStatus {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `iface`
+    #[inline]
+    pub fn r#iface(&self) -> &i32 {
+        &self.r#iface
+    }
+    ///Return a mutable reference to `iface`
+    #[inline]
+    pub fn mut_iface(&mut self) -> &mut i32 {
+        &mut self.r#iface
+    }
+    ///Set the value of `iface`
+    #[inline]
+    pub fn set_iface(&mut self, value: i32) -> &mut Self {
+        self.r#iface = value.into();
+        self
+    }
+    ///Builder method that sets the value of `iface`. Useful for initializing the message.
+    #[inline]
+    pub fn init_iface(mut self, value: i32) -> Self {
+        self.r#iface = value.into();
+        self
+    }
+    ///Return a reference to `net_link_up`
+    #[inline]
+    pub fn r#net_link_up(&self) -> &i32 {
+        &self.r#net_link_up
+    }
+    ///Return a mutable reference to `net_link_up`
+    #[inline]
+    pub fn mut_net_link_up(&mut self) -> &mut i32 {
+        &mut self.r#net_link_up
+    }
+    ///Set the value of `net_link_up`
+    #[inline]
+    pub fn set_net_link_up(&mut self, value: i32) -> &mut Self {
+        self.r#net_link_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `net_link_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_net_link_up(mut self, value: i32) -> Self {
+        self.r#net_link_up = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_up`
+    #[inline]
+    pub fn r#dhcp_up(&self) -> &i32 {
+        &self.r#dhcp_up
+    }
+    ///Return a mutable reference to `dhcp_up`
+    #[inline]
+    pub fn mut_dhcp_up(&mut self) -> &mut i32 {
+        &mut self.r#dhcp_up
+    }
+    ///Set the value of `dhcp_up`
+    #[inline]
+    pub fn set_dhcp_up(&mut self, value: i32) -> &mut Self {
+        self.r#dhcp_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_up(mut self, value: i32) -> Self {
+        self.r#dhcp_up = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_ip`
+    #[inline]
+    pub fn r#dhcp_ip(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_ip
+    }
+    ///Return a mutable reference to `dhcp_ip`
+    #[inline]
+    pub fn mut_dhcp_ip(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_ip
+    }
+    ///Set the value of `dhcp_ip`
+    #[inline]
+    pub fn set_dhcp_ip(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_ip = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_ip`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_ip(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_ip = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_nm`
+    #[inline]
+    pub fn r#dhcp_nm(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_nm
+    }
+    ///Return a mutable reference to `dhcp_nm`
+    #[inline]
+    pub fn mut_dhcp_nm(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_nm
+    }
+    ///Set the value of `dhcp_nm`
+    #[inline]
+    pub fn set_dhcp_nm(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_nm = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_nm`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_nm(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_nm = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_gw`
+    #[inline]
+    pub fn r#dhcp_gw(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_gw
+    }
+    ///Return a mutable reference to `dhcp_gw`
+    #[inline]
+    pub fn mut_dhcp_gw(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_gw
+    }
+    ///Set the value of `dhcp_gw`
+    #[inline]
+    pub fn set_dhcp_gw(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_gw = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_gw`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_gw(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_gw = value.into();
+        self
+    }
+    ///Return a reference to `dns_up`
+    #[inline]
+    pub fn r#dns_up(&self) -> &i32 {
+        &self.r#dns_up
+    }
+    ///Return a mutable reference to `dns_up`
+    #[inline]
+    pub fn mut_dns_up(&mut self) -> &mut i32 {
+        &mut self.r#dns_up
+    }
+    ///Set the value of `dns_up`
+    #[inline]
+    pub fn set_dns_up(&mut self, value: i32) -> &mut Self {
+        self.r#dns_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_up(mut self, value: i32) -> Self {
+        self.r#dns_up = value.into();
+        self
+    }
+    ///Return a reference to `dns_ip`
+    #[inline]
+    pub fn r#dns_ip(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dns_ip
+    }
+    ///Return a mutable reference to `dns_ip`
+    #[inline]
+    pub fn mut_dns_ip(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dns_ip
+    }
+    ///Set the value of `dns_ip`
+    #[inline]
+    pub fn set_dns_ip(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dns_ip = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_ip`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_ip(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dns_ip = value.into();
+        self
+    }
+    ///Return a reference to `dns_type`
+    #[inline]
+    pub fn r#dns_type(&self) -> &i32 {
+        &self.r#dns_type
+    }
+    ///Return a mutable reference to `dns_type`
+    #[inline]
+    pub fn mut_dns_type(&mut self) -> &mut i32 {
+        &mut self.r#dns_type
+    }
+    ///Set the value of `dns_type`
+    #[inline]
+    pub fn set_dns_type(&mut self, value: i32) -> &mut Self {
+        self.r#dns_type = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_type`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_type(mut self, value: i32) -> Self {
+        self.r#dns_type = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_GetDhcpDnsStatus {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#iface;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#net_link_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#dhcp_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#dhcp_ip;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#dhcp_nm;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                7u32 => {
+                    let mut_ref = &mut self.r#dhcp_gw;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                8u32 => {
+                    let mut_ref = &mut self.r#dns_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                9u32 => {
+                    let mut_ref = &mut self.r#dns_ip;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                10u32 => {
+                    let mut_ref = &mut self.r#dns_type;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_GetDhcpDnsStatus {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#iface;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#net_link_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_ip;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(42u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_nm;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(50u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_gw;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(58u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(64u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_ip;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(74u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_type;
+            if *val_ref != 0 {
+                encoder.encode_varint32(80u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#iface;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#net_link_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_ip;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_nm;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_gw;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dns_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dns_ip;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dns_type;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Event_ESPInit {
+    pub r#init_data: ::micropb::heapless::Vec<u8, 64>,
+}
+impl CtrlMsg_Event_ESPInit {
+    ///Return a reference to `init_data`
+    #[inline]
+    pub fn r#init_data(&self) -> &::micropb::heapless::Vec<u8, 64> {
+        &self.r#init_data
+    }
+    ///Return a mutable reference to `init_data`
+    #[inline]
+    pub fn mut_init_data(&mut self) -> &mut ::micropb::heapless::Vec<u8, 64> {
+        &mut self.r#init_data
+    }
+    ///Set the value of `init_data`
+    #[inline]
+    pub fn set_init_data(&mut self, value: ::micropb::heapless::Vec<u8, 64>) -> &mut Self {
+        self.r#init_data = value.into();
+        self
+    }
+    ///Builder method that sets the value of `init_data`. Useful for initializing the message.
+    #[inline]
+    pub fn init_init_data(mut self, value: ::micropb::heapless::Vec<u8, 64>) -> Self {
+        self.r#init_data = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Event_ESPInit {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#init_data;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Event_ESPInit {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(65usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#init_data;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(10u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#init_data;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Event_Heartbeat {
+    pub r#hb_num: i32,
+}
+impl CtrlMsg_Event_Heartbeat {
+    ///Return a reference to `hb_num`
+    #[inline]
+    pub fn r#hb_num(&self) -> &i32 {
+        &self.r#hb_num
+    }
+    ///Return a mutable reference to `hb_num`
+    #[inline]
+    pub fn mut_hb_num(&mut self) -> &mut i32 {
+        &mut self.r#hb_num
+    }
+    ///Set the value of `hb_num`
+    #[inline]
+    pub fn set_hb_num(&mut self, value: i32) -> &mut Self {
+        self.r#hb_num = value.into();
+        self
+    }
+    ///Builder method that sets the value of `hb_num`. Useful for initializing the message.
+    #[inline]
+    pub fn init_hb_num(mut self, value: i32) -> Self {
+        self.r#hb_num = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Event_Heartbeat {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#hb_num;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Event_Heartbeat {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#hb_num;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#hb_num;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Event_StationDisconnectFromAP {
+    pub r#resp: i32,
+    pub r#ssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#ssid_len: u32,
+    pub r#bssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#reason: u32,
+    pub r#rssi: i32,
+}
+impl CtrlMsg_Event_StationDisconnectFromAP {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `ssid`
+    #[inline]
+    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#ssid
+    }
+    ///Return a mutable reference to `ssid`
+    #[inline]
+    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#ssid
+    }
+    ///Set the value of `ssid`
+    #[inline]
+    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Return a reference to `ssid_len`
+    #[inline]
+    pub fn r#ssid_len(&self) -> &u32 {
+        &self.r#ssid_len
+    }
+    ///Return a mutable reference to `ssid_len`
+    #[inline]
+    pub fn mut_ssid_len(&mut self) -> &mut u32 {
+        &mut self.r#ssid_len
+    }
+    ///Set the value of `ssid_len`
+    #[inline]
+    pub fn set_ssid_len(&mut self, value: u32) -> &mut Self {
+        self.r#ssid_len = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid_len`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid_len(mut self, value: u32) -> Self {
+        self.r#ssid_len = value.into();
+        self
+    }
+    ///Return a reference to `bssid`
+    #[inline]
+    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#bssid
+    }
+    ///Return a mutable reference to `bssid`
+    #[inline]
+    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#bssid
+    }
+    ///Set the value of `bssid`
+    #[inline]
+    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Return a reference to `reason`
+    #[inline]
+    pub fn r#reason(&self) -> &u32 {
+        &self.r#reason
+    }
+    ///Return a mutable reference to `reason`
+    #[inline]
+    pub fn mut_reason(&mut self) -> &mut u32 {
+        &mut self.r#reason
+    }
+    ///Set the value of `reason`
+    #[inline]
+    pub fn set_reason(&mut self, value: u32) -> &mut Self {
+        self.r#reason = value.into();
+        self
+    }
+    ///Builder method that sets the value of `reason`. Useful for initializing the message.
+    #[inline]
+    pub fn init_reason(mut self, value: u32) -> Self {
+        self.r#reason = value.into();
+        self
+    }
+    ///Return a reference to `rssi`
+    #[inline]
+    pub fn r#rssi(&self) -> &i32 {
+        &self.r#rssi
+    }
+    ///Return a mutable reference to `rssi`
+    #[inline]
+    pub fn mut_rssi(&mut self) -> &mut i32 {
+        &mut self.r#rssi
+    }
+    ///Set the value of `rssi`
+    #[inline]
+    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
+        self.r#rssi = value.into();
+        self
+    }
+    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
+    #[inline]
+    pub fn init_rssi(mut self, value: i32) -> Self {
+        self.r#rssi = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Event_StationDisconnectFromAP {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#ssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#ssid_len;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#bssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#reason;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#rssi;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Event_StationDisconnectFromAP {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#ssid_len;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(34u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#reason;
+            if *val_ref != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#rssi;
+            if *val_ref != 0 {
+                encoder.encode_varint32(48u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#ssid_len;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#reason;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#rssi;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Event_StationConnectedToAP {
+    pub r#resp: i32,
+    pub r#ssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#ssid_len: u32,
+    pub r#bssid: ::micropb::heapless::Vec<u8, 32>,
+    pub r#channel: u32,
+    pub r#authmode: i32,
+    pub r#aid: i32,
+}
+impl CtrlMsg_Event_StationConnectedToAP {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `ssid`
+    #[inline]
+    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#ssid
+    }
+    ///Return a mutable reference to `ssid`
+    #[inline]
+    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#ssid
+    }
+    ///Set the value of `ssid`
+    #[inline]
+    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#ssid = value.into();
+        self
+    }
+    ///Return a reference to `ssid_len`
+    #[inline]
+    pub fn r#ssid_len(&self) -> &u32 {
+        &self.r#ssid_len
+    }
+    ///Return a mutable reference to `ssid_len`
+    #[inline]
+    pub fn mut_ssid_len(&mut self) -> &mut u32 {
+        &mut self.r#ssid_len
+    }
+    ///Set the value of `ssid_len`
+    #[inline]
+    pub fn set_ssid_len(&mut self, value: u32) -> &mut Self {
+        self.r#ssid_len = value.into();
+        self
+    }
+    ///Builder method that sets the value of `ssid_len`. Useful for initializing the message.
+    #[inline]
+    pub fn init_ssid_len(mut self, value: u32) -> Self {
+        self.r#ssid_len = value.into();
+        self
+    }
+    ///Return a reference to `bssid`
+    #[inline]
+    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#bssid
+    }
+    ///Return a mutable reference to `bssid`
+    #[inline]
+    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#bssid
+    }
+    ///Set the value of `bssid`
+    #[inline]
+    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#bssid = value.into();
+        self
+    }
+    ///Return a reference to `channel`
+    #[inline]
+    pub fn r#channel(&self) -> &u32 {
+        &self.r#channel
+    }
+    ///Return a mutable reference to `channel`
+    #[inline]
+    pub fn mut_channel(&mut self) -> &mut u32 {
+        &mut self.r#channel
+    }
+    ///Set the value of `channel`
+    #[inline]
+    pub fn set_channel(&mut self, value: u32) -> &mut Self {
+        self.r#channel = value.into();
+        self
+    }
+    ///Builder method that sets the value of `channel`. Useful for initializing the message.
+    #[inline]
+    pub fn init_channel(mut self, value: u32) -> Self {
+        self.r#channel = value.into();
+        self
+    }
+    ///Return a reference to `authmode`
+    #[inline]
+    pub fn r#authmode(&self) -> &i32 {
+        &self.r#authmode
+    }
+    ///Return a mutable reference to `authmode`
+    #[inline]
+    pub fn mut_authmode(&mut self) -> &mut i32 {
+        &mut self.r#authmode
+    }
+    ///Set the value of `authmode`
+    #[inline]
+    pub fn set_authmode(&mut self, value: i32) -> &mut Self {
+        self.r#authmode = value.into();
+        self
+    }
+    ///Builder method that sets the value of `authmode`. Useful for initializing the message.
+    #[inline]
+    pub fn init_authmode(mut self, value: i32) -> Self {
+        self.r#authmode = value.into();
+        self
+    }
+    ///Return a reference to `aid`
+    #[inline]
+    pub fn r#aid(&self) -> &i32 {
+        &self.r#aid
+    }
+    ///Return a mutable reference to `aid`
+    #[inline]
+    pub fn mut_aid(&mut self) -> &mut i32 {
+        &mut self.r#aid
+    }
+    ///Set the value of `aid`
+    #[inline]
+    pub fn set_aid(&mut self, value: i32) -> &mut Self {
+        self.r#aid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `aid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_aid(mut self, value: i32) -> Self {
+        self.r#aid = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Event_StationConnectedToAP {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#ssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#ssid_len;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#bssid;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#channel;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#authmode;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                7u32 => {
+                    let mut_ref = &mut self.r#aid;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Event_StationConnectedToAP {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#ssid_len;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(34u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#channel;
+            if *val_ref != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#authmode;
+            if *val_ref != 0 {
+                encoder.encode_varint32(48u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#aid;
+            if *val_ref != 0 {
+                encoder.encode_varint32(56u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#ssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#ssid_len;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#bssid;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#channel;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#authmode;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#aid;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Event_StationDisconnectFromESPSoftAP {
+    pub r#resp: i32,
+    pub r#mac: ::micropb::heapless::Vec<u8, 32>,
+    pub r#aid: u32,
+    pub r#is_mesh_child: bool,
+    pub r#reason: u32,
+}
+impl CtrlMsg_Event_StationDisconnectFromESPSoftAP {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `mac`
+    #[inline]
+    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#mac
+    }
+    ///Return a mutable reference to `mac`
+    #[inline]
+    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#mac
+    }
+    ///Set the value of `mac`
+    #[inline]
+    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mac`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Return a reference to `aid`
+    #[inline]
+    pub fn r#aid(&self) -> &u32 {
+        &self.r#aid
+    }
+    ///Return a mutable reference to `aid`
+    #[inline]
+    pub fn mut_aid(&mut self) -> &mut u32 {
+        &mut self.r#aid
+    }
+    ///Set the value of `aid`
+    #[inline]
+    pub fn set_aid(&mut self, value: u32) -> &mut Self {
+        self.r#aid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `aid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_aid(mut self, value: u32) -> Self {
+        self.r#aid = value.into();
+        self
+    }
+    ///Return a reference to `is_mesh_child`
+    #[inline]
+    pub fn r#is_mesh_child(&self) -> &bool {
+        &self.r#is_mesh_child
+    }
+    ///Return a mutable reference to `is_mesh_child`
+    #[inline]
+    pub fn mut_is_mesh_child(&mut self) -> &mut bool {
+        &mut self.r#is_mesh_child
+    }
+    ///Set the value of `is_mesh_child`
+    #[inline]
+    pub fn set_is_mesh_child(&mut self, value: bool) -> &mut Self {
+        self.r#is_mesh_child = value.into();
+        self
+    }
+    ///Builder method that sets the value of `is_mesh_child`. Useful for initializing the message.
+    #[inline]
+    pub fn init_is_mesh_child(mut self, value: bool) -> Self {
+        self.r#is_mesh_child = value.into();
+        self
+    }
+    ///Return a reference to `reason`
+    #[inline]
+    pub fn r#reason(&self) -> &u32 {
+        &self.r#reason
+    }
+    ///Return a mutable reference to `reason`
+    #[inline]
+    pub fn mut_reason(&mut self) -> &mut u32 {
+        &mut self.r#reason
+    }
+    ///Set the value of `reason`
+    #[inline]
+    pub fn set_reason(&mut self, value: u32) -> &mut Self {
+        self.r#reason = value.into();
+        self
+    }
+    ///Builder method that sets the value of `reason`. Useful for initializing the message.
+    #[inline]
+    pub fn init_reason(mut self, value: u32) -> Self {
+        self.r#reason = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Event_StationDisconnectFromESPSoftAP {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#mac;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#aid;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#is_mesh_child;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#reason;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Event_StationDisconnectFromESPSoftAP {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#aid;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#is_mesh_child;
+            if *val_ref {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#reason;
+            if *val_ref != 0 {
+                encoder.encode_varint32(40u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#aid;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#is_mesh_child;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        {
+            let val_ref = &self.r#reason;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Event_StationConnectedToESPSoftAP {
+    pub r#resp: i32,
+    pub r#mac: ::micropb::heapless::Vec<u8, 32>,
+    pub r#aid: u32,
+    pub r#is_mesh_child: bool,
+}
+impl CtrlMsg_Event_StationConnectedToESPSoftAP {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `mac`
+    #[inline]
+    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#mac
+    }
+    ///Return a mutable reference to `mac`
+    #[inline]
+    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#mac
+    }
+    ///Set the value of `mac`
+    #[inline]
+    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Builder method that sets the value of `mac`. Useful for initializing the message.
+    #[inline]
+    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#mac = value.into();
+        self
+    }
+    ///Return a reference to `aid`
+    #[inline]
+    pub fn r#aid(&self) -> &u32 {
+        &self.r#aid
+    }
+    ///Return a mutable reference to `aid`
+    #[inline]
+    pub fn mut_aid(&mut self) -> &mut u32 {
+        &mut self.r#aid
+    }
+    ///Set the value of `aid`
+    #[inline]
+    pub fn set_aid(&mut self, value: u32) -> &mut Self {
+        self.r#aid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `aid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_aid(mut self, value: u32) -> Self {
+        self.r#aid = value.into();
+        self
+    }
+    ///Return a reference to `is_mesh_child`
+    #[inline]
+    pub fn r#is_mesh_child(&self) -> &bool {
+        &self.r#is_mesh_child
+    }
+    ///Return a mutable reference to `is_mesh_child`
+    #[inline]
+    pub fn mut_is_mesh_child(&mut self) -> &mut bool {
+        &mut self.r#is_mesh_child
+    }
+    ///Set the value of `is_mesh_child`
+    #[inline]
+    pub fn set_is_mesh_child(&mut self, value: bool) -> &mut Self {
+        self.r#is_mesh_child = value.into();
+        self
+    }
+    ///Builder method that sets the value of `is_mesh_child`. Useful for initializing the message.
+    #[inline]
+    pub fn init_is_mesh_child(mut self, value: bool) -> Self {
+        self.r#is_mesh_child = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Event_StationConnectedToESPSoftAP {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#mac;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#aid;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#is_mesh_child;
+                    {
+                        let val = decoder.decode_bool()?;
+                        let val_ref = &val;
+                        if *val_ref {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Event_StationConnectedToESPSoftAP {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#aid;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#is_mesh_child;
+            if *val_ref {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_bool(*val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#mac;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#aid;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#is_mesh_child;
+            if *val_ref {
+                size += 1usize + 1;
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Event_SetDhcpDnsStatus {
+    pub r#iface: i32,
+    pub r#net_link_up: i32,
+    pub r#dhcp_up: i32,
+    pub r#dhcp_ip: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dhcp_nm: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dhcp_gw: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dns_up: i32,
+    pub r#dns_ip: ::micropb::heapless::Vec<u8, 32>,
+    pub r#dns_type: i32,
+    pub r#resp: i32,
+}
+impl CtrlMsg_Event_SetDhcpDnsStatus {
+    ///Return a reference to `iface`
+    #[inline]
+    pub fn r#iface(&self) -> &i32 {
+        &self.r#iface
+    }
+    ///Return a mutable reference to `iface`
+    #[inline]
+    pub fn mut_iface(&mut self) -> &mut i32 {
+        &mut self.r#iface
+    }
+    ///Set the value of `iface`
+    #[inline]
+    pub fn set_iface(&mut self, value: i32) -> &mut Self {
+        self.r#iface = value.into();
+        self
+    }
+    ///Builder method that sets the value of `iface`. Useful for initializing the message.
+    #[inline]
+    pub fn init_iface(mut self, value: i32) -> Self {
+        self.r#iface = value.into();
+        self
+    }
+    ///Return a reference to `net_link_up`
+    #[inline]
+    pub fn r#net_link_up(&self) -> &i32 {
+        &self.r#net_link_up
+    }
+    ///Return a mutable reference to `net_link_up`
+    #[inline]
+    pub fn mut_net_link_up(&mut self) -> &mut i32 {
+        &mut self.r#net_link_up
+    }
+    ///Set the value of `net_link_up`
+    #[inline]
+    pub fn set_net_link_up(&mut self, value: i32) -> &mut Self {
+        self.r#net_link_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `net_link_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_net_link_up(mut self, value: i32) -> Self {
+        self.r#net_link_up = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_up`
+    #[inline]
+    pub fn r#dhcp_up(&self) -> &i32 {
+        &self.r#dhcp_up
+    }
+    ///Return a mutable reference to `dhcp_up`
+    #[inline]
+    pub fn mut_dhcp_up(&mut self) -> &mut i32 {
+        &mut self.r#dhcp_up
+    }
+    ///Set the value of `dhcp_up`
+    #[inline]
+    pub fn set_dhcp_up(&mut self, value: i32) -> &mut Self {
+        self.r#dhcp_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_up(mut self, value: i32) -> Self {
+        self.r#dhcp_up = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_ip`
+    #[inline]
+    pub fn r#dhcp_ip(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_ip
+    }
+    ///Return a mutable reference to `dhcp_ip`
+    #[inline]
+    pub fn mut_dhcp_ip(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_ip
+    }
+    ///Set the value of `dhcp_ip`
+    #[inline]
+    pub fn set_dhcp_ip(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_ip = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_ip`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_ip(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_ip = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_nm`
+    #[inline]
+    pub fn r#dhcp_nm(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_nm
+    }
+    ///Return a mutable reference to `dhcp_nm`
+    #[inline]
+    pub fn mut_dhcp_nm(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_nm
+    }
+    ///Set the value of `dhcp_nm`
+    #[inline]
+    pub fn set_dhcp_nm(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_nm = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_nm`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_nm(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_nm = value.into();
+        self
+    }
+    ///Return a reference to `dhcp_gw`
+    #[inline]
+    pub fn r#dhcp_gw(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dhcp_gw
+    }
+    ///Return a mutable reference to `dhcp_gw`
+    #[inline]
+    pub fn mut_dhcp_gw(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dhcp_gw
+    }
+    ///Set the value of `dhcp_gw`
+    #[inline]
+    pub fn set_dhcp_gw(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dhcp_gw = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dhcp_gw`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dhcp_gw(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dhcp_gw = value.into();
+        self
+    }
+    ///Return a reference to `dns_up`
+    #[inline]
+    pub fn r#dns_up(&self) -> &i32 {
+        &self.r#dns_up
+    }
+    ///Return a mutable reference to `dns_up`
+    #[inline]
+    pub fn mut_dns_up(&mut self) -> &mut i32 {
+        &mut self.r#dns_up
+    }
+    ///Set the value of `dns_up`
+    #[inline]
+    pub fn set_dns_up(&mut self, value: i32) -> &mut Self {
+        self.r#dns_up = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_up`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_up(mut self, value: i32) -> Self {
+        self.r#dns_up = value.into();
+        self
+    }
+    ///Return a reference to `dns_ip`
+    #[inline]
+    pub fn r#dns_ip(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#dns_ip
+    }
+    ///Return a mutable reference to `dns_ip`
+    #[inline]
+    pub fn mut_dns_ip(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#dns_ip
+    }
+    ///Set the value of `dns_ip`
+    #[inline]
+    pub fn set_dns_ip(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#dns_ip = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_ip`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_ip(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#dns_ip = value.into();
+        self
+    }
+    ///Return a reference to `dns_type`
+    #[inline]
+    pub fn r#dns_type(&self) -> &i32 {
+        &self.r#dns_type
+    }
+    ///Return a mutable reference to `dns_type`
+    #[inline]
+    pub fn mut_dns_type(&mut self) -> &mut i32 {
+        &mut self.r#dns_type
+    }
+    ///Set the value of `dns_type`
+    #[inline]
+    pub fn set_dns_type(&mut self, value: i32) -> &mut Self {
+        self.r#dns_type = value.into();
+        self
+    }
+    ///Builder method that sets the value of `dns_type`. Useful for initializing the message.
+    #[inline]
+    pub fn init_dns_type(mut self, value: i32) -> Self {
+        self.r#dns_type = value.into();
+        self
+    }
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Event_SetDhcpDnsStatus {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#iface;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#net_link_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#dhcp_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#dhcp_ip;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                5u32 => {
+                    let mut_ref = &mut self.r#dhcp_nm;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                6u32 => {
+                    let mut_ref = &mut self.r#dhcp_gw;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                7u32 => {
+                    let mut_ref = &mut self.r#dns_up;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                8u32 => {
+                    let mut_ref = &mut self.r#dns_ip;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                9u32 => {
+                    let mut_ref = &mut self.r#dns_type;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                10u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Event_SetDhcpDnsStatus {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#iface;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#net_link_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_ip;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(34u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_nm;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(42u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_gw;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(50u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_up;
+            if *val_ref != 0 {
+                encoder.encode_varint32(56u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_ip;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(66u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        {
+            let val_ref = &self.r#dns_type;
+            if *val_ref != 0 {
+                encoder.encode_varint32(72u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(80u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#iface;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#net_link_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_ip;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_nm;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dhcp_gw;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dns_up;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#dns_ip;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        {
+            let val_ref = &self.r#dns_type;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Req_CustomRpcUnserialisedMsg {
+    pub r#custom_msg_id: u32,
+    pub r#data: ::micropb::heapless::Vec<u8, 32>,
+}
+impl CtrlMsg_Req_CustomRpcUnserialisedMsg {
+    ///Return a reference to `custom_msg_id`
+    #[inline]
+    pub fn r#custom_msg_id(&self) -> &u32 {
+        &self.r#custom_msg_id
+    }
+    ///Return a mutable reference to `custom_msg_id`
+    #[inline]
+    pub fn mut_custom_msg_id(&mut self) -> &mut u32 {
+        &mut self.r#custom_msg_id
+    }
+    ///Set the value of `custom_msg_id`
+    #[inline]
+    pub fn set_custom_msg_id(&mut self, value: u32) -> &mut Self {
+        self.r#custom_msg_id = value.into();
+        self
+    }
+    ///Builder method that sets the value of `custom_msg_id`. Useful for initializing the message.
+    #[inline]
+    pub fn init_custom_msg_id(mut self, value: u32) -> Self {
+        self.r#custom_msg_id = value.into();
+        self
+    }
+    ///Return a reference to `data`
+    #[inline]
+    pub fn r#data(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#data
+    }
+    ///Return a mutable reference to `data`
+    #[inline]
+    pub fn mut_data(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#data
+    }
+    ///Set the value of `data`
+    #[inline]
+    pub fn set_data(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#data = value.into();
+        self
+    }
+    ///Builder method that sets the value of `data`. Useful for initializing the message.
+    #[inline]
+    pub fn init_data(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#data = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Req_CustomRpcUnserialisedMsg {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#custom_msg_id;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#data;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Req_CustomRpcUnserialisedMsg {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#custom_msg_id;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#data;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(18u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#custom_msg_id;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#data;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Resp_CustomRpcUnserialisedMsg {
+    pub r#resp: i32,
+    pub r#custom_msg_id: u32,
+    pub r#data: ::micropb::heapless::Vec<u8, 32>,
+}
+impl CtrlMsg_Resp_CustomRpcUnserialisedMsg {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `custom_msg_id`
+    #[inline]
+    pub fn r#custom_msg_id(&self) -> &u32 {
+        &self.r#custom_msg_id
+    }
+    ///Return a mutable reference to `custom_msg_id`
+    #[inline]
+    pub fn mut_custom_msg_id(&mut self) -> &mut u32 {
+        &mut self.r#custom_msg_id
+    }
+    ///Set the value of `custom_msg_id`
+    #[inline]
+    pub fn set_custom_msg_id(&mut self, value: u32) -> &mut Self {
+        self.r#custom_msg_id = value.into();
+        self
+    }
+    ///Builder method that sets the value of `custom_msg_id`. Useful for initializing the message.
+    #[inline]
+    pub fn init_custom_msg_id(mut self, value: u32) -> Self {
+        self.r#custom_msg_id = value.into();
+        self
+    }
+    ///Return a reference to `data`
+    #[inline]
+    pub fn r#data(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#data
+    }
+    ///Return a mutable reference to `data`
+    #[inline]
+    pub fn mut_data(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#data
+    }
+    ///Set the value of `data`
+    #[inline]
+    pub fn set_data(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#data = value.into();
+        self
+    }
+    ///Builder method that sets the value of `data`. Useful for initializing the message.
+    #[inline]
+    pub fn init_data(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#data = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Resp_CustomRpcUnserialisedMsg {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#custom_msg_id;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#data;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Resp_CustomRpcUnserialisedMsg {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#custom_msg_id;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#data;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(26u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#custom_msg_id;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#data;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg_Event_CustomRpcUnserialisedMsg {
+    pub r#resp: i32,
+    pub r#custom_evt_id: u32,
+    pub r#data: ::micropb::heapless::Vec<u8, 32>,
+}
+impl CtrlMsg_Event_CustomRpcUnserialisedMsg {
+    ///Return a reference to `resp`
+    #[inline]
+    pub fn r#resp(&self) -> &i32 {
+        &self.r#resp
+    }
+    ///Return a mutable reference to `resp`
+    #[inline]
+    pub fn mut_resp(&mut self) -> &mut i32 {
+        &mut self.r#resp
+    }
+    ///Set the value of `resp`
+    #[inline]
+    pub fn set_resp(&mut self, value: i32) -> &mut Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Builder method that sets the value of `resp`. Useful for initializing the message.
+    #[inline]
+    pub fn init_resp(mut self, value: i32) -> Self {
+        self.r#resp = value.into();
+        self
+    }
+    ///Return a reference to `custom_evt_id`
+    #[inline]
+    pub fn r#custom_evt_id(&self) -> &u32 {
+        &self.r#custom_evt_id
+    }
+    ///Return a mutable reference to `custom_evt_id`
+    #[inline]
+    pub fn mut_custom_evt_id(&mut self) -> &mut u32 {
+        &mut self.r#custom_evt_id
+    }
+    ///Set the value of `custom_evt_id`
+    #[inline]
+    pub fn set_custom_evt_id(&mut self, value: u32) -> &mut Self {
+        self.r#custom_evt_id = value.into();
+        self
+    }
+    ///Builder method that sets the value of `custom_evt_id`. Useful for initializing the message.
+    #[inline]
+    pub fn init_custom_evt_id(mut self, value: u32) -> Self {
+        self.r#custom_evt_id = value.into();
+        self
+    }
+    ///Return a reference to `data`
+    #[inline]
+    pub fn r#data(&self) -> &::micropb::heapless::Vec<u8, 32> {
+        &self.r#data
+    }
+    ///Return a mutable reference to `data`
+    #[inline]
+    pub fn mut_data(&mut self) -> &mut ::micropb::heapless::Vec<u8, 32> {
+        &mut self.r#data
+    }
+    ///Set the value of `data`
+    #[inline]
+    pub fn set_data(&mut self, value: ::micropb::heapless::Vec<u8, 32>) -> &mut Self {
+        self.r#data = value.into();
+        self
+    }
+    ///Builder method that sets the value of `data`. Useful for initializing the message.
+    #[inline]
+    pub fn init_data(mut self, value: ::micropb::heapless::Vec<u8, 32>) -> Self {
+        self.r#data = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg_Event_CustomRpcUnserialisedMsg {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#resp;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#custom_evt_id;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#data;
+                    {
+                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
+                    };
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg_Event_CustomRpcUnserialisedMsg {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(33usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#custom_evt_id;
+            if *val_ref != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#data;
+            if !val_ref.is_empty() {
+                encoder.encode_varint32(26u32)?;
+                encoder.encode_bytes(val_ref)?;
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#resp;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#custom_evt_id;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#data;
+            if !val_ref.is_empty() {
+                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
+            }
+        }
+        size
+    }
+}
+pub mod CtrlMsg_ {
+    #[derive(Debug, PartialEq, Clone)]
+    #[cfg_attr(feature = "defmt", derive(defmt::Format))]
+    pub enum Payload {
+        ReqGetMacAddress(super::CtrlMsg_Req_GetMacAddress),
+        ReqSetMacAddress(super::CtrlMsg_Req_SetMacAddress),
+        ReqGetWifiMode(super::CtrlMsg_Req_GetMode),
+        ReqSetWifiMode(super::CtrlMsg_Req_SetMode),
+        ReqScanApList(super::CtrlMsg_Req_ScanResult),
+        ReqGetApConfig(super::CtrlMsg_Req_GetAPConfig),
+        ReqConnectAp(super::CtrlMsg_Req_ConnectAP),
+        ReqDisconnectAp(super::CtrlMsg_Req_GetStatus),
+        ReqGetSoftapConfig(super::CtrlMsg_Req_GetSoftAPConfig),
+        ReqSetSoftapVendorSpecificIe(super::CtrlMsg_Req_SetSoftAPVendorSpecificIE),
+        ReqStartSoftap(super::CtrlMsg_Req_StartSoftAP),
+        ReqSoftapConnectedStasList(super::CtrlMsg_Req_SoftAPConnectedSTA),
+        ReqStopSoftap(super::CtrlMsg_Req_GetStatus),
+        ReqSetPowerSaveMode(super::CtrlMsg_Req_SetMode),
+        ReqGetPowerSaveMode(super::CtrlMsg_Req_GetMode),
+        ReqOtaBegin(super::CtrlMsg_Req_OTABegin),
+        ReqOtaWrite(super::CtrlMsg_Req_OTAWrite),
+        ReqOtaEnd(super::CtrlMsg_Req_OTAEnd),
+        ReqSetWifiMaxTxPower(super::CtrlMsg_Req_SetWifiMaxTxPower),
+        ReqGetWifiCurrTxPower(super::CtrlMsg_Req_GetWifiCurrTxPower),
+        ReqConfigHeartbeat(super::CtrlMsg_Req_ConfigHeartbeat),
+        ReqEnableDisableFeat(super::CtrlMsg_Req_EnableDisable),
+        ReqGetFwVersion(super::CtrlMsg_Req_GetFwVersion),
+        ReqSetCountryCode(super::CtrlMsg_Req_SetCountryCode),
+        ReqGetCountryCode(super::CtrlMsg_Req_GetCountryCode),
+        ReqSetDhcpDnsStatus(super::CtrlMsg_Req_SetDhcpDnsStatus),
+        ReqGetDhcpDnsStatus(super::CtrlMsg_Req_GetDhcpDnsStatus),
+        ReqCustomRpcUnserialisedMsg(super::CtrlMsg_Req_CustomRpcUnserialisedMsg),
+        RespGetMacAddress(super::CtrlMsg_Resp_GetMacAddress),
+        RespSetMacAddress(super::CtrlMsg_Resp_SetMacAddress),
+        RespGetWifiMode(super::CtrlMsg_Resp_GetMode),
+        RespSetWifiMode(super::CtrlMsg_Resp_SetMode),
+        RespScanApList(super::CtrlMsg_Resp_ScanResult),
+        RespGetApConfig(super::CtrlMsg_Resp_GetAPConfig),
+        RespConnectAp(super::CtrlMsg_Resp_ConnectAP),
+        RespDisconnectAp(super::CtrlMsg_Resp_GetStatus),
+        RespGetSoftapConfig(super::CtrlMsg_Resp_GetSoftAPConfig),
+        RespSetSoftapVendorSpecificIe(super::CtrlMsg_Resp_SetSoftAPVendorSpecificIE),
+        RespStartSoftap(super::CtrlMsg_Resp_StartSoftAP),
+        RespSoftapConnectedStasList(super::CtrlMsg_Resp_SoftAPConnectedSTA),
+        RespStopSoftap(super::CtrlMsg_Resp_GetStatus),
+        RespSetPowerSaveMode(super::CtrlMsg_Resp_SetMode),
+        RespGetPowerSaveMode(super::CtrlMsg_Resp_GetMode),
+        RespOtaBegin(super::CtrlMsg_Resp_OTABegin),
+        RespOtaWrite(super::CtrlMsg_Resp_OTAWrite),
+        RespOtaEnd(super::CtrlMsg_Resp_OTAEnd),
+        RespSetWifiMaxTxPower(super::CtrlMsg_Resp_SetWifiMaxTxPower),
+        RespGetWifiCurrTxPower(super::CtrlMsg_Resp_GetWifiCurrTxPower),
+        RespConfigHeartbeat(super::CtrlMsg_Resp_ConfigHeartbeat),
+        RespEnableDisableFeat(super::CtrlMsg_Resp_EnableDisable),
+        RespGetFwVersion(super::CtrlMsg_Resp_GetFwVersion),
+        RespSetCountryCode(super::CtrlMsg_Resp_SetCountryCode),
+        RespGetCountryCode(super::CtrlMsg_Resp_GetCountryCode),
+        RespSetDhcpDnsStatus(super::CtrlMsg_Resp_SetDhcpDnsStatus),
+        RespGetDhcpDnsStatus(super::CtrlMsg_Resp_GetDhcpDnsStatus),
+        RespCustomRpcUnserialisedMsg(super::CtrlMsg_Resp_CustomRpcUnserialisedMsg),
+        EventEspInit(super::CtrlMsg_Event_ESPInit),
+        EventHeartbeat(super::CtrlMsg_Event_Heartbeat),
+        EventStationDisconnectFromAp(super::CtrlMsg_Event_StationDisconnectFromAP),
+        EventStationDisconnectFromEspSoftAp(super::CtrlMsg_Event_StationDisconnectFromESPSoftAP),
+        EventStationConnectedToAp(super::CtrlMsg_Event_StationConnectedToAP),
+        EventStationConnectedToEspSoftAp(super::CtrlMsg_Event_StationConnectedToESPSoftAP),
+        EventSetDhcpDnsStatus(super::CtrlMsg_Event_SetDhcpDnsStatus),
+        EventCustomRpcUnserialisedMsg(super::CtrlMsg_Event_CustomRpcUnserialisedMsg),
+    }
+}
+#[derive(Debug, Default, PartialEq, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsg {
+    pub r#msg_type: CtrlMsgType,
+    pub r#msg_id: CtrlMsgId,
+    pub r#uid: i32,
+    pub r#req_resp_type: u32,
+    pub r#payload: ::core::option::Option<CtrlMsg_::Payload>,
+}
+impl CtrlMsg {
+    ///Return a reference to `msg_type`
+    #[inline]
+    pub fn r#msg_type(&self) -> &CtrlMsgType {
+        &self.r#msg_type
+    }
+    ///Return a mutable reference to `msg_type`
+    #[inline]
+    pub fn mut_msg_type(&mut self) -> &mut CtrlMsgType {
+        &mut self.r#msg_type
+    }
+    ///Set the value of `msg_type`
+    #[inline]
+    pub fn set_msg_type(&mut self, value: CtrlMsgType) -> &mut Self {
+        self.r#msg_type = value.into();
+        self
+    }
+    ///Builder method that sets the value of `msg_type`. Useful for initializing the message.
+    #[inline]
+    pub fn init_msg_type(mut self, value: CtrlMsgType) -> Self {
+        self.r#msg_type = value.into();
+        self
+    }
+    ///Return a reference to `msg_id`
+    #[inline]
+    pub fn r#msg_id(&self) -> &CtrlMsgId {
+        &self.r#msg_id
+    }
+    ///Return a mutable reference to `msg_id`
+    #[inline]
+    pub fn mut_msg_id(&mut self) -> &mut CtrlMsgId {
+        &mut self.r#msg_id
+    }
+    ///Set the value of `msg_id`
+    #[inline]
+    pub fn set_msg_id(&mut self, value: CtrlMsgId) -> &mut Self {
+        self.r#msg_id = value.into();
+        self
+    }
+    ///Builder method that sets the value of `msg_id`. Useful for initializing the message.
+    #[inline]
+    pub fn init_msg_id(mut self, value: CtrlMsgId) -> Self {
+        self.r#msg_id = value.into();
+        self
+    }
+    ///Return a reference to `uid`
+    #[inline]
+    pub fn r#uid(&self) -> &i32 {
+        &self.r#uid
+    }
+    ///Return a mutable reference to `uid`
+    #[inline]
+    pub fn mut_uid(&mut self) -> &mut i32 {
+        &mut self.r#uid
+    }
+    ///Set the value of `uid`
+    #[inline]
+    pub fn set_uid(&mut self, value: i32) -> &mut Self {
+        self.r#uid = value.into();
+        self
+    }
+    ///Builder method that sets the value of `uid`. Useful for initializing the message.
+    #[inline]
+    pub fn init_uid(mut self, value: i32) -> Self {
+        self.r#uid = value.into();
+        self
+    }
+    ///Return a reference to `req_resp_type`
+    #[inline]
+    pub fn r#req_resp_type(&self) -> &u32 {
+        &self.r#req_resp_type
+    }
+    ///Return a mutable reference to `req_resp_type`
+    #[inline]
+    pub fn mut_req_resp_type(&mut self) -> &mut u32 {
+        &mut self.r#req_resp_type
+    }
+    ///Set the value of `req_resp_type`
+    #[inline]
+    pub fn set_req_resp_type(&mut self, value: u32) -> &mut Self {
+        self.r#req_resp_type = value.into();
+        self
+    }
+    ///Builder method that sets the value of `req_resp_type`. Useful for initializing the message.
+    #[inline]
+    pub fn init_req_resp_type(mut self, value: u32) -> Self {
+        self.r#req_resp_type = value.into();
+        self
+    }
+}
+impl ::micropb::MessageDecode for CtrlMsg {
+    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
+        &mut self,
+        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
+        len: usize,
+    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
+        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
+        let before = decoder.bytes_read();
+        while decoder.bytes_read() - before < len {
+            let tag = decoder.decode_tag()?;
+            match tag.field_num() {
+                0 => return Err(::micropb::DecodeError::ZeroField),
+                1u32 => {
+                    let mut_ref = &mut self.r#msg_type;
+                    {
+                        let val = decoder.decode_int32().map(|n| CtrlMsgType(n as _))?;
+                        let val_ref = &val;
+                        if val_ref.0 != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                2u32 => {
+                    let mut_ref = &mut self.r#msg_id;
+                    {
+                        let val = decoder.decode_int32().map(|n| CtrlMsgId(n as _))?;
+                        let val_ref = &val;
+                        if val_ref.0 != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                3u32 => {
+                    let mut_ref = &mut self.r#uid;
+                    {
+                        let val = decoder.decode_int32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                4u32 => {
+                    let mut_ref = &mut self.r#req_resp_type;
+                    {
+                        let val = decoder.decode_varint32()?;
+                        let val_ref = &val;
+                        if *val_ref != 0 {
+                            *mut_ref = val as _;
+                        }
+                    };
+                }
+                101u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetMacAddress(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetMacAddress(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                102u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqSetMacAddress(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqSetMacAddress(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                103u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetWifiMode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetWifiMode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                104u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqSetWifiMode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqSetWifiMode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                105u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqScanApList(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqScanApList(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                106u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetApConfig(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetApConfig(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                107u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqConnectAp(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqConnectAp(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                108u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqDisconnectAp(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqDisconnectAp(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                109u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetSoftapConfig(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetSoftapConfig(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                110u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqSetSoftapVendorSpecificIe(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqSetSoftapVendorSpecificIe(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                111u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqStartSoftap(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqStartSoftap(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                112u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqSoftapConnectedStasList(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqSoftapConnectedStasList(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                113u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqStopSoftap(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqStopSoftap(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                114u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqSetPowerSaveMode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqSetPowerSaveMode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                115u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetPowerSaveMode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetPowerSaveMode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                116u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqOtaBegin(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqOtaBegin(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                117u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqOtaWrite(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqOtaWrite(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                118u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqOtaEnd(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqOtaEnd(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                119u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqSetWifiMaxTxPower(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqSetWifiMaxTxPower(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                120u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetWifiCurrTxPower(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetWifiCurrTxPower(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                121u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqConfigHeartbeat(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqConfigHeartbeat(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                122u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqEnableDisableFeat(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqEnableDisableFeat(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                123u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetFwVersion(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetFwVersion(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                124u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqSetCountryCode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqSetCountryCode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                125u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetCountryCode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetCountryCode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                126u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqSetDhcpDnsStatus(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqSetDhcpDnsStatus(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                127u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqGetDhcpDnsStatus(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqGetDhcpDnsStatus(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                128u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::ReqCustomRpcUnserialisedMsg(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::ReqCustomRpcUnserialisedMsg(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                201u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetMacAddress(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetMacAddress(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                202u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespSetMacAddress(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespSetMacAddress(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                203u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetWifiMode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetWifiMode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                204u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespSetWifiMode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespSetWifiMode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                205u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespScanApList(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespScanApList(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                206u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetApConfig(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetApConfig(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                207u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespConnectAp(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespConnectAp(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                208u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespDisconnectAp(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespDisconnectAp(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                209u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetSoftapConfig(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetSoftapConfig(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                210u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespSetSoftapVendorSpecificIe(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(
+                            CtrlMsg_::Payload::RespSetSoftapVendorSpecificIe(::core::default::Default::default()),
+                        );
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                211u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespStartSoftap(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespStartSoftap(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                212u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespSoftapConnectedStasList(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespSoftapConnectedStasList(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                213u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespStopSoftap(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespStopSoftap(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                214u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespSetPowerSaveMode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespSetPowerSaveMode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                215u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetPowerSaveMode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetPowerSaveMode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                216u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespOtaBegin(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespOtaBegin(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                217u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespOtaWrite(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespOtaWrite(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                218u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespOtaEnd(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespOtaEnd(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                219u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespSetWifiMaxTxPower(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespSetWifiMaxTxPower(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                220u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetWifiCurrTxPower(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetWifiCurrTxPower(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                221u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespConfigHeartbeat(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespConfigHeartbeat(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                222u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespEnableDisableFeat(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespEnableDisableFeat(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                223u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetFwVersion(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetFwVersion(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                224u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespSetCountryCode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespSetCountryCode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                225u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetCountryCode(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetCountryCode(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                226u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespSetDhcpDnsStatus(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespSetDhcpDnsStatus(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                227u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespGetDhcpDnsStatus(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespGetDhcpDnsStatus(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                228u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::RespCustomRpcUnserialisedMsg(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::RespCustomRpcUnserialisedMsg(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                301u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::EventEspInit(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::EventEspInit(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                302u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::EventHeartbeat(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::EventHeartbeat(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                303u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::EventStationDisconnectFromAp(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::EventStationDisconnectFromAp(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                304u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::EventStationDisconnectFromEspSoftAp(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(
+                            CtrlMsg_::Payload::EventStationDisconnectFromEspSoftAp(::core::default::Default::default()),
+                        );
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                305u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::EventStationConnectedToAp(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::EventStationConnectedToAp(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                306u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::EventStationConnectedToEspSoftAp(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(
+                            CtrlMsg_::Payload::EventStationConnectedToEspSoftAp(::core::default::Default::default()),
+                        );
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                307u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::EventSetDhcpDnsStatus(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(CtrlMsg_::Payload::EventSetDhcpDnsStatus(
+                            ::core::default::Default::default(),
+                        ));
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                308u32 => {
+                    let mut_ref = loop {
+                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
+                            if let CtrlMsg_::Payload::EventCustomRpcUnserialisedMsg(variant) = &mut *variant {
+                                break &mut *variant;
+                            }
+                        }
+                        self.r#payload = ::core::option::Option::Some(
+                            CtrlMsg_::Payload::EventCustomRpcUnserialisedMsg(::core::default::Default::default()),
+                        );
+                    };
+                    mut_ref.decode_len_delimited(decoder)?;
+                }
+                _ => {
+                    decoder.skip_wire_value(tag.wire_type())?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+impl ::micropb::MessageEncode for CtrlMsg {
+    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
+        let mut max_size = 0;
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(CtrlMsgType::_MAX_SIZE), |size| size
+                + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(CtrlMsgId::_MAX_SIZE), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) =
+            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
+        {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        if let ::core::option::Option::Some(size) = 'oneof: {
+            let mut max_size = 0;
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_GetMacAddress as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_SetMacAddress as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_GetMode as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_SetMode as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_ScanResult as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_GetAPConfig as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_ConnectAP as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_GetStatus as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_GetSoftAPConfig as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_SetSoftAPVendorSpecificIE as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_StartSoftAP as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_SoftAPConnectedSTA as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_GetStatus as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_SetMode as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_GetMode as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_OTABegin as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_OTAWrite as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Req_OTAEnd as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_SetWifiMaxTxPower as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_GetWifiCurrTxPower as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_ConfigHeartbeat as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_EnableDisable as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_GetFwVersion as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_SetCountryCode as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_GetCountryCode as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_SetDhcpDnsStatus as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_GetDhcpDnsStatus as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Req_CustomRpcUnserialisedMsg as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_GetMacAddress as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_SetMacAddress as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_GetMode as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_SetMode as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_ScanResult as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_GetAPConfig as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_ConnectAP as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_GetStatus as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_GetSoftAPConfig as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_SetSoftAPVendorSpecificIE as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_StartSoftAP as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_SoftAPConnectedSTA as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_GetStatus as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_SetMode as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_GetMode as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_OTABegin as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_OTAWrite as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Resp_OTAEnd as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_SetWifiMaxTxPower as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_GetWifiCurrTxPower as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_ConfigHeartbeat as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_EnableDisable as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_GetFwVersion as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_SetCountryCode as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_GetCountryCode as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_SetDhcpDnsStatus as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_GetDhcpDnsStatus as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Resp_CustomRpcUnserialisedMsg as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(<CtrlMsg_Event_ESPInit as ::micropb::MessageEncode>::MAX_SIZE, |size| {
+                    ::micropb::size::sizeof_len_record(size)
+                }),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Event_Heartbeat as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Event_StationDisconnectFromAP as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Event_StationDisconnectFromESPSoftAP as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Event_StationConnectedToAP as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Event_StationConnectedToESPSoftAP as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Event_SetDhcpDnsStatus as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
+                ::micropb::const_map!(
+                    <CtrlMsg_Event_CustomRpcUnserialisedMsg as ::micropb::MessageEncode>::MAX_SIZE,
+                    |size| ::micropb::size::sizeof_len_record(size)
+                ),
+                |size| size + 2usize
+            ) {
+                if size > max_size {
+                    max_size = size;
+                }
+            } else {
+                break 'oneof (::core::option::Option::<usize>::None);
+            }
+            ::core::option::Option::Some(max_size)
+        } {
+            max_size += size;
+        } else {
+            break 'msg (::core::option::Option::<usize>::None);
+        };
+        ::core::option::Option::Some(max_size)
+    };
+    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
+        &self,
+        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
+    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
+        use ::micropb::{FieldEncode, PbMap};
+        {
+            let val_ref = &self.r#msg_type;
+            if val_ref.0 != 0 {
+                encoder.encode_varint32(8u32)?;
+                encoder.encode_int32(val_ref.0 as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#msg_id;
+            if val_ref.0 != 0 {
+                encoder.encode_varint32(16u32)?;
+                encoder.encode_int32(val_ref.0 as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#uid;
+            if *val_ref != 0 {
+                encoder.encode_varint32(24u32)?;
+                encoder.encode_int32(*val_ref as _)?;
+            }
+        }
+        {
+            let val_ref = &self.r#req_resp_type;
+            if *val_ref != 0 {
+                encoder.encode_varint32(32u32)?;
+                encoder.encode_varint32(*val_ref as _)?;
+            }
+        }
+        if let Some(oneof) = &self.r#payload {
+            match &*oneof {
+                CtrlMsg_::Payload::ReqGetMacAddress(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(810u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqSetMacAddress(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(818u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqGetWifiMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(826u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqSetWifiMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(834u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqScanApList(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(842u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqGetApConfig(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(850u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqConnectAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(858u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqDisconnectAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(866u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqGetSoftapConfig(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(874u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqSetSoftapVendorSpecificIe(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(882u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqStartSoftap(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(890u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqSoftapConnectedStasList(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(898u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqStopSoftap(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(906u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqSetPowerSaveMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(914u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqGetPowerSaveMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(922u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqOtaBegin(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(930u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqOtaWrite(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(938u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqOtaEnd(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(946u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqSetWifiMaxTxPower(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(954u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqGetWifiCurrTxPower(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(962u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqConfigHeartbeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(970u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqEnableDisableFeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(978u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqGetFwVersion(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(986u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqSetCountryCode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(994u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqGetCountryCode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1002u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqSetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1010u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqGetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1018u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::ReqCustomRpcUnserialisedMsg(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1026u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetMacAddress(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1610u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespSetMacAddress(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1618u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetWifiMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1626u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespSetWifiMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1634u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespScanApList(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1642u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetApConfig(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1650u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespConnectAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1658u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespDisconnectAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1666u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetSoftapConfig(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1674u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespSetSoftapVendorSpecificIe(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1682u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespStartSoftap(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1690u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespSoftapConnectedStasList(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1698u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespStopSoftap(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1706u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespSetPowerSaveMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1714u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetPowerSaveMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1722u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespOtaBegin(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1730u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespOtaWrite(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1738u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespOtaEnd(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1746u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespSetWifiMaxTxPower(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1754u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetWifiCurrTxPower(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1762u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespConfigHeartbeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1770u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespEnableDisableFeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1778u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetFwVersion(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1786u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespSetCountryCode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1794u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetCountryCode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1802u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespSetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1810u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespGetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1818u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::RespCustomRpcUnserialisedMsg(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(1826u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::EventEspInit(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(2410u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::EventHeartbeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(2418u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::EventStationDisconnectFromAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(2426u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::EventStationDisconnectFromEspSoftAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(2434u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::EventStationConnectedToAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(2442u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::EventStationConnectedToEspSoftAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(2450u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::EventSetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(2458u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+                CtrlMsg_::Payload::EventCustomRpcUnserialisedMsg(val_ref) => {
+                    let val_ref = &*val_ref;
+                    encoder.encode_varint32(2466u32)?;
+                    val_ref.encode_len_delimited(encoder)?;
+                }
+            }
+        }
+        Ok(())
+    }
+    fn compute_size(&self) -> usize {
+        use ::micropb::{FieldEncode, PbMap};
+        let mut size = 0;
+        {
+            let val_ref = &self.r#msg_type;
+            if val_ref.0 != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
+            }
+        }
+        {
+            let val_ref = &self.r#msg_id;
+            if val_ref.0 != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
+            }
+        }
+        {
+            let val_ref = &self.r#uid;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
+            }
+        }
+        {
+            let val_ref = &self.r#req_resp_type;
+            if *val_ref != 0 {
+                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
+            }
+        }
+        if let Some(oneof) = &self.r#payload {
+            match &*oneof {
+                CtrlMsg_::Payload::ReqGetMacAddress(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqSetMacAddress(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqGetWifiMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqSetWifiMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqScanApList(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqGetApConfig(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqConnectAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqDisconnectAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqGetSoftapConfig(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqSetSoftapVendorSpecificIe(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqStartSoftap(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqSoftapConnectedStasList(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqStopSoftap(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqSetPowerSaveMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqGetPowerSaveMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqOtaBegin(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqOtaWrite(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqOtaEnd(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqSetWifiMaxTxPower(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqGetWifiCurrTxPower(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqConfigHeartbeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqEnableDisableFeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqGetFwVersion(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqSetCountryCode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqGetCountryCode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqSetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqGetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::ReqCustomRpcUnserialisedMsg(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetMacAddress(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespSetMacAddress(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetWifiMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespSetWifiMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespScanApList(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetApConfig(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespConnectAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespDisconnectAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetSoftapConfig(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespSetSoftapVendorSpecificIe(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespStartSoftap(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespSoftapConnectedStasList(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespStopSoftap(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespSetPowerSaveMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetPowerSaveMode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespOtaBegin(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespOtaWrite(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespOtaEnd(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespSetWifiMaxTxPower(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetWifiCurrTxPower(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespConfigHeartbeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespEnableDisableFeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetFwVersion(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespSetCountryCode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetCountryCode(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespSetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespGetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::RespCustomRpcUnserialisedMsg(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::EventEspInit(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::EventHeartbeat(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::EventStationDisconnectFromAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::EventStationDisconnectFromEspSoftAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::EventStationConnectedToAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::EventStationConnectedToEspSoftAp(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::EventSetDhcpDnsStatus(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+                CtrlMsg_::Payload::EventCustomRpcUnserialisedMsg(val_ref) => {
+                    let val_ref = &*val_ref;
+                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
+                }
+            }
+        }
+        size
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ctrl_VendorIEType(pub i32);
+impl Ctrl_VendorIEType {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const Beacon: Self = Self(0);
+    pub const ProbeReq: Self = Self(1);
+    pub const ProbeResp: Self = Self(2);
+    pub const AssocReq: Self = Self(3);
+    pub const AssocResp: Self = Self(4);
+}
+impl core::default::Default for Ctrl_VendorIEType {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for Ctrl_VendorIEType {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ctrl_VendorIEID(pub i32);
+impl Ctrl_VendorIEID {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const Id0: Self = Self(0);
+    pub const Id1: Self = Self(1);
+}
+impl core::default::Default for Ctrl_VendorIEID {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for Ctrl_VendorIEID {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ctrl_WifiMode(pub i32);
+impl Ctrl_WifiMode {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const None: Self = Self(0);
+    pub const Sta: Self = Self(1);
+    pub const Ap: Self = Self(2);
+    pub const Apsta: Self = Self(3);
+}
+impl core::default::Default for Ctrl_WifiMode {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for Ctrl_WifiMode {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ctrl_WifiBw(pub i32);
+impl Ctrl_WifiBw {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const BwInvalid: Self = Self(0);
+    pub const Ht20: Self = Self(1);
+    pub const Ht40: Self = Self(2);
+}
+impl core::default::Default for Ctrl_WifiBw {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for Ctrl_WifiBw {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ctrl_WifiPowerSave(pub i32);
+impl Ctrl_WifiPowerSave {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const NoPs: Self = Self(0);
+    pub const MinModem: Self = Self(1);
+    pub const MaxModem: Self = Self(2);
+    pub const PsInvalid: Self = Self(3);
+}
+impl core::default::Default for Ctrl_WifiPowerSave {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for Ctrl_WifiPowerSave {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ctrl_WifiSecProt(pub i32);
+impl Ctrl_WifiSecProt {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const Open: Self = Self(0);
+    pub const Wep: Self = Self(1);
+    pub const WpaPsk: Self = Self(2);
+    pub const Wpa2Psk: Self = Self(3);
+    pub const WpaWpa2Psk: Self = Self(4);
+    pub const Wpa2Enterprise: Self = Self(5);
+    pub const Wpa3Psk: Self = Self(6);
+    pub const Wpa2Wpa3Psk: Self = Self(7);
+}
+impl core::default::Default for Ctrl_WifiSecProt {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for Ctrl_WifiSecProt {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct Ctrl_Status(pub i32);
+impl Ctrl_Status {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const Connected: Self = Self(0);
+    pub const NotConnected: Self = Self(1);
+    pub const NoApFound: Self = Self(2);
+    pub const ConnectionFail: Self = Self(3);
+    pub const InvalidArgument: Self = Self(4);
+    pub const OutOfRange: Self = Self(5);
+}
+impl core::default::Default for Ctrl_Status {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for Ctrl_Status {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsgType(pub i32);
+impl CtrlMsgType {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const MsgTypeInvalid: Self = Self(0);
+    pub const Req: Self = Self(1);
+    pub const Resp: Self = Self(2);
+    pub const Event: Self = Self(3);
+    pub const MsgTypeMax: Self = Self(4);
+}
+impl core::default::Default for CtrlMsgType {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for CtrlMsgType {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct CtrlMsgId(pub i32);
+impl CtrlMsgId {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const MsgIdInvalid: Self = Self(0);
+    pub const ReqBase: Self = Self(100);
+    pub const ReqGetMacAddress: Self = Self(101);
+    pub const ReqSetMacAddress: Self = Self(102);
+    pub const ReqGetWifiMode: Self = Self(103);
+    pub const ReqSetWifiMode: Self = Self(104);
+    pub const ReqGetApScanList: Self = Self(105);
+    pub const ReqGetApConfig: Self = Self(106);
+    pub const ReqConnectAp: Self = Self(107);
+    pub const ReqDisconnectAp: Self = Self(108);
+    pub const ReqGetSoftApConfig: Self = Self(109);
+    pub const ReqSetSoftApVendorSpecificIe: Self = Self(110);
+    pub const ReqStartSoftAp: Self = Self(111);
+    pub const ReqGetSoftApConnectedStaList: Self = Self(112);
+    pub const ReqStopSoftAp: Self = Self(113);
+    pub const ReqSetPowerSaveMode: Self = Self(114);
+    pub const ReqGetPowerSaveMode: Self = Self(115);
+    pub const ReqOtaBegin: Self = Self(116);
+    pub const ReqOtaWrite: Self = Self(117);
+    pub const ReqOtaEnd: Self = Self(118);
+    pub const ReqSetWifiMaxTxPower: Self = Self(119);
+    pub const ReqGetWifiCurrTxPower: Self = Self(120);
+    pub const ReqConfigHeartbeat: Self = Self(121);
+    pub const ReqEnableDisable: Self = Self(122);
+    pub const ReqGetFwVersion: Self = Self(123);
+    pub const ReqSetCountryCode: Self = Self(124);
+    pub const ReqGetCountryCode: Self = Self(125);
+    pub const ReqSetDhcpDnsStatus: Self = Self(126);
+    pub const ReqGetDhcpDnsStatus: Self = Self(127);
+    pub const ReqCustomRpcUnserialisedMsg: Self = Self(128);
+    pub const ReqMax: Self = Self(129);
+    pub const RespBase: Self = Self(200);
+    pub const RespGetMacAddress: Self = Self(201);
+    pub const RespSetMacAddress: Self = Self(202);
+    pub const RespGetWifiMode: Self = Self(203);
+    pub const RespSetWifiMode: Self = Self(204);
+    pub const RespGetApScanList: Self = Self(205);
+    pub const RespGetApConfig: Self = Self(206);
+    pub const RespConnectAp: Self = Self(207);
+    pub const RespDisconnectAp: Self = Self(208);
+    pub const RespGetSoftApConfig: Self = Self(209);
+    pub const RespSetSoftApVendorSpecificIe: Self = Self(210);
+    pub const RespStartSoftAp: Self = Self(211);
+    pub const RespGetSoftApConnectedStaList: Self = Self(212);
+    pub const RespStopSoftAp: Self = Self(213);
+    pub const RespSetPowerSaveMode: Self = Self(214);
+    pub const RespGetPowerSaveMode: Self = Self(215);
+    pub const RespOtaBegin: Self = Self(216);
+    pub const RespOtaWrite: Self = Self(217);
+    pub const RespOtaEnd: Self = Self(218);
+    pub const RespSetWifiMaxTxPower: Self = Self(219);
+    pub const RespGetWifiCurrTxPower: Self = Self(220);
+    pub const RespConfigHeartbeat: Self = Self(221);
+    pub const RespEnableDisable: Self = Self(222);
+    pub const RespGetFwVersion: Self = Self(223);
+    pub const RespSetCountryCode: Self = Self(224);
+    pub const RespGetCountryCode: Self = Self(225);
+    pub const RespSetDhcpDnsStatus: Self = Self(226);
+    pub const RespGetDhcpDnsStatus: Self = Self(227);
+    pub const RespCustomRpcUnserialisedMsg: Self = Self(228);
+    pub const RespMax: Self = Self(229);
+    pub const EventBase: Self = Self(300);
+    pub const EventEspInit: Self = Self(301);
+    pub const EventHeartbeat: Self = Self(302);
+    pub const EventStationDisconnectFromAp: Self = Self(303);
+    pub const EventStationDisconnectFromEspSoftAp: Self = Self(304);
+    pub const EventStationConnectedToAp: Self = Self(305);
+    pub const EventStationConnectedToEspSoftAp: Self = Self(306);
+    pub const EventSetDhcpDnsStatus: Self = Self(307);
+    pub const EventCustomRpcUnserialisedMsg: Self = Self(308);
+    pub const EventMax: Self = Self(309);
+}
+impl core::default::Default for CtrlMsgId {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for CtrlMsgId {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct HostedFeature(pub i32);
+impl HostedFeature {
+    pub const _MAX_SIZE: usize = 10usize;
+    pub const HostedInvalidFeature: Self = Self(0);
+    pub const HostedWifi: Self = Self(1);
+    pub const HostedBluetooth: Self = Self(2);
+    pub const HostedIsNetworkSplitOn: Self = Self(3);
+}
+impl core::default::Default for HostedFeature {
+    fn default() -> Self {
+        Self(0)
+    }
+}
+impl core::convert::From<i32> for HostedFeature {
+    fn from(val: i32) -> Self {
+        Self(val)
+    }
 }
diff --git a/embassy-net-nrf91/CHANGELOG.md b/embassy-net-nrf91/CHANGELOG.md
index 52cbf5ef3..11974ac04 100644
--- a/embassy-net-nrf91/CHANGELOG.md
+++ b/embassy-net-nrf91/CHANGELOG.md
@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- changed: updated to nrf-pac with nrf52/nrf53/nrf91 register layout more similar to nrf54
+
 ## 0.1.1 - 2025-08-14
 
 - First release with changelog.
diff --git a/embassy-net-nrf91/Cargo.toml b/embassy-net-nrf91/Cargo.toml
index ecb10246a..75b7aeeb2 100644
--- a/embassy-net-nrf91/Cargo.toml
+++ b/embassy-net-nrf91/Cargo.toml
@@ -18,7 +18,7 @@ log = ["dep:log"]
 defmt = { version = "1.0.1", optional = true }
 log = { version = "0.4.14", optional = true }
 
-nrf-pac = "0.1.0"
+nrf-pac = { version = "0.1.0", git = "https://github.com/embassy-rs/nrf-pac.git", rev = "58198c23bce72edc10b4e1656d1b54441fc74e7c" }
 cortex-m = "0.7.7"
 
 embassy-time = { version = "0.5.0", path = "../embassy-time" }
diff --git a/embassy-net/CHANGELOG.md b/embassy-net/CHANGELOG.md
index 1ae4f2a68..40f720d0d 100644
--- a/embassy-net/CHANGELOG.md
+++ b/embassy-net/CHANGELOG.md
@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- tcp: Add `set_nagle_enabled()` to control TcpSocket nagle algorithm.
+
 ## 0.7.1 - 2025-08-26
 
 No unreleased changes yet... Quick, go send a PR!
diff --git a/embassy-net/src/tcp.rs b/embassy-net/src/tcp.rs
index 6792c5526..b4db7b88c 100644
--- a/embassy-net/src/tcp.rs
+++ b/embassy-net/src/tcp.rs
@@ -373,6 +373,20 @@ impl<'a> TcpSocket<'a> {
         self.io.with_mut(|s, _| s.set_hop_limit(hop_limit))
     }
 
+    /// Enable or disable Nagles's algorithm.
+    ///
+    /// By default, Nagle's algorithm is enabled.
+    /// When enabled, Nagle’s Algorithm prevents sending segments smaller
+    /// than MSS if there is data in flight (sent but not acknowledged).
+    /// In other words, it ensures at most only one segment smaller than
+    /// MSS is in flight at a time.
+    /// It ensures better network utilization by preventing sending many
+    /// very small packets, at the cost of increased latency in some
+    /// situations, particularly when the remote peer has ACK delay enabled.
+    pub fn set_nagle_enabled(&mut self, enabled: bool) {
+        self.io.with_mut(|s, _| s.set_nagle_enabled(enabled))
+    }
+
     /// Get the local endpoint of the socket.
     ///
     /// Returns `None` if the socket is not bound (listening) or not connected.
diff --git a/embassy-nrf/CHANGELOG.md b/embassy-nrf/CHANGELOG.md
index 0244dedab..72ecb116a 100644
--- a/embassy-nrf/CHANGELOG.md
+++ b/embassy-nrf/CHANGELOG.md
@@ -7,7 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- next-header -->
 ## Unreleased - ReleaseDate
+
+- added: Add basic RTC support for nRF54L
 - changed: apply trimming values from FICR.TRIMCNF on nrf53/54l
+- changed: do not panic on BufferedUarte overrun
+- added: allow direct access to the input pin of `gpiote::InputChannel`
+- bugfix: use DETECTMODE_SEC in GPIOTE in secure mode
+- added: allow configuring the idle state of GPIO pins connected to PWM channels
+- changed: allow configuring the PWM peripheral in the constructor of `SimplePwm`
+- changed: support setting duty cycles with inverted polarity in `SimplePwm`
+- added: support setting the duty cycles of all channels at once in `SimplePwm`
+- changed: updated to nrf-pac with nrf52/nrf53/nrf91 register layout more similar to nrf54
+- added: support for nrf54l peripherals: uart, gpiote, twim, twis, spim, spis, dppi, pwm, saadc, cracen
+- added: support for changing nrf54l clock speed
+- bugfix: Do not write to UICR from non-secure code on nrf53
+- bugfix: Add delay to uart init anomaly fix
+- changed: `BufferedUarte::read_ready` now uses the same definition for 'empty' so following read calls will not block when true is returned
 
 ## 0.8.0 - 2025-09-30
 
diff --git a/embassy-nrf/Cargo.toml b/embassy-nrf/Cargo.toml
index 17ffaf439..08f4b280b 100644
--- a/embassy-nrf/Cargo.toml
+++ b/embassy-nrf/Cargo.toml
@@ -80,6 +80,8 @@ unstable-pac = []
 gpiote = []
 
 ## Use RTC1 as the time driver for `embassy-time`, with a tick rate of 32.768khz
+## 
+## Note: For nRF54L, it's actually RTC30
 time-driver-rtc1 = ["_time-driver"]
 
 ## Enable embassy-net 802.15.4 driver
@@ -102,17 +104,17 @@ qspi-multiwrite-flash = []
 
 #! ### Chip selection features
 ## nRF51
-nrf51 = ["nrf-pac/nrf51", "_nrf51"]
+nrf51 = ["nrf-pac/nrf51", "_nrf51", "_spi-v1"]
 ## nRF52805
-nrf52805 = ["nrf-pac/nrf52805", "_nrf52"]
+nrf52805 = ["nrf-pac/nrf52805", "_nrf52", "_spi-v1"]
 ## nRF52810
-nrf52810 = ["nrf-pac/nrf52810", "_nrf52"]
+nrf52810 = ["nrf-pac/nrf52810", "_nrf52", "_spi-v1"]
 ## nRF52811
-nrf52811 = ["nrf-pac/nrf52811", "_nrf52"]
+nrf52811 = ["nrf-pac/nrf52811", "_nrf52", "_spi-v1"]
 ## nRF52820
-nrf52820 = ["nrf-pac/nrf52820", "_nrf52"]
+nrf52820 = ["nrf-pac/nrf52820", "_nrf52", "_spi-v1"]
 ## nRF52832
-nrf52832 = ["nrf-pac/nrf52832", "_nrf52", "_nrf52832_anomaly_109"]
+nrf52832 = ["nrf-pac/nrf52832", "_nrf52", "_nrf52832_anomaly_109", "_spi-v1"]
 ## nRF52833
 nrf52833 = ["nrf-pac/nrf52833", "_nrf52", "_gpio-p1"]
 ## nRF52840
@@ -152,10 +154,10 @@ _nrf54l15-app = ["_nrf54l15", "nrf-pac/nrf54l15-app"]
 _nrf54l15 = ["_nrf54l", "_gpio-p1", "_gpio-p2"]
 _nrf54l = ["_dppi"]
 
-_nrf9160 = ["nrf-pac/nrf9160", "_dppi"]
-_nrf9120 = ["nrf-pac/nrf9120", "_dppi"]
+_nrf9160 = ["nrf-pac/nrf9160", "_dppi", "_spi-v1"]
+_nrf9120 = ["nrf-pac/nrf9120", "_dppi", "_spi-v1"]
 _nrf52 = ["_ppi"]
-_nrf51 = ["_ppi"]
+_nrf51 = ["_ppi", "_spi-v1"]
 _nrf91 = []
 
 _time-driver = ["dep:embassy-time-driver", "embassy-time-driver?/tick-hz-32_768", "dep:embassy-time-queue-utils", "embassy-embedded-hal/time"]
@@ -170,6 +172,7 @@ _ppi = []
 _dppi = []
 _gpio-p1 = []
 _gpio-p2 = []
+_spi-v1 = []
 
 # Errata workarounds
 _nrf52832_anomaly_109 = []
@@ -197,7 +200,7 @@ embedded-io-async = { version = "0.6.1" }
 rand-core-06 = { package = "rand_core", version = "0.6" }
 rand-core-09 = { package = "rand_core", version = "0.9" }
 
-nrf-pac = "0.1.0"
+nrf-pac = { version = "0.1.0", git = "https://github.com/embassy-rs/nrf-pac.git", rev = "58198c23bce72edc10b4e1656d1b54441fc74e7c" }
 
 defmt = { version = "1.0.1", optional = true }
 bitflags = "2.4.2"
diff --git a/embassy-nrf/src/buffered_uarte/mod.rs b/embassy-nrf/src/buffered_uarte/mod.rs
new file mode 100644
index 000000000..75d84baac
--- /dev/null
+++ b/embassy-nrf/src/buffered_uarte/mod.rs
@@ -0,0 +1,14 @@
+//! Async buffered UART driver.
+//!
+//! Note that discarding a future from a read or write operation may lead to losing
+//! data. For example, when using `futures_util::future::select` and completion occurs
+//! on the "other" future, you should capture the incomplete future and continue to use
+//! it for the next read or write. This pattern is a consideration for all IO, and not
+//! just serial communications.
+//!
+//! Please also see [crate::uarte] to understand when [BufferedUarte] should be used.
+#[cfg_attr(not(feature = "_nrf54l"), path = "v1.rs")]
+#[cfg_attr(feature = "_nrf54l", path = "v2.rs")]
+mod _version;
+
+pub use _version::*;
diff --git a/embassy-nrf/src/buffered_uarte.rs b/embassy-nrf/src/buffered_uarte/v1.rs
index 4c946497d..ec360f7d0 100644
--- a/embassy-nrf/src/buffered_uarte.rs
+++ b/embassy-nrf/src/buffered_uarte/v1.rs
@@ -40,6 +40,7 @@ pub(crate) struct State {
     rx_started_count: AtomicU8,
     rx_ended_count: AtomicU8,
     rx_ppi_ch: AtomicU8,
+    rx_overrun: AtomicBool,
 }
 
 /// UART error.
@@ -47,7 +48,8 @@ pub(crate) struct State {
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[non_exhaustive]
 pub enum Error {
-    // No errors for now
+    /// Buffer Overrun
+    Overrun,
 }
 
 impl State {
@@ -61,6 +63,7 @@ impl State {
             rx_started_count: AtomicU8::new(0),
             rx_ended_count: AtomicU8::new(0),
             rx_ppi_ch: AtomicU8::new(0),
+            rx_overrun: AtomicBool::new(false),
         }
     }
 }
@@ -87,7 +90,8 @@ impl<U: UarteInstance> interrupt::typelevel::Handler<U::Interrupt> for Interrupt
                 r.errorsrc().write_value(errs);
 
                 if errs.overrun() {
-                    panic!("BufferedUarte overrun");
+                    s.rx_overrun.store(true, Ordering::Release);
+                    ss.rx_waker.wake();
                 }
             }
 
@@ -98,25 +102,25 @@ impl<U: UarteInstance> interrupt::typelevel::Handler<U::Interrupt> for Interrupt
                 ss.rx_waker.wake();
             }
 
-            if r.events_endrx().read() != 0 {
+            if r.events_dma().rx().end().read() != 0 {
                 //trace!("  irq_rx: endrx");
-                r.events_endrx().write_value(0);
+                r.events_dma().rx().end().write_value(0);
 
                 let val = s.rx_ended_count.load(Ordering::Relaxed);
                 s.rx_ended_count.store(val.wrapping_add(1), Ordering::Relaxed);
             }
 
-            if r.events_rxstarted().read() != 0 || !s.rx_started.load(Ordering::Relaxed) {
+            if r.events_dma().rx().ready().read() != 0 || !s.rx_started.load(Ordering::Relaxed) {
                 //trace!("  irq_rx: rxstarted");
                 let (ptr, len) = rx.push_buf();
                 if len >= half_len {
-                    r.events_rxstarted().write_value(0);
+                    r.events_dma().rx().ready().write_value(0);
 
                     //trace!("  irq_rx: starting second {:?}", half_len);
 
                     // Set up the DMA read
-                    r.rxd().ptr().write_value(ptr as u32);
-                    r.rxd().maxcnt().write(|w| w.set_maxcnt(half_len as _));
+                    r.dma().rx().ptr().write_value(ptr as u32);
+                    r.dma().rx().maxcnt().write(|w| w.set_maxcnt(half_len as _));
 
                     let chn = s.rx_ppi_ch.load(Ordering::Relaxed);
 
@@ -129,9 +133,9 @@ impl<U: UarteInstance> interrupt::typelevel::Handler<U::Interrupt> for Interrupt
                     // and manually start.
 
                     // check again in case endrx has happened between the last check and now.
-                    if r.events_endrx().read() != 0 {
+                    if r.events_dma().rx().end().read() != 0 {
                         //trace!("  irq_rx: endrx");
-                        r.events_endrx().write_value(0);
+                        r.events_dma().rx().end().write_value(0);
 
                         let val = s.rx_ended_count.load(Ordering::Relaxed);
                         s.rx_ended_count.store(val.wrapping_add(1), Ordering::Relaxed);
@@ -157,7 +161,7 @@ impl<U: UarteInstance> interrupt::typelevel::Handler<U::Interrupt> for Interrupt
                         ppi::regs().chenclr().write(|w| w.set_ch(chn as _, true));
 
                         // manually start
-                        r.tasks_startrx().write_value(1);
+                        r.tasks_dma().rx().start().write_value(1);
                     }
 
                     rx.push_done(half_len);
@@ -166,7 +170,7 @@ impl<U: UarteInstance> interrupt::typelevel::Handler<U::Interrupt> for Interrupt
                     s.rx_started.store(true, Ordering::Relaxed);
                 } else {
                     //trace!("  irq_rx: rxstarted no buf");
-                    r.intenclr().write(|w| w.set_rxstarted(true));
+                    r.intenclr().write(|w| w.set_dmarxready(true));
                 }
             }
         }
@@ -175,8 +179,8 @@ impl<U: UarteInstance> interrupt::typelevel::Handler<U::Interrupt> for Interrupt
 
         if let Some(mut tx) = unsafe { s.tx_buf.try_reader() } {
             // TX end
-            if r.events_endtx().read() != 0 {
-                r.events_endtx().write_value(0);
+            if r.events_dma().tx().end().read() != 0 {
+                r.events_dma().tx().end().write_value(0);
 
                 let n = s.tx_count.load(Ordering::Relaxed);
                 //trace!("  irq_tx: endtx {:?}", n);
@@ -194,11 +198,11 @@ impl<U: UarteInstance> interrupt::typelevel::Handler<U::Interrupt> for Interrupt
                     s.tx_count.store(len, Ordering::Relaxed);
 
                     // Set up the DMA write
-                    r.txd().ptr().write_value(ptr as u32);
-                    r.txd().maxcnt().write(|w| w.set_maxcnt(len as _));
+                    r.dma().tx().ptr().write_value(ptr as u32);
+                    r.dma().tx().maxcnt().write(|w| w.set_maxcnt(len as _));
 
                     // Start UARTE Transmit transaction
-                    r.tasks_starttx().write_value(1);
+                    r.tasks_dma().tx().start().write_value(1);
                 }
             }
         }
@@ -452,11 +456,11 @@ impl<'d> BufferedUarteTx<'d> {
         let len = tx_buffer.len();
         unsafe { buffered_state.tx_buf.init(tx_buffer.as_mut_ptr(), len) };
 
-        r.events_txstarted().write_value(0);
+        r.events_dma().tx().ready().write_value(0);
 
         // Enable interrupts
         r.intenset().write(|w| {
-            w.set_endtx(true);
+            w.set_dmatxend(true);
         });
 
         Self {
@@ -547,11 +551,11 @@ impl<'a> Drop for BufferedUarteTx<'a> {
 
         r.intenclr().write(|w| {
             w.set_txdrdy(true);
-            w.set_txstarted(true);
+            w.set_dmatxready(true);
             w.set_txstopped(true);
         });
         r.events_txstopped().write_value(0);
-        r.tasks_stoptx().write_value(1);
+        r.tasks_dma().tx().stop().write_value(1);
         while r.events_txstopped().read() == 0 {}
 
         let s = self.buffered_state;
@@ -689,6 +693,7 @@ impl<'d> BufferedUarteRx<'d> {
         buffered_state.rx_started_count.store(0, Ordering::Relaxed);
         buffered_state.rx_ended_count.store(0, Ordering::Relaxed);
         buffered_state.rx_started.store(false, Ordering::Relaxed);
+        buffered_state.rx_overrun.store(false, Ordering::Relaxed);
         let rx_len = rx_buffer.len().min(EASY_DMA_SIZE * 2);
         unsafe { buffered_state.rx_buf.init(rx_buffer.as_mut_ptr(), rx_len) };
 
@@ -696,16 +701,16 @@ impl<'d> BufferedUarteRx<'d> {
         let errors = r.errorsrc().read();
         r.errorsrc().write_value(errors);
 
-        r.events_rxstarted().write_value(0);
+        r.events_dma().rx().ready().write_value(0);
         r.events_error().write_value(0);
-        r.events_endrx().write_value(0);
+        r.events_dma().rx().end().write_value(0);
 
         // Enable interrupts
         r.intenset().write(|w| {
-            w.set_endtx(true);
-            w.set_rxstarted(true);
+            w.set_dmatxend(true);
+            w.set_dmarxready(true);
             w.set_error(true);
-            w.set_endrx(true);
+            w.set_dmarxend(true);
         });
 
         // Configure byte counter.
@@ -724,8 +729,8 @@ impl<'d> BufferedUarteRx<'d> {
         let mut ppi_group = PpiGroup::new(ppi_group);
         let mut ppi_ch2 = Ppi::new_one_to_two(
             ppi_ch2,
-            Event::from_reg(r.events_endrx()),
-            Task::from_reg(r.tasks_startrx()),
+            Event::from_reg(r.events_dma().rx().end()),
+            Task::from_reg(r.tasks_dma().rx().start()),
             ppi_group.task_disable_all(),
         );
         ppi_ch2.disable();
@@ -743,6 +748,30 @@ impl<'d> BufferedUarteRx<'d> {
         }
     }
 
+    fn get_rxdrdy_counter(&self) -> usize {
+        let s = self.buffered_state;
+        let timer = &self.timer;
+
+        // Read the RXDRDY counter.
+        timer.cc(0).capture();
+        let mut rxdrdy = timer.cc(0).read() as usize;
+        //trace!("  rxdrdy count = {:?}", rxdrdy);
+
+        // We've set a compare channel that resets the counter to 0 when it reaches `len*2`.
+        // However, it's unclear if that's instant, or there's a small window where you can
+        // still read `len()*2`.
+        // This could happen if in one clock cycle the counter is updated, and in the next the
+        // clear takes effect. The docs are very sparse, they just say "Task delays: After TIMER
+        // is started, the CLEAR, COUNT, and STOP tasks are guaranteed to take effect within one
+        // clock cycle of the PCLK16M." :shrug:
+        // So, we wrap the counter ourselves, just in case.
+        if rxdrdy > s.rx_buf.len() * 2 {
+            rxdrdy = 0;
+        }
+
+        rxdrdy
+    }
+
     /// Pull some bytes from this source into the specified buffer, returning how many bytes were read.
     pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
         let data = self.fill_buf().await?;
@@ -757,28 +786,17 @@ impl<'d> BufferedUarteRx<'d> {
         let r = self.r;
         let s = self.buffered_state;
         let ss = self.state;
-        let timer = &self.timer;
+
         poll_fn(move |cx| {
             compiler_fence(Ordering::SeqCst);
             //trace!("poll_read");
 
-            // Read the RXDRDY counter.
-            timer.cc(0).capture();
-            let mut end = timer.cc(0).read() as usize;
-            //trace!("  rxdrdy count = {:?}", end);
-
-            // We've set a compare channel that resets the counter to 0 when it reaches `len*2`.
-            // However, it's unclear if that's instant, or there's a small window where you can
-            // still read `len()*2`.
-            // This could happen if in one clock cycle the counter is updated, and in the next the
-            // clear takes effect. The docs are very sparse, they just say "Task delays: After TIMER
-            // is started, the CLEAR, COUNT, and STOP tasks are guaranteed to take effect within one
-            // clock cycle of the PCLK16M." :shrug:
-            // So, we wrap the counter ourselves, just in case.
-            if end > s.rx_buf.len() * 2 {
-                end = 0
+            if s.rx_overrun.swap(false, Ordering::Acquire) {
+                return Poll::Ready(Err(Error::Overrun));
             }
 
+            let mut end = self.get_rxdrdy_counter();
+
             // This logic mirrors `atomic_ring_buffer::Reader::pop_buf()`
             let mut start = s.rx_buf.start.load(Ordering::Relaxed);
             let len = s.rx_buf.len();
@@ -814,13 +832,20 @@ impl<'d> BufferedUarteRx<'d> {
         let s = self.buffered_state;
         let mut rx = unsafe { s.rx_buf.reader() };
         rx.pop_done(amt);
-        self.r.intenset().write(|w| w.set_rxstarted(true));
+        self.r.intenset().write(|w| w.set_dmarxready(true));
     }
 
     /// we are ready to read if there is data in the buffer
     fn read_ready(&self) -> Result<bool, Error> {
         let state = self.buffered_state;
-        Ok(!state.rx_buf.is_empty())
+        if state.rx_overrun.swap(false, Ordering::Acquire) {
+            return Err(Error::Overrun);
+        }
+
+        let start = state.rx_buf.start.load(Ordering::Relaxed);
+        let end = self.get_rxdrdy_counter();
+
+        Ok(start != end)
     }
 }
 
@@ -834,11 +859,11 @@ impl<'a> Drop for BufferedUarteRx<'a> {
 
         r.intenclr().write(|w| {
             w.set_rxdrdy(true);
-            w.set_rxstarted(true);
+            w.set_dmarxready(true);
             w.set_rxto(true);
         });
         r.events_rxto().write_value(0);
-        r.tasks_stoprx().write_value(1);
+        r.tasks_dma().rx().stop().write_value(1);
         while r.events_rxto().read() == 0 {}
 
         let s = self.buffered_state;
@@ -854,7 +879,9 @@ mod _embedded_io {
 
     impl embedded_io_async::Error for Error {
         fn kind(&self) -> embedded_io_async::ErrorKind {
-            match *self {}
+            match *self {
+                Error::Overrun => embedded_io_async::ErrorKind::OutOfMemory,
+            }
         }
     }
 
diff --git a/embassy-nrf/src/buffered_uarte/v2.rs b/embassy-nrf/src/buffered_uarte/v2.rs
new file mode 100644
index 000000000..d0d2d97d1
--- /dev/null
+++ b/embassy-nrf/src/buffered_uarte/v2.rs
@@ -0,0 +1,687 @@
+//! Async buffered UART driver.
+//!
+//! Note that discarding a future from a read or write operation may lead to losing
+//! data. For example, when using `futures_util::future::select` and completion occurs
+//! on the "other" future, you should capture the incomplete future and continue to use
+//! it for the next read or write. This pattern is a consideration for all IO, and not
+//! just serial communications.
+//!
+//! Please also see [crate::uarte] to understand when [BufferedUarte] should be used.
+//!
+//! The code is based on the generic buffered_uarte implementation but uses the nrf54l
+//! frame timeout event to correctly determine the size of transferred data.
+//! Counting of rxrdy events, used in the generic implementation, cannot be applied
+//! to nrf54l chips, as they buffer up to 4 bytes in a single DMA transaction.
+//! The only reliable way to find the number of bytes received is to stop the transfer,
+//! wait for the DMA stopped event, and read the value in the rx.dma.amount register.
+//! This also flushes all in-flight data to RAM.
+
+use core::cmp::min;
+use core::future::{Future, poll_fn};
+use core::marker::PhantomData;
+use core::slice;
+use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering, compiler_fence};
+use core::task::Poll;
+
+use embassy_hal_internal::Peri;
+use embassy_hal_internal::atomic_ring_buffer::RingBuffer;
+use pac::uarte::vals;
+// Re-export SVD variants to allow user to directly set values
+pub use pac::uarte::vals::{Baudrate, ConfigParity as Parity};
+
+use crate::gpio::{AnyPin, Pin as GpioPin};
+use crate::interrupt::typelevel::Interrupt;
+use crate::uarte::{Config, Instance as UarteInstance, configure, configure_rx_pins, configure_tx_pins, drop_tx_rx};
+use crate::{EASY_DMA_SIZE, interrupt, pac};
+
+pub(crate) struct State {
+    tx_buf: RingBuffer,
+    tx_count: AtomicUsize,
+
+    rx_buf: RingBuffer,
+    rx_started: AtomicBool,
+}
+
+/// UART error.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub enum Error {
+    // No errors for now
+}
+
+impl State {
+    pub(crate) const fn new() -> Self {
+        Self {
+            tx_buf: RingBuffer::new(),
+            tx_count: AtomicUsize::new(0),
+
+            rx_buf: RingBuffer::new(),
+            rx_started: AtomicBool::new(false),
+        }
+    }
+}
+
+/// Interrupt handler.
+pub struct InterruptHandler<U: UarteInstance> {
+    _phantom: PhantomData<U>,
+}
+
+impl<U: UarteInstance> interrupt::typelevel::Handler<U::Interrupt> for InterruptHandler<U> {
+    unsafe fn on_interrupt() {
+        info!("irq: start");
+        let r = U::regs();
+        let ss = U::state();
+        let s = U::buffered_state();
+
+        if let Some(mut rx) = unsafe { s.rx_buf.try_writer() } {
+            let buf_len = s.rx_buf.len();
+            let half_len = buf_len / 2;
+
+            if r.events_error().read() != 0 {
+                r.events_error().write_value(0);
+                let errs = r.errorsrc().read();
+                r.errorsrc().write_value(errs);
+
+                if errs.overrun() {
+                    panic!("BufferedUarte UART overrun");
+                }
+            }
+
+            let first_run = !s.rx_started.swap(true, Ordering::Relaxed);
+            if r.events_dma().rx().end().read() != 0 || first_run {
+                //trace!("  irq_rx: endrx");
+                r.events_dma().rx().end().write_value(0);
+
+                if !first_run {
+                    // Received some bytes, wake task.
+                    let rxed = r.dma().rx().amount().read().amount() as usize;
+                    rx.push_done(rxed);
+                    ss.rx_waker.wake();
+                }
+
+                let (ptr, len) = rx.push_buf();
+                if len == 0 {
+                    panic!("BufferedUarte buffer overrun");
+                }
+
+                let len = if len > half_len { half_len } else { len };
+
+                // Set up the DMA read
+                r.dma().rx().ptr().write_value(ptr as u32);
+                r.dma().rx().maxcnt().write(|w| w.set_maxcnt(len as _));
+
+                // manually start
+                r.tasks_dma().rx().start().write_value(1);
+            }
+        }
+
+        // =============================
+
+        if let Some(mut tx) = unsafe { s.tx_buf.try_reader() } {
+            // TX end
+            if r.events_dma().tx().end().read() != 0 {
+                r.events_dma().tx().end().write_value(0);
+
+                let n = s.tx_count.load(Ordering::Relaxed);
+                //trace!("  irq_tx: endtx {:?}", n);
+                tx.pop_done(n);
+                ss.tx_waker.wake();
+                s.tx_count.store(0, Ordering::Relaxed);
+            }
+
+            // If not TXing, start.
+            if s.tx_count.load(Ordering::Relaxed) == 0 {
+                let (ptr, len) = tx.pop_buf();
+                let len = len.min(EASY_DMA_SIZE);
+                if len != 0 {
+                    //trace!("  irq_tx: starting {:?}", len);
+                    s.tx_count.store(len, Ordering::Relaxed);
+
+                    // Set up the DMA write
+                    r.dma().tx().ptr().write_value(ptr as u32);
+                    r.dma().tx().maxcnt().write(|w| w.set_maxcnt(len as _));
+
+                    // Start UARTE Transmit transaction
+                    r.tasks_dma().tx().start().write_value(1);
+                }
+            }
+        }
+
+        //trace!("irq: end");
+    }
+}
+
+/// Buffered UARTE driver.
+pub struct BufferedUarte<'d, U: UarteInstance> {
+    tx: BufferedUarteTx<'d, U>,
+    rx: BufferedUarteRx<'d, U>,
+}
+
+impl<'d, U: UarteInstance> Unpin for BufferedUarte<'d, U> {}
+
+impl<'d, U: UarteInstance> BufferedUarte<'d, U> {
+    /// Create a new BufferedUarte without hardware flow control.
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        uarte: Peri<'d, U>,
+        rxd: Peri<'d, impl GpioPin>,
+        txd: Peri<'d, impl GpioPin>,
+        _irq: impl interrupt::typelevel::Binding<U::Interrupt, InterruptHandler<U>> + 'd,
+        config: Config,
+        rx_buffer: &'d mut [u8],
+        tx_buffer: &'d mut [u8],
+    ) -> Self {
+        Self::new_inner(uarte, rxd.into(), txd.into(), None, None, config, rx_buffer, tx_buffer)
+    }
+
+    /// Create a new BufferedUarte with hardware flow control (RTS/CTS)
+    #[allow(clippy::too_many_arguments)]
+    pub fn new_with_rtscts(
+        uarte: Peri<'d, U>,
+        rxd: Peri<'d, impl GpioPin>,
+        txd: Peri<'d, impl GpioPin>,
+        cts: Peri<'d, impl GpioPin>,
+        rts: Peri<'d, impl GpioPin>,
+        _irq: impl interrupt::typelevel::Binding<U::Interrupt, InterruptHandler<U>> + 'd,
+        config: Config,
+        rx_buffer: &'d mut [u8],
+        tx_buffer: &'d mut [u8],
+    ) -> Self {
+        Self::new_inner(
+            uarte,
+            rxd.into(),
+            txd.into(),
+            Some(cts.into()),
+            Some(rts.into()),
+            config,
+            rx_buffer,
+            tx_buffer,
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn new_inner(
+        peri: Peri<'d, U>,
+        rxd: Peri<'d, AnyPin>,
+        txd: Peri<'d, AnyPin>,
+        cts: Option<Peri<'d, AnyPin>>,
+        rts: Option<Peri<'d, AnyPin>>,
+        config: Config,
+        rx_buffer: &'d mut [u8],
+        tx_buffer: &'d mut [u8],
+    ) -> Self {
+        configure(U::regs(), config, cts.is_some());
+
+        let tx = BufferedUarteTx::new_innerer(unsafe { peri.clone_unchecked() }, txd, cts, tx_buffer);
+        let rx = BufferedUarteRx::new_innerer(peri, rxd, rts, rx_buffer);
+
+        U::regs().enable().write(|w| w.set_enable(vals::Enable::ENABLED));
+        U::Interrupt::pend();
+        unsafe { U::Interrupt::enable() };
+
+        U::state().tx_rx_refcount.store(2, Ordering::Relaxed);
+
+        Self { tx, rx }
+    }
+
+    /// Adjust the baud rate to the provided value.
+    pub fn set_baudrate(&mut self, baudrate: Baudrate) {
+        let r = U::regs();
+        r.baudrate().write(|w| w.set_baudrate(baudrate));
+    }
+
+    /// Split the UART in reader and writer parts.
+    ///
+    /// This allows reading and writing concurrently from independent tasks.
+    pub fn split(self) -> (BufferedUarteRx<'d, U>, BufferedUarteTx<'d, U>) {
+        (self.rx, self.tx)
+    }
+
+    /// Split the UART in reader and writer parts, by reference.
+    ///
+    /// The returned halves borrow from `self`, so you can drop them and go back to using
+    /// the "un-split" `self`. This allows temporarily splitting the UART.
+    pub fn split_by_ref(&mut self) -> (&mut BufferedUarteRx<'d, U>, &mut BufferedUarteTx<'d, U>) {
+        (&mut self.rx, &mut self.tx)
+    }
+
+    /// Pull some bytes from this source into the specified buffer, returning how many bytes were read.
+    pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
+        self.rx.read(buf).await
+    }
+
+    /// Return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.
+    pub async fn fill_buf(&mut self) -> Result<&[u8], Error> {
+        self.rx.fill_buf().await
+    }
+
+    /// Tell this buffer that `amt` bytes have been consumed from the buffer, so they should no longer be returned in calls to `fill_buf`.
+    pub fn consume(&mut self, amt: usize) {
+        self.rx.consume(amt)
+    }
+
+    /// Write a buffer into this writer, returning how many bytes were written.
+    pub async fn write(&mut self, buf: &[u8]) -> Result<usize, Error> {
+        self.tx.write(buf).await
+    }
+
+    /// Try writing a buffer without waiting, returning how many bytes were written.
+    pub fn try_write(&mut self, buf: &[u8]) -> Result<usize, Error> {
+        self.tx.try_write(buf)
+    }
+
+    /// Flush this output stream, ensuring that all intermediately buffered contents reach their destination.
+    pub async fn flush(&mut self) -> Result<(), Error> {
+        self.tx.flush().await
+    }
+}
+
+/// Reader part of the buffered UARTE driver.
+pub struct BufferedUarteTx<'d, U: UarteInstance> {
+    _peri: Peri<'d, U>,
+}
+
+impl<'d, U: UarteInstance> BufferedUarteTx<'d, U> {
+    /// Create a new BufferedUarteTx without hardware flow control.
+    pub fn new(
+        uarte: Peri<'d, U>,
+        txd: Peri<'d, impl GpioPin>,
+        _irq: impl interrupt::typelevel::Binding<U::Interrupt, InterruptHandler<U>> + 'd,
+        config: Config,
+        tx_buffer: &'d mut [u8],
+    ) -> Self {
+        Self::new_inner(uarte, txd.into(), None, config, tx_buffer)
+    }
+
+    /// Create a new BufferedUarte with hardware flow control (RTS/CTS)
+    pub fn new_with_cts(
+        uarte: Peri<'d, U>,
+        txd: Peri<'d, impl GpioPin>,
+        cts: Peri<'d, impl GpioPin>,
+        _irq: impl interrupt::typelevel::Binding<U::Interrupt, InterruptHandler<U>> + 'd,
+        config: Config,
+        tx_buffer: &'d mut [u8],
+    ) -> Self {
+        Self::new_inner(uarte, txd.into(), Some(cts.into()), config, tx_buffer)
+    }
+
+    fn new_inner(
+        peri: Peri<'d, U>,
+        txd: Peri<'d, AnyPin>,
+        cts: Option<Peri<'d, AnyPin>>,
+        config: Config,
+        tx_buffer: &'d mut [u8],
+    ) -> Self {
+        configure(U::regs(), config, cts.is_some());
+
+        let this = Self::new_innerer(peri, txd, cts, tx_buffer);
+
+        U::regs().enable().write(|w| w.set_enable(vals::Enable::ENABLED));
+        U::Interrupt::pend();
+        unsafe { U::Interrupt::enable() };
+
+        U::state().tx_rx_refcount.store(1, Ordering::Relaxed);
+
+        this
+    }
+
+    fn new_innerer(
+        peri: Peri<'d, U>,
+        txd: Peri<'d, AnyPin>,
+        cts: Option<Peri<'d, AnyPin>>,
+        tx_buffer: &'d mut [u8],
+    ) -> Self {
+        let r = U::regs();
+
+        configure_tx_pins(r, txd, cts);
+
+        // Initialize state
+        let s = U::buffered_state();
+        s.tx_count.store(0, Ordering::Relaxed);
+        let len = tx_buffer.len();
+        unsafe { s.tx_buf.init(tx_buffer.as_mut_ptr(), len) };
+
+        r.events_dma().tx().ready().write_value(0);
+
+        // Enable interrupts
+        r.intenset().write(|w| {
+            w.set_dmatxend(true);
+        });
+
+        Self { _peri: peri }
+    }
+
+    /// Write a buffer into this writer, returning how many bytes were written.
+    pub fn write<'a>(&'a mut self, buf: &'a [u8]) -> impl Future<Output = Result<usize, Error>> + 'a {
+        poll_fn(move |cx| {
+            //trace!("poll_write: {:?}", buf.len());
+            let ss = U::state();
+            let s = U::buffered_state();
+            let mut tx = unsafe { s.tx_buf.writer() };
+
+            let tx_buf = tx.push_slice();
+            if tx_buf.is_empty() {
+                //trace!("poll_write: pending");
+                ss.tx_waker.register(cx.waker());
+                return Poll::Pending;
+            }
+
+            let n = min(tx_buf.len(), buf.len());
+            tx_buf[..n].copy_from_slice(&buf[..n]);
+            tx.push_done(n);
+
+            //trace!("poll_write: queued {:?}", n);
+
+            compiler_fence(Ordering::SeqCst);
+            U::Interrupt::pend();
+
+            Poll::Ready(Ok(n))
+        })
+    }
+
+    /// Try writing a buffer without waiting, returning how many bytes were written.
+    pub fn try_write(&mut self, buf: &[u8]) -> Result<usize, Error> {
+        //trace!("poll_write: {:?}", buf.len());
+        let s = U::buffered_state();
+        let mut tx = unsafe { s.tx_buf.writer() };
+
+        let tx_buf = tx.push_slice();
+        if tx_buf.is_empty() {
+            return Ok(0);
+        }
+
+        let n = min(tx_buf.len(), buf.len());
+        tx_buf[..n].copy_from_slice(&buf[..n]);
+        tx.push_done(n);
+
+        //trace!("poll_write: queued {:?}", n);
+
+        compiler_fence(Ordering::SeqCst);
+        U::Interrupt::pend();
+
+        Ok(n)
+    }
+
+    /// Flush this output stream, ensuring that all intermediately buffered contents reach their destination.
+    pub fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + '_ {
+        poll_fn(move |cx| {
+            //trace!("poll_flush");
+            let ss = U::state();
+            let s = U::buffered_state();
+            if !s.tx_buf.is_empty() {
+                //trace!("poll_flush: pending");
+                ss.tx_waker.register(cx.waker());
+                return Poll::Pending;
+            }
+
+            Poll::Ready(Ok(()))
+        })
+    }
+}
+
+impl<'a, U: UarteInstance> Drop for BufferedUarteTx<'a, U> {
+    fn drop(&mut self) {
+        let r = U::regs();
+
+        r.intenclr().write(|w| {
+            w.set_txdrdy(true);
+            w.set_dmatxready(true);
+            w.set_txstopped(true);
+        });
+        r.events_txstopped().write_value(0);
+        r.tasks_dma().tx().stop().write_value(1);
+        while r.events_txstopped().read() == 0 {}
+
+        let s = U::buffered_state();
+        unsafe { s.tx_buf.deinit() }
+
+        let s = U::state();
+        drop_tx_rx(r, s);
+    }
+}
+
+/// Reader part of the buffered UARTE driver.
+pub struct BufferedUarteRx<'d, U: UarteInstance> {
+    _peri: Peri<'d, U>,
+}
+
+impl<'d, U: UarteInstance> BufferedUarteRx<'d, U> {
+    /// Create a new BufferedUarte without hardware flow control.
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        uarte: Peri<'d, U>,
+        _irq: impl interrupt::typelevel::Binding<U::Interrupt, InterruptHandler<U>> + 'd,
+        rxd: Peri<'d, impl GpioPin>,
+        config: Config,
+        rx_buffer: &'d mut [u8],
+    ) -> Self {
+        Self::new_inner(uarte, rxd.into(), None, config, rx_buffer)
+    }
+
+    /// Create a new BufferedUarte with hardware flow control (RTS/CTS)
+    #[allow(clippy::too_many_arguments)]
+    pub fn new_with_rts(
+        uarte: Peri<'d, U>,
+        rxd: Peri<'d, impl GpioPin>,
+        rts: Peri<'d, impl GpioPin>,
+        _irq: impl interrupt::typelevel::Binding<U::Interrupt, InterruptHandler<U>> + 'd,
+        config: Config,
+        rx_buffer: &'d mut [u8],
+    ) -> Self {
+        Self::new_inner(uarte, rxd.into(), Some(rts.into()), config, rx_buffer)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn new_inner(
+        peri: Peri<'d, U>,
+        rxd: Peri<'d, AnyPin>,
+        rts: Option<Peri<'d, AnyPin>>,
+        config: Config,
+        rx_buffer: &'d mut [u8],
+    ) -> Self {
+        configure(U::regs(), config, rts.is_some());
+
+        let this = Self::new_innerer(peri, rxd, rts, rx_buffer);
+
+        U::regs().enable().write(|w| w.set_enable(vals::Enable::ENABLED));
+        U::Interrupt::pend();
+        unsafe { U::Interrupt::enable() };
+
+        U::state().tx_rx_refcount.store(1, Ordering::Relaxed);
+
+        this
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn new_innerer(
+        peri: Peri<'d, U>,
+        rxd: Peri<'d, AnyPin>,
+        rts: Option<Peri<'d, AnyPin>>,
+        rx_buffer: &'d mut [u8],
+    ) -> Self {
+        let r = U::regs();
+
+        configure_rx_pins(r, rxd, rts);
+
+        // Initialize state
+        let s = U::buffered_state();
+        let rx_len = rx_buffer.len().min(EASY_DMA_SIZE * 2);
+        let rx_ptr = rx_buffer.as_mut_ptr();
+        unsafe { s.rx_buf.init(rx_ptr, rx_len) };
+
+        // clear errors
+        let errors = r.errorsrc().read();
+        r.errorsrc().write_value(errors);
+
+        r.events_error().write_value(0);
+        r.events_dma().rx().end().write_value(0);
+
+        // set timeout-to-stop short
+        r.shorts().write(|w| {
+            w.set_frametimeout_dma_rx_stop(true);
+        });
+
+        // set default timeout
+        r.frametimeout().write_value(pac::uarte::regs::Frametimeout(0x10));
+
+        // Enable interrupts
+        r.intenset().write(|w| {
+            w.set_dmatxend(true);
+            w.set_error(true);
+            w.set_dmarxend(true);
+        });
+
+        Self { _peri: peri }
+    }
+
+    /// Pull some bytes from this source into the specified buffer, returning how many bytes were read.
+    pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> {
+        let data = self.fill_buf().await?;
+        let n = data.len().min(buf.len());
+        buf[..n].copy_from_slice(&data[..n]);
+        self.consume(n);
+        Ok(n)
+    }
+
+    /// Return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.
+    pub fn fill_buf(&mut self) -> impl Future<Output = Result<&'_ [u8], Error>> {
+        poll_fn(move |cx| {
+            compiler_fence(Ordering::SeqCst);
+            //trace!("poll_read");
+
+            let s = U::buffered_state();
+            let ss = U::state();
+            let mut rx = unsafe { s.rx_buf.reader() };
+
+            let (ptr, n) = rx.pop_buf();
+            if n == 0 {
+                //trace!("  empty");
+                ss.rx_waker.register(cx.waker());
+                Poll::Pending
+            } else {
+                Poll::Ready(Ok(unsafe { slice::from_raw_parts(ptr, n) }))
+            }
+        })
+    }
+
+    /// Tell this buffer that `amt` bytes have been consumed from the buffer, so they should no longer be returned in calls to `fill_buf`.
+    pub fn consume(&mut self, amt: usize) {
+        if amt == 0 {
+            return;
+        }
+
+        let s = U::buffered_state();
+        let mut rx = unsafe { s.rx_buf.reader() };
+        rx.pop_done(amt);
+    }
+
+    /// we are ready to read if there is data in the buffer
+    fn read_ready() -> Result<bool, Error> {
+        let state = U::buffered_state();
+        Ok(!state.rx_buf.is_empty())
+    }
+}
+
+impl<'a, U: UarteInstance> Drop for BufferedUarteRx<'a, U> {
+    fn drop(&mut self) {
+        let r = U::regs();
+
+        r.intenclr().write(|w| {
+            w.set_rxto(true);
+        });
+        r.events_rxto().write_value(0);
+
+        let s = U::buffered_state();
+        unsafe { s.rx_buf.deinit() }
+
+        let s = U::state();
+        drop_tx_rx(r, s);
+    }
+}
+
+mod _embedded_io {
+    use super::*;
+
+    impl embedded_io_async::Error for Error {
+        fn kind(&self) -> embedded_io_async::ErrorKind {
+            match *self {}
+        }
+    }
+
+    impl<'d, U: UarteInstance> embedded_io_async::ErrorType for BufferedUarte<'d, U> {
+        type Error = Error;
+    }
+
+    impl<'d, U: UarteInstance> embedded_io_async::ErrorType for BufferedUarteRx<'d, U> {
+        type Error = Error;
+    }
+
+    impl<'d, U: UarteInstance> embedded_io_async::ErrorType for BufferedUarteTx<'d, U> {
+        type Error = Error;
+    }
+
+    impl<'d, U: UarteInstance> embedded_io_async::Read for BufferedUarte<'d, U> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+            self.read(buf).await
+        }
+    }
+
+    impl<'d: 'd, U: UarteInstance> embedded_io_async::Read for BufferedUarteRx<'d, U> {
+        async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+            self.read(buf).await
+        }
+    }
+
+    impl<'d, U: UarteInstance> embedded_io_async::ReadReady for BufferedUarte<'d, U> {
+        fn read_ready(&mut self) -> Result<bool, Self::Error> {
+            BufferedUarteRx::<'d, U>::read_ready()
+        }
+    }
+
+    impl<'d, U: UarteInstance> embedded_io_async::ReadReady for BufferedUarteRx<'d, U> {
+        fn read_ready(&mut self) -> Result<bool, Self::Error> {
+            Self::read_ready()
+        }
+    }
+
+    impl<'d, U: UarteInstance> embedded_io_async::BufRead for BufferedUarte<'d, U> {
+        async fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
+            self.fill_buf().await
+        }
+
+        fn consume(&mut self, amt: usize) {
+            self.consume(amt)
+        }
+    }
+
+    impl<'d: 'd, U: UarteInstance> embedded_io_async::BufRead for BufferedUarteRx<'d, U> {
+        async fn fill_buf(&mut self) -> Result<&[u8], Self::Error> {
+            self.fill_buf().await
+        }
+
+        fn consume(&mut self, amt: usize) {
+            self.consume(amt)
+        }
+    }
+
+    impl<'d, U: UarteInstance> embedded_io_async::Write for BufferedUarte<'d, U> {
+        async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+            self.write(buf).await
+        }
+
+        async fn flush(&mut self) -> Result<(), Self::Error> {
+            self.flush().await
+        }
+    }
+
+    impl<'d: 'd, U: UarteInstance> embedded_io_async::Write for BufferedUarteTx<'d, U> {
+        async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+            self.write(buf).await
+        }
+
+        async fn flush(&mut self) -> Result<(), Self::Error> {
+            self.flush().await
+        }
+    }
+}
diff --git a/embassy-nrf/src/chips/nrf51.rs b/embassy-nrf/src/chips/nrf51.rs
index 3976e8ff0..1184c4409 100644
--- a/embassy-nrf/src/chips/nrf51.rs
+++ b/embassy-nrf/src/chips/nrf51.rs
@@ -115,6 +115,11 @@ impl_rtc!(RTC0, RTC0, RTC0);
 #[cfg(not(feature = "time-driver-rtc1"))]
 impl_rtc!(RTC1, RTC1, RTC1);
 
+impl_ppi_group!(PPI_GROUP0, PPI, 0);
+impl_ppi_group!(PPI_GROUP1, PPI, 1);
+impl_ppi_group!(PPI_GROUP2, PPI, 2);
+impl_ppi_group!(PPI_GROUP3, PPI, 3);
+
 impl_pin!(P0_00, 0, 0);
 impl_pin!(P0_01, 0, 1);
 impl_pin!(P0_02, 0, 2);
diff --git a/embassy-nrf/src/chips/nrf52805.rs b/embassy-nrf/src/chips/nrf52805.rs
index 63ba6999a..dd2e66927 100644
--- a/embassy-nrf/src/chips/nrf52805.rs
+++ b/embassy-nrf/src/chips/nrf52805.rs
@@ -195,28 +195,35 @@ impl_pin!(P0_29, 0, 29);
 impl_pin!(P0_30, 0, 30);
 impl_pin!(P0_31, 0, 31);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => static);
-impl_ppi_channel!(PPI_CH21, 21 => static);
-impl_ppi_channel!(PPI_CH22, 22 => static);
-impl_ppi_channel!(PPI_CH23, 23 => static);
-impl_ppi_channel!(PPI_CH24, 24 => static);
-impl_ppi_channel!(PPI_CH25, 25 => static);
-impl_ppi_channel!(PPI_CH26, 26 => static);
-impl_ppi_channel!(PPI_CH27, 27 => static);
-impl_ppi_channel!(PPI_CH28, 28 => static);
-impl_ppi_channel!(PPI_CH29, 29 => static);
-impl_ppi_channel!(PPI_CH30, 30 => static);
-impl_ppi_channel!(PPI_CH31, 31 => static);
+impl_ppi_channel!(PPI_CH0, PPI, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, PPI, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, PPI, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, PPI, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, PPI, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, PPI, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, PPI, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, PPI, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, PPI, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, PPI, 9 => configurable);
+impl_ppi_channel!(PPI_CH20, PPI, 20 => static);
+impl_ppi_channel!(PPI_CH21, PPI, 21 => static);
+impl_ppi_channel!(PPI_CH22, PPI, 22 => static);
+impl_ppi_channel!(PPI_CH23, PPI, 23 => static);
+impl_ppi_channel!(PPI_CH24, PPI, 24 => static);
+impl_ppi_channel!(PPI_CH25, PPI, 25 => static);
+impl_ppi_channel!(PPI_CH26, PPI, 26 => static);
+impl_ppi_channel!(PPI_CH27, PPI, 27 => static);
+impl_ppi_channel!(PPI_CH28, PPI, 28 => static);
+impl_ppi_channel!(PPI_CH29, PPI, 29 => static);
+impl_ppi_channel!(PPI_CH30, PPI, 30 => static);
+impl_ppi_channel!(PPI_CH31, PPI, 31 => static);
+
+impl_ppi_group!(PPI_GROUP0, PPI, 0);
+impl_ppi_group!(PPI_GROUP1, PPI, 1);
+impl_ppi_group!(PPI_GROUP2, PPI, 2);
+impl_ppi_group!(PPI_GROUP3, PPI, 3);
+impl_ppi_group!(PPI_GROUP4, PPI, 4);
+impl_ppi_group!(PPI_GROUP5, PPI, 5);
 
 impl_saadc_input!(P0_04, ANALOG_INPUT2);
 impl_saadc_input!(P0_05, ANALOG_INPUT3);
diff --git a/embassy-nrf/src/chips/nrf52810.rs b/embassy-nrf/src/chips/nrf52810.rs
index 7f744f9fb..7acb53a03 100644
--- a/embassy-nrf/src/chips/nrf52810.rs
+++ b/embassy-nrf/src/chips/nrf52810.rs
@@ -205,38 +205,45 @@ impl_pin!(P0_29, 0, 29);
 impl_pin!(P0_30, 0, 30);
 impl_pin!(P0_31, 0, 31);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
-impl_ppi_channel!(PPI_CH16, 16 => configurable);
-impl_ppi_channel!(PPI_CH17, 17 => configurable);
-impl_ppi_channel!(PPI_CH18, 18 => configurable);
-impl_ppi_channel!(PPI_CH19, 19 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => static);
-impl_ppi_channel!(PPI_CH21, 21 => static);
-impl_ppi_channel!(PPI_CH22, 22 => static);
-impl_ppi_channel!(PPI_CH23, 23 => static);
-impl_ppi_channel!(PPI_CH24, 24 => static);
-impl_ppi_channel!(PPI_CH25, 25 => static);
-impl_ppi_channel!(PPI_CH26, 26 => static);
-impl_ppi_channel!(PPI_CH27, 27 => static);
-impl_ppi_channel!(PPI_CH28, 28 => static);
-impl_ppi_channel!(PPI_CH29, 29 => static);
-impl_ppi_channel!(PPI_CH30, 30 => static);
-impl_ppi_channel!(PPI_CH31, 31 => static);
+impl_ppi_channel!(PPI_CH0, PPI, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, PPI, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, PPI, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, PPI, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, PPI, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, PPI, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, PPI, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, PPI, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, PPI, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, PPI, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, PPI, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, PPI, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, PPI, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, PPI, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, PPI, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, PPI, 15 => configurable);
+impl_ppi_channel!(PPI_CH16, PPI, 16 => configurable);
+impl_ppi_channel!(PPI_CH17, PPI, 17 => configurable);
+impl_ppi_channel!(PPI_CH18, PPI, 18 => configurable);
+impl_ppi_channel!(PPI_CH19, PPI, 19 => configurable);
+impl_ppi_channel!(PPI_CH20, PPI, 20 => static);
+impl_ppi_channel!(PPI_CH21, PPI, 21 => static);
+impl_ppi_channel!(PPI_CH22, PPI, 22 => static);
+impl_ppi_channel!(PPI_CH23, PPI, 23 => static);
+impl_ppi_channel!(PPI_CH24, PPI, 24 => static);
+impl_ppi_channel!(PPI_CH25, PPI, 25 => static);
+impl_ppi_channel!(PPI_CH26, PPI, 26 => static);
+impl_ppi_channel!(PPI_CH27, PPI, 27 => static);
+impl_ppi_channel!(PPI_CH28, PPI, 28 => static);
+impl_ppi_channel!(PPI_CH29, PPI, 29 => static);
+impl_ppi_channel!(PPI_CH30, PPI, 30 => static);
+impl_ppi_channel!(PPI_CH31, PPI, 31 => static);
+
+impl_ppi_group!(PPI_GROUP0, PPI, 0);
+impl_ppi_group!(PPI_GROUP1, PPI, 1);
+impl_ppi_group!(PPI_GROUP2, PPI, 2);
+impl_ppi_group!(PPI_GROUP3, PPI, 3);
+impl_ppi_group!(PPI_GROUP4, PPI, 4);
+impl_ppi_group!(PPI_GROUP5, PPI, 5);
 
 impl_saadc_input!(P0_02, ANALOG_INPUT0);
 impl_saadc_input!(P0_03, ANALOG_INPUT1);
diff --git a/embassy-nrf/src/chips/nrf52811.rs b/embassy-nrf/src/chips/nrf52811.rs
index 908167e31..4178ef6cd 100644
--- a/embassy-nrf/src/chips/nrf52811.rs
+++ b/embassy-nrf/src/chips/nrf52811.rs
@@ -207,38 +207,45 @@ impl_pin!(P0_29, 0, 29);
 impl_pin!(P0_30, 0, 30);
 impl_pin!(P0_31, 0, 31);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
-impl_ppi_channel!(PPI_CH16, 16 => configurable);
-impl_ppi_channel!(PPI_CH17, 17 => configurable);
-impl_ppi_channel!(PPI_CH18, 18 => configurable);
-impl_ppi_channel!(PPI_CH19, 19 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => static);
-impl_ppi_channel!(PPI_CH21, 21 => static);
-impl_ppi_channel!(PPI_CH22, 22 => static);
-impl_ppi_channel!(PPI_CH23, 23 => static);
-impl_ppi_channel!(PPI_CH24, 24 => static);
-impl_ppi_channel!(PPI_CH25, 25 => static);
-impl_ppi_channel!(PPI_CH26, 26 => static);
-impl_ppi_channel!(PPI_CH27, 27 => static);
-impl_ppi_channel!(PPI_CH28, 28 => static);
-impl_ppi_channel!(PPI_CH29, 29 => static);
-impl_ppi_channel!(PPI_CH30, 30 => static);
-impl_ppi_channel!(PPI_CH31, 31 => static);
+impl_ppi_channel!(PPI_CH0, PPI, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, PPI, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, PPI, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, PPI, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, PPI, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, PPI, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, PPI, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, PPI, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, PPI, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, PPI, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, PPI, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, PPI, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, PPI, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, PPI, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, PPI, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, PPI, 15 => configurable);
+impl_ppi_channel!(PPI_CH16, PPI, 16 => configurable);
+impl_ppi_channel!(PPI_CH17, PPI, 17 => configurable);
+impl_ppi_channel!(PPI_CH18, PPI, 18 => configurable);
+impl_ppi_channel!(PPI_CH19, PPI, 19 => configurable);
+impl_ppi_channel!(PPI_CH20, PPI, 20 => static);
+impl_ppi_channel!(PPI_CH21, PPI, 21 => static);
+impl_ppi_channel!(PPI_CH22, PPI, 22 => static);
+impl_ppi_channel!(PPI_CH23, PPI, 23 => static);
+impl_ppi_channel!(PPI_CH24, PPI, 24 => static);
+impl_ppi_channel!(PPI_CH25, PPI, 25 => static);
+impl_ppi_channel!(PPI_CH26, PPI, 26 => static);
+impl_ppi_channel!(PPI_CH27, PPI, 27 => static);
+impl_ppi_channel!(PPI_CH28, PPI, 28 => static);
+impl_ppi_channel!(PPI_CH29, PPI, 29 => static);
+impl_ppi_channel!(PPI_CH30, PPI, 30 => static);
+impl_ppi_channel!(PPI_CH31, PPI, 31 => static);
+
+impl_ppi_group!(PPI_GROUP0, PPI, 0);
+impl_ppi_group!(PPI_GROUP1, PPI, 1);
+impl_ppi_group!(PPI_GROUP2, PPI, 2);
+impl_ppi_group!(PPI_GROUP3, PPI, 3);
+impl_ppi_group!(PPI_GROUP4, PPI, 4);
+impl_ppi_group!(PPI_GROUP5, PPI, 5);
 
 impl_saadc_input!(P0_02, ANALOG_INPUT0);
 impl_saadc_input!(P0_03, ANALOG_INPUT1);
diff --git a/embassy-nrf/src/chips/nrf52820.rs b/embassy-nrf/src/chips/nrf52820.rs
index 22360575b..32304b3ea 100644
--- a/embassy-nrf/src/chips/nrf52820.rs
+++ b/embassy-nrf/src/chips/nrf52820.rs
@@ -207,38 +207,45 @@ impl_pin!(P0_29, 0, 29);
 impl_pin!(P0_30, 0, 30);
 impl_pin!(P0_31, 0, 31);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
-impl_ppi_channel!(PPI_CH16, 16 => configurable);
-impl_ppi_channel!(PPI_CH17, 17 => configurable);
-impl_ppi_channel!(PPI_CH18, 18 => configurable);
-impl_ppi_channel!(PPI_CH19, 19 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => static);
-impl_ppi_channel!(PPI_CH21, 21 => static);
-impl_ppi_channel!(PPI_CH22, 22 => static);
-impl_ppi_channel!(PPI_CH23, 23 => static);
-impl_ppi_channel!(PPI_CH24, 24 => static);
-impl_ppi_channel!(PPI_CH25, 25 => static);
-impl_ppi_channel!(PPI_CH26, 26 => static);
-impl_ppi_channel!(PPI_CH27, 27 => static);
-impl_ppi_channel!(PPI_CH28, 28 => static);
-impl_ppi_channel!(PPI_CH29, 29 => static);
-impl_ppi_channel!(PPI_CH30, 30 => static);
-impl_ppi_channel!(PPI_CH31, 31 => static);
+impl_ppi_channel!(PPI_CH0, PPI, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, PPI, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, PPI, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, PPI, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, PPI, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, PPI, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, PPI, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, PPI, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, PPI, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, PPI, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, PPI, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, PPI, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, PPI, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, PPI, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, PPI, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, PPI, 15 => configurable);
+impl_ppi_channel!(PPI_CH16, PPI, 16 => configurable);
+impl_ppi_channel!(PPI_CH17, PPI, 17 => configurable);
+impl_ppi_channel!(PPI_CH18, PPI, 18 => configurable);
+impl_ppi_channel!(PPI_CH19, PPI, 19 => configurable);
+impl_ppi_channel!(PPI_CH20, PPI, 20 => static);
+impl_ppi_channel!(PPI_CH21, PPI, 21 => static);
+impl_ppi_channel!(PPI_CH22, PPI, 22 => static);
+impl_ppi_channel!(PPI_CH23, PPI, 23 => static);
+impl_ppi_channel!(PPI_CH24, PPI, 24 => static);
+impl_ppi_channel!(PPI_CH25, PPI, 25 => static);
+impl_ppi_channel!(PPI_CH26, PPI, 26 => static);
+impl_ppi_channel!(PPI_CH27, PPI, 27 => static);
+impl_ppi_channel!(PPI_CH28, PPI, 28 => static);
+impl_ppi_channel!(PPI_CH29, PPI, 29 => static);
+impl_ppi_channel!(PPI_CH30, PPI, 30 => static);
+impl_ppi_channel!(PPI_CH31, PPI, 31 => static);
+
+impl_ppi_group!(PPI_GROUP0, PPI, 0);
+impl_ppi_group!(PPI_GROUP1, PPI, 1);
+impl_ppi_group!(PPI_GROUP2, PPI, 2);
+impl_ppi_group!(PPI_GROUP3, PPI, 3);
+impl_ppi_group!(PPI_GROUP4, PPI, 4);
+impl_ppi_group!(PPI_GROUP5, PPI, 5);
 
 impl_radio!(RADIO, RADIO, RADIO);
 
diff --git a/embassy-nrf/src/chips/nrf52832.rs b/embassy-nrf/src/chips/nrf52832.rs
index 1598df3fe..06363a467 100644
--- a/embassy-nrf/src/chips/nrf52832.rs
+++ b/embassy-nrf/src/chips/nrf52832.rs
@@ -240,38 +240,45 @@ impl_pin!(P0_29, 0, 29);
 impl_pin!(P0_30, 0, 30);
 impl_pin!(P0_31, 0, 31);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
-impl_ppi_channel!(PPI_CH16, 16 => configurable);
-impl_ppi_channel!(PPI_CH17, 17 => configurable);
-impl_ppi_channel!(PPI_CH18, 18 => configurable);
-impl_ppi_channel!(PPI_CH19, 19 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => static);
-impl_ppi_channel!(PPI_CH21, 21 => static);
-impl_ppi_channel!(PPI_CH22, 22 => static);
-impl_ppi_channel!(PPI_CH23, 23 => static);
-impl_ppi_channel!(PPI_CH24, 24 => static);
-impl_ppi_channel!(PPI_CH25, 25 => static);
-impl_ppi_channel!(PPI_CH26, 26 => static);
-impl_ppi_channel!(PPI_CH27, 27 => static);
-impl_ppi_channel!(PPI_CH28, 28 => static);
-impl_ppi_channel!(PPI_CH29, 29 => static);
-impl_ppi_channel!(PPI_CH30, 30 => static);
-impl_ppi_channel!(PPI_CH31, 31 => static);
+impl_ppi_channel!(PPI_CH0, PPI, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, PPI, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, PPI, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, PPI, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, PPI, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, PPI, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, PPI, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, PPI, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, PPI, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, PPI, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, PPI, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, PPI, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, PPI, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, PPI, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, PPI, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, PPI, 15 => configurable);
+impl_ppi_channel!(PPI_CH16, PPI, 16 => configurable);
+impl_ppi_channel!(PPI_CH17, PPI, 17 => configurable);
+impl_ppi_channel!(PPI_CH18, PPI, 18 => configurable);
+impl_ppi_channel!(PPI_CH19, PPI, 19 => configurable);
+impl_ppi_channel!(PPI_CH20, PPI, 20 => static);
+impl_ppi_channel!(PPI_CH21, PPI, 21 => static);
+impl_ppi_channel!(PPI_CH22, PPI, 22 => static);
+impl_ppi_channel!(PPI_CH23, PPI, 23 => static);
+impl_ppi_channel!(PPI_CH24, PPI, 24 => static);
+impl_ppi_channel!(PPI_CH25, PPI, 25 => static);
+impl_ppi_channel!(PPI_CH26, PPI, 26 => static);
+impl_ppi_channel!(PPI_CH27, PPI, 27 => static);
+impl_ppi_channel!(PPI_CH28, PPI, 28 => static);
+impl_ppi_channel!(PPI_CH29, PPI, 29 => static);
+impl_ppi_channel!(PPI_CH30, PPI, 30 => static);
+impl_ppi_channel!(PPI_CH31, PPI, 31 => static);
+
+impl_ppi_group!(PPI_GROUP0, PPI, 0);
+impl_ppi_group!(PPI_GROUP1, PPI, 1);
+impl_ppi_group!(PPI_GROUP2, PPI, 2);
+impl_ppi_group!(PPI_GROUP3, PPI, 3);
+impl_ppi_group!(PPI_GROUP4, PPI, 4);
+impl_ppi_group!(PPI_GROUP5, PPI, 5);
 
 impl_saadc_input!(P0_02, ANALOG_INPUT0);
 impl_saadc_input!(P0_03, ANALOG_INPUT1);
diff --git a/embassy-nrf/src/chips/nrf52833.rs b/embassy-nrf/src/chips/nrf52833.rs
index 6931fb064..754943d33 100644
--- a/embassy-nrf/src/chips/nrf52833.rs
+++ b/embassy-nrf/src/chips/nrf52833.rs
@@ -282,38 +282,45 @@ impl_pin!(P1_13, 1, 13);
 impl_pin!(P1_14, 1, 14);
 impl_pin!(P1_15, 1, 15);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
-impl_ppi_channel!(PPI_CH16, 16 => configurable);
-impl_ppi_channel!(PPI_CH17, 17 => configurable);
-impl_ppi_channel!(PPI_CH18, 18 => configurable);
-impl_ppi_channel!(PPI_CH19, 19 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => static);
-impl_ppi_channel!(PPI_CH21, 21 => static);
-impl_ppi_channel!(PPI_CH22, 22 => static);
-impl_ppi_channel!(PPI_CH23, 23 => static);
-impl_ppi_channel!(PPI_CH24, 24 => static);
-impl_ppi_channel!(PPI_CH25, 25 => static);
-impl_ppi_channel!(PPI_CH26, 26 => static);
-impl_ppi_channel!(PPI_CH27, 27 => static);
-impl_ppi_channel!(PPI_CH28, 28 => static);
-impl_ppi_channel!(PPI_CH29, 29 => static);
-impl_ppi_channel!(PPI_CH30, 30 => static);
-impl_ppi_channel!(PPI_CH31, 31 => static);
+impl_ppi_channel!(PPI_CH0, PPI, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, PPI, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, PPI, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, PPI, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, PPI, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, PPI, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, PPI, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, PPI, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, PPI, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, PPI, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, PPI, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, PPI, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, PPI, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, PPI, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, PPI, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, PPI, 15 => configurable);
+impl_ppi_channel!(PPI_CH16, PPI, 16 => configurable);
+impl_ppi_channel!(PPI_CH17, PPI, 17 => configurable);
+impl_ppi_channel!(PPI_CH18, PPI, 18 => configurable);
+impl_ppi_channel!(PPI_CH19, PPI, 19 => configurable);
+impl_ppi_channel!(PPI_CH20, PPI, 20 => static);
+impl_ppi_channel!(PPI_CH21, PPI, 21 => static);
+impl_ppi_channel!(PPI_CH22, PPI, 22 => static);
+impl_ppi_channel!(PPI_CH23, PPI, 23 => static);
+impl_ppi_channel!(PPI_CH24, PPI, 24 => static);
+impl_ppi_channel!(PPI_CH25, PPI, 25 => static);
+impl_ppi_channel!(PPI_CH26, PPI, 26 => static);
+impl_ppi_channel!(PPI_CH27, PPI, 27 => static);
+impl_ppi_channel!(PPI_CH28, PPI, 28 => static);
+impl_ppi_channel!(PPI_CH29, PPI, 29 => static);
+impl_ppi_channel!(PPI_CH30, PPI, 30 => static);
+impl_ppi_channel!(PPI_CH31, PPI, 31 => static);
+
+impl_ppi_group!(PPI_GROUP0, PPI, 0);
+impl_ppi_group!(PPI_GROUP1, PPI, 1);
+impl_ppi_group!(PPI_GROUP2, PPI, 2);
+impl_ppi_group!(PPI_GROUP3, PPI, 3);
+impl_ppi_group!(PPI_GROUP4, PPI, 4);
+impl_ppi_group!(PPI_GROUP5, PPI, 5);
 
 impl_saadc_input!(P0_02, ANALOG_INPUT0);
 impl_saadc_input!(P0_03, ANALOG_INPUT1);
diff --git a/embassy-nrf/src/chips/nrf52840.rs b/embassy-nrf/src/chips/nrf52840.rs
index 5fa521aae..ac07cd820 100644
--- a/embassy-nrf/src/chips/nrf52840.rs
+++ b/embassy-nrf/src/chips/nrf52840.rs
@@ -287,38 +287,45 @@ impl_pin!(P1_13, 1, 13);
 impl_pin!(P1_14, 1, 14);
 impl_pin!(P1_15, 1, 15);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
-impl_ppi_channel!(PPI_CH16, 16 => configurable);
-impl_ppi_channel!(PPI_CH17, 17 => configurable);
-impl_ppi_channel!(PPI_CH18, 18 => configurable);
-impl_ppi_channel!(PPI_CH19, 19 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => static);
-impl_ppi_channel!(PPI_CH21, 21 => static);
-impl_ppi_channel!(PPI_CH22, 22 => static);
-impl_ppi_channel!(PPI_CH23, 23 => static);
-impl_ppi_channel!(PPI_CH24, 24 => static);
-impl_ppi_channel!(PPI_CH25, 25 => static);
-impl_ppi_channel!(PPI_CH26, 26 => static);
-impl_ppi_channel!(PPI_CH27, 27 => static);
-impl_ppi_channel!(PPI_CH28, 28 => static);
-impl_ppi_channel!(PPI_CH29, 29 => static);
-impl_ppi_channel!(PPI_CH30, 30 => static);
-impl_ppi_channel!(PPI_CH31, 31 => static);
+impl_ppi_channel!(PPI_CH0, PPI, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, PPI, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, PPI, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, PPI, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, PPI, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, PPI, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, PPI, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, PPI, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, PPI, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, PPI, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, PPI, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, PPI, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, PPI, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, PPI, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, PPI, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, PPI, 15 => configurable);
+impl_ppi_channel!(PPI_CH16, PPI, 16 => configurable);
+impl_ppi_channel!(PPI_CH17, PPI, 17 => configurable);
+impl_ppi_channel!(PPI_CH18, PPI, 18 => configurable);
+impl_ppi_channel!(PPI_CH19, PPI, 19 => configurable);
+impl_ppi_channel!(PPI_CH20, PPI, 20 => static);
+impl_ppi_channel!(PPI_CH21, PPI, 21 => static);
+impl_ppi_channel!(PPI_CH22, PPI, 22 => static);
+impl_ppi_channel!(PPI_CH23, PPI, 23 => static);
+impl_ppi_channel!(PPI_CH24, PPI, 24 => static);
+impl_ppi_channel!(PPI_CH25, PPI, 25 => static);
+impl_ppi_channel!(PPI_CH26, PPI, 26 => static);
+impl_ppi_channel!(PPI_CH27, PPI, 27 => static);
+impl_ppi_channel!(PPI_CH28, PPI, 28 => static);
+impl_ppi_channel!(PPI_CH29, PPI, 29 => static);
+impl_ppi_channel!(PPI_CH30, PPI, 30 => static);
+impl_ppi_channel!(PPI_CH31, PPI, 31 => static);
+
+impl_ppi_group!(PPI_GROUP0, PPI, 0);
+impl_ppi_group!(PPI_GROUP1, PPI, 1);
+impl_ppi_group!(PPI_GROUP2, PPI, 2);
+impl_ppi_group!(PPI_GROUP3, PPI, 3);
+impl_ppi_group!(PPI_GROUP4, PPI, 4);
+impl_ppi_group!(PPI_GROUP5, PPI, 5);
 
 impl_saadc_input!(P0_02, ANALOG_INPUT0);
 impl_saadc_input!(P0_03, ANALOG_INPUT1);
diff --git a/embassy-nrf/src/chips/nrf5340_app.rs b/embassy-nrf/src/chips/nrf5340_app.rs
index 730c9842d..aa51527fb 100644
--- a/embassy-nrf/src/chips/nrf5340_app.rs
+++ b/embassy-nrf/src/chips/nrf5340_app.rs
@@ -435,38 +435,45 @@ impl_pin!(P1_13, 1, 13);
 impl_pin!(P1_14, 1, 14);
 impl_pin!(P1_15, 1, 15);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
-impl_ppi_channel!(PPI_CH16, 16 => configurable);
-impl_ppi_channel!(PPI_CH17, 17 => configurable);
-impl_ppi_channel!(PPI_CH18, 18 => configurable);
-impl_ppi_channel!(PPI_CH19, 19 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => configurable);
-impl_ppi_channel!(PPI_CH21, 21 => configurable);
-impl_ppi_channel!(PPI_CH22, 22 => configurable);
-impl_ppi_channel!(PPI_CH23, 23 => configurable);
-impl_ppi_channel!(PPI_CH24, 24 => configurable);
-impl_ppi_channel!(PPI_CH25, 25 => configurable);
-impl_ppi_channel!(PPI_CH26, 26 => configurable);
-impl_ppi_channel!(PPI_CH27, 27 => configurable);
-impl_ppi_channel!(PPI_CH28, 28 => configurable);
-impl_ppi_channel!(PPI_CH29, 29 => configurable);
-impl_ppi_channel!(PPI_CH30, 30 => configurable);
-impl_ppi_channel!(PPI_CH31, 31 => configurable);
+impl_ppi_channel!(PPI_CH0, DPPIC, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, DPPIC, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, DPPIC, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, DPPIC, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, DPPIC, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, DPPIC, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, DPPIC, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, DPPIC, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, DPPIC, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, DPPIC, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, DPPIC, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, DPPIC, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, DPPIC, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, DPPIC, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, DPPIC, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, DPPIC, 15 => configurable);
+impl_ppi_channel!(PPI_CH16, DPPIC, 16 => configurable);
+impl_ppi_channel!(PPI_CH17, DPPIC, 17 => configurable);
+impl_ppi_channel!(PPI_CH18, DPPIC, 18 => configurable);
+impl_ppi_channel!(PPI_CH19, DPPIC, 19 => configurable);
+impl_ppi_channel!(PPI_CH20, DPPIC, 20 => configurable);
+impl_ppi_channel!(PPI_CH21, DPPIC, 21 => configurable);
+impl_ppi_channel!(PPI_CH22, DPPIC, 22 => configurable);
+impl_ppi_channel!(PPI_CH23, DPPIC, 23 => configurable);
+impl_ppi_channel!(PPI_CH24, DPPIC, 24 => configurable);
+impl_ppi_channel!(PPI_CH25, DPPIC, 25 => configurable);
+impl_ppi_channel!(PPI_CH26, DPPIC, 26 => configurable);
+impl_ppi_channel!(PPI_CH27, DPPIC, 27 => configurable);
+impl_ppi_channel!(PPI_CH28, DPPIC, 28 => configurable);
+impl_ppi_channel!(PPI_CH29, DPPIC, 29 => configurable);
+impl_ppi_channel!(PPI_CH30, DPPIC, 30 => configurable);
+impl_ppi_channel!(PPI_CH31, DPPIC, 31 => configurable);
+
+impl_ppi_group!(PPI_GROUP0, DPPIC, 0);
+impl_ppi_group!(PPI_GROUP1, DPPIC, 1);
+impl_ppi_group!(PPI_GROUP2, DPPIC, 2);
+impl_ppi_group!(PPI_GROUP3, DPPIC, 3);
+impl_ppi_group!(PPI_GROUP4, DPPIC, 4);
+impl_ppi_group!(PPI_GROUP5, DPPIC, 5);
 
 impl_saadc_input!(P0_04, ANALOG_INPUT0);
 impl_saadc_input!(P0_05, ANALOG_INPUT1);
diff --git a/embassy-nrf/src/chips/nrf5340_net.rs b/embassy-nrf/src/chips/nrf5340_net.rs
index 413afc5c5..2207e7bda 100644
--- a/embassy-nrf/src/chips/nrf5340_net.rs
+++ b/embassy-nrf/src/chips/nrf5340_net.rs
@@ -275,38 +275,45 @@ impl_pin!(P1_13, 1, 13);
 impl_pin!(P1_14, 1, 14);
 impl_pin!(P1_15, 1, 15);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
-impl_ppi_channel!(PPI_CH16, 16 => configurable);
-impl_ppi_channel!(PPI_CH17, 17 => configurable);
-impl_ppi_channel!(PPI_CH18, 18 => configurable);
-impl_ppi_channel!(PPI_CH19, 19 => configurable);
-impl_ppi_channel!(PPI_CH20, 20 => configurable);
-impl_ppi_channel!(PPI_CH21, 21 => configurable);
-impl_ppi_channel!(PPI_CH22, 22 => configurable);
-impl_ppi_channel!(PPI_CH23, 23 => configurable);
-impl_ppi_channel!(PPI_CH24, 24 => configurable);
-impl_ppi_channel!(PPI_CH25, 25 => configurable);
-impl_ppi_channel!(PPI_CH26, 26 => configurable);
-impl_ppi_channel!(PPI_CH27, 27 => configurable);
-impl_ppi_channel!(PPI_CH28, 28 => configurable);
-impl_ppi_channel!(PPI_CH29, 29 => configurable);
-impl_ppi_channel!(PPI_CH30, 30 => configurable);
-impl_ppi_channel!(PPI_CH31, 31 => configurable);
+impl_ppi_channel!(PPI_CH0, DPPIC, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, DPPIC, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, DPPIC, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, DPPIC, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, DPPIC, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, DPPIC, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, DPPIC, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, DPPIC, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, DPPIC, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, DPPIC, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, DPPIC, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, DPPIC, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, DPPIC, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, DPPIC, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, DPPIC, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, DPPIC, 15 => configurable);
+impl_ppi_channel!(PPI_CH16, DPPIC, 16 => configurable);
+impl_ppi_channel!(PPI_CH17, DPPIC, 17 => configurable);
+impl_ppi_channel!(PPI_CH18, DPPIC, 18 => configurable);
+impl_ppi_channel!(PPI_CH19, DPPIC, 19 => configurable);
+impl_ppi_channel!(PPI_CH20, DPPIC, 20 => configurable);
+impl_ppi_channel!(PPI_CH21, DPPIC, 21 => configurable);
+impl_ppi_channel!(PPI_CH22, DPPIC, 22 => configurable);
+impl_ppi_channel!(PPI_CH23, DPPIC, 23 => configurable);
+impl_ppi_channel!(PPI_CH24, DPPIC, 24 => configurable);
+impl_ppi_channel!(PPI_CH25, DPPIC, 25 => configurable);
+impl_ppi_channel!(PPI_CH26, DPPIC, 26 => configurable);
+impl_ppi_channel!(PPI_CH27, DPPIC, 27 => configurable);
+impl_ppi_channel!(PPI_CH28, DPPIC, 28 => configurable);
+impl_ppi_channel!(PPI_CH29, DPPIC, 29 => configurable);
+impl_ppi_channel!(PPI_CH30, DPPIC, 30 => configurable);
+impl_ppi_channel!(PPI_CH31, DPPIC, 31 => configurable);
+
+impl_ppi_group!(PPI_GROUP0, DPPIC, 0);
+impl_ppi_group!(PPI_GROUP1, DPPIC, 1);
+impl_ppi_group!(PPI_GROUP2, DPPIC, 2);
+impl_ppi_group!(PPI_GROUP3, DPPIC, 3);
+impl_ppi_group!(PPI_GROUP4, DPPIC, 4);
+impl_ppi_group!(PPI_GROUP5, DPPIC, 5);
 
 impl_radio!(RADIO, RADIO, RADIO);
 
diff --git a/embassy-nrf/src/chips/nrf54l15_app.rs b/embassy-nrf/src/chips/nrf54l15_app.rs
index 82d30104f..0724f2ff6 100644
--- a/embassy-nrf/src/chips/nrf54l15_app.rs
+++ b/embassy-nrf/src/chips/nrf54l15_app.rs
@@ -200,13 +200,180 @@ pub mod pac {
 
 /// The maximum buffer size that the EasyDMA can send/recv in one operation.
 pub const EASY_DMA_SIZE: usize = (1 << 16) - 1;
-//pub const FORCE_COPY_BUFFER_SIZE: usize = 1024;
+pub const FORCE_COPY_BUFFER_SIZE: usize = 1024;
 
 // 1.5 MB NVM
 #[allow(unused)]
 pub const FLASH_SIZE: usize = 1536 * 1024;
 
 embassy_hal_internal::peripherals! {
+    // PPI
+    PPI00_CH0,
+    PPI00_CH1,
+    PPI00_CH2,
+    PPI00_CH3,
+    PPI00_CH4,
+    PPI00_CH5,
+    PPI00_CH6,
+    PPI00_CH7,
+
+    PPI10_CH0,
+    PPI10_CH1,
+    PPI10_CH2,
+    PPI10_CH3,
+    PPI10_CH4,
+    PPI10_CH5,
+    PPI10_CH6,
+    PPI10_CH7,
+    PPI10_CH8,
+    PPI10_CH9,
+    PPI10_CH10,
+    PPI10_CH11,
+    PPI10_CH12,
+    PPI10_CH13,
+    PPI10_CH14,
+    PPI10_CH15,
+    PPI10_CH16,
+    PPI10_CH17,
+    PPI10_CH18,
+    PPI10_CH19,
+    PPI10_CH20,
+    PPI10_CH21,
+    PPI10_CH22,
+    PPI10_CH23,
+
+    PPI20_CH0,
+    PPI20_CH1,
+    PPI20_CH2,
+    PPI20_CH3,
+    PPI20_CH4,
+    PPI20_CH5,
+    PPI20_CH6,
+    PPI20_CH7,
+    PPI20_CH8,
+    PPI20_CH9,
+    PPI20_CH10,
+    PPI20_CH11,
+    PPI20_CH12,
+    PPI20_CH13,
+    PPI20_CH14,
+    PPI20_CH15,
+
+    PPI30_CH0,
+    PPI30_CH1,
+    PPI30_CH2,
+    PPI30_CH3,
+
+    PPI00_GROUP0,
+    PPI00_GROUP1,
+
+    PPI10_GROUP0,
+    PPI10_GROUP1,
+    PPI10_GROUP2,
+    PPI10_GROUP3,
+    PPI10_GROUP4,
+    PPI10_GROUP5,
+
+    PPI20_GROUP0,
+    PPI20_GROUP1,
+    PPI20_GROUP2,
+    PPI20_GROUP3,
+    PPI20_GROUP4,
+    PPI20_GROUP5,
+
+    PPI30_GROUP0,
+    PPI30_GROUP1,
+
+    // PPI BRIDGE channels
+    PPIB00_CH0,
+    PPIB00_CH1,
+    PPIB00_CH2,
+    PPIB00_CH3,
+    PPIB00_CH4,
+    PPIB00_CH5,
+    PPIB00_CH6,
+    PPIB00_CH7,
+
+    PPIB01_CH0,
+    PPIB01_CH1,
+    PPIB01_CH2,
+    PPIB01_CH3,
+    PPIB01_CH4,
+    PPIB01_CH5,
+    PPIB01_CH6,
+    PPIB01_CH7,
+
+    PPIB10_CH0,
+    PPIB10_CH1,
+    PPIB10_CH2,
+    PPIB10_CH3,
+    PPIB10_CH4,
+    PPIB10_CH5,
+    PPIB10_CH6,
+    PPIB10_CH7,
+
+    PPIB11_CH0,
+    PPIB11_CH1,
+    PPIB11_CH2,
+    PPIB11_CH3,
+    PPIB11_CH4,
+    PPIB11_CH5,
+    PPIB11_CH6,
+    PPIB11_CH7,
+    PPIB11_CH8,
+    PPIB11_CH9,
+    PPIB11_CH10,
+    PPIB11_CH11,
+    PPIB11_CH12,
+    PPIB11_CH13,
+    PPIB11_CH14,
+    PPIB11_CH15,
+
+    PPIB20_CH0,
+    PPIB20_CH1,
+    PPIB20_CH2,
+    PPIB20_CH3,
+    PPIB20_CH4,
+    PPIB20_CH5,
+    PPIB20_CH6,
+    PPIB20_CH7,
+
+    PPIB21_CH0,
+    PPIB21_CH1,
+    PPIB21_CH2,
+    PPIB21_CH3,
+    PPIB21_CH4,
+    PPIB21_CH5,
+    PPIB21_CH6,
+    PPIB21_CH7,
+    PPIB21_CH8,
+    PPIB21_CH9,
+    PPIB21_CH10,
+    PPIB21_CH11,
+    PPIB21_CH12,
+    PPIB21_CH13,
+    PPIB21_CH14,
+    PPIB21_CH15,
+
+    PPIB22_CH0,
+    PPIB22_CH1,
+    PPIB22_CH2,
+    PPIB22_CH3,
+
+    PPIB30_CH0,
+    PPIB30_CH1,
+    PPIB30_CH2,
+    PPIB30_CH3,
+
+    // Timers
+    TIMER00,
+    TIMER10,
+    TIMER20,
+    TIMER21,
+    TIMER22,
+    TIMER23,
+    TIMER24,
+
     // GPIO port 0
     P0_00,
     P0_01,
@@ -249,6 +416,54 @@ embassy_hal_internal::peripherals! {
     P2_09,
     P2_10,
 
+    // GRTC
+    GRTC,
+
+    // RTC
+    RTC10,
+    RTC30,
+
+    // PWM
+    PWM20,
+    PWM21,
+    PWM22,
+
+    // SERIAL
+    SERIAL00,
+    SERIAL20,
+    SERIAL21,
+    SERIAL22,
+    SERIAL30,
+
+    // SAADC
+    SAADC,
+
+    // RADIO
+    RADIO,
+
+
+    // GPIOTE instances
+    GPIOTE20,
+    GPIOTE30,
+
+    // GPIOTE channels
+    GPIOTE20_CH0,
+    GPIOTE20_CH1,
+    GPIOTE20_CH2,
+    GPIOTE20_CH3,
+    GPIOTE20_CH4,
+    GPIOTE20_CH5,
+    GPIOTE20_CH6,
+    GPIOTE20_CH7,
+    GPIOTE30_CH0,
+    GPIOTE30_CH1,
+    GPIOTE30_CH2,
+    GPIOTE30_CH3,
+
+    // CRACEN
+    #[cfg(feature = "_s")]
+    CRACEN,
+
     #[cfg(feature = "_s")]
     // RRAMC
     RRAMC,
@@ -303,12 +518,173 @@ impl_pin!(P2_08, 2, 8);
 impl_pin!(P2_09, 2, 9);
 impl_pin!(P2_10, 2, 10);
 
+cfg_if::cfg_if! {
+    if #[cfg(feature = "gpiote")] {
+        impl_gpiote_pin!(P0_00, GPIOTE30);
+        impl_gpiote_pin!(P0_01, GPIOTE30);
+        impl_gpiote_pin!(P0_02, GPIOTE30);
+        impl_gpiote_pin!(P0_03, GPIOTE30);
+        impl_gpiote_pin!(P0_04, GPIOTE30);
+        impl_gpiote_pin!(P0_05, GPIOTE30);
+        impl_gpiote_pin!(P0_06, GPIOTE30);
+
+        impl_gpiote_pin!(P1_00, GPIOTE20);
+        impl_gpiote_pin!(P1_01, GPIOTE20);
+        impl_gpiote_pin!(P1_02, GPIOTE20);
+        impl_gpiote_pin!(P1_03, GPIOTE20);
+        impl_gpiote_pin!(P1_04, GPIOTE20);
+        impl_gpiote_pin!(P1_05, GPIOTE20);
+        impl_gpiote_pin!(P1_06, GPIOTE20);
+        impl_gpiote_pin!(P1_07, GPIOTE20);
+        impl_gpiote_pin!(P1_08, GPIOTE20);
+        impl_gpiote_pin!(P1_09, GPIOTE20);
+        impl_gpiote_pin!(P1_10, GPIOTE20);
+        impl_gpiote_pin!(P1_11, GPIOTE20);
+        impl_gpiote_pin!(P1_12, GPIOTE20);
+        impl_gpiote_pin!(P1_13, GPIOTE20);
+        impl_gpiote_pin!(P1_14, GPIOTE20);
+        impl_gpiote_pin!(P1_15, GPIOTE20);
+        impl_gpiote_pin!(P1_16, GPIOTE20);
+    }
+}
+
+impl_rtc!(RTC10, RTC10, RTC10);
+impl_rtc!(RTC30, RTC30, RTC30);
+
 #[cfg(feature = "_ns")]
 impl_wdt!(WDT, WDT31, WDT31, 0);
 #[cfg(feature = "_s")]
 impl_wdt!(WDT0, WDT31, WDT31, 0);
 #[cfg(feature = "_s")]
 impl_wdt!(WDT1, WDT30, WDT30, 1);
+// DPPI00 channels
+impl_ppi_channel!(PPI00_CH0, DPPIC00, 0 => configurable);
+impl_ppi_channel!(PPI00_CH1, DPPIC00, 1 => configurable);
+impl_ppi_channel!(PPI00_CH2, DPPIC00, 2 => configurable);
+impl_ppi_channel!(PPI00_CH3, DPPIC00, 3 => configurable);
+impl_ppi_channel!(PPI00_CH4, DPPIC00, 4 => configurable);
+impl_ppi_channel!(PPI00_CH5, DPPIC00, 5 => configurable);
+impl_ppi_channel!(PPI00_CH6, DPPIC00, 6 => configurable);
+impl_ppi_channel!(PPI00_CH7, DPPIC00, 7 => configurable);
+
+// DPPI10 channels
+impl_ppi_channel!(PPI10_CH0, DPPIC10, 0 => static);
+
+// DPPI20 channels
+impl_ppi_channel!(PPI20_CH0, DPPIC20, 0 => configurable);
+impl_ppi_channel!(PPI20_CH1, DPPIC20, 1 => configurable);
+impl_ppi_channel!(PPI20_CH2, DPPIC20, 2 => configurable);
+impl_ppi_channel!(PPI20_CH3, DPPIC20, 3 => configurable);
+impl_ppi_channel!(PPI20_CH4, DPPIC20, 4 => configurable);
+impl_ppi_channel!(PPI20_CH5, DPPIC20, 5 => configurable);
+impl_ppi_channel!(PPI20_CH6, DPPIC20, 6 => configurable);
+impl_ppi_channel!(PPI20_CH7, DPPIC20, 7 => configurable);
+impl_ppi_channel!(PPI20_CH8, DPPIC20, 8 => configurable);
+impl_ppi_channel!(PPI20_CH9, DPPIC20, 9 => configurable);
+impl_ppi_channel!(PPI20_CH10, DPPIC20, 10 => configurable);
+impl_ppi_channel!(PPI20_CH11, DPPIC20, 11 => configurable);
+impl_ppi_channel!(PPI20_CH12, DPPIC20, 12 => configurable);
+impl_ppi_channel!(PPI20_CH13, DPPIC20, 13 => configurable);
+impl_ppi_channel!(PPI20_CH14, DPPIC20, 14 => configurable);
+impl_ppi_channel!(PPI20_CH15, DPPIC20, 15 => configurable);
+
+// DPPI30 channels
+impl_ppi_channel!(PPI30_CH0, DPPIC30, 0 => configurable);
+impl_ppi_channel!(PPI30_CH1, DPPIC30, 1 => configurable);
+impl_ppi_channel!(PPI30_CH2, DPPIC30, 2 => configurable);
+impl_ppi_channel!(PPI30_CH3, DPPIC30, 3 => configurable);
+
+// DPPI00 groups
+impl_ppi_group!(PPI00_GROUP0, DPPIC00, 0);
+impl_ppi_group!(PPI00_GROUP1, DPPIC00, 1);
+
+// DPPI10 groups
+impl_ppi_group!(PPI10_GROUP0, DPPIC10, 0);
+
+// DPPI20 groups
+impl_ppi_group!(PPI20_GROUP0, DPPIC20, 0);
+impl_ppi_group!(PPI20_GROUP1, DPPIC20, 1);
+impl_ppi_group!(PPI20_GROUP2, DPPIC20, 2);
+impl_ppi_group!(PPI20_GROUP3, DPPIC20, 3);
+impl_ppi_group!(PPI20_GROUP4, DPPIC20, 4);
+impl_ppi_group!(PPI20_GROUP5, DPPIC20, 5);
+
+// DPPI30 groups
+impl_ppi_group!(PPI30_GROUP0, DPPIC30, 0);
+impl_ppi_group!(PPI30_GROUP1, DPPIC30, 1);
+
+impl_timer!(TIMER00, TIMER00, TIMER00);
+impl_timer!(TIMER10, TIMER10, TIMER10);
+impl_timer!(TIMER20, TIMER20, TIMER20);
+impl_timer!(TIMER21, TIMER21, TIMER21);
+impl_timer!(TIMER22, TIMER22, TIMER22);
+impl_timer!(TIMER23, TIMER23, TIMER23);
+impl_timer!(TIMER24, TIMER24, TIMER24);
+
+impl_twim!(SERIAL20, TWIM20, SERIAL20);
+impl_twim!(SERIAL21, TWIM21, SERIAL21);
+impl_twim!(SERIAL22, TWIM22, SERIAL22);
+impl_twim!(SERIAL30, TWIM30, SERIAL30);
+
+impl_twis!(SERIAL20, TWIS20, SERIAL20);
+impl_twis!(SERIAL21, TWIS21, SERIAL21);
+impl_twis!(SERIAL22, TWIS22, SERIAL22);
+impl_twis!(SERIAL30, TWIS30, SERIAL30);
+
+impl_pwm!(PWM20, PWM20, PWM20);
+impl_pwm!(PWM21, PWM21, PWM21);
+impl_pwm!(PWM22, PWM22, PWM22);
+
+#[cfg(feature = "_s")]
+impl_spim!(
+    SERIAL00,
+    SPIM00,
+    SERIAL00,
+    match pac::OSCILLATORS_S.pll().currentfreq().read().currentfreq() {
+        pac::oscillators::vals::Currentfreq::CK128M => 128_000_000,
+        pac::oscillators::vals::Currentfreq::CK64M => 64_000_000,
+        _ => unreachable!(),
+    }
+);
+#[cfg(feature = "_ns")]
+impl_spim!(
+    SERIAL00,
+    SPIM00,
+    SERIAL00,
+    match pac::OSCILLATORS_NS.pll().currentfreq().read().currentfreq() {
+        pac::oscillators::vals::Currentfreq::CK128M => 128_000_000,
+        pac::oscillators::vals::Currentfreq::CK64M => 64_000_000,
+        _ => unreachable!(),
+    }
+);
+impl_spim!(SERIAL20, SPIM20, SERIAL20, 16_000_000);
+impl_spim!(SERIAL21, SPIM21, SERIAL21, 16_000_000);
+impl_spim!(SERIAL22, SPIM22, SERIAL22, 16_000_000);
+impl_spim!(SERIAL30, SPIM30, SERIAL30, 16_000_000);
+
+impl_spis!(SERIAL20, SPIS20, SERIAL20);
+impl_spis!(SERIAL21, SPIS21, SERIAL21);
+impl_spis!(SERIAL22, SPIS22, SERIAL22);
+impl_spis!(SERIAL30, SPIS30, SERIAL30);
+
+impl_uarte!(SERIAL00, UARTE00, SERIAL00);
+impl_uarte!(SERIAL20, UARTE20, SERIAL20);
+impl_uarte!(SERIAL21, UARTE21, SERIAL21);
+impl_uarte!(SERIAL22, UARTE22, SERIAL22);
+impl_uarte!(SERIAL30, UARTE30, SERIAL30);
+
+// NB: SAADC uses "pin" abstraction, not "AIN"
+impl_saadc_input!(P1_04, 1, 4);
+impl_saadc_input!(P1_05, 1, 5);
+impl_saadc_input!(P1_06, 1, 6);
+impl_saadc_input!(P1_07, 1, 7);
+impl_saadc_input!(P1_11, 1, 11);
+impl_saadc_input!(P1_12, 1, 12);
+impl_saadc_input!(P1_13, 1, 13);
+impl_saadc_input!(P1_14, 1, 14);
+
+#[cfg(feature = "_s")]
+impl_cracen!(CRACEN, CRACEN, CRACEN);
 
 embassy_hal_internal::interrupt_mod!(
     SWI00,
diff --git a/embassy-nrf/src/chips/nrf9120.rs b/embassy-nrf/src/chips/nrf9120.rs
index 5aee19d97..e9f313fef 100644
--- a/embassy-nrf/src/chips/nrf9120.rs
+++ b/embassy-nrf/src/chips/nrf9120.rs
@@ -314,22 +314,29 @@ impl_pin!(P0_29, 0, 29);
 impl_pin!(P0_30, 0, 30);
 impl_pin!(P0_31, 0, 31);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
+impl_ppi_channel!(PPI_CH0, DPPIC, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, DPPIC, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, DPPIC, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, DPPIC, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, DPPIC, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, DPPIC, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, DPPIC, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, DPPIC, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, DPPIC, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, DPPIC, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, DPPIC, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, DPPIC, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, DPPIC, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, DPPIC, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, DPPIC, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, DPPIC, 15 => configurable);
+
+impl_ppi_group!(PPI_GROUP0, DPPIC, 0);
+impl_ppi_group!(PPI_GROUP1, DPPIC, 1);
+impl_ppi_group!(PPI_GROUP2, DPPIC, 2);
+impl_ppi_group!(PPI_GROUP3, DPPIC, 3);
+impl_ppi_group!(PPI_GROUP4, DPPIC, 4);
+impl_ppi_group!(PPI_GROUP5, DPPIC, 5);
 
 impl_saadc_input!(P0_13, ANALOG_INPUT0);
 impl_saadc_input!(P0_14, ANALOG_INPUT1);
diff --git a/embassy-nrf/src/chips/nrf9160.rs b/embassy-nrf/src/chips/nrf9160.rs
index 64aec217c..4c6f055dd 100644
--- a/embassy-nrf/src/chips/nrf9160.rs
+++ b/embassy-nrf/src/chips/nrf9160.rs
@@ -314,22 +314,29 @@ impl_pin!(P0_29, 0, 29);
 impl_pin!(P0_30, 0, 30);
 impl_pin!(P0_31, 0, 31);
 
-impl_ppi_channel!(PPI_CH0, 0 => configurable);
-impl_ppi_channel!(PPI_CH1, 1 => configurable);
-impl_ppi_channel!(PPI_CH2, 2 => configurable);
-impl_ppi_channel!(PPI_CH3, 3 => configurable);
-impl_ppi_channel!(PPI_CH4, 4 => configurable);
-impl_ppi_channel!(PPI_CH5, 5 => configurable);
-impl_ppi_channel!(PPI_CH6, 6 => configurable);
-impl_ppi_channel!(PPI_CH7, 7 => configurable);
-impl_ppi_channel!(PPI_CH8, 8 => configurable);
-impl_ppi_channel!(PPI_CH9, 9 => configurable);
-impl_ppi_channel!(PPI_CH10, 10 => configurable);
-impl_ppi_channel!(PPI_CH11, 11 => configurable);
-impl_ppi_channel!(PPI_CH12, 12 => configurable);
-impl_ppi_channel!(PPI_CH13, 13 => configurable);
-impl_ppi_channel!(PPI_CH14, 14 => configurable);
-impl_ppi_channel!(PPI_CH15, 15 => configurable);
+impl_ppi_channel!(PPI_CH0, DPPIC, 0 => configurable);
+impl_ppi_channel!(PPI_CH1, DPPIC, 1 => configurable);
+impl_ppi_channel!(PPI_CH2, DPPIC, 2 => configurable);
+impl_ppi_channel!(PPI_CH3, DPPIC, 3 => configurable);
+impl_ppi_channel!(PPI_CH4, DPPIC, 4 => configurable);
+impl_ppi_channel!(PPI_CH5, DPPIC, 5 => configurable);
+impl_ppi_channel!(PPI_CH6, DPPIC, 6 => configurable);
+impl_ppi_channel!(PPI_CH7, DPPIC, 7 => configurable);
+impl_ppi_channel!(PPI_CH8, DPPIC, 8 => configurable);
+impl_ppi_channel!(PPI_CH9, DPPIC, 9 => configurable);
+impl_ppi_channel!(PPI_CH10, DPPIC, 10 => configurable);
+impl_ppi_channel!(PPI_CH11, DPPIC, 11 => configurable);
+impl_ppi_channel!(PPI_CH12, DPPIC, 12 => configurable);
+impl_ppi_channel!(PPI_CH13, DPPIC, 13 => configurable);
+impl_ppi_channel!(PPI_CH14, DPPIC, 14 => configurable);
+impl_ppi_channel!(PPI_CH15, DPPIC, 15 => configurable);
+
+impl_ppi_group!(PPI_GROUP0, DPPIC, 0);
+impl_ppi_group!(PPI_GROUP1, DPPIC, 1);
+impl_ppi_group!(PPI_GROUP2, DPPIC, 2);
+impl_ppi_group!(PPI_GROUP3, DPPIC, 3);
+impl_ppi_group!(PPI_GROUP4, DPPIC, 4);
+impl_ppi_group!(PPI_GROUP5, DPPIC, 5);
 
 impl_saadc_input!(P0_13, ANALOG_INPUT0);
 impl_saadc_input!(P0_14, ANALOG_INPUT1);
diff --git a/embassy-nrf/src/cracen.rs b/embassy-nrf/src/cracen.rs
new file mode 100644
index 000000000..47ef1cd87
--- /dev/null
+++ b/embassy-nrf/src/cracen.rs
@@ -0,0 +1,157 @@
+//! CRACEN - Cryptographic Accelerator Engine driver.
+
+#![macro_use]
+
+use core::marker::PhantomData;
+
+use crate::mode::{Blocking, Mode};
+use crate::{Peri, interrupt, pac, peripherals};
+
+/// A wrapper around an nRF54 CRACEN peripheral.
+///
+/// It has a blocking api through `rand`.
+pub struct Cracen<'d, M: Mode> {
+    _peri: Peri<'d, peripherals::CRACEN>,
+    _p: PhantomData<M>,
+}
+
+impl<'d> Cracen<'d, Blocking> {
+    /// Create a new CRACEN driver.
+    pub fn new_blocking(_peri: Peri<'d, peripherals::CRACEN>) -> Self {
+        let me = Self { _peri, _p: PhantomData };
+
+        me.stop();
+        me
+    }
+}
+
+impl<'d, M: Mode> Cracen<'d, M> {
+    fn regs() -> pac::cracen::Cracen {
+        pac::CRACEN
+    }
+
+    fn core() -> pac::cracencore::Cracencore {
+        pac::CRACENCORE
+    }
+
+    fn start_rng(&self) {
+        let r = Self::regs();
+        r.enable().write(|w| {
+            w.set_rng(true);
+        });
+
+        let r = Self::core();
+        r.rngcontrol().control().write(|w| {
+            w.set_enable(true);
+        });
+
+        while r.rngcontrol().status().read().state() == pac::cracencore::vals::State::STARTUP {}
+    }
+
+    fn stop(&self) {
+        let r = Self::regs();
+        r.enable().write(|w| {
+            w.set_cryptomaster(false);
+            w.set_rng(false);
+            w.set_pkeikg(false);
+        });
+    }
+
+    /// Fill the buffer with random bytes, blocking version.
+    pub fn blocking_fill_bytes(&mut self, dest: &mut [u8]) {
+        self.start_rng();
+
+        let r = Self::core();
+        for chunk in dest.chunks_mut(4) {
+            while r.rngcontrol().fifolevel().read() == 0 {}
+            let word = r.rngcontrol().fifo(0).read().to_ne_bytes();
+            let to_copy = word.len().min(chunk.len());
+            chunk[..to_copy].copy_from_slice(&word[..to_copy]);
+        }
+
+        self.stop();
+    }
+
+    /// Generate a random u32
+    pub fn blocking_next_u32(&mut self) -> u32 {
+        let mut bytes = [0; 4];
+        self.blocking_fill_bytes(&mut bytes);
+        // We don't care about the endianness, so just use the native one.
+        u32::from_ne_bytes(bytes)
+    }
+
+    /// Generate a random u64
+    pub fn blocking_next_u64(&mut self) -> u64 {
+        let mut bytes = [0; 8];
+        self.blocking_fill_bytes(&mut bytes);
+        u64::from_ne_bytes(bytes)
+    }
+}
+
+impl<'d, M: Mode> Drop for Cracen<'d, M> {
+    fn drop(&mut self) {
+        let r = Self::core();
+        r.rngcontrol().control().write(|w| {
+            w.set_enable(false);
+        });
+
+        while r.rngcontrol().status().read().state() != pac::cracencore::vals::State::RESET {}
+
+        let r = Self::regs();
+        r.enable().write(|w| {
+            w.set_cryptomaster(false);
+            w.set_rng(false);
+            w.set_pkeikg(false);
+        });
+    }
+}
+
+impl<'d, M: Mode> rand_core_06::RngCore for Cracen<'d, M> {
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.blocking_fill_bytes(dest);
+    }
+    fn next_u32(&mut self) -> u32 {
+        self.blocking_next_u32()
+    }
+    fn next_u64(&mut self) -> u64 {
+        self.blocking_next_u64()
+    }
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core_06::Error> {
+        self.blocking_fill_bytes(dest);
+        Ok(())
+    }
+}
+
+impl<'d, M: Mode> rand_core_06::CryptoRng for Cracen<'d, M> {}
+
+impl<'d, M: Mode> rand_core_09::RngCore for Cracen<'d, M> {
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.blocking_fill_bytes(dest);
+    }
+    fn next_u32(&mut self) -> u32 {
+        self.blocking_next_u32()
+    }
+    fn next_u64(&mut self) -> u64 {
+        self.blocking_next_u64()
+    }
+}
+
+impl<'d, M: Mode> rand_core_09::CryptoRng for Cracen<'d, M> {}
+
+pub(crate) trait SealedInstance {}
+
+/// CRACEN peripheral instance.
+#[allow(private_bounds)]
+pub trait Instance: SealedInstance + 'static + Send {
+    /// Interrupt for this peripheral.
+    type Interrupt: interrupt::typelevel::Interrupt;
+}
+
+macro_rules! impl_cracen {
+    ($type:ident, $pac_type:ident, $irq:ident) => {
+        impl crate::cracen::SealedInstance for peripherals::$type {}
+        impl crate::cracen::Instance for peripherals::$type {
+            type Interrupt = crate::interrupt::typelevel::$irq;
+        }
+    };
+}
diff --git a/embassy-nrf/src/gpio.rs b/embassy-nrf/src/gpio.rs
index 7ed3a7927..43d1b9cb2 100644
--- a/embassy-nrf/src/gpio.rs
+++ b/embassy-nrf/src/gpio.rs
@@ -585,7 +585,6 @@ impl SealedPin for AnyPin {
 // ====================
 
 #[cfg(not(feature = "_nrf51"))]
-#[cfg_attr(feature = "_nrf54l", allow(unused))] // TODO
 pub(crate) trait PselBits {
     fn psel_bits(&self) -> pac::shared::regs::Psel;
 }
@@ -602,7 +601,6 @@ impl<'a, P: Pin> PselBits for Option<Peri<'a, P>> {
 }
 
 #[cfg(not(feature = "_nrf51"))]
-#[cfg_attr(feature = "_nrf54l", allow(unused))] // TODO
 pub(crate) const DISCONNECTED: Psel = Psel(1 << 31);
 
 #[cfg(not(feature = "_nrf51"))]
diff --git a/embassy-nrf/src/gpiote.rs b/embassy-nrf/src/gpiote.rs
index a490d5b60..91944d8cd 100644
--- a/embassy-nrf/src/gpiote.rs
+++ b/embassy-nrf/src/gpiote.rs
@@ -1,4 +1,5 @@
 //! GPIO task/event (GPIOTE) driver.
+#![macro_use]
 
 use core::convert::Infallible;
 use core::future::{Future, poll_fn};
@@ -7,7 +8,7 @@ use core::task::{Context, Poll};
 use embassy_hal_internal::{Peri, PeripheralType, impl_peripheral};
 use embassy_sync::waitqueue::AtomicWaker;
 
-use crate::gpio::{AnyPin, Flex, Input, Output, Pin as GpioPin, SealedPin as _};
+use crate::gpio::{AnyPin, Flex, Input, Level, Output, OutputDrive, Pin as GpioPin, Pull, SealedPin as _};
 use crate::interrupt::InterruptExt;
 #[cfg(not(feature = "_nrf51"))]
 use crate::pac::gpio::vals::Detectmode;
@@ -19,13 +20,28 @@ use crate::{interrupt, pac, peripherals};
 #[cfg(feature = "_nrf51")]
 /// Amount of GPIOTE channels in the chip.
 const CHANNEL_COUNT: usize = 4;
-#[cfg(not(feature = "_nrf51"))]
+#[cfg(not(any(feature = "_nrf51", feature = "_nrf54l")))]
 /// Amount of GPIOTE channels in the chip.
 const CHANNEL_COUNT: usize = 8;
-
-#[cfg(any(feature = "nrf52833", feature = "nrf52840", feature = "_nrf5340"))]
+#[cfg(any(feature = "_nrf54l"))]
+/// Amount of GPIOTE channels in the chip.
+const CHANNEL_COUNT: usize = 12;
+/// Max channels per port
+const CHANNELS_PER_PORT: usize = 8;
+
+#[cfg(any(
+    feature = "nrf52833",
+    feature = "nrf52840",
+    feature = "_nrf5340",
+    feature = "_nrf54l"
+))]
 const PIN_COUNT: usize = 48;
-#[cfg(not(any(feature = "nrf52833", feature = "nrf52840", feature = "_nrf5340")))]
+#[cfg(not(any(
+    feature = "nrf52833",
+    feature = "nrf52840",
+    feature = "_nrf5340",
+    feature = "_nrf54l"
+)))]
 const PIN_COUNT: usize = 32;
 
 #[allow(clippy::declare_interior_mutable_const)]
@@ -54,18 +70,6 @@ pub enum OutputChannelPolarity {
     Toggle,
 }
 
-fn regs() -> pac::gpiote::Gpiote {
-    cfg_if::cfg_if! {
-        if #[cfg(any(feature="nrf5340-app-s", feature="nrf9160-s", feature="nrf9120-s"))] {
-            pac::GPIOTE0
-        } else if #[cfg(any(feature="nrf5340-app-ns", feature="nrf9160-ns", feature="nrf9120-ns"))] {
-            pac::GPIOTE1
-        } else {
-            pac::GPIOTE
-        }
-    }
-}
-
 pub(crate) fn init(irq_prio: crate::interrupt::Priority) {
     // no latched GPIO detect in nrf51.
     #[cfg(not(feature = "_nrf51"))]
@@ -77,6 +81,9 @@ pub(crate) fn init(irq_prio: crate::interrupt::Priority) {
 
         for &p in ports {
             // Enable latched detection
+            #[cfg(all(feature = "_s", not(feature = "_nrf54l")))]
+            p.detectmode_sec().write(|w| w.set_detectmode(Detectmode::LDETECT));
+            #[cfg(any(not(feature = "_s"), all(feature = "_s", feature = "_nrf54l")))]
             p.detectmode().write(|w| w.set_detectmode(Detectmode::LDETECT));
             // Clear latch
             p.latch().write(|w| w.0 = 0xFFFFFFFF)
@@ -85,57 +92,130 @@ pub(crate) fn init(irq_prio: crate::interrupt::Priority) {
 
     // Enable interrupts
     #[cfg(any(feature = "nrf5340-app-s", feature = "nrf9160-s", feature = "nrf9120-s"))]
-    let irq = interrupt::GPIOTE0;
+    let irqs = &[(pac::GPIOTE0, interrupt::GPIOTE0)];
     #[cfg(any(feature = "nrf5340-app-ns", feature = "nrf9160-ns", feature = "nrf9120-ns"))]
-    let irq = interrupt::GPIOTE1;
+    let irqs = &[(pac::GPIOTE1, interrupt::GPIOTE1)];
     #[cfg(any(feature = "_nrf51", feature = "_nrf52", feature = "nrf5340-net"))]
-    let irq = interrupt::GPIOTE;
+    let irqs = &[(pac::GPIOTE, interrupt::GPIOTE)];
+    #[cfg(any(feature = "_nrf54l"))]
+    let irqs = &[
+        #[cfg(feature = "_s")]
+        (pac::GPIOTE20, interrupt::GPIOTE20_0),
+        #[cfg(feature = "_s")]
+        (pac::GPIOTE30, interrupt::GPIOTE30_0),
+        #[cfg(feature = "_ns")]
+        (pac::GPIOTE20, interrupt::GPIOTE20_1),
+        #[cfg(feature = "_ns")]
+        (pac::GPIOTE30, interrupt::GPIOTE30_1),
+    ];
+
+    for (inst, irq) in irqs {
+        irq.unpend();
+        irq.set_priority(irq_prio);
+        unsafe { irq.enable() };
 
-    irq.unpend();
-    irq.set_priority(irq_prio);
-    unsafe { irq.enable() };
+        let g = inst;
+        #[cfg(not(feature = "_nrf54l"))]
+        g.intenset(INTNUM).write(|w| w.set_port(true));
 
-    let g = regs();
-    g.intenset().write(|w| w.set_port(true));
+        #[cfg(all(feature = "_nrf54l", feature = "_ns"))]
+        g.intenset(INTNUM).write(|w| w.set_port0nonsecure(true));
+
+        #[cfg(all(feature = "_nrf54l", feature = "_s"))]
+        g.intenset(INTNUM).write(|w| w.set_port0secure(true));
+    }
 }
 
+#[cfg(all(feature = "_nrf54l", feature = "_ns"))]
+const INTNUM: usize = 1;
+
+#[cfg(any(not(feature = "_nrf54l"), feature = "_s"))]
+const INTNUM: usize = 0;
+
 #[cfg(any(feature = "nrf5340-app-s", feature = "nrf9160-s", feature = "nrf9120-s"))]
 #[cfg(feature = "rt")]
 #[interrupt]
 fn GPIOTE0() {
-    unsafe { handle_gpiote_interrupt() };
+    unsafe { handle_gpiote_interrupt(pac::GPIOTE0) };
 }
 
 #[cfg(any(feature = "nrf5340-app-ns", feature = "nrf9160-ns", feature = "nrf9120-ns"))]
 #[cfg(feature = "rt")]
 #[interrupt]
 fn GPIOTE1() {
-    unsafe { handle_gpiote_interrupt() };
+    unsafe { handle_gpiote_interrupt(pac::GPIOTE1) };
 }
 
 #[cfg(any(feature = "_nrf51", feature = "_nrf52", feature = "nrf5340-net"))]
 #[cfg(feature = "rt")]
 #[interrupt]
 fn GPIOTE() {
-    unsafe { handle_gpiote_interrupt() };
+    unsafe { handle_gpiote_interrupt(pac::GPIOTE) };
 }
 
-unsafe fn handle_gpiote_interrupt() {
-    let g = regs();
+#[cfg(all(feature = "_nrf54l", feature = "_s"))]
+#[cfg(feature = "rt")]
+#[interrupt]
+fn GPIOTE20_0() {
+    unsafe { handle_gpiote_interrupt(pac::GPIOTE20) };
+}
 
-    for i in 0..CHANNEL_COUNT {
+#[cfg(all(feature = "_nrf54l", feature = "_s"))]
+#[cfg(feature = "rt")]
+#[interrupt]
+fn GPIOTE30_0() {
+    unsafe { handle_gpiote_interrupt(pac::GPIOTE30) };
+}
+
+#[cfg(all(feature = "_nrf54l", feature = "_ns"))]
+#[cfg(feature = "rt")]
+#[interrupt]
+fn GPIOTE20_1() {
+    unsafe { handle_gpiote_interrupt(pac::GPIOTE20) };
+}
+
+#[cfg(all(feature = "_nrf54l", feature = "_ns"))]
+#[cfg(feature = "rt")]
+#[interrupt]
+fn GPIOTE30_1() {
+    unsafe { handle_gpiote_interrupt(pac::GPIOTE30) };
+}
+
+unsafe fn handle_gpiote_interrupt(g: pac::gpiote::Gpiote) {
+    for c in 0..CHANNEL_COUNT {
+        let i = c % CHANNELS_PER_PORT;
         if g.events_in(i).read() != 0 {
-            g.intenclr().write(|w| w.0 = 1 << i);
-            CHANNEL_WAKERS[i].wake();
+            g.intenclr(INTNUM).write(|w| w.0 = 1 << i);
+            CHANNEL_WAKERS[c].wake();
         }
     }
 
-    if g.events_port().read() != 0 {
-        g.events_port().write_value(0);
+    #[cfg(not(feature = "_nrf54l"))]
+    let eport = g.events_port(0);
 
-        #[cfg(any(feature = "nrf52833", feature = "nrf52840", feature = "_nrf5340"))]
+    #[cfg(all(feature = "_nrf54l", feature = "_ns"))]
+    let eport = g.events_port(0).nonsecure();
+
+    #[cfg(all(feature = "_nrf54l", feature = "_s"))]
+    let eport = g.events_port(0).secure();
+
+    if eport.read() != 0 {
+        eport.write_value(0);
+
+        #[cfg(any(
+            feature = "nrf52833",
+            feature = "nrf52840",
+            feature = "_nrf5340",
+            feature = "_nrf54l"
+        ))]
         let ports = &[pac::P0, pac::P1];
-        #[cfg(not(any(feature = "_nrf51", feature = "nrf52833", feature = "nrf52840", feature = "_nrf5340")))]
+        #[cfg(not(any(
+            feature = "_nrf51",
+            feature = "nrf52833",
+            feature = "nrf52840",
+            feature = "_nrf5340",
+            feature = "_nrf54l"
+        )))]
         let ports = &[pac::P0];
         #[cfg(feature = "_nrf51")]
         let ports = &[pac::GPIO];
@@ -204,19 +284,43 @@ impl InputChannel<'static> {
 
 impl<'d> Drop for InputChannel<'d> {
     fn drop(&mut self) {
-        let g = regs();
+        let g = self.ch.regs();
         let num = self.ch.number();
         g.config(num).write(|w| w.set_mode(Mode::DISABLED));
-        g.intenclr().write(|w| w.0 = 1 << num);
+        g.intenclr(INTNUM).write(|w| w.0 = 1 << num);
     }
 }
 
 impl<'d> InputChannel<'d> {
     /// Create a new GPIOTE input channel driver.
-    pub fn new(ch: Peri<'d, impl Channel>, pin: Input<'d>, polarity: InputChannelPolarity) -> Self {
-        let g = regs();
-        let num = ch.number();
+    #[cfg(feature = "_nrf54l")]
+    pub fn new<C: Channel, T: GpiotePin<Instance = C::Instance>>(
+        ch: Peri<'d, C>,
+        pin: Peri<'d, T>,
+        pull: Pull,
+        polarity: InputChannelPolarity,
+    ) -> Self {
+        let pin = Input::new(pin, pull);
+        let ch = ch.into();
+        Self::new_inner(ch, pin, polarity)
+    }
 
+    /// Create a new GPIOTE output channel driver.
+    #[cfg(not(feature = "_nrf54l"))]
+    pub fn new<C: Channel, T: GpioPin>(
+        ch: Peri<'d, C>,
+        pin: Peri<'d, T>,
+        pull: Pull,
+        polarity: InputChannelPolarity,
+    ) -> Self {
+        let pin = Input::new(pin, pull);
+        let ch = ch.into();
+        Self::new_inner(ch, pin, polarity)
+    }
+
+    fn new_inner(ch: Peri<'d, AnyChannel>, pin: Input<'d>, polarity: InputChannelPolarity) -> Self {
+        let g = ch.regs();
+        let num = ch.number();
         g.config(num).write(|w| {
             w.set_mode(Mode::EVENT);
             match polarity {
@@ -225,30 +329,37 @@ impl<'d> InputChannel<'d> {
                 InputChannelPolarity::None => w.set_polarity(Polarity::NONE),
                 InputChannelPolarity::Toggle => w.set_polarity(Polarity::TOGGLE),
             };
-            #[cfg(any(feature = "nrf52833", feature = "nrf52840", feature = "_nrf5340"))]
+            #[cfg(any(feature = "nrf52833", feature = "nrf52840", feature = "_nrf5340",))]
             w.set_port(match pin.pin.pin.port() {
                 crate::gpio::Port::Port0 => false,
                 crate::gpio::Port::Port1 => true,
             });
+            #[cfg(any(feature = "_nrf54l"))]
+            w.set_port(match pin.pin.pin.port() {
+                crate::gpio::Port::Port0 => 0,
+                crate::gpio::Port::Port1 => 1,
+                crate::gpio::Port::Port2 => 2,
+            });
             w.set_psel(pin.pin.pin.pin());
         });
 
         g.events_in(num).write_value(0);
 
-        InputChannel { ch: ch.into(), pin }
+        InputChannel { ch, pin }
     }
 
     /// Asynchronously wait for an event in this channel.
     pub async fn wait(&self) {
-        let g = regs();
+        let g = self.ch.regs();
         let num = self.ch.number();
+        let waker = self.ch.waker();
 
         // Enable interrupt
         g.events_in(num).write_value(0);
-        g.intenset().write(|w| w.0 = 1 << num);
+        g.intenset(INTNUM).write(|w| w.0 = 1 << num);
 
         poll_fn(|cx| {
-            CHANNEL_WAKERS[num].register(cx.waker());
+            CHANNEL_WAKERS[waker].register(cx.waker());
 
             if g.events_in(num).read() != 0 {
                 Poll::Ready(())
@@ -259,9 +370,14 @@ impl<'d> InputChannel<'d> {
         .await;
     }
 
+    /// Get the associated input pin.
+    pub fn pin(&self) -> &Input<'_> {
+        &self.pin
+    }
+
     /// Returns the IN event, for use with PPI.
     pub fn event_in(&self) -> Event<'d> {
-        let g = regs();
+        let g = self.ch.regs();
         Event::from_reg(g.events_in(self.ch.number()))
     }
 }
@@ -283,17 +399,44 @@ impl OutputChannel<'static> {
 
 impl<'d> Drop for OutputChannel<'d> {
     fn drop(&mut self) {
-        let g = regs();
+        let g = self.ch.regs();
         let num = self.ch.number();
         g.config(num).write(|w| w.set_mode(Mode::DISABLED));
-        g.intenclr().write(|w| w.0 = 1 << num);
+        g.intenclr(INTNUM).write(|w| w.0 = 1 << num);
     }
 }
 
 impl<'d> OutputChannel<'d> {
     /// Create a new GPIOTE output channel driver.
-    pub fn new(ch: Peri<'d, impl Channel>, pin: Output<'d>, polarity: OutputChannelPolarity) -> Self {
-        let g = regs();
+    #[cfg(feature = "_nrf54l")]
+    pub fn new<C: Channel, T: GpiotePin<Instance = C::Instance>>(
+        ch: Peri<'d, C>,
+        pin: Peri<'d, T>,
+        initial_output: Level,
+        drive: OutputDrive,
+        polarity: OutputChannelPolarity,
+    ) -> Self {
+        let pin = Output::new(pin, initial_output, drive);
+        let ch = ch.into();
+        Self::new_inner(ch, pin, polarity)
+    }
+
+    /// Create a new GPIOTE output channel driver.
+    #[cfg(not(feature = "_nrf54l"))]
+    pub fn new<C: Channel, T: GpioPin>(
+        ch: Peri<'d, C>,
+        pin: Peri<'d, T>,
+        initial_output: Level,
+        drive: OutputDrive,
+        polarity: OutputChannelPolarity,
+    ) -> Self {
+        let pin = Output::new(pin, initial_output, drive);
+        let ch = ch.into();
+        Self::new_inner(ch, pin, polarity)
+    }
+
+    fn new_inner(ch: Peri<'d, AnyChannel>, pin: Output<'d>, polarity: OutputChannelPolarity) -> Self {
+        let g = ch.regs();
         let num = ch.number();
 
         g.config(num).write(|w| {
@@ -312,52 +455,55 @@ impl<'d> OutputChannel<'d> {
                 crate::gpio::Port::Port0 => false,
                 crate::gpio::Port::Port1 => true,
             });
+            #[cfg(any(feature = "_nrf54l"))]
+            w.set_port(match pin.pin.pin.port() {
+                crate::gpio::Port::Port0 => 0,
+                crate::gpio::Port::Port1 => 1,
+                crate::gpio::Port::Port2 => 2,
+            });
             w.set_psel(pin.pin.pin.pin());
         });
 
-        OutputChannel {
-            ch: ch.into(),
-            _pin: pin,
-        }
+        OutputChannel { ch, _pin: pin }
     }
 
     /// Triggers the OUT task (does the action as configured with task_out_polarity, defaults to Toggle).
     pub fn out(&self) {
-        let g = regs();
+        let g = self.ch.regs();
         g.tasks_out(self.ch.number()).write_value(1);
     }
 
     /// Triggers the SET task (set associated pin high).
     #[cfg(not(feature = "_nrf51"))]
     pub fn set(&self) {
-        let g = regs();
+        let g = self.ch.regs();
         g.tasks_set(self.ch.number()).write_value(1);
     }
 
     /// Triggers the CLEAR task (set associated pin low).
     #[cfg(not(feature = "_nrf51"))]
     pub fn clear(&self) {
-        let g = regs();
+        let g = self.ch.regs();
         g.tasks_clr(self.ch.number()).write_value(1);
     }
 
     /// Returns the OUT task, for use with PPI.
     pub fn task_out(&self) -> Task<'d> {
-        let g = regs();
+        let g = self.ch.regs();
         Task::from_reg(g.tasks_out(self.ch.number()))
     }
 
     /// Returns the CLR task, for use with PPI.
     #[cfg(not(feature = "_nrf51"))]
     pub fn task_clr(&self) -> Task<'d> {
-        let g = regs();
+        let g = self.ch.regs();
         Task::from_reg(g.tasks_clr(self.ch.number()))
     }
 
     /// Returns the SET task, for use with PPI.
     #[cfg(not(feature = "_nrf51"))]
     pub fn task_set(&self) -> Task<'d> {
-        let g = regs();
+        let g = self.ch.regs();
         Task::from_reg(g.tasks_set(self.ch.number()))
     }
 }
@@ -459,31 +605,52 @@ impl<'d> Flex<'d> {
         PortInputFuture::new(self.pin.reborrow()).await
     }
 }
-
 // =======================
+//
 
-trait SealedChannel {}
+trait SealedChannel {
+    fn waker(&self) -> usize;
+    fn regs(&self) -> pac::gpiote::Gpiote;
+}
 
 /// GPIOTE channel trait.
 ///
 /// Implemented by all GPIOTE channels.
 #[allow(private_bounds)]
 pub trait Channel: PeripheralType + SealedChannel + Into<AnyChannel> + Sized + 'static {
+    #[cfg(feature = "_nrf54l")]
+    /// GPIOTE instance this channel belongs to.
+    type Instance: GpioteInstance;
     /// Get the channel number.
     fn number(&self) -> usize;
 }
 
-/// Type-erased channel.
-///
-/// Obtained by calling `Channel::into()`.
-///
-/// This allows using several channels in situations that might require
-/// them to be the same type, like putting them in an array.
-pub struct AnyChannel {
+struct AnyChannel {
     number: u8,
+    regs: pac::gpiote::Gpiote,
+    waker: u8,
 }
+
 impl_peripheral!(AnyChannel);
-impl SealedChannel for AnyChannel {}
+
+impl SealedChannel for AnyChannel {
+    fn waker(&self) -> usize {
+        self.waker as usize
+    }
+
+    fn regs(&self) -> pac::gpiote::Gpiote {
+        self.regs
+    }
+}
+
+#[cfg(feature = "_nrf54l")]
+impl AnyChannel {
+    fn number(&self) -> usize {
+        self.number as usize
+    }
+}
+
+#[cfg(not(feature = "_nrf54l"))]
 impl Channel for AnyChannel {
     fn number(&self) -> usize {
         self.number as usize
@@ -491,9 +658,19 @@ impl Channel for AnyChannel {
 }
 
 macro_rules! impl_channel {
-    ($type:ident, $number:expr) => {
-        impl SealedChannel for peripherals::$type {}
+    ($type:ident, $inst:ident, $number:expr, $waker:expr) => {
+        impl SealedChannel for peripherals::$type {
+            fn waker(&self) -> usize {
+                $waker as usize
+            }
+
+            fn regs(&self) -> pac::gpiote::Gpiote {
+                pac::$inst
+            }
+        }
         impl Channel for peripherals::$type {
+            #[cfg(feature = "_nrf54l")]
+            type Instance = peripherals::$inst;
             fn number(&self) -> usize {
                 $number as usize
             }
@@ -503,24 +680,95 @@ macro_rules! impl_channel {
             fn from(val: peripherals::$type) -> Self {
                 Self {
                     number: val.number() as u8,
+                    waker: val.waker() as u8,
+                    regs: val.regs(),
                 }
             }
         }
     };
 }
 
-impl_channel!(GPIOTE_CH0, 0);
-impl_channel!(GPIOTE_CH1, 1);
-impl_channel!(GPIOTE_CH2, 2);
-impl_channel!(GPIOTE_CH3, 3);
-#[cfg(not(feature = "_nrf51"))]
-impl_channel!(GPIOTE_CH4, 4);
-#[cfg(not(feature = "_nrf51"))]
-impl_channel!(GPIOTE_CH5, 5);
-#[cfg(not(feature = "_nrf51"))]
-impl_channel!(GPIOTE_CH6, 6);
-#[cfg(not(feature = "_nrf51"))]
-impl_channel!(GPIOTE_CH7, 7);
+cfg_if::cfg_if! {
+    if #[cfg(feature = "_nrf54l")] {
+        trait SealedGpioteInstance {}
+        /// Represents a GPIOTE instance.
+        #[allow(private_bounds)]
+        pub trait GpioteInstance: PeripheralType + SealedGpioteInstance + Sized + 'static {}
+
+        macro_rules! impl_gpiote {
+            ($type:ident) => {
+                impl SealedGpioteInstance for peripherals::$type {}
+                impl GpioteInstance for peripherals::$type {}
+            };
+        }
+
+        pub(crate) trait SealedGpiotePin {}
+
+        /// Represents a GPIO pin that can be used with GPIOTE.
+        #[allow(private_bounds)]
+        pub trait GpiotePin: GpioPin + SealedGpiotePin {
+            /// The GPIOTE instance this pin belongs to.
+            type Instance: GpioteInstance;
+        }
+
+        macro_rules! impl_gpiote_pin {
+            ($type:ident, $inst:ident) => {
+                impl crate::gpiote::SealedGpiotePin for peripherals::$type {}
+                impl crate::gpiote::GpiotePin for peripherals::$type {
+                    type Instance = peripherals::$inst;
+                }
+            };
+        }
+
+        impl_gpiote!(GPIOTE20);
+        impl_gpiote!(GPIOTE30);
+        impl_channel!(GPIOTE20_CH0, GPIOTE20, 0, 0);
+        impl_channel!(GPIOTE20_CH1, GPIOTE20, 1, 1);
+        impl_channel!(GPIOTE20_CH2, GPIOTE20, 2, 2);
+        impl_channel!(GPIOTE20_CH3, GPIOTE20, 3, 3);
+        impl_channel!(GPIOTE20_CH4, GPIOTE20, 4, 4);
+        impl_channel!(GPIOTE20_CH5, GPIOTE20, 5, 5);
+        impl_channel!(GPIOTE20_CH6, GPIOTE20, 6, 6);
+        impl_channel!(GPIOTE20_CH7, GPIOTE20, 7, 7);
+
+        impl_channel!(GPIOTE30_CH0, GPIOTE30, 0, 8);
+        impl_channel!(GPIOTE30_CH1, GPIOTE30, 1, 9);
+        impl_channel!(GPIOTE30_CH2, GPIOTE30, 2, 10);
+        impl_channel!(GPIOTE30_CH3, GPIOTE30, 3, 11);
+    } else if #[cfg(feature = "_nrf51")] {
+        impl_channel!(GPIOTE_CH0, GPIOTE, 0, 0);
+        impl_channel!(GPIOTE_CH1, GPIOTE, 1, 1);
+        impl_channel!(GPIOTE_CH2, GPIOTE, 2, 2);
+        impl_channel!(GPIOTE_CH3, GPIOTE, 3, 3);
+    } else if #[cfg(all(feature = "_s", any(feature = "_nrf91", feature = "_nrf5340")))] {
+        impl_channel!(GPIOTE_CH0, GPIOTE0, 0, 0);
+        impl_channel!(GPIOTE_CH1, GPIOTE0, 1, 1);
+        impl_channel!(GPIOTE_CH2, GPIOTE0, 2, 2);
+        impl_channel!(GPIOTE_CH3, GPIOTE0, 3, 3);
+        impl_channel!(GPIOTE_CH4, GPIOTE0, 4, 4);
+        impl_channel!(GPIOTE_CH5, GPIOTE0, 5, 5);
+        impl_channel!(GPIOTE_CH6, GPIOTE0, 6, 6);
+        impl_channel!(GPIOTE_CH7, GPIOTE0, 7, 7);
+    } else if #[cfg(all(feature = "_ns", any(feature = "_nrf91", feature = "_nrf5340")))] {
+        impl_channel!(GPIOTE_CH0, GPIOTE1, 0, 0);
+        impl_channel!(GPIOTE_CH1, GPIOTE1, 1, 1);
+        impl_channel!(GPIOTE_CH2, GPIOTE1, 2, 2);
+        impl_channel!(GPIOTE_CH3, GPIOTE1, 3, 3);
+        impl_channel!(GPIOTE_CH4, GPIOTE1, 4, 4);
+        impl_channel!(GPIOTE_CH5, GPIOTE1, 5, 5);
+        impl_channel!(GPIOTE_CH6, GPIOTE1, 6, 6);
+        impl_channel!(GPIOTE_CH7, GPIOTE1, 7, 7);
+    } else {
+        impl_channel!(GPIOTE_CH0, GPIOTE, 0, 0);
+        impl_channel!(GPIOTE_CH1, GPIOTE, 1, 1);
+        impl_channel!(GPIOTE_CH2, GPIOTE, 2, 2);
+        impl_channel!(GPIOTE_CH3, GPIOTE, 3, 3);
+        impl_channel!(GPIOTE_CH4, GPIOTE, 4, 4);
+        impl_channel!(GPIOTE_CH5, GPIOTE, 5, 5);
+        impl_channel!(GPIOTE_CH6, GPIOTE, 6, 6);
+        impl_channel!(GPIOTE_CH7, GPIOTE, 7, 7);
+    }
+}
 
 // ====================
 
diff --git a/embassy-nrf/src/lib.rs b/embassy-nrf/src/lib.rs
index 1b7fb7e7f..2f5ad352f 100644
--- a/embassy-nrf/src/lib.rs
+++ b/embassy-nrf/src/lib.rs
@@ -76,14 +76,12 @@ pub(crate) mod util;
 #[cfg(feature = "_time-driver")]
 mod time_driver;
 
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(feature = "_nrf51"))]
 pub mod buffered_uarte;
 #[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(feature = "_nrf51"))]
 pub mod egu;
 pub mod gpio;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(feature = "gpiote")]
 pub mod gpiote;
 #[cfg(not(feature = "_nrf54l"))] // TODO
@@ -119,9 +117,7 @@ pub mod pdm;
 #[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(any(feature = "nrf52840", feature = "nrf9160-s", feature = "nrf9160-ns"))]
 pub mod power;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 pub mod ppi;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(any(
     feature = "_nrf51",
     feature = "nrf52805",
@@ -149,34 +145,28 @@ pub mod radio;
 #[cfg(feature = "_net-driver")]
 pub mod embassy_net_802154_driver;
 
+#[cfg(all(feature = "_nrf54l", feature = "_s"))]
+pub mod cracen;
 #[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(feature = "_nrf5340")]
 pub mod reset;
-#[cfg(not(feature = "_nrf54l"))] // TODO
+#[cfg(not(feature = "_nrf54l"))]
 #[cfg(not(any(feature = "_nrf5340-app", feature = "_nrf91")))]
 pub mod rng;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 pub mod rtc;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(any(feature = "_nrf51", feature = "nrf52820", feature = "_nrf5340-net")))]
 pub mod saadc;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(feature = "_nrf51"))]
 pub mod spim;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(feature = "_nrf51"))]
 pub mod spis;
 #[cfg(not(any(feature = "_nrf5340-app", feature = "_nrf91")))]
 pub mod temp;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 pub mod timer;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(feature = "_nrf51"))]
 pub mod twim;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(feature = "_nrf51"))]
 pub mod twis;
-#[cfg(not(feature = "_nrf54l"))] // TODO
 #[cfg(not(feature = "_nrf51"))]
 pub mod uarte;
 #[cfg(not(feature = "_nrf54l"))] // TODO
@@ -295,6 +285,15 @@ pub use crate::pac::NVIC_PRIO_BITS;
 pub mod config {
     //! Configuration options used when initializing the HAL.
 
+    /// Clock speed
+    #[cfg(feature = "_nrf54l")]
+    pub enum ClockSpeed {
+        /// Run at 128 MHz.
+        CK128,
+        /// Run at 64 MHz.
+        CK64,
+    }
+
     /// High frequency clock source.
     pub enum HfclkSource {
         /// Internal source
@@ -564,6 +563,9 @@ pub mod config {
         pub time_interrupt_priority: crate::interrupt::Priority,
         /// Enable or disable the debug port.
         pub debug: Debug,
+        /// Clock speed configuration.
+        #[cfg(feature = "_nrf54l")]
+        pub clock_speed: ClockSpeed,
     }
 
     impl Default for Config {
@@ -604,6 +606,8 @@ pub mod config {
                 debug: Debug::NotConfigured,
                 #[cfg(not(feature = "_ns"))]
                 debug: Debug::Allowed,
+                #[cfg(feature = "_nrf54l")]
+                clock_speed: ClockSpeed::CK64,
             }
         }
     }
@@ -710,6 +714,23 @@ pub fn init(config: config::Config) -> Peripherals {
     #[allow(unused_mut)]
     let mut needs_reset = false;
 
+    // set clock speed
+    #[cfg(feature = "_nrf54l")]
+    {
+        #[cfg(feature = "_s")]
+        let regs = pac::OSCILLATORS_S;
+        #[cfg(feature = "_ns")]
+        let regs = pac::OSCILLATORS_NS;
+
+        use pac::oscillators::vals::Freq;
+        regs.pll().freq().write(|w| {
+            w.set_freq(match config.clock_speed {
+                config::ClockSpeed::CK64 => Freq::CK64M,
+                config::ClockSpeed::CK128 => Freq::CK128M,
+            });
+        });
+    }
+
     // Workaround used in the nrf mdk: file system_nrf91.c , function SystemInit(), after `#if !defined(NRF_SKIP_UICR_HFXO_WORKAROUND)`
     #[cfg(all(feature = "_nrf91", feature = "_s"))]
     {
@@ -934,7 +955,7 @@ pub fn init(config: config::Config) -> Peripherals {
         }
     }
 
-    #[cfg(any(feature = "_nrf52", feature = "_nrf5340-app"))]
+    #[cfg(any(feature = "_nrf52", all(feature = "_nrf5340-app", feature = "_s")))]
     unsafe {
         let value = if cfg!(feature = "nfc-pins-as-gpio") { 0 } else { 1 };
         let res = uicr_write_masked(consts::UICR_NFCPINS, value, 1);
@@ -1154,7 +1175,6 @@ pub fn init(config: config::Config) -> Peripherals {
     }
 
     // Init GPIOTE
-    #[cfg(not(feature = "_nrf54l"))] // TODO
     #[cfg(feature = "gpiote")]
     gpiote::init(config.gpiote_interrupt_priority);
 
diff --git a/embassy-nrf/src/ppi/dppi.rs b/embassy-nrf/src/ppi/dppi.rs
index 168647be3..d43a25c4e 100644
--- a/embassy-nrf/src/ppi/dppi.rs
+++ b/embassy-nrf/src/ppi/dppi.rs
@@ -1,11 +1,12 @@
 use super::{Channel, ConfigurableChannel, Event, Ppi, Task};
-use crate::{Peri, pac};
+use crate::Peri;
 
 const DPPI_ENABLE_BIT: u32 = 0x8000_0000;
 const DPPI_CHANNEL_MASK: u32 = 0x0000_00FF;
 
-pub(crate) fn regs() -> pac::dppic::Dppic {
-    pac::DPPIC
+#[cfg(not(feature = "_nrf54l"))]
+pub(crate) fn regs() -> crate::pac::dppic::Dppic {
+    crate::pac::DPPIC
 }
 
 impl<'d, C: ConfigurableChannel> Ppi<'d, C, 1, 1> {
@@ -49,13 +50,13 @@ impl<'d, C: Channel, const EVENT_COUNT: usize, const TASK_COUNT: usize> Ppi<'d,
     /// Enables the channel.
     pub fn enable(&mut self) {
         let n = self.ch.number();
-        regs().chenset().write(|w| w.0 = 1 << n);
+        self.ch.regs().chenset().write(|w| w.0 = 1 << n);
     }
 
     /// Disables the channel.
     pub fn disable(&mut self) {
         let n = self.ch.number();
-        regs().chenclr().write(|w| w.0 = 1 << n);
+        self.ch.regs().chenclr().write(|w| w.0 = 1 << n);
     }
 }
 
diff --git a/embassy-nrf/src/ppi/mod.rs b/embassy-nrf/src/ppi/mod.rs
index f30c2218d..a880d3188 100644
--- a/embassy-nrf/src/ppi/mod.rs
+++ b/embassy-nrf/src/ppi/mod.rs
@@ -21,11 +21,13 @@ use core::ptr::NonNull;
 use embassy_hal_internal::{Peri, PeripheralType, impl_peripheral};
 
 use crate::pac::common::{RW, Reg, W};
-use crate::peripherals;
+use crate::pac::{self};
 
 #[cfg_attr(feature = "_dppi", path = "dppi.rs")]
 #[cfg_attr(feature = "_ppi", path = "ppi.rs")]
 mod _version;
+
+#[allow(unused_imports)]
 pub(crate) use _version::*;
 
 /// PPI channel driver.
@@ -47,7 +49,7 @@ impl<'d, G: Group> PpiGroup<'d, G> {
     ///
     /// The group is initialized as containing no channels.
     pub fn new(g: Peri<'d, G>) -> Self {
-        let r = regs();
+        let r = g.regs();
         let n = g.number();
         r.chg(n).write(|_| ());
 
@@ -61,7 +63,7 @@ impl<'d, G: Group> PpiGroup<'d, G> {
         &mut self,
         ch: &Ppi<'_, C, EVENT_COUNT, TASK_COUNT>,
     ) {
-        let r = regs();
+        let r = self.g.regs();
         let ng = self.g.number();
         let nc = ch.ch.number();
         r.chg(ng).modify(|w| w.set_ch(nc, true));
@@ -74,7 +76,7 @@ impl<'d, G: Group> PpiGroup<'d, G> {
         &mut self,
         ch: &Ppi<'_, C, EVENT_COUNT, TASK_COUNT>,
     ) {
-        let r = regs();
+        let r = self.g.regs();
         let ng = self.g.number();
         let nc = ch.ch.number();
         r.chg(ng).modify(|w| w.set_ch(nc, false));
@@ -83,13 +85,13 @@ impl<'d, G: Group> PpiGroup<'d, G> {
     /// Enable all the channels in this group.
     pub fn enable_all(&mut self) {
         let n = self.g.number();
-        regs().tasks_chg(n).en().write_value(1);
+        self.g.regs().tasks_chg(n).en().write_value(1);
     }
 
     /// Disable all the channels in this group.
     pub fn disable_all(&mut self) {
         let n = self.g.number();
-        regs().tasks_chg(n).dis().write_value(1);
+        self.g.regs().tasks_chg(n).dis().write_value(1);
     }
 
     /// Get a reference to the "enable all" task.
@@ -97,7 +99,7 @@ impl<'d, G: Group> PpiGroup<'d, G> {
     /// When triggered, it will enable all the channels in this group.
     pub fn task_enable_all(&self) -> Task<'d> {
         let n = self.g.number();
-        Task::from_reg(regs().tasks_chg(n).en())
+        Task::from_reg(self.g.regs().tasks_chg(n).en())
     }
 
     /// Get a reference to the "disable all" task.
@@ -105,7 +107,7 @@ impl<'d, G: Group> PpiGroup<'d, G> {
     /// When triggered, it will disable all the channels in this group.
     pub fn task_disable_all(&self) -> Task<'d> {
         let n = self.g.number();
-        Task::from_reg(regs().tasks_chg(n).dis())
+        Task::from_reg(self.g.regs().tasks_chg(n).dis())
     }
 }
 impl<G: Group> PpiGroup<'static, G> {
@@ -119,7 +121,7 @@ impl<G: Group> PpiGroup<'static, G> {
 
 impl<'d, G: Group> Drop for PpiGroup<'d, G> {
     fn drop(&mut self) {
-        let r = regs();
+        let r = self.g.regs();
         let n = self.g.number();
         r.chg(n).write(|_| ());
     }
@@ -211,8 +213,16 @@ unsafe impl Send for Event<'_> {}
 // ======================
 //       traits
 
-pub(crate) trait SealedChannel {}
-pub(crate) trait SealedGroup {}
+pub(crate) trait SealedChannel {
+    #[cfg(feature = "_dppi")]
+    fn regs(&self) -> pac::dppic::Dppic;
+}
+pub(crate) trait SealedGroup {
+    #[cfg(feature = "_dppi")]
+    fn regs(&self) -> pac::dppic::Dppic;
+    #[cfg(not(feature = "_dppi"))]
+    fn regs(&self) -> pac::ppi::Ppi;
+}
 
 /// Interface for PPI channels.
 #[allow(private_bounds)]
@@ -241,9 +251,16 @@ pub trait Group: SealedGroup + PeripheralType + Into<AnyGroup> + Sized + 'static
 /// This can be used to have fewer generic parameters in some places.
 pub struct AnyStaticChannel {
     pub(crate) number: u8,
+    #[cfg(feature = "_dppi")]
+    pub(crate) regs: pac::dppic::Dppic,
 }
 impl_peripheral!(AnyStaticChannel);
-impl SealedChannel for AnyStaticChannel {}
+impl SealedChannel for AnyStaticChannel {
+    #[cfg(feature = "_dppi")]
+    fn regs(&self) -> pac::dppic::Dppic {
+        self.regs
+    }
+}
 impl Channel for AnyStaticChannel {
     fn number(&self) -> usize {
         self.number as usize
@@ -255,9 +272,16 @@ impl StaticChannel for AnyStaticChannel {}
 /// This can be used to have fewer generic parameters in some places.
 pub struct AnyConfigurableChannel {
     pub(crate) number: u8,
+    #[cfg(feature = "_dppi")]
+    pub(crate) regs: pac::dppic::Dppic,
 }
 impl_peripheral!(AnyConfigurableChannel);
-impl SealedChannel for AnyConfigurableChannel {}
+impl SealedChannel for AnyConfigurableChannel {
+    #[cfg(feature = "_dppi")]
+    fn regs(&self) -> pac::dppic::Dppic {
+        self.regs
+    }
+}
 impl Channel for AnyConfigurableChannel {
     fn number(&self) -> usize {
         self.number as usize
@@ -267,32 +291,41 @@ impl ConfigurableChannel for AnyConfigurableChannel {}
 
 #[cfg(not(feature = "_nrf51"))]
 macro_rules! impl_ppi_channel {
-    ($type:ident, $number:expr) => {
-        impl crate::ppi::SealedChannel for peripherals::$type {}
+    ($type:ident, $inst:ident, $number:expr) => {
+        impl crate::ppi::SealedChannel for peripherals::$type {
+            #[cfg(feature = "_dppi")]
+            fn regs(&self) -> pac::dppic::Dppic {
+                pac::$inst
+            }
+        }
         impl crate::ppi::Channel for peripherals::$type {
             fn number(&self) -> usize {
                 $number
             }
         }
     };
-    ($type:ident, $number:expr => static) => {
-        impl_ppi_channel!($type, $number);
+    ($type:ident, $inst:ident, $number:expr => static) => {
+        impl_ppi_channel!($type, $inst, $number);
         impl crate::ppi::StaticChannel for peripherals::$type {}
         impl From<peripherals::$type> for crate::ppi::AnyStaticChannel {
             fn from(val: peripherals::$type) -> Self {
                 Self {
                     number: crate::ppi::Channel::number(&val) as u8,
+                    #[cfg(feature = "_dppi")]
+                    regs: pac::$inst,
                 }
             }
         }
     };
-    ($type:ident, $number:expr => configurable) => {
-        impl_ppi_channel!($type, $number);
+    ($type:ident, $inst:ident, $number:expr => configurable) => {
+        impl_ppi_channel!($type, $inst, $number);
         impl crate::ppi::ConfigurableChannel for peripherals::$type {}
         impl From<peripherals::$type> for crate::ppi::AnyConfigurableChannel {
             fn from(val: peripherals::$type) -> Self {
                 Self {
                     number: crate::ppi::Channel::number(&val) as u8,
+                    #[cfg(feature = "_dppi")]
+                    regs: pac::$inst,
                 }
             }
         }
@@ -304,40 +337,54 @@ macro_rules! impl_ppi_channel {
 
 /// A type erased PPI group.
 pub struct AnyGroup {
-    number: u8,
+    pub(crate) number: u8,
+    #[cfg(feature = "_dppi")]
+    pub(crate) regs: pac::dppic::Dppic,
+    #[cfg(not(feature = "_dppi"))]
+    pub(crate) regs: pac::ppi::Ppi,
 }
 impl_peripheral!(AnyGroup);
-impl SealedGroup for AnyGroup {}
+impl SealedGroup for AnyGroup {
+    #[cfg(feature = "_dppi")]
+    fn regs(&self) -> pac::dppic::Dppic {
+        self.regs
+    }
+    #[cfg(not(feature = "_dppi"))]
+    fn regs(&self) -> pac::ppi::Ppi {
+        self.regs
+    }
+}
 impl Group for AnyGroup {
     fn number(&self) -> usize {
         self.number as usize
     }
 }
 
-macro_rules! impl_group {
-    ($type:ident, $number:expr) => {
-        impl SealedGroup for peripherals::$type {}
-        impl Group for peripherals::$type {
+macro_rules! impl_ppi_group {
+    ($type:ident, $inst:ident, $number:expr) => {
+        impl crate::ppi::SealedGroup for crate::peripherals::$type {
+            #[cfg(feature = "_dppi")]
+            fn regs(&self) -> pac::dppic::Dppic {
+                pac::$inst
+            }
+            #[cfg(not(feature = "_dppi"))]
+            fn regs(&self) -> pac::ppi::Ppi {
+                pac::$inst
+            }
+        }
+        impl crate::ppi::Group for crate::peripherals::$type {
             fn number(&self) -> usize {
                 $number
             }
         }
 
-        impl From<peripherals::$type> for crate::ppi::AnyGroup {
-            fn from(val: peripherals::$type) -> Self {
+        impl From<crate::peripherals::$type> for crate::ppi::AnyGroup {
+            fn from(val: crate::peripherals::$type) -> Self {
                 Self {
                     number: crate::ppi::Group::number(&val) as u8,
+                    regs: pac::$inst,
                 }
             }
         }
     };
 }
-
-impl_group!(PPI_GROUP0, 0);
-impl_group!(PPI_GROUP1, 1);
-impl_group!(PPI_GROUP2, 2);
-impl_group!(PPI_GROUP3, 3);
-#[cfg(not(feature = "_nrf51"))]
-impl_group!(PPI_GROUP4, 4);
-#[cfg(not(feature = "_nrf51"))]
-impl_group!(PPI_GROUP5, 5);
diff --git a/embassy-nrf/src/pwm.rs b/embassy-nrf/src/pwm.rs
index e038f44b8..04eb14a77 100644
--- a/embassy-nrf/src/pwm.rs
+++ b/embassy-nrf/src/pwm.rs
@@ -6,7 +6,7 @@ use core::sync::atomic::{Ordering, compiler_fence};
 
 use embassy_hal_internal::{Peri, PeripheralType};
 
-use crate::gpio::{AnyPin, DISCONNECTED, OutputDrive, Pin as GpioPin, PselBits, SealedPin as _, convert_drive};
+use crate::gpio::{AnyPin, DISCONNECTED, Level, OutputDrive, Pin as GpioPin, PselBits, SealedPin as _, convert_drive};
 use crate::pac::gpio::vals as gpiovals;
 use crate::pac::pwm::vals;
 use crate::ppi::{Event, Task};
@@ -17,7 +17,7 @@ use crate::{interrupt, pac};
 /// to simply set a duty cycle across up to four channels.
 pub struct SimplePwm<'d> {
     r: pac::pwm::Pwm,
-    duty: [u16; 4],
+    duty: [DutyCycle; 4],
     ch0: Option<Peri<'d, AnyPin>>,
     ch1: Option<Peri<'d, AnyPin>>,
     ch2: Option<Peri<'d, AnyPin>>,
@@ -53,13 +53,11 @@ pub const PWM_CLK_HZ: u32 = 16_000_000;
 
 impl<'d> SequencePwm<'d> {
     /// Create a new 1-channel PWM
-    #[allow(unused_unsafe)]
     pub fn new_1ch<T: Instance>(pwm: Peri<'d, T>, ch0: Peri<'d, impl GpioPin>, config: Config) -> Result<Self, Error> {
         Self::new_inner(pwm, Some(ch0.into()), None, None, None, config)
     }
 
     /// Create a new 2-channel PWM
-    #[allow(unused_unsafe)]
     pub fn new_2ch<T: Instance>(
         pwm: Peri<'d, T>,
         ch0: Peri<'d, impl GpioPin>,
@@ -70,7 +68,6 @@ impl<'d> SequencePwm<'d> {
     }
 
     /// Create a new 3-channel PWM
-    #[allow(unused_unsafe)]
     pub fn new_3ch<T: Instance>(
         pwm: Peri<'d, T>,
         ch0: Peri<'d, impl GpioPin>,
@@ -82,7 +79,6 @@ impl<'d> SequencePwm<'d> {
     }
 
     /// Create a new 4-channel PWM
-    #[allow(unused_unsafe)]
     pub fn new_4ch<T: Instance>(
         pwm: Peri<'d, T>,
         ch0: Peri<'d, impl GpioPin>,
@@ -111,44 +107,27 @@ impl<'d> SequencePwm<'d> {
     ) -> Result<Self, Error> {
         let r = T::regs();
 
-        if let Some(pin) = &ch0 {
-            pin.set_low();
-            pin.conf().write(|w| {
-                w.set_dir(gpiovals::Dir::OUTPUT);
-                w.set_input(gpiovals::Input::DISCONNECT);
-                convert_drive(w, config.ch0_drive);
-            });
-        }
-        if let Some(pin) = &ch1 {
-            pin.set_low();
-            pin.conf().write(|w| {
-                w.set_dir(gpiovals::Dir::OUTPUT);
-                w.set_input(gpiovals::Input::DISCONNECT);
-                convert_drive(w, config.ch1_drive);
-            });
-        }
-        if let Some(pin) = &ch2 {
-            pin.set_low();
-            pin.conf().write(|w| {
-                w.set_dir(gpiovals::Dir::OUTPUT);
-                w.set_input(gpiovals::Input::DISCONNECT);
-                convert_drive(w, config.ch2_drive);
-            });
-        }
-        if let Some(pin) = &ch3 {
-            pin.set_low();
-            pin.conf().write(|w| {
-                w.set_dir(gpiovals::Dir::OUTPUT);
-                w.set_input(gpiovals::Input::DISCONNECT);
-                convert_drive(w, config.ch3_drive);
-            });
+        let channels = [
+            (&ch0, config.ch0_drive, config.ch0_idle_level),
+            (&ch1, config.ch1_drive, config.ch1_idle_level),
+            (&ch2, config.ch2_drive, config.ch2_idle_level),
+            (&ch3, config.ch3_drive, config.ch3_idle_level),
+        ];
+        for (i, (pin, drive, idle_level)) in channels.into_iter().enumerate() {
+            if let Some(pin) = pin {
+                match idle_level {
+                    Level::Low => pin.set_low(),
+                    Level::High => pin.set_high(),
+                }
+                pin.conf().write(|w| {
+                    w.set_dir(gpiovals::Dir::OUTPUT);
+                    w.set_input(gpiovals::Input::DISCONNECT);
+                    convert_drive(w, drive);
+                });
+            }
+            r.psel().out(i).write_value(pin.psel_bits());
         }
 
-        r.psel().out(0).write_value(ch0.psel_bits());
-        r.psel().out(1).write_value(ch1.psel_bits());
-        r.psel().out(2).write_value(ch2.psel_bits());
-        r.psel().out(3).write_value(ch3.psel_bits());
-
         // Disable all interrupts
         r.intenclr().write(|w| w.0 = 0xFFFF_FFFF);
         r.shorts().write(|_| ());
@@ -173,13 +152,7 @@ impl<'d> SequencePwm<'d> {
             .write(|w| w.set_prescaler(vals::Prescaler::from_bits(config.prescaler as u8)));
         r.countertop().write(|w| w.set_countertop(config.max_duty));
 
-        Ok(Self {
-            r: T::regs(),
-            ch0,
-            ch1,
-            ch2,
-            ch3,
-        })
+        Ok(Self { r, ch0, ch1, ch2, ch3 })
     }
 
     /// Returns reference to `Stopped` event endpoint for PPI.
@@ -230,7 +203,7 @@ impl<'d> SequencePwm<'d> {
     /// Interacting with the sequence while it runs puts it in an unknown state
     #[inline(always)]
     pub unsafe fn task_start_seq0(&self) -> Task<'d> {
-        Task::from_reg(self.r.tasks_seqstart(0))
+        Task::from_reg(self.r.tasks_dma().seq(0).start())
     }
 
     /// Returns reference to `Seq1 Started` task endpoint for PPI.
@@ -239,7 +212,7 @@ impl<'d> SequencePwm<'d> {
     /// Interacting with the sequence while it runs puts it in an unknown state
     #[inline(always)]
     pub unsafe fn task_start_seq1(&self) -> Task<'d> {
-        Task::from_reg(self.r.tasks_seqstart(1))
+        Task::from_reg(self.r.tasks_dma().seq(1).start())
     }
 
     /// Returns reference to `NextStep` task endpoint for PPI.
@@ -289,6 +262,8 @@ impl<'a> Drop for SequencePwm<'a> {
 }
 
 /// Configuration for the PWM as a whole.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[non_exhaustive]
 pub struct Config {
     /// Selects up mode or up-and-down mode for the counter
@@ -307,11 +282,19 @@ pub struct Config {
     pub ch2_drive: OutputDrive,
     /// Drive strength for the channel 3 line.
     pub ch3_drive: OutputDrive,
+    /// Output level for the channel 0 line when PWM if disabled.
+    pub ch0_idle_level: Level,
+    /// Output level for the channel 1 line when PWM if disabled.
+    pub ch1_idle_level: Level,
+    /// Output level for the channel 2 line when PWM if disabled.
+    pub ch2_idle_level: Level,
+    /// Output level for the channel 3 line when PWM if disabled.
+    pub ch3_idle_level: Level,
 }
 
 impl Default for Config {
-    fn default() -> Config {
-        Config {
+    fn default() -> Self {
+        Self {
             counter_mode: CounterMode::Up,
             max_duty: 1000,
             prescaler: Prescaler::Div16,
@@ -320,13 +303,65 @@ impl Default for Config {
             ch1_drive: OutputDrive::Standard,
             ch2_drive: OutputDrive::Standard,
             ch3_drive: OutputDrive::Standard,
+            ch0_idle_level: Level::Low,
+            ch1_idle_level: Level::Low,
+            ch2_idle_level: Level::Low,
+            ch3_idle_level: Level::Low,
+        }
+    }
+}
+
+/// Configuration for the simple PWM driver.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+#[non_exhaustive]
+pub struct SimpleConfig {
+    /// Selects up mode or up-and-down mode for the counter
+    pub counter_mode: CounterMode,
+    /// Top value to be compared against buffer values
+    pub max_duty: u16,
+    /// Configuration for PWM_CLK
+    pub prescaler: Prescaler,
+    /// Drive strength for the channel 0 line.
+    pub ch0_drive: OutputDrive,
+    /// Drive strength for the channel 1 line.
+    pub ch1_drive: OutputDrive,
+    /// Drive strength for the channel 2 line.
+    pub ch2_drive: OutputDrive,
+    /// Drive strength for the channel 3 line.
+    pub ch3_drive: OutputDrive,
+    /// Output level for the channel 0 line when PWM if disabled.
+    pub ch0_idle_level: Level,
+    /// Output level for the channel 1 line when PWM if disabled.
+    pub ch1_idle_level: Level,
+    /// Output level for the channel 2 line when PWM if disabled.
+    pub ch2_idle_level: Level,
+    /// Output level for the channel 3 line when PWM if disabled.
+    pub ch3_idle_level: Level,
+}
+
+impl Default for SimpleConfig {
+    fn default() -> Self {
+        Self {
+            counter_mode: CounterMode::Up,
+            max_duty: 1000,
+            prescaler: Prescaler::Div16,
+            ch0_drive: OutputDrive::Standard,
+            ch1_drive: OutputDrive::Standard,
+            ch2_drive: OutputDrive::Standard,
+            ch3_drive: OutputDrive::Standard,
+            ch0_idle_level: Level::Low,
+            ch1_idle_level: Level::Low,
+            ch2_idle_level: Level::Low,
+            ch3_idle_level: Level::Low,
         }
     }
 }
 
 /// Configuration per sequence
 #[non_exhaustive]
-#[derive(Clone)]
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct SequenceConfig {
     /// Number of PWM periods to delay between each sequence sample
     pub refresh: u32,
@@ -345,6 +380,8 @@ impl Default for SequenceConfig {
 
 /// A composition of a sequence buffer and its configuration.
 #[non_exhaustive]
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct Sequence<'s> {
     /// The words comprising the sequence. Must not exceed 32767 words.
     pub words: &'s [u16],
@@ -407,6 +444,21 @@ pub struct Sequencer<'d, 's> {
     sequence1: Option<Sequence<'s>>,
 }
 
+#[cfg(feature = "_nrf54l")]
+fn pwmseq(r: pac::pwm::Pwm, n: usize) -> pac::pwm::PwmSeq {
+    r.seq(n)
+}
+
+#[cfg(not(feature = "_nrf54l"))]
+fn pwmseq(r: pac::pwm::Pwm, n: usize) -> pac::pwm::DmaSeq {
+    r.dma().seq(n)
+}
+
+#[cfg(feature = "_nrf54l")]
+const CNT_UNIT: u32 = 2;
+#[cfg(not(feature = "_nrf54l"))]
+const CNT_UNIT: u32 = 1;
+
 impl<'d, 's> Sequencer<'d, 's> {
     /// Create a new double sequence. In the absence of sequence 1, sequence 0
     /// will be used twice in the one loop.
@@ -439,15 +491,21 @@ impl<'d, 's> Sequencer<'d, 's> {
 
         let r = self._pwm.r;
 
-        r.seq(0).refresh().write(|w| w.0 = sequence0.config.refresh);
-        r.seq(0).enddelay().write(|w| w.0 = sequence0.config.end_delay);
-        r.seq(0).ptr().write_value(sequence0.words.as_ptr() as u32);
-        r.seq(0).cnt().write(|w| w.0 = sequence0.words.len() as u32);
-
-        r.seq(1).refresh().write(|w| w.0 = alt_sequence.config.refresh);
-        r.seq(1).enddelay().write(|w| w.0 = alt_sequence.config.end_delay);
-        r.seq(1).ptr().write_value(alt_sequence.words.as_ptr() as u32);
-        r.seq(1).cnt().write(|w| w.0 = alt_sequence.words.len() as u32);
+        pwmseq(r, 0).refresh().write(|w| w.0 = sequence0.config.refresh);
+        pwmseq(r, 0).enddelay().write(|w| w.0 = sequence0.config.end_delay);
+        r.dma().seq(0).ptr().write_value(sequence0.words.as_ptr() as u32);
+        r.dma()
+            .seq(0)
+            .maxcnt()
+            .write(|w| w.0 = sequence0.words.len() as u32 * CNT_UNIT);
+
+        pwmseq(r, 1).refresh().write(|w| w.0 = alt_sequence.config.refresh);
+        pwmseq(r, 1).enddelay().write(|w| w.0 = alt_sequence.config.end_delay);
+        r.dma().seq(1).ptr().write_value(alt_sequence.words.as_ptr() as u32);
+        r.dma()
+            .seq(1)
+            .maxcnt()
+            .write(|w| w.0 = alt_sequence.words.len() as u32 * CNT_UNIT);
 
         r.enable().write(|w| w.set_enable(true));
 
@@ -463,11 +521,11 @@ impl<'d, 's> Sequencer<'d, 's> {
             // to play infinitely, repeat the sequence one time, then have loops done self trigger seq0 again
             SequenceMode::Infinite => {
                 r.loop_().write(|w| w.set_cnt(vals::LoopCnt::from_bits(1)));
-                r.shorts().write(|w| w.set_loopsdone_seqstart0(true));
+                r.shorts().write(|w| w.set_loopsdone_dma_seq0_start(true));
             }
         }
 
-        r.tasks_seqstart(seqstart_index).write_value(1);
+        r.tasks_dma().seq(seqstart_index).start().write_value(1);
 
         Ok(())
     }
@@ -496,6 +554,7 @@ impl<'d, 's> Drop for Sequencer<'d, 's> {
 
 /// How many times to run a single sequence
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum SingleSequenceMode {
     /// Run a single sequence n Times total.
     Times(u16),
@@ -505,6 +564,7 @@ pub enum SingleSequenceMode {
 
 /// Which sequence to start a loop with
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum StartSequence {
     /// Start with Sequence 0
     Zero,
@@ -514,6 +574,7 @@ pub enum StartSequence {
 
 /// How many loops to run two sequences
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum SequenceMode {
     /// Run two sequences n loops i.e. (n * (seq0 + seq1.unwrap_or(seq0)))
     Loop(u16),
@@ -523,6 +584,7 @@ pub enum SequenceMode {
 
 /// PWM Base clock is system clock (16MHz) divided by prescaler
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum Prescaler {
     /// Divide by 1
     Div1,
@@ -544,6 +606,7 @@ pub enum Prescaler {
 
 /// How the sequence values are distributed across the channels
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum SequenceLoad {
     /// Provided sequence will be used across all channels
     Common,
@@ -560,6 +623,7 @@ pub enum SequenceLoad {
 
 /// Selects up mode or up-and-down mode for the counter
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum CounterMode {
     /// Up counter (edge-aligned PWM duty cycle)
     Up,
@@ -567,48 +631,128 @@ pub enum CounterMode {
     UpAndDown,
 }
 
+/// Duty value and polarity for a single channel.
+///
+/// If the channel has inverted polarity, the output is set high as long as the counter is below the duty value.
+#[repr(transparent)]
+#[derive(Eq, PartialEq, Clone, Copy)]
+pub struct DutyCycle {
+    /// The raw duty cycle valuea.
+    ///
+    /// This has the duty cycle in the lower 15 bits.
+    /// The highest bit indicates that the duty cycle has inverted polarity.
+    raw: u16,
+}
+
+impl DutyCycle {
+    /// Make a new duty value with normal polarity.
+    ///
+    /// The value is truncated to 15 bits.
+    ///
+    /// The output is set high if the counter is at or above the duty value.
+    pub const fn normal(value: u16) -> Self {
+        let raw = value & 0x7FFF;
+        Self { raw }
+    }
+
+    /// Make a new duty cycle with inverted polarity.
+    ///
+    /// The value is truncated to 15 bits.
+    ///
+    /// The output is set high if the counter is below the duty value.
+    pub const fn inverted(value: u16) -> Self {
+        let raw = value | 0x8000;
+        Self { raw }
+    }
+
+    /// Adjust the polarity of the duty cycle (returns a new object).
+    #[must_use = "this function return a new object, it does not modify self"]
+    pub const fn with_inverted(self, inverted_polarity: bool) -> Self {
+        if inverted_polarity {
+            Self::inverted(self.value())
+        } else {
+            Self::normal(self.value())
+        }
+    }
+
+    /// Gets the 15-bit value of the duty cycle.
+    pub const fn value(&self) -> u16 {
+        self.raw & 0x7FFF
+    }
+
+    /// Checks if the duty period has inverted polarity.
+    ///
+    /// If the channel has inverted polarity, the output is set high as long as the counter is below the duty value.
+    pub const fn is_inverted(&self) -> bool {
+        self.raw & 0x8000 != 0
+    }
+}
+
+impl core::fmt::Debug for DutyCycle {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("DutyCycle")
+            .field("value", &self.value())
+            .field("inverted", &self.is_inverted())
+            .finish()
+    }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for DutyCycle {
+    fn format(&self, f: defmt::Formatter) {
+        defmt::write!(
+            f,
+            "DutyCycle {{ value: {=u16}, inverted: {=bool} }}",
+            self.value(),
+            self.is_inverted(),
+        );
+    }
+}
+
 impl<'d> SimplePwm<'d> {
     /// Create a new 1-channel PWM
-    #[allow(unused_unsafe)]
-    pub fn new_1ch<T: Instance>(pwm: Peri<'d, T>, ch0: Peri<'d, impl GpioPin>) -> Self {
-        unsafe { Self::new_inner(pwm, Some(ch0.into()), None, None, None) }
+    pub fn new_1ch<T: Instance>(pwm: Peri<'d, T>, ch0: Peri<'d, impl GpioPin>, config: &SimpleConfig) -> Self {
+        Self::new_inner(pwm, Some(ch0.into()), None, None, None, config)
     }
 
     /// Create a new 2-channel PWM
-    #[allow(unused_unsafe)]
-    pub fn new_2ch<T: Instance>(pwm: Peri<'d, T>, ch0: Peri<'d, impl GpioPin>, ch1: Peri<'d, impl GpioPin>) -> Self {
-        Self::new_inner(pwm, Some(ch0.into()), Some(ch1.into()), None, None)
+    pub fn new_2ch<T: Instance>(
+        pwm: Peri<'d, T>,
+        ch0: Peri<'d, impl GpioPin>,
+        ch1: Peri<'d, impl GpioPin>,
+        config: &SimpleConfig,
+    ) -> Self {
+        Self::new_inner(pwm, Some(ch0.into()), Some(ch1.into()), None, None, config)
     }
 
     /// Create a new 3-channel PWM
-    #[allow(unused_unsafe)]
     pub fn new_3ch<T: Instance>(
         pwm: Peri<'d, T>,
         ch0: Peri<'d, impl GpioPin>,
         ch1: Peri<'d, impl GpioPin>,
         ch2: Peri<'d, impl GpioPin>,
+        config: &SimpleConfig,
     ) -> Self {
-        unsafe { Self::new_inner(pwm, Some(ch0.into()), Some(ch1.into()), Some(ch2.into()), None) }
+        Self::new_inner(pwm, Some(ch0.into()), Some(ch1.into()), Some(ch2.into()), None, config)
     }
 
     /// Create a new 4-channel PWM
-    #[allow(unused_unsafe)]
     pub fn new_4ch<T: Instance>(
         pwm: Peri<'d, T>,
         ch0: Peri<'d, impl GpioPin>,
         ch1: Peri<'d, impl GpioPin>,
         ch2: Peri<'d, impl GpioPin>,
         ch3: Peri<'d, impl GpioPin>,
+        config: &SimpleConfig,
     ) -> Self {
-        unsafe {
-            Self::new_inner(
-                pwm,
-                Some(ch0.into()),
-                Some(ch1.into()),
-                Some(ch2.into()),
-                Some(ch3.into()),
-            )
-        }
+        Self::new_inner(
+            pwm,
+            Some(ch0.into()),
+            Some(ch1.into()),
+            Some(ch2.into()),
+            Some(ch3.into()),
+            config,
+        )
     }
 
     fn new_inner<T: Instance>(
@@ -617,29 +761,38 @@ impl<'d> SimplePwm<'d> {
         ch1: Option<Peri<'d, AnyPin>>,
         ch2: Option<Peri<'d, AnyPin>>,
         ch3: Option<Peri<'d, AnyPin>>,
+        config: &SimpleConfig,
     ) -> Self {
         let r = T::regs();
 
-        for (i, ch) in [&ch0, &ch1, &ch2, &ch3].into_iter().enumerate() {
-            if let Some(pin) = ch {
-                pin.set_low();
-
+        let channels = [
+            (&ch0, config.ch0_drive, config.ch0_idle_level),
+            (&ch1, config.ch1_drive, config.ch1_idle_level),
+            (&ch2, config.ch2_drive, config.ch2_idle_level),
+            (&ch3, config.ch3_drive, config.ch3_idle_level),
+        ];
+        for (i, (pin, drive, idle_level)) in channels.into_iter().enumerate() {
+            if let Some(pin) = pin {
+                match idle_level {
+                    Level::Low => pin.set_low(),
+                    Level::High => pin.set_high(),
+                }
                 pin.conf().write(|w| {
                     w.set_dir(gpiovals::Dir::OUTPUT);
                     w.set_input(gpiovals::Input::DISCONNECT);
-                    w.set_drive(gpiovals::Drive::S0S1);
+                    convert_drive(w, drive);
                 });
             }
-            r.psel().out(i).write_value(ch.psel_bits());
+            r.psel().out(i).write_value(pin.psel_bits());
         }
 
         let pwm = Self {
-            r: T::regs(),
+            r,
             ch0,
             ch1,
             ch2,
             ch3,
-            duty: [0; 4],
+            duty: [const { DutyCycle::normal(0) }; 4],
         };
 
         // Disable all interrupts
@@ -649,18 +802,22 @@ impl<'d> SimplePwm<'d> {
         // Enable
         r.enable().write(|w| w.set_enable(true));
 
-        r.seq(0).ptr().write_value((pwm.duty).as_ptr() as u32);
-        r.seq(0).cnt().write(|w| w.0 = 4);
-        r.seq(0).refresh().write(|w| w.0 = 0);
-        r.seq(0).enddelay().write(|w| w.0 = 0);
+        r.dma().seq(0).ptr().write_value((pwm.duty).as_ptr() as u32);
+        r.dma().seq(0).maxcnt().write(|w| w.0 = 4 * CNT_UNIT);
+        pwmseq(r, 0).refresh().write(|w| w.0 = 0);
+        pwmseq(r, 0).enddelay().write(|w| w.0 = 0);
 
         r.decoder().write(|w| {
             w.set_load(vals::Load::INDIVIDUAL);
             w.set_mode(vals::Mode::REFRESH_COUNT);
         });
-        r.mode().write(|w| w.set_updown(vals::Updown::UP));
-        r.prescaler().write(|w| w.set_prescaler(vals::Prescaler::DIV_16));
-        r.countertop().write(|w| w.set_countertop(1000));
+        r.mode().write(|w| match config.counter_mode {
+            CounterMode::UpAndDown => w.set_updown(vals::Updown::UP_AND_DOWN),
+            CounterMode::Up => w.set_updown(vals::Updown::UP),
+        });
+        r.prescaler()
+            .write(|w| w.set_prescaler(vals::Prescaler::from_bits(config.prescaler as u8)));
+        r.countertop().write(|w| w.set_countertop(config.max_duty));
         r.loop_().write(|w| w.set_cnt(vals::LoopCnt::DISABLED));
 
         pwm
@@ -684,17 +841,33 @@ impl<'d> SimplePwm<'d> {
         self.r.enable().write(|w| w.set_enable(false));
     }
 
-    /// Returns the current duty of the channel
-    pub fn duty(&self, channel: usize) -> u16 {
+    /// Returns the current duty of the channel.
+    pub fn duty(&self, channel: usize) -> DutyCycle {
         self.duty[channel]
     }
 
-    /// Sets duty cycle (15 bit) for a PWM channel.
-    pub fn set_duty(&mut self, channel: usize, duty: u16) {
-        self.duty[channel] = duty & 0x7FFF;
+    /// Sets duty cycle (15 bit) and polarity for a PWM channel.
+    pub fn set_duty(&mut self, channel: usize, duty: DutyCycle) {
+        self.duty[channel] = duty;
+        self.sync_duty_cyles_to_peripheral();
+    }
+
+    /// Sets the duty cycle (15 bit) and polarity for all PWM channels.
+    ///
+    /// You can safely set the duty cycle of disabled PWM channels.
+    ///
+    /// When using this function, a single DMA transfer sets all the duty cycles.
+    /// If you call [`Self::set_duty()`] multiple times,
+    /// each duty cycle will be set by a separate DMA transfer.
+    pub fn set_all_duties(&mut self, duty: [DutyCycle; 4]) {
+        self.duty = duty;
+        self.sync_duty_cyles_to_peripheral();
+    }
 
+    /// Transfer the duty cycles from `self` to the peripheral.
+    fn sync_duty_cyles_to_peripheral(&self) {
         // reload ptr in case self was moved
-        self.r.seq(0).ptr().write_value((self.duty).as_ptr() as u32);
+        self.r.dma().seq(0).ptr().write_value((self.duty).as_ptr() as u32);
 
         // defensive before seqstart
         compiler_fence(Ordering::SeqCst);
@@ -702,7 +875,7 @@ impl<'d> SimplePwm<'d> {
         self.r.events_seqend(0).write_value(0);
 
         // tasks_seqstart() doesn't exist in all svds so write its bit instead
-        self.r.tasks_seqstart(0).write_value(1);
+        self.r.tasks_dma().seq(0).start().write_value(1);
 
         // defensive wait until waveform is loaded after seqstart so set_duty
         // can't be called again while dma is still reading
diff --git a/embassy-nrf/src/saadc.rs b/embassy-nrf/src/saadc.rs
index a199c1c4d..ca8cbd73e 100644
--- a/embassy-nrf/src/saadc.rs
+++ b/embassy-nrf/src/saadc.rs
@@ -10,6 +10,7 @@ use core::task::Poll;
 use embassy_hal_internal::drop::OnDrop;
 use embassy_hal_internal::{Peri, impl_peripheral};
 use embassy_sync::waitqueue::AtomicWaker;
+#[cfg(not(feature = "_nrf54l"))]
 pub(crate) use vals::Psel as InputChannel;
 
 use crate::interrupt::InterruptExt;
@@ -84,6 +85,7 @@ pub struct ChannelConfig<'d> {
     /// Gain used to control the effective input range of the SAADC.
     pub gain: Gain,
     /// Positive channel resistor control.
+    #[cfg(not(feature = "_nrf54l"))]
     pub resistor: Resistor,
     /// Acquisition time in microseconds.
     pub time: Time,
@@ -98,7 +100,11 @@ impl<'d> ChannelConfig<'d> {
     pub fn single_ended(input: impl Input + 'd) -> Self {
         Self {
             reference: Reference::INTERNAL,
+            #[cfg(not(feature = "_nrf54l"))]
             gain: Gain::GAIN1_6,
+            #[cfg(feature = "_nrf54l")]
+            gain: Gain::GAIN2_8,
+            #[cfg(not(feature = "_nrf54l"))]
             resistor: Resistor::BYPASS,
             time: Time::_10US,
             p_channel: input.degrade_saadc(),
@@ -109,7 +115,11 @@ impl<'d> ChannelConfig<'d> {
     pub fn differential(p_input: impl Input + 'd, n_input: impl Input + 'd) -> Self {
         Self {
             reference: Reference::INTERNAL,
+            #[cfg(not(feature = "_nrf54l"))]
             gain: Gain::GAIN1_6,
+            #[cfg(feature = "_nrf54l")]
+            gain: Gain::GAIN2_8,
+            #[cfg(not(feature = "_nrf54l"))]
             resistor: Resistor::BYPASS,
             time: Time::_10US,
             p_channel: p_input.degrade_saadc(),
@@ -118,6 +128,8 @@ impl<'d> ChannelConfig<'d> {
     }
 }
 
+const CNT_UNIT: usize = if cfg!(feature = "_nrf54l") { 2 } else { 1 };
+
 /// Value returned by the SAADC callback, deciding what happens next.
 #[derive(PartialEq)]
 pub enum CallbackResult {
@@ -150,19 +162,38 @@ impl<'d, const N: usize> Saadc<'d, N> {
         r.oversample().write(|w| w.set_oversample(oversample.into()));
 
         for (i, cc) in channel_configs.iter().enumerate() {
+            #[cfg(not(feature = "_nrf54l"))]
             r.ch(i).pselp().write(|w| w.set_pselp(cc.p_channel.channel()));
+            #[cfg(feature = "_nrf54l")]
+            r.ch(i).pselp().write(|w| {
+                w.set_port(cc.p_channel.port());
+                w.set_pin(cc.p_channel.pin());
+                w.set_internal(cc.p_channel.internal());
+                w.set_connect(cc.p_channel.connect());
+            });
             if let Some(n_channel) = &cc.n_channel {
+                #[cfg(not(feature = "_nrf54l"))]
                 r.ch(i).pseln().write(|w| w.set_pseln(n_channel.channel()));
+                #[cfg(feature = "_nrf54l")]
+                r.ch(i).pseln().write(|w| {
+                    w.set_port(n_channel.port());
+                    w.set_pin(n_channel.pin());
+                    w.set_connect(n_channel.connect().to_bits().into());
+                });
             }
             r.ch(i).config().write(|w| {
                 w.set_refsel(cc.reference.into());
                 w.set_gain(cc.gain.into());
                 w.set_tacq(cc.time.into());
+                #[cfg(feature = "_nrf54l")]
+                w.set_tconv(7); // 7 is the default from the Nordic C driver
                 w.set_mode(match cc.n_channel {
                     None => vals::ConfigMode::SE,
                     Some(_) => vals::ConfigMode::DIFF,
                 });
+                #[cfg(not(feature = "_nrf54l"))]
                 w.set_resp(cc.resistor.into());
+                #[cfg(not(feature = "_nrf54l"))]
                 w.set_resn(vals::Resn::BYPASS);
                 w.set_burst(!matches!(oversample, Oversample::BYPASS));
             });
@@ -222,7 +253,7 @@ impl<'d, const N: usize> Saadc<'d, N> {
 
         // Set up the DMA
         r.result().ptr().write_value(buf.as_mut_ptr() as u32);
-        r.result().maxcnt().write(|w| w.set_maxcnt(N as _));
+        r.result().maxcnt().write(|w| w.set_maxcnt((N * CNT_UNIT) as _));
 
         // Reset and enable the end event
         r.events_end().write_value(0);
@@ -354,7 +385,7 @@ impl<'d, const N: usize> Saadc<'d, N> {
 
         // Set up the initial DMA
         r.result().ptr().write_value(bufs[0].as_mut_ptr() as u32);
-        r.result().maxcnt().write(|w| w.set_maxcnt((N0 * N) as _));
+        r.result().maxcnt().write(|w| w.set_maxcnt((N0 * N * CNT_UNIT) as _));
 
         // Reset and enable the events
         r.events_end().write_value(0);
@@ -473,12 +504,21 @@ impl<'d, const N: usize> Drop for Saadc<'d, N> {
         let r = Self::regs();
         r.enable().write(|w| w.set_enable(false));
         for i in 0..N {
-            r.ch(i).pselp().write(|w| w.set_pselp(InputChannel::NC));
-            r.ch(i).pseln().write(|w| w.set_pseln(InputChannel::NC));
+            #[cfg(not(feature = "_nrf54l"))]
+            {
+                r.ch(i).pselp().write(|w| w.set_pselp(InputChannel::NC));
+                r.ch(i).pseln().write(|w| w.set_pseln(InputChannel::NC));
+            }
+            #[cfg(feature = "_nrf54l")]
+            {
+                r.ch(i).pselp().write(|w| w.set_connect(vals::PselpConnect::NC));
+                r.ch(i).pseln().write(|w| w.set_connect(vals::PselnConnect::NC));
+            }
         }
     }
 }
 
+#[cfg(not(feature = "_nrf54l"))]
 impl From<Gain> for vals::Gain {
     fn from(gain: Gain) -> Self {
         match gain {
@@ -494,7 +534,24 @@ impl From<Gain> for vals::Gain {
     }
 }
 
+#[cfg(feature = "_nrf54l")]
+impl From<Gain> for vals::Gain {
+    fn from(gain: Gain) -> Self {
+        match gain {
+            Gain::GAIN2_8 => vals::Gain::GAIN2_8,
+            Gain::GAIN2_7 => vals::Gain::GAIN2_7,
+            Gain::GAIN2_6 => vals::Gain::GAIN2_6,
+            Gain::GAIN2_5 => vals::Gain::GAIN2_5,
+            Gain::GAIN2_4 => vals::Gain::GAIN2_4,
+            Gain::GAIN2_3 => vals::Gain::GAIN2_3,
+            Gain::GAIN1 => vals::Gain::GAIN1,
+            Gain::GAIN2 => vals::Gain::GAIN2,
+        }
+    }
+}
+
 /// Gain control
+#[cfg(not(feature = "_nrf54l"))]
 #[non_exhaustive]
 #[derive(Clone, Copy)]
 pub enum Gain {
@@ -516,11 +573,37 @@ pub enum Gain {
     GAIN4 = 7,
 }
 
+/// Gain control
+#[cfg(feature = "_nrf54l")]
+#[non_exhaustive]
+#[derive(Clone, Copy)]
+pub enum Gain {
+    /// 2/8
+    GAIN2_8 = 0,
+    /// 2/7
+    GAIN2_7 = 1,
+    /// 2/6
+    GAIN2_6 = 2,
+    /// 2/5
+    GAIN2_5 = 3,
+    /// 2/4
+    GAIN2_4 = 4,
+    /// 2/3
+    GAIN2_3 = 5,
+    /// 1
+    GAIN1 = 6,
+    /// 2
+    GAIN2 = 7,
+}
+
 impl From<Reference> for vals::Refsel {
     fn from(reference: Reference) -> Self {
         match reference {
             Reference::INTERNAL => vals::Refsel::INTERNAL,
+            #[cfg(not(feature = "_nrf54l"))]
             Reference::VDD1_4 => vals::Refsel::VDD1_4,
+            #[cfg(feature = "_nrf54l")]
+            Reference::EXTERNAL => vals::Refsel::EXTERNAL,
         }
     }
 }
@@ -531,10 +614,15 @@ impl From<Reference> for vals::Refsel {
 pub enum Reference {
     /// Internal reference (0.6 V)
     INTERNAL = 0,
+    #[cfg(not(feature = "_nrf54l"))]
     /// VDD/4 as reference
     VDD1_4 = 1,
+    /// PADC_EXT_REF_1V2 as reference
+    #[cfg(feature = "_nrf54l")]
+    EXTERNAL = 1,
 }
 
+#[cfg(not(feature = "_nrf54l"))]
 impl From<Resistor> for vals::Resp {
     fn from(resistor: Resistor) -> Self {
         match resistor {
@@ -549,6 +637,7 @@ impl From<Resistor> for vals::Resp {
 /// Positive channel resistor control
 #[non_exhaustive]
 #[derive(Clone, Copy)]
+#[cfg(not(feature = "_nrf54l"))]
 pub enum Resistor {
     /// Bypass resistor ladder
     BYPASS = 0,
@@ -560,6 +649,7 @@ pub enum Resistor {
     VDD1_2 = 3,
 }
 
+#[cfg(not(feature = "_nrf54l"))]
 impl From<Time> for vals::Tacq {
     fn from(time: Time) -> Self {
         match time {
@@ -573,6 +663,20 @@ impl From<Time> for vals::Tacq {
     }
 }
 
+#[cfg(feature = "_nrf54l")]
+impl From<Time> for u16 {
+    fn from(time: Time) -> Self {
+        match time {
+            Time::_3US => (3000 / 125) - 1,
+            Time::_5US => (5000 / 125) - 1,
+            Time::_10US => (10000 / 125) - 1,
+            Time::_15US => (15000 / 125) - 1,
+            Time::_20US => (20000 / 125) - 1,
+            Time::_40US => (40000 / 125) - 1,
+        }
+    }
+}
+
 /// Acquisition time, the time the SAADC uses to sample the input voltage
 #[non_exhaustive]
 #[derive(Clone, Copy)]
@@ -657,7 +761,20 @@ pub enum Resolution {
 }
 
 pub(crate) trait SealedInput {
+    #[cfg(not(feature = "_nrf54l"))]
     fn channel(&self) -> InputChannel;
+
+    #[cfg(feature = "_nrf54l")]
+    fn pin(&self) -> u8;
+
+    #[cfg(feature = "_nrf54l")]
+    fn port(&self) -> u8;
+
+    #[cfg(feature = "_nrf54l")]
+    fn internal(&self) -> vals::Internal;
+
+    #[cfg(feature = "_nrf54l")]
+    fn connect(&self) -> vals::PselpConnect;
 }
 
 /// An input that can be used as either or negative end of a ADC differential in the SAADC periperhal.
@@ -667,6 +784,7 @@ pub trait Input: SealedInput + Sized {
     ///
     /// This allows using several inputs  in situations that might require
     /// them to be the same type, like putting them in an array.
+    #[cfg(not(feature = "_nrf54l"))]
     fn degrade_saadc<'a>(self) -> AnyInput<'a>
     where
         Self: 'a,
@@ -676,17 +794,49 @@ pub trait Input: SealedInput + Sized {
             _phantom: core::marker::PhantomData,
         }
     }
+
+    /// Convert this SAADC input to a type-erased `AnyInput`.
+    ///
+    /// This allows using several inputs  in situations that might require
+    /// them to be the same type, like putting them in an array.
+    #[cfg(feature = "_nrf54l")]
+    fn degrade_saadc<'a>(self) -> AnyInput<'a>
+    where
+        Self: 'a,
+    {
+        AnyInput {
+            pin: self.pin(),
+            port: self.port(),
+            internal: self.internal(),
+            connect: self.connect(),
+            _phantom: core::marker::PhantomData,
+        }
+    }
 }
 
 /// A type-erased SAADC input.
 ///
 /// This allows using several inputs  in situations that might require
 /// them to be the same type, like putting them in an array.
+#[cfg(not(feature = "_nrf54l"))]
 pub struct AnyInput<'a> {
     channel: InputChannel,
     _phantom: PhantomData<&'a ()>,
 }
 
+/// A type-erased SAADC input.
+///
+/// This allows using several inputs  in situations that might require
+/// them to be the same type, like putting them in an array.
+#[cfg(feature = "_nrf54l")]
+pub struct AnyInput<'a> {
+    pin: u8,
+    port: u8,
+    internal: vals::Internal,
+    connect: vals::PselpConnect,
+    _phantom: PhantomData<&'a ()>,
+}
+
 impl<'a> AnyInput<'a> {
     /// Reborrow into a "child" AnyInput.
     ///
@@ -694,21 +844,56 @@ impl<'a> AnyInput<'a> {
     pub fn reborrow(&mut self) -> AnyInput<'_> {
         // safety: we're returning the clone inside a new Peripheral that borrows
         // self, so user code can't use both at the same time.
-        Self {
-            channel: self.channel,
-            _phantom: PhantomData,
+        #[cfg(not(feature = "_nrf54l"))]
+        {
+            Self {
+                channel: self.channel,
+                _phantom: PhantomData,
+            }
+        }
+        #[cfg(feature = "_nrf54l")]
+        {
+            Self {
+                pin: self.pin,
+                port: self.port,
+                internal: self.internal,
+                connect: self.connect,
+                _phantom: PhantomData,
+            }
         }
     }
 }
 
 impl SealedInput for AnyInput<'_> {
+    #[cfg(not(feature = "_nrf54l"))]
     fn channel(&self) -> InputChannel {
         self.channel
     }
+
+    #[cfg(feature = "_nrf54l")]
+    fn pin(&self) -> u8 {
+        self.pin
+    }
+
+    #[cfg(feature = "_nrf54l")]
+    fn port(&self) -> u8 {
+        self.port
+    }
+
+    #[cfg(feature = "_nrf54l")]
+    fn internal(&self) -> vals::Internal {
+        self.internal
+    }
+
+    #[cfg(feature = "_nrf54l")]
+    fn connect(&self) -> vals::PselpConnect {
+        self.connect
+    }
 }
 
 impl Input for AnyInput<'_> {}
 
+#[cfg(not(feature = "_nrf54l"))]
 macro_rules! impl_saadc_input {
     ($pin:ident, $ch:ident) => {
         impl_saadc_input!(@local, crate::Peri<'_, crate::peripherals::$pin>, $ch);
@@ -723,15 +908,45 @@ macro_rules! impl_saadc_input {
     };
 }
 
+#[cfg(feature = "_nrf54l")]
+macro_rules! impl_saadc_input {
+    ($pin:ident, $port:expr, $ain:expr) => {
+        impl_saadc_input!(@local, crate::Peri<'_, crate::peripherals::$pin>, $port, $ain, AVDD, ANALOG_INPUT);
+    };
+    (@local, $pin:ty, $port:expr, $ain:expr, $internal:ident, $connect:ident) => {
+        impl crate::saadc::SealedInput for $pin {
+            fn pin(&self) -> u8 {
+                $ain
+            }
+
+            fn port(&self) -> u8 {
+                $port
+            }
+
+            fn internal(&self) -> crate::pac::saadc::vals::Internal {
+                crate::pac::saadc::vals::Internal::$internal
+            }
+
+            fn connect(&self) -> crate::pac::saadc::vals::PselpConnect {
+                crate::pac::saadc::vals::PselpConnect::$connect
+            }
+        }
+        impl crate::saadc::Input for $pin {}
+    };
+}
+
 /// A dummy `Input` pin implementation for SAADC peripheral sampling from the
 /// internal voltage.
 pub struct VddInput;
 
 impl_peripheral!(VddInput);
+#[cfg(not(feature = "_nrf54l"))]
 #[cfg(not(feature = "_nrf91"))]
 impl_saadc_input!(@local, VddInput, VDD);
 #[cfg(feature = "_nrf91")]
 impl_saadc_input!(@local, VddInput, VDD_GPIO);
+#[cfg(feature = "_nrf54l")]
+impl_saadc_input!(@local, VddInput, 0, 0, VDD, INTERNAL);
 
 /// A dummy `Input` pin implementation for SAADC peripheral sampling from the
 /// VDDH / 5 voltage.
@@ -743,3 +958,21 @@ impl_peripheral!(VddhDiv5Input);
 
 #[cfg(any(feature = "_nrf5340-app", feature = "nrf52833", feature = "nrf52840"))]
 impl_saadc_input!(@local, VddhDiv5Input, VDDHDIV5);
+
+/// A dummy `Input` pin implementation for SAADC peripheral sampling from the
+/// AVDD internal voltage of the nrf54l chip family.
+#[cfg(feature = "_nrf54l")]
+pub struct AVddInput;
+#[cfg(feature = "_nrf54l")]
+embassy_hal_internal::impl_peripheral!(AVddInput);
+#[cfg(feature = "_nrf54l")]
+impl_saadc_input!(@local, AVddInput, 0, 0, AVDD, INTERNAL);
+
+/// A dummy `Input` pin implementation for SAADC peripheral sampling from the
+/// DVDD internal voltage of the nrf54l chip family.
+#[cfg(feature = "_nrf54l")]
+pub struct DVddInput;
+#[cfg(feature = "_nrf54l")]
+embassy_hal_internal::impl_peripheral!(DVddInput);
+#[cfg(feature = "_nrf54l")]
+impl_saadc_input!(@local, DVddInput, 0, 0, DVDD, INTERNAL);
diff --git a/embassy-nrf/src/spim.rs b/embassy-nrf/src/spim.rs
index ce994dbc9..34485609b 100644
--- a/embassy-nrf/src/spim.rs
+++ b/embassy-nrf/src/spim.rs
@@ -13,7 +13,7 @@ use embassy_embedded_hal::SetConfig;
 use embassy_hal_internal::{Peri, PeripheralType};
 use embassy_sync::waitqueue::AtomicWaker;
 pub use embedded_hal_02::spi::{MODE_0, MODE_1, MODE_2, MODE_3, Mode, Phase, Polarity};
-pub use pac::spim::vals::{Frequency, Order as BitOrder};
+pub use pac::spim::vals::Order as BitOrder;
 
 use crate::chip::{EASY_DMA_SIZE, FORCE_COPY_BUFFER_SIZE};
 use crate::gpio::{self, AnyPin, OutputDrive, Pin as GpioPin, PselBits, SealedPin as _, convert_drive};
@@ -23,6 +23,110 @@ use crate::pac::spim::vals;
 use crate::util::slice_in_ram_or;
 use crate::{interrupt, pac};
 
+/// SPI frequencies.
+#[repr(transparent)]
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+pub struct Frequency(u32);
+impl Frequency {
+    #[doc = "125 kbps"]
+    pub const K125: Self = Self(0x0200_0000);
+    #[doc = "250 kbps"]
+    pub const K250: Self = Self(0x0400_0000);
+    #[doc = "500 kbps"]
+    pub const K500: Self = Self(0x0800_0000);
+    #[doc = "1 Mbps"]
+    pub const M1: Self = Self(0x1000_0000);
+    #[doc = "2 Mbps"]
+    pub const M2: Self = Self(0x2000_0000);
+    #[doc = "4 Mbps"]
+    pub const M4: Self = Self(0x4000_0000);
+    #[doc = "8 Mbps"]
+    pub const M8: Self = Self(0x8000_0000);
+    #[cfg(not(feature = "_spi-v1"))]
+    #[doc = "16 Mbps"]
+    pub const M16: Self = Self(0x0a00_0000);
+    #[cfg(not(feature = "_spi-v1"))]
+    #[doc = "32 Mbps"]
+    pub const M32: Self = Self(0x1400_0000);
+}
+
+impl Frequency {
+    #[cfg(feature = "_nrf54l")]
+    fn to_divisor(&self, clk: u32) -> u8 {
+        let frequency = match *self {
+            #[cfg(not(feature = "_spi-v1"))]
+            Self::M32 => 32_000_000,
+            #[cfg(not(feature = "_spi-v1"))]
+            Self::M16 => 16_000_000,
+            Self::M8 => 8_000_000,
+            Self::M4 => 4_000_000,
+            Self::M2 => 2_000_000,
+            Self::M1 => 1_000_000,
+            Self::K500 => 500_000,
+            Self::K250 => 250_000,
+            Self::K125 => 125_000,
+            _ => unreachable!(),
+        };
+        let divisor = (clk / frequency) as u8;
+        divisor
+    }
+}
+impl core::fmt::Debug for Frequency {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        match self.0 {
+            0x0200_0000 => f.write_str("K125"),
+            0x0400_0000 => f.write_str("K250"),
+            0x0800_0000 => f.write_str("K500"),
+            0x0a00_0000 => f.write_str("M16"),
+            0x1000_0000 => f.write_str("M1"),
+            0x1400_0000 => f.write_str("M32"),
+            0x2000_0000 => f.write_str("M2"),
+            0x4000_0000 => f.write_str("M4"),
+            0x8000_0000 => f.write_str("M8"),
+            other => core::write!(f, "0x{:02X}", other),
+        }
+    }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Frequency {
+    fn format(&self, f: defmt::Formatter) {
+        match self.0 {
+            0x0200_0000 => defmt::write!(f, "K125"),
+            0x0400_0000 => defmt::write!(f, "K250"),
+            0x0800_0000 => defmt::write!(f, "K500"),
+            0x0a00_0000 => defmt::write!(f, "M16"),
+            0x1000_0000 => defmt::write!(f, "M1"),
+            0x1400_0000 => defmt::write!(f, "M32"),
+            0x2000_0000 => defmt::write!(f, "M2"),
+            0x4000_0000 => defmt::write!(f, "M4"),
+            0x8000_0000 => defmt::write!(f, "M8"),
+            other => defmt::write!(f, "0x{:02X}", other),
+        }
+    }
+}
+
+#[cfg(not(feature = "_nrf54l"))]
+impl Into<pac::spim::vals::Frequency> for Frequency {
+    fn into(self) -> pac::spim::vals::Frequency {
+        use pac::spim::vals::Frequency as Freq;
+        match self {
+            #[cfg(not(feature = "_spi-v1"))]
+            Self::M32 => Freq::M32,
+            #[cfg(not(feature = "_spi-v1"))]
+            Self::M16 => Freq::M16,
+            Self::M8 => Freq::M8,
+            Self::M4 => Freq::M4,
+            Self::M2 => Freq::M2,
+            Self::M1 => Freq::M1,
+            Self::K500 => Freq::K500,
+            Self::K250 => Freq::K250,
+            Self::K125 => Freq::K125,
+            _ => unreachable!(),
+        }
+    }
+}
+
 /// SPIM error
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
@@ -103,6 +207,8 @@ pub struct Spim<'d> {
     r: pac::spim::Spim,
     irq: interrupt::Interrupt,
     state: &'static State,
+    #[cfg(feature = "_nrf54l")]
+    clk: u32,
     _p: PhantomData<&'d ()>,
 }
 
@@ -208,6 +314,8 @@ impl<'d> Spim<'d> {
             r: T::regs(),
             irq: T::Interrupt::IRQ,
             state: T::state(),
+            #[cfg(feature = "_nrf54l")]
+            clk: T::clk(),
             _p: PhantomData {},
         };
 
@@ -238,13 +346,13 @@ impl<'d> Spim<'d> {
 
         // Set up the DMA read.
         let (rx_ptr, rx_len) = xfer_params(rx as *mut u8 as _, rx.len() as _, offset, length);
-        r.rxd().ptr().write_value(rx_ptr);
-        r.rxd().maxcnt().write(|w| w.set_maxcnt(rx_len as _));
+        r.dma().rx().ptr().write_value(rx_ptr);
+        r.dma().rx().maxcnt().write(|w| w.set_maxcnt(rx_len as _));
 
         // Set up the DMA write.
         let (tx_ptr, tx_len) = xfer_params(tx as *const u8 as _, tx.len() as _, offset, length);
-        r.txd().ptr().write_value(tx_ptr);
-        r.txd().maxcnt().write(|w| w.set_maxcnt(tx_len as _));
+        r.dma().tx().ptr().write_value(tx_ptr);
+        r.dma().tx().maxcnt().write(|w| w.set_maxcnt(tx_len as _));
 
         /*
         trace!("XFER: offset: {}, length: {}", offset, length);
@@ -259,8 +367,8 @@ impl<'d> Spim<'d> {
             r.events_started().write_value(0);
 
             // Set rx/tx buffer lengths to 0...
-            r.txd().maxcnt().write(|_| ());
-            r.rxd().maxcnt().write(|_| ());
+            r.dma().tx().maxcnt().write(|_| ());
+            r.dma().rx().maxcnt().write(|_| ());
 
             // ...and keep track of original buffer lengths...
             s.tx.store(tx_len as _, Ordering::Relaxed);
@@ -447,8 +555,14 @@ impl<'d> Spim<'d> {
             r.events_end().write_value(0);
 
             // Update DMA registers with correct rx/tx buffer sizes
-            r.rxd().maxcnt().write(|w| w.set_maxcnt(s.rx.load(Ordering::Relaxed)));
-            r.txd().maxcnt().write(|w| w.set_maxcnt(s.tx.load(Ordering::Relaxed)));
+            r.dma()
+                .rx()
+                .maxcnt()
+                .write(|w| w.set_maxcnt(s.rx.load(Ordering::Relaxed)));
+            r.dma()
+                .tx()
+                .maxcnt()
+                .write(|w| w.set_maxcnt(s.tx.load(Ordering::Relaxed)));
 
             r.intenset().write(|w| w.set_end(true));
             // ... and start actual, hopefully glitch-free transmission
@@ -503,6 +617,8 @@ impl State {
 pub(crate) trait SealedInstance {
     fn regs() -> pac::spim::Spim;
     fn state() -> &'static State;
+    #[cfg(feature = "_nrf54l")]
+    fn clk() -> u32;
 }
 
 /// SPIM peripheral instance
@@ -512,6 +628,28 @@ pub trait Instance: SealedInstance + PeripheralType + 'static {
     type Interrupt: interrupt::typelevel::Interrupt;
 }
 
+#[cfg(feature = "_nrf54l")]
+macro_rules! impl_spim {
+    ($type:ident, $pac_type:ident, $irq:ident, $clk:expr) => {
+        impl crate::spim::SealedInstance for peripherals::$type {
+            fn regs() -> pac::spim::Spim {
+                pac::$pac_type
+            }
+            fn state() -> &'static crate::spim::State {
+                static STATE: crate::spim::State = crate::spim::State::new();
+                &STATE
+            }
+            fn clk() -> u32 {
+                $clk
+            }
+        }
+        impl crate::spim::Instance for peripherals::$type {
+            type Interrupt = crate::interrupt::typelevel::$irq;
+        }
+    };
+}
+
+#[cfg(not(feature = "_nrf54l"))]
 macro_rules! impl_spim {
     ($type:ident, $pac_type:ident, $irq:ident) => {
         impl crate::spim::SealedInstance for peripherals::$type {
@@ -638,7 +776,12 @@ impl<'d> SetConfig for Spim<'d> {
 
         // Configure frequency.
         let frequency = config.frequency;
-        r.frequency().write(|w| w.set_frequency(frequency));
+        #[cfg(not(feature = "_nrf54l"))]
+        r.frequency().write(|w| w.set_frequency(frequency.into()));
+        #[cfg(feature = "_nrf54l")]
+        {
+            r.prescaler().write(|w| w.set_divisor(frequency.to_divisor(self.clk)));
+        }
 
         // Set over-read character
         let orc = config.orc;
diff --git a/embassy-nrf/src/spis.rs b/embassy-nrf/src/spis.rs
index 885821146..96a9c0ae0 100644
--- a/embassy-nrf/src/spis.rs
+++ b/embassy-nrf/src/spis.rs
@@ -224,15 +224,15 @@ impl<'d> Spis<'d> {
         if tx.len() > EASY_DMA_SIZE {
             return Err(Error::TxBufferTooLong);
         }
-        r.txd().ptr().write_value(tx as *const u8 as _);
-        r.txd().maxcnt().write(|w| w.set_maxcnt(tx.len() as _));
+        r.dma().tx().ptr().write_value(tx as *const u8 as _);
+        r.dma().tx().maxcnt().write(|w| w.set_maxcnt(tx.len() as _));
 
         // Set up the DMA read.
         if rx.len() > EASY_DMA_SIZE {
             return Err(Error::RxBufferTooLong);
         }
-        r.rxd().ptr().write_value(rx as *mut u8 as _);
-        r.rxd().maxcnt().write(|w| w.set_maxcnt(rx.len() as _));
+        r.dma().rx().ptr().write_value(rx as *mut u8 as _);
+        r.dma().rx().maxcnt().write(|w| w.set_maxcnt(rx.len() as _));
 
         // Reset end event.
         r.events_end().write_value(0);
@@ -260,8 +260,8 @@ impl<'d> Spis<'d> {
         // Wait for 'end' event.
         while r.events_end().read() == 0 {}
 
-        let n_rx = r.rxd().amount().read().0 as usize;
-        let n_tx = r.txd().amount().read().0 as usize;
+        let n_rx = r.dma().rx().amount().read().0 as usize;
+        let n_tx = r.dma().tx().amount().read().0 as usize;
 
         compiler_fence(Ordering::SeqCst);
 
@@ -326,8 +326,8 @@ impl<'d> Spis<'d> {
         })
         .await;
 
-        let n_rx = r.rxd().amount().read().0 as usize;
-        let n_tx = r.txd().amount().read().0 as usize;
+        let n_rx = r.dma().rx().amount().read().0 as usize;
+        let n_tx = r.dma().tx().amount().read().0 as usize;
 
         compiler_fence(Ordering::SeqCst);
 
diff --git a/embassy-nrf/src/twim.rs b/embassy-nrf/src/twim.rs
index 93255c832..abf9a923f 100644
--- a/embassy-nrf/src/twim.rs
+++ b/embassy-nrf/src/twim.rs
@@ -141,10 +141,19 @@ impl<'d> Twim<'d> {
         sda.conf().write(|w| {
             w.set_dir(gpiovals::Dir::OUTPUT);
             w.set_input(gpiovals::Input::CONNECT);
+            #[cfg(not(feature = "_nrf54l"))]
             w.set_drive(match config.sda_high_drive {
                 true => gpiovals::Drive::H0D1,
                 false => gpiovals::Drive::S0D1,
             });
+            #[cfg(feature = "_nrf54l")]
+            {
+                w.set_drive0(match config.sda_high_drive {
+                    true => gpiovals::Drive::H,
+                    false => gpiovals::Drive::S,
+                });
+                w.set_drive1(gpiovals::Drive::D);
+            }
             if config.sda_pullup {
                 w.set_pull(gpiovals::Pull::PULLUP);
             }
@@ -152,10 +161,19 @@ impl<'d> Twim<'d> {
         scl.conf().write(|w| {
             w.set_dir(gpiovals::Dir::OUTPUT);
             w.set_input(gpiovals::Input::CONNECT);
+            #[cfg(not(feature = "_nrf54l"))]
             w.set_drive(match config.scl_high_drive {
                 true => gpiovals::Drive::H0D1,
                 false => gpiovals::Drive::S0D1,
             });
+            #[cfg(feature = "_nrf54l")]
+            {
+                w.set_drive0(match config.scl_high_drive {
+                    true => gpiovals::Drive::H,
+                    false => gpiovals::Drive::S,
+                });
+                w.set_drive1(gpiovals::Drive::D);
+            }
             if config.sda_pullup {
                 w.set_pull(gpiovals::Pull::PULLUP);
             }
@@ -210,8 +228,8 @@ impl<'d> Twim<'d> {
         // We're giving the register a pointer to the stack. Since we're
         // waiting for the I2C transaction to end before this stack pointer
         // becomes invalid, there's nothing wrong here.
-        r.txd().ptr().write_value(buffer.as_ptr() as u32);
-        r.txd().maxcnt().write(|w|
+        r.dma().tx().ptr().write_value(buffer.as_ptr() as u32);
+        r.dma().tx().maxcnt().write(|w|
             // We're giving it the length of the buffer, so no danger of
             // accessing invalid memory. We have verified that the length of the
             // buffer fits in an `u8`, so the cast to `u8` is also fine.
@@ -237,8 +255,8 @@ impl<'d> Twim<'d> {
         // We're giving the register a pointer to the stack. Since we're
         // waiting for the I2C transaction to end before this stack pointer
         // becomes invalid, there's nothing wrong here.
-        r.rxd().ptr().write_value(buffer.as_mut_ptr() as u32);
-        r.rxd().maxcnt().write(|w|
+        r.dma().rx().ptr().write_value(buffer.as_mut_ptr() as u32);
+        r.dma().rx().maxcnt().write(|w|
             // We're giving it the length of the buffer, so no danger of
             // accessing invalid memory. We have verified that the length of the
             // buffer fits in an `u8`, so the cast to the type of maxcnt
@@ -281,7 +299,7 @@ impl<'d> Twim<'d> {
 
     fn check_rx(&self, len: usize) -> Result<(), Error> {
         let r = self.r;
-        if r.rxd().amount().read().0 != len as u32 {
+        if r.dma().rx().amount().read().0 != len as u32 {
             Err(Error::Receive)
         } else {
             Ok(())
@@ -290,7 +308,7 @@ impl<'d> Twim<'d> {
 
     fn check_tx(&self, len: usize) -> Result<(), Error> {
         let r = self.r;
-        if r.txd().amount().read().0 != len as u32 {
+        if r.dma().tx().amount().read().0 != len as u32 {
             Err(Error::Transmit)
         } else {
             Ok(())
@@ -412,7 +430,7 @@ impl<'d> Twim<'d> {
                 }
 
                 r.shorts().write(|w| {
-                    w.set_lastrx_starttx(true);
+                    w.set_lastrx_dma_tx_start(true);
                     if stop {
                         w.set_lasttx_stop(true);
                     } else {
@@ -421,7 +439,7 @@ impl<'d> Twim<'d> {
                 });
 
                 // Start read+write operation.
-                r.tasks_startrx().write_value(1);
+                r.tasks_dma().rx().start().write_value(1);
                 if last_op.is_some() {
                     r.tasks_resume().write_value(1);
                 }
@@ -429,7 +447,7 @@ impl<'d> Twim<'d> {
                 // TODO: Handle empty write buffer
                 if rd_buffer.is_empty() {
                     // With a zero-length buffer, LASTRX doesn't fire (because there's no last byte!), so do the STARTTX ourselves.
-                    r.tasks_starttx().write_value(1);
+                    r.tasks_dma().tx().start().write_value(1);
                 }
 
                 Ok(2)
@@ -443,7 +461,7 @@ impl<'d> Twim<'d> {
                 r.shorts().write(|w| w.set_lastrx_stop(true));
 
                 // Start read operation.
-                r.tasks_startrx().write_value(1);
+                r.tasks_dma().rx().start().write_value(1);
                 if last_op.is_some() {
                     r.tasks_resume().write_value(1);
                 }
@@ -466,11 +484,11 @@ impl<'d> Twim<'d> {
 
                 // Start write+read operation.
                 r.shorts().write(|w| {
-                    w.set_lasttx_startrx(true);
+                    w.set_lasttx_dma_rx_start(true);
                     w.set_lastrx_stop(true);
                 });
 
-                r.tasks_starttx().write_value(1);
+                r.tasks_dma().tx().start().write_value(1);
                 if last_op.is_some() {
                     r.tasks_resume().write_value(1);
                 }
@@ -494,7 +512,7 @@ impl<'d> Twim<'d> {
                     }
                 });
 
-                r.tasks_starttx().write_value(1);
+                r.tasks_dma().tx().start().write_value(1);
                 if last_op.is_some() {
                     r.tasks_resume().write_value(1);
                 }
diff --git a/embassy-nrf/src/twis.rs b/embassy-nrf/src/twis.rs
index 2bc0a5c13..b3a699f71 100644
--- a/embassy-nrf/src/twis.rs
+++ b/embassy-nrf/src/twis.rs
@@ -161,10 +161,19 @@ impl<'d> Twis<'d> {
         sda.conf().write(|w| {
             w.set_dir(gpiovals::Dir::INPUT);
             w.set_input(gpiovals::Input::CONNECT);
+            #[cfg(not(feature = "_nrf54l"))]
             w.set_drive(match config.sda_high_drive {
                 true => gpiovals::Drive::H0D1,
                 false => gpiovals::Drive::S0D1,
             });
+            #[cfg(feature = "_nrf54l")]
+            {
+                w.set_drive0(match config.sda_high_drive {
+                    true => gpiovals::Drive::H,
+                    false => gpiovals::Drive::S,
+                });
+                w.set_drive1(gpiovals::Drive::D);
+            }
             if config.sda_pullup {
                 w.set_pull(gpiovals::Pull::PULLUP);
             }
@@ -172,10 +181,19 @@ impl<'d> Twis<'d> {
         scl.conf().write(|w| {
             w.set_dir(gpiovals::Dir::INPUT);
             w.set_input(gpiovals::Input::CONNECT);
+            #[cfg(not(feature = "_nrf54l"))]
             w.set_drive(match config.scl_high_drive {
                 true => gpiovals::Drive::H0D1,
                 false => gpiovals::Drive::S0D1,
             });
+            #[cfg(feature = "_nrf54l")]
+            {
+                w.set_drive0(match config.scl_high_drive {
+                    true => gpiovals::Drive::H,
+                    false => gpiovals::Drive::S,
+                });
+                w.set_drive1(gpiovals::Drive::D);
+            }
             if config.sda_pullup {
                 w.set_pull(gpiovals::Pull::PULLUP);
             }
@@ -228,8 +246,8 @@ impl<'d> Twis<'d> {
         // We're giving the register a pointer to the stack. Since we're
         // waiting for the I2C transaction to end before this stack pointer
         // becomes invalid, there's nothing wrong here.
-        r.txd().ptr().write_value(buffer.as_ptr() as u32);
-        r.txd().maxcnt().write(|w|
+        r.dma().tx().ptr().write_value(buffer.as_ptr() as u32);
+        r.dma().tx().maxcnt().write(|w|
             // We're giving it the length of the buffer, so no danger of
             // accessing invalid memory. We have verified that the length of the
             // buffer fits in an `u8`, so the cast to `u8` is also fine.
@@ -255,8 +273,8 @@ impl<'d> Twis<'d> {
         // We're giving the register a pointer to the stack. Since we're
         // waiting for the I2C transaction to end before this stack pointer
         // becomes invalid, there's nothing wrong here.
-        r.rxd().ptr().write_value(buffer.as_mut_ptr() as u32);
-        r.rxd().maxcnt().write(|w|
+        r.dma().rx().ptr().write_value(buffer.as_mut_ptr() as u32);
+        r.dma().rx().maxcnt().write(|w|
             // We're giving it the length of the buffer, so no danger of
             // accessing invalid memory. We have verified that the length of the
             // buffer fits in an `u8`, so the cast to the type of maxcnt
@@ -330,13 +348,13 @@ impl<'d> Twis<'d> {
                 return match status {
                     Status::Read => Ok(Command::Read),
                     Status::Write => {
-                        let n = r.rxd().amount().read().0 as usize;
+                        let n = r.dma().rx().amount().read().0 as usize;
                         Ok(Command::Write(n))
                     }
                 };
             } else if r.events_read().read() != 0 {
                 r.events_read().write_value(0);
-                let n = r.rxd().amount().read().0 as usize;
+                let n = r.dma().rx().amount().read().0 as usize;
                 return Ok(Command::WriteRead(n));
             }
         }
@@ -360,7 +378,7 @@ impl<'d> Twis<'d> {
                 }
             } else if r.events_stopped().read() != 0 {
                 r.events_stopped().write_value(0);
-                let n = r.txd().amount().read().0 as usize;
+                let n = r.dma().tx().amount().read().0 as usize;
                 return Ok(n);
             }
         }
@@ -386,7 +404,7 @@ impl<'d> Twis<'d> {
                 }
             } else if r.events_stopped().read() != 0 {
                 r.events_stopped().write_value(0);
-                let n = r.txd().amount().read().0 as usize;
+                let n = r.dma().tx().amount().read().0 as usize;
                 return Ok(n);
             } else if Instant::now() > deadline {
                 r.tasks_stop().write_value(1);
@@ -442,13 +460,13 @@ impl<'d> Twis<'d> {
                 return match status {
                     Status::Read => Ok(Command::Read),
                     Status::Write => {
-                        let n = r.rxd().amount().read().0 as usize;
+                        let n = r.dma().rx().amount().read().0 as usize;
                         Ok(Command::Write(n))
                     }
                 };
             } else if r.events_read().read() != 0 {
                 r.events_read().write_value(0);
-                let n = r.rxd().amount().read().0 as usize;
+                let n = r.dma().rx().amount().read().0 as usize;
                 return Ok(Command::WriteRead(n));
             } else if Instant::now() > deadline {
                 r.tasks_stop().write_value(1);
@@ -478,7 +496,7 @@ impl<'d> Twis<'d> {
                 }
             } else if r.events_stopped().read() != 0 {
                 r.events_stopped().write_value(0);
-                let n = r.txd().amount().read().0 as usize;
+                let n = r.dma().tx().amount().read().0 as usize;
                 return Poll::Ready(Ok(n));
             }
 
@@ -529,13 +547,13 @@ impl<'d> Twis<'d> {
                 return match status {
                     Status::Read => Poll::Ready(Ok(Command::Read)),
                     Status::Write => {
-                        let n = r.rxd().amount().read().0 as usize;
+                        let n = r.dma().rx().amount().read().0 as usize;
                         Poll::Ready(Ok(Command::Write(n)))
                     }
                 };
             } else if r.events_read().read() != 0 {
                 r.events_read().write_value(0);
-                let n = r.rxd().amount().read().0 as usize;
+                let n = r.dma().rx().amount().read().0 as usize;
                 return Poll::Ready(Ok(Command::WriteRead(n)));
             }
             Poll::Pending
diff --git a/embassy-nrf/src/uarte.rs b/embassy-nrf/src/uarte.rs
index 1ee452173..049830aed 100644
--- a/embassy-nrf/src/uarte.rs
+++ b/embassy-nrf/src/uarte.rs
@@ -113,20 +113,20 @@ impl<T: Instance> interrupt::typelevel::Handler<T::Interrupt> for InterruptHandl
         let r = T::regs();
         let s = T::state();
 
-        let endrx = r.events_endrx().read();
+        let endrx = r.events_dma().rx().end().read();
         let error = r.events_error().read();
         if endrx != 0 || error != 0 {
             s.rx_waker.wake();
             if endrx != 0 {
-                r.intenclr().write(|w| w.set_endrx(true));
+                r.intenclr().write(|w| w.set_dmarxend(true));
             }
             if error != 0 {
                 r.intenclr().write(|w| w.set_error(true));
             }
         }
-        if r.events_endtx().read() != 0 {
+        if r.events_dma().tx().end().read() != 0 {
             s.tx_waker.wake();
-            r.intenclr().write(|w| w.set_endtx(true));
+            r.intenclr().write(|w| w.set_dmatxend(true));
         }
     }
 }
@@ -257,7 +257,7 @@ impl<'d> Uarte<'d> {
     /// Return the endtx event for use with PPI
     pub fn event_endtx(&self) -> Event<'_> {
         let r = self.tx.r;
-        Event::from_reg(r.events_endtx())
+        Event::from_reg(r.events_dma().tx().end())
     }
 
     /// Read bytes until the buffer is filled.
@@ -296,7 +296,13 @@ pub(crate) fn configure_tx_pins(r: pac::uarte::Uarte, txd: Peri<'_, AnyPin>, cts
     txd.conf().write(|w| {
         w.set_dir(gpiovals::Dir::OUTPUT);
         w.set_input(gpiovals::Input::DISCONNECT);
+        #[cfg(not(feature = "_nrf54l"))]
         w.set_drive(gpiovals::Drive::H0H1);
+        #[cfg(feature = "_nrf54l")]
+        {
+            w.set_drive0(gpiovals::Drive::H);
+            w.set_drive1(gpiovals::Drive::H);
+        }
     });
     r.psel().txd().write_value(txd.psel_bits());
 
@@ -304,7 +310,13 @@ pub(crate) fn configure_tx_pins(r: pac::uarte::Uarte, txd: Peri<'_, AnyPin>, cts
         pin.conf().write(|w| {
             w.set_dir(gpiovals::Dir::INPUT);
             w.set_input(gpiovals::Input::CONNECT);
+            #[cfg(not(feature = "_nrf54l"))]
             w.set_drive(gpiovals::Drive::H0H1);
+            #[cfg(feature = "_nrf54l")]
+            {
+                w.set_drive0(gpiovals::Drive::H);
+                w.set_drive1(gpiovals::Drive::H);
+            }
         });
     }
     r.psel().cts().write_value(cts.psel_bits());
@@ -314,7 +326,13 @@ pub(crate) fn configure_rx_pins(r: pac::uarte::Uarte, rxd: Peri<'_, AnyPin>, rts
     rxd.conf().write(|w| {
         w.set_dir(gpiovals::Dir::INPUT);
         w.set_input(gpiovals::Input::CONNECT);
+        #[cfg(not(feature = "_nrf54l"))]
         w.set_drive(gpiovals::Drive::H0H1);
+        #[cfg(feature = "_nrf54l")]
+        {
+            w.set_drive0(gpiovals::Drive::H);
+            w.set_drive1(gpiovals::Drive::H);
+        }
     });
     r.psel().rxd().write_value(rxd.psel_bits());
 
@@ -323,7 +341,13 @@ pub(crate) fn configure_rx_pins(r: pac::uarte::Uarte, rxd: Peri<'_, AnyPin>, rts
         pin.conf().write(|w| {
             w.set_dir(gpiovals::Dir::OUTPUT);
             w.set_input(gpiovals::Input::DISCONNECT);
+            #[cfg(not(feature = "_nrf54l"))]
             w.set_drive(gpiovals::Drive::H0H1);
+            #[cfg(feature = "_nrf54l")]
+            {
+                w.set_drive0(gpiovals::Drive::H);
+                w.set_drive1(gpiovals::Drive::H);
+            }
         });
     }
     r.psel().rts().write_value(rts.psel_bits());
@@ -333,6 +357,10 @@ pub(crate) fn configure(r: pac::uarte::Uarte, config: Config, hardware_flow_cont
     r.config().write(|w| {
         w.set_hwfc(hardware_flow_control);
         w.set_parity(config.parity);
+        #[cfg(feature = "_nrf54l")]
+        w.set_framesize(vals::Framesize::_8BIT);
+        #[cfg(feature = "_nrf54l")]
+        w.set_frametimeout(true);
     });
     r.baudrate().write(|w| w.set_baudrate(config.baudrate));
 
@@ -341,8 +369,8 @@ pub(crate) fn configure(r: pac::uarte::Uarte, config: Config, hardware_flow_cont
 
     // Reset rxstarted, txstarted. These are used by drop to know whether a transfer was
     // stopped midway or not.
-    r.events_rxstarted().write_value(0);
-    r.events_txstarted().write_value(0);
+    r.events_dma().rx().ready().write_value(0);
+    r.events_dma().tx().ready().write_value(0);
 
     // reset all pins
     r.psel().txd().write_value(DISCONNECTED);
@@ -434,29 +462,29 @@ impl<'d> UarteTx<'d> {
         let drop = OnDrop::new(move || {
             trace!("write drop: stopping");
 
-            r.intenclr().write(|w| w.set_endtx(true));
+            r.intenclr().write(|w| w.set_dmatxend(true));
             r.events_txstopped().write_value(0);
-            r.tasks_stoptx().write_value(1);
+            r.tasks_dma().tx().stop().write_value(1);
 
             // TX is stopped almost instantly, spinning is fine.
-            while r.events_endtx().read() == 0 {}
+            while r.events_dma().tx().end().read() == 0 {}
             trace!("write drop: stopped");
         });
 
-        r.txd().ptr().write_value(ptr as u32);
-        r.txd().maxcnt().write(|w| w.set_maxcnt(len as _));
+        r.dma().tx().ptr().write_value(ptr as u32);
+        r.dma().tx().maxcnt().write(|w| w.set_maxcnt(len as _));
 
-        r.events_endtx().write_value(0);
-        r.intenset().write(|w| w.set_endtx(true));
+        r.events_dma().tx().end().write_value(0);
+        r.intenset().write(|w| w.set_dmatxend(true));
 
         compiler_fence(Ordering::SeqCst);
 
         trace!("starttx");
-        r.tasks_starttx().write_value(1);
+        r.tasks_dma().tx().start().write_value(1);
 
         poll_fn(|cx| {
             s.tx_waker.register(cx.waker());
-            if r.events_endtx().read() != 0 {
+            if r.events_dma().tx().end().read() != 0 {
                 return Poll::Ready(());
             }
             Poll::Pending
@@ -464,7 +492,7 @@ impl<'d> UarteTx<'d> {
         .await;
 
         compiler_fence(Ordering::SeqCst);
-        r.events_txstarted().write_value(0);
+        r.events_dma().tx().ready().write_value(0);
         drop.defuse();
 
         Ok(())
@@ -500,21 +528,21 @@ impl<'d> UarteTx<'d> {
 
         let r = self.r;
 
-        r.txd().ptr().write_value(ptr as u32);
-        r.txd().maxcnt().write(|w| w.set_maxcnt(len as _));
+        r.dma().tx().ptr().write_value(ptr as u32);
+        r.dma().tx().maxcnt().write(|w| w.set_maxcnt(len as _));
 
-        r.events_endtx().write_value(0);
-        r.intenclr().write(|w| w.set_endtx(true));
+        r.events_dma().tx().end().write_value(0);
+        r.intenclr().write(|w| w.set_dmatxend(true));
 
         compiler_fence(Ordering::SeqCst);
 
         trace!("starttx");
-        r.tasks_starttx().write_value(1);
+        r.tasks_dma().tx().start().write_value(1);
 
-        while r.events_endtx().read() == 0 {}
+        while r.events_dma().tx().end().read() == 0 {}
 
         compiler_fence(Ordering::SeqCst);
-        r.events_txstarted().write_value(0);
+        r.events_dma().tx().ready().write_value(0);
 
         Ok(())
     }
@@ -526,7 +554,7 @@ impl<'a> Drop for UarteTx<'a> {
 
         let r = self.r;
 
-        let did_stoptx = r.events_txstarted().read() != 0;
+        let did_stoptx = r.events_dma().tx().ready().read() != 0;
         trace!("did_stoptx {}", did_stoptx);
 
         // Wait for txstopped, if needed.
@@ -629,7 +657,7 @@ impl<'d> UarteRx<'d> {
         let mut ppi_ch2 = Ppi::new_one_to_one(
             ppi_ch2.into(),
             timer.cc(0).event_compare(),
-            Task::from_reg(r.tasks_stoprx()),
+            Task::from_reg(r.tasks_dma().rx().stop()),
         );
         ppi_ch2.enable();
 
@@ -664,41 +692,41 @@ impl<'d> UarteRx<'d> {
             trace!("read drop: stopping");
 
             r.intenclr().write(|w| {
-                w.set_endrx(true);
+                w.set_dmarxend(true);
                 w.set_error(true);
             });
             r.events_rxto().write_value(0);
             r.events_error().write_value(0);
-            r.tasks_stoprx().write_value(1);
+            r.tasks_dma().rx().stop().write_value(1);
 
-            while r.events_endrx().read() == 0 {}
+            while r.events_dma().rx().end().read() == 0 {}
 
             trace!("read drop: stopped");
         });
 
-        r.rxd().ptr().write_value(ptr as u32);
-        r.rxd().maxcnt().write(|w| w.set_maxcnt(len as _));
+        r.dma().rx().ptr().write_value(ptr as u32);
+        r.dma().rx().maxcnt().write(|w| w.set_maxcnt(len as _));
 
-        r.events_endrx().write_value(0);
+        r.events_dma().rx().end().write_value(0);
         r.events_error().write_value(0);
         r.intenset().write(|w| {
-            w.set_endrx(true);
+            w.set_dmarxend(true);
             w.set_error(true);
         });
 
         compiler_fence(Ordering::SeqCst);
 
         trace!("startrx");
-        r.tasks_startrx().write_value(1);
+        r.tasks_dma().rx().start().write_value(1);
 
         let result = poll_fn(|cx| {
             s.rx_waker.register(cx.waker());
 
             if let Err(e) = self.check_and_clear_errors() {
-                r.tasks_stoprx().write_value(1);
+                r.tasks_dma().rx().stop().write_value(1);
                 return Poll::Ready(Err(e));
             }
-            if r.events_endrx().read() != 0 {
+            if r.events_dma().rx().end().read() != 0 {
                 return Poll::Ready(Ok(()));
             }
             Poll::Pending
@@ -706,7 +734,7 @@ impl<'d> UarteRx<'d> {
         .await;
 
         compiler_fence(Ordering::SeqCst);
-        r.events_rxstarted().write_value(0);
+        r.events_dma().rx().ready().write_value(0);
         drop.defuse();
 
         result
@@ -726,25 +754,25 @@ impl<'d> UarteRx<'d> {
 
         let r = self.r;
 
-        r.rxd().ptr().write_value(ptr as u32);
-        r.rxd().maxcnt().write(|w| w.set_maxcnt(len as _));
+        r.dma().rx().ptr().write_value(ptr as u32);
+        r.dma().rx().maxcnt().write(|w| w.set_maxcnt(len as _));
 
-        r.events_endrx().write_value(0);
+        r.events_dma().rx().end().write_value(0);
         r.events_error().write_value(0);
         r.intenclr().write(|w| {
-            w.set_endrx(true);
+            w.set_dmarxend(true);
             w.set_error(true);
         });
 
         compiler_fence(Ordering::SeqCst);
 
         trace!("startrx");
-        r.tasks_startrx().write_value(1);
+        r.tasks_dma().rx().start().write_value(1);
 
-        while r.events_endrx().read() == 0 && r.events_error().read() == 0 {}
+        while r.events_dma().rx().end().read() == 0 && r.events_error().read() == 0 {}
 
         compiler_fence(Ordering::SeqCst);
-        r.events_rxstarted().write_value(0);
+        r.events_dma().rx().ready().write_value(0);
 
         self.check_and_clear_errors()
     }
@@ -756,7 +784,7 @@ impl<'a> Drop for UarteRx<'a> {
 
         let r = self.r;
 
-        let did_stoprx = r.events_rxstarted().read() != 0;
+        let did_stoprx = r.events_dma().rx().ready().read() != 0;
         trace!("did_stoprx {}", did_stoprx);
 
         // Wait for rxto, if needed.
@@ -816,38 +844,38 @@ impl<'d> UarteRxWithIdle<'d> {
             self.timer.stop();
 
             r.intenclr().write(|w| {
-                w.set_endrx(true);
+                w.set_dmarxend(true);
                 w.set_error(true);
             });
             r.events_rxto().write_value(0);
             r.events_error().write_value(0);
-            r.tasks_stoprx().write_value(1);
+            r.tasks_dma().rx().stop().write_value(1);
 
-            while r.events_endrx().read() == 0 {}
+            while r.events_dma().rx().end().read() == 0 {}
         });
 
-        r.rxd().ptr().write_value(ptr as u32);
-        r.rxd().maxcnt().write(|w| w.set_maxcnt(len as _));
+        r.dma().rx().ptr().write_value(ptr as u32);
+        r.dma().rx().maxcnt().write(|w| w.set_maxcnt(len as _));
 
-        r.events_endrx().write_value(0);
+        r.events_dma().rx().end().write_value(0);
         r.events_error().write_value(0);
         r.intenset().write(|w| {
-            w.set_endrx(true);
+            w.set_dmarxend(true);
             w.set_error(true);
         });
 
         compiler_fence(Ordering::SeqCst);
 
-        r.tasks_startrx().write_value(1);
+        r.tasks_dma().rx().start().write_value(1);
 
         let result = poll_fn(|cx| {
             s.rx_waker.register(cx.waker());
 
             if let Err(e) = self.rx.check_and_clear_errors() {
-                r.tasks_stoprx().write_value(1);
+                r.tasks_dma().rx().stop().write_value(1);
                 return Poll::Ready(Err(e));
             }
-            if r.events_endrx().read() != 0 {
+            if r.events_dma().rx().end().read() != 0 {
                 return Poll::Ready(Ok(()));
             }
 
@@ -856,10 +884,10 @@ impl<'d> UarteRxWithIdle<'d> {
         .await;
 
         compiler_fence(Ordering::SeqCst);
-        let n = r.rxd().amount().read().0 as usize;
+        let n = r.dma().rx().amount().read().0 as usize;
 
         self.timer.stop();
-        r.events_rxstarted().write_value(0);
+        r.events_dma().rx().ready().write_value(0);
 
         drop.defuse();
 
@@ -884,27 +912,27 @@ impl<'d> UarteRxWithIdle<'d> {
 
         self.ppi_ch1.enable();
 
-        r.rxd().ptr().write_value(ptr as u32);
-        r.rxd().maxcnt().write(|w| w.set_maxcnt(len as _));
+        r.dma().rx().ptr().write_value(ptr as u32);
+        r.dma().rx().maxcnt().write(|w| w.set_maxcnt(len as _));
 
-        r.events_endrx().write_value(0);
+        r.events_dma().rx().end().write_value(0);
         r.events_error().write_value(0);
         r.intenclr().write(|w| {
-            w.set_endrx(true);
+            w.set_dmarxend(true);
             w.set_error(true);
         });
 
         compiler_fence(Ordering::SeqCst);
 
-        r.tasks_startrx().write_value(1);
+        r.tasks_dma().rx().start().write_value(1);
 
-        while r.events_endrx().read() == 0 && r.events_error().read() == 0 {}
+        while r.events_dma().rx().end().read() == 0 && r.events_error().read() == 0 {}
 
         compiler_fence(Ordering::SeqCst);
-        let n = r.rxd().amount().read().0 as usize;
+        let n = r.dma().rx().amount().read().0 as usize;
 
         self.timer.stop();
-        r.events_rxstarted().write_value(0);
+        r.events_dma().rx().ready().write_value(0);
 
         self.rx.check_and_clear_errors().map(|_| n)
     }
@@ -927,14 +955,14 @@ pub(crate) fn apply_workaround_for_enable_anomaly(r: pac::uarte::Uarte) {
     // NB Safety: This is taken from Nordic's driver -
     // https://github.com/NordicSemiconductor/nrfx/blob/master/drivers/src/nrfx_uarte.c#L197
     if unsafe { core::ptr::read_volatile(txenable_reg) } == 1 {
-        r.tasks_stoptx().write_value(1);
+        r.tasks_dma().tx().stop().write_value(1);
     }
 
     // NB Safety: This is taken from Nordic's driver -
     // https://github.com/NordicSemiconductor/nrfx/blob/master/drivers/src/nrfx_uarte.c#L197
     if unsafe { core::ptr::read_volatile(rxenable_reg) } == 1 {
         r.enable().write(|w| w.set_enable(vals::Enable::ENABLED));
-        r.tasks_stoprx().write_value(1);
+        r.tasks_dma().rx().stop().write_value(1);
 
         let mut workaround_succeded = false;
         // The UARTE is able to receive up to four bytes after the STOPRX task has been triggered.
@@ -948,6 +976,14 @@ pub(crate) fn apply_workaround_for_enable_anomaly(r: pac::uarte::Uarte) {
                 break;
             } else {
                 // Need to sleep for 1us here
+
+                // Get the worst case clock speed
+                #[cfg(feature = "_nrf9160")]
+                const CLOCK_SPEED: u32 = 64_000_000;
+                #[cfg(feature = "_nrf5340")]
+                const CLOCK_SPEED: u32 = 128_000_000;
+
+                cortex_m::asm::delay(CLOCK_SPEED / 1_000_000);
             }
         }
 
diff --git a/embassy-nxp/CHANGELOG.md b/embassy-nxp/CHANGELOG.md
index 0fb677cd8..39f5c75bd 100644
--- a/embassy-nxp/CHANGELOG.md
+++ b/embassy-nxp/CHANGELOG.md
@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!-- next-header -->
 ## Unreleased - ReleaseDate
+- LPC55: PWM simple
+- LPC55: Move ALT definitions for USART to TX/RX pin impls. 
+- LPC55: Remove internal match_iocon macro
 - LPC55: DMA Controller and asynchronous version of USART
 - Moved NXP LPC55S69 from `lpc55-pac` to `nxp-pac`
 - First release with changelog.
diff --git a/embassy-nxp/Cargo.toml b/embassy-nxp/Cargo.toml
index 33f0f2dff..f8c63ba29 100644
--- a/embassy-nxp/Cargo.toml
+++ b/embassy-nxp/Cargo.toml
@@ -38,13 +38,13 @@ embassy-time-queue-utils = { version = "0.3.0", path = "../embassy-time-queue-ut
 embedded-io = "0.6.1"
 embedded-hal-02 = { package = "embedded-hal", version = "0.2.6", features = ["unproven"] }
 ## Chip dependencies
-nxp-pac = { version = "0.1.0", optional = true, git = "https://github.com/i509VCB/nxp-pac", rev = "b736e3038254d593024aaa1a5a7b1f95a5728538"}
+nxp-pac = { version = "0.1.0", optional = true, git = "https://github.com/i509VCB/nxp-pac", rev = "477dfdbfd5e6c75c0730c56494b601c1b2257263"}
 
 imxrt-rt = { version = "0.1.7", optional = true, features = ["device"] }
 
 [build-dependencies]
 cfg_aliases = "0.2.1"
-nxp-pac = { version = "0.1.0", git = "https://github.com/i509VCB/nxp-pac", rev = "b736e3038254d593024aaa1a5a7b1f95a5728538", features = ["metadata"], optional = true }
+nxp-pac = { version = "0.1.0", git = "https://github.com/i509VCB/nxp-pac", rev = "477dfdbfd5e6c75c0730c56494b601c1b2257263", features = ["metadata"], optional = true }
 proc-macro2 = "1.0.95"
 quote = "1.0.15"
 
diff --git a/embassy-nxp/src/chips/lpc55.rs b/embassy-nxp/src/chips/lpc55.rs
index 9f4e7269f..e9addddb6 100644
--- a/embassy-nxp/src/chips/lpc55.rs
+++ b/embassy-nxp/src/chips/lpc55.rs
@@ -97,6 +97,18 @@ embassy_hal_internal::peripherals! {
     DMA_CH21,
     DMA_CH22,
 
+    // Pulse-Width Modulation Outputs.
+    PWM_OUTPUT0,
+    PWM_OUTPUT1,
+    PWM_OUTPUT2,
+    PWM_OUTPUT3,
+    PWM_OUTPUT4,
+    PWM_OUTPUT5,
+    PWM_OUTPUT6,
+    PWM_OUTPUT7,
+    PWM_OUTPUT8,
+    PWM_OUTPUT9,
+
     // Universal Synchronous/Asynchronous Receiver/Transmitter (USART) instances.
     USART0,
     USART1,
diff --git a/embassy-nxp/src/fmt.rs b/embassy-nxp/src/fmt.rs
index 27d41ace6..11275235e 100644
--- a/embassy-nxp/src/fmt.rs
+++ b/embassy-nxp/src/fmt.rs
@@ -1,5 +1,4 @@
 //! Copied from embassy-rp
-
 #![macro_use]
 #![allow(unused)]
 
diff --git a/embassy-nxp/src/gpio/lpc55.rs b/embassy-nxp/src/gpio/lpc55.rs
index ac8a27d4f..6039d8ca8 100644
--- a/embassy-nxp/src/gpio/lpc55.rs
+++ b/embassy-nxp/src/gpio/lpc55.rs
@@ -1,7 +1,8 @@
 use embassy_hal_internal::{PeripheralType, impl_peripheral};
 
+use crate::pac::common::{RW, Reg};
 use crate::pac::iocon::vals::{PioDigimode, PioMode};
-use crate::pac::{GPIO, IOCON, SYSCON};
+use crate::pac::{GPIO, IOCON, SYSCON, iocon};
 use crate::{Peri, peripherals};
 
 pub(crate) fn init() {
@@ -109,13 +110,7 @@ impl<'d> Input<'d> {
 
     /// Set the pull configuration for the pin. To disable the pull, use [Pull::None].
     pub fn set_pull(&mut self, pull: Pull) {
-        match_iocon!(register, self.pin.pin_bank(), self.pin.pin_number(), {
-            register.modify(|w| match pull {
-                Pull::None => w.set_mode(PioMode::INACTIVE),
-                Pull::Up => w.set_mode(PioMode::PULL_UP),
-                Pull::Down => w.set_mode(PioMode::PULL_DOWN),
-            });
-        });
+        self.pin.set_pull(pull);
     }
 
     /// Get the current input level of the pin.
@@ -193,11 +188,20 @@ impl<'d> Flex<'d> {
         1 << self.pin.pin_number()
     }
 
+    /// Set the pull configuration for the pin. To disable the pull, use [Pull::None].
+    pub fn set_pull(&mut self, pull: Pull) {
+        self.pin.pio().modify(|w| match pull {
+            Pull::None => w.set_mode(PioMode::INACTIVE),
+            Pull::Up => w.set_mode(PioMode::PULL_UP),
+            Pull::Down => w.set_mode(PioMode::PULL_DOWN),
+        });
+    }
+
     /// Set the pin to digital mode. This is required for using a pin as a GPIO pin. The default
     /// setting for pins is (usually) non-digital.
     fn set_as_digital(&mut self) {
-        match_iocon!(register, self.pin_bank(), self.pin_number(), {
-            register.modify(|w| w.set_digimode(PioDigimode::DIGITAL));
+        self.pin.pio().modify(|w| {
+            w.set_digimode(PioDigimode::DIGITAL);
         });
     }
 
@@ -220,6 +224,14 @@ impl<'d> Flex<'d> {
 pub(crate) trait SealedPin: Sized {
     fn pin_bank(&self) -> Bank;
     fn pin_number(&self) -> u8;
+
+    #[inline]
+    fn pio(&self) -> Reg<iocon::regs::Pio, RW> {
+        match self.pin_bank() {
+            Bank::Bank0 => IOCON.pio0(self.pin_number() as usize),
+            Bank::Bank1 => IOCON.pio1(self.pin_number() as usize),
+        }
+    }
 }
 
 /// Interface for a Pin that can be configured by an [Input] or [Output] driver, or converted to an
@@ -272,40 +284,6 @@ impl SealedPin for AnyPin {
     }
 }
 
-/// Match the pin bank and number of a pin to the corresponding IOCON register.
-///
-/// # Example
-/// ```
-/// use embassy_nxp::gpio::Bank;
-/// use embassy_nxp::pac_utils::{iocon_reg, match_iocon};
-///
-/// // Make pin PIO1_6 digital and set it to pull-down mode.
-/// match_iocon!(register, Bank::Bank1, 6, {
-///     register.modify(|w|{
-///         w.set_mode(PioMode::PULL_DOWN);
-///         w.set_digimode(PioDigimode::DIGITAL);
-///
-///     }
-/// });
-/// ```
-macro_rules! match_iocon {
-    ($register:ident, $pin_bank:expr, $pin_number:expr, $action:expr) => {
-        match $pin_bank {
-            Bank::Bank0 => {
-                let $register = IOCON.pio0($pin_number as usize);
-                $action;
-            }
-
-            Bank::Bank1 => {
-                let $register = IOCON.pio1($pin_number as usize);
-                $action;
-            }
-        }
-    };
-}
-
-pub(crate) use match_iocon;
-
 macro_rules! impl_pin {
     ($name:ident, $bank:expr, $pin_num:expr) => {
         impl Pin for peripherals::$name {}
diff --git a/embassy-nxp/src/lib.rs b/embassy-nxp/src/lib.rs
index 9576f02b1..4058881a5 100644
--- a/embassy-nxp/src/lib.rs
+++ b/embassy-nxp/src/lib.rs
@@ -10,6 +10,8 @@ pub mod gpio;
 #[cfg(feature = "lpc55-core0")]
 pub mod pint;
 #[cfg(feature = "lpc55-core0")]
+pub mod pwm;
+#[cfg(feature = "lpc55-core0")]
 pub mod usart;
 
 #[cfg(feature = "_time_driver")]
@@ -154,7 +156,10 @@ pub fn init(_config: config::Config) -> Peripherals {
     gpio::init();
 
     #[cfg(feature = "lpc55-core0")]
-    pint::init();
+    {
+        pint::init();
+        pwm::Pwm::reset();
+    }
 
     #[cfg(feature = "_time_driver")]
     time_driver::init();
diff --git a/embassy-nxp/src/pwm.rs b/embassy-nxp/src/pwm.rs
new file mode 100644
index 000000000..68980924a
--- /dev/null
+++ b/embassy-nxp/src/pwm.rs
@@ -0,0 +1,5 @@
+//! Pulse-Width Modulation (PWM) driver.
+
+#[cfg_attr(feature = "lpc55-core0", path = "./pwm/lpc55.rs")]
+mod inner;
+pub use inner::*;
diff --git a/embassy-nxp/src/pwm/lpc55.rs b/embassy-nxp/src/pwm/lpc55.rs
new file mode 100644
index 000000000..197184ad6
--- /dev/null
+++ b/embassy-nxp/src/pwm/lpc55.rs
@@ -0,0 +1,325 @@
+use core::sync::atomic::{AtomicU8, AtomicU32, Ordering};
+
+use embassy_hal_internal::{Peri, PeripheralType};
+
+use crate::gpio::AnyPin;
+use crate::pac::iocon::vals::{PioDigimode, PioFunc, PioMode, PioOd, PioSlew};
+use crate::pac::sct0::vals;
+use crate::pac::syscon::vals::{SctRst, SctclkselSel};
+use crate::pac::{SCT0, SYSCON};
+
+// Since for now the counter is shared, the TOP value has to be kept.
+static TOP_VALUE: AtomicU32 = AtomicU32::new(0);
+// To check if there are still active instances.
+static REF_COUNT: AtomicU8 = AtomicU8::new(0);
+
+/// The configuration of a PWM output.
+/// Note the period in clock cycles of an output can be computed as:
+/// `(top + 1) * (phase_correct ? 1 : 2) * divider * prescale_factor`
+/// By default, the clock used is 96 MHz.
+#[non_exhaustive]
+#[derive(Clone)]
+pub struct Config {
+    /// Inverts the PWM output signal.
+    pub invert: bool,
+    /// Enables phase-correct mode for PWM operation.
+    /// In phase-correct mode, the PWM signal is generated in such a way that
+    /// the pulse is always centered regardless of the duty cycle.
+    /// The output frequency is halved when phase-correct mode is enabled.
+    pub phase_correct: bool,
+    /// Enables the PWM output, allowing it to generate an output.
+    pub enable: bool,
+    /// A SYSCON clock divider allows precise control over
+    /// the PWM output frequency by gating the PWM counter increment.
+    /// A higher value will result in a slower output frequency.
+    /// The clock is divided by `divider + 1`.
+    pub divider: u8,
+    /// Specifies the factor by which the SCT clock is prescaled to produce the unified
+    /// counter clock. The counter clock is clocked at the rate of the SCT clock divided by
+    /// `PRE + 1`.
+    pub prescale_factor: u8,
+    /// The output goes high when `compare` is higher than the
+    /// counter. A compare of 0 will produce an always low output, while a
+    /// compare of `top` will produce an always high output.
+    pub compare: u32,
+    /// The point at which the counter resets, representing the maximum possible
+    /// period. The counter will either wrap to 0 or reverse depending on the
+    /// setting of `phase_correct`.
+    pub top: u32,
+}
+
+impl Config {
+    pub fn new(compare: u32, top: u32) -> Self {
+        Self {
+            invert: false,
+            phase_correct: false,
+            enable: true,
+            divider: 255,
+            prescale_factor: 255,
+            compare,
+            top,
+        }
+    }
+}
+
+/// PWM driver.
+pub struct Pwm<'d> {
+    _pin: Peri<'d, AnyPin>,
+    output: usize,
+}
+
+impl<'d> Pwm<'d> {
+    pub(crate) fn reset() {
+        // Reset SCTimer => Reset counter and halt it.
+        // It should be done only once during the initialization of the board.
+        SYSCON.presetctrl1().modify(|w| w.set_sct_rst(SctRst::ASSERTED));
+        SYSCON.presetctrl1().modify(|w| w.set_sct_rst(SctRst::RELEASED));
+    }
+    fn new_inner<T: Output>(output: usize, channel: Peri<'d, impl OutputChannelPin<T>>, config: Config) -> Self {
+        // Enable clocks (Syscon is enabled by default)
+        critical_section::with(|_cs| {
+            if !SYSCON.ahbclkctrl0().read().iocon() {
+                SYSCON.ahbclkctrl0().modify(|w| w.set_iocon(true));
+            }
+            if !SYSCON.ahbclkctrl1().read().sct() {
+                SYSCON.ahbclkctrl1().modify(|w| w.set_sct(true));
+            }
+        });
+
+        // Choose the clock for PWM.
+        SYSCON.sctclksel().modify(|w| w.set_sel(SctclkselSel::ENUM_0X3));
+        // For now, 96 MHz.
+
+        // IOCON Setup
+        channel.pio().modify(|w| {
+            w.set_func(channel.pin_func());
+            w.set_digimode(PioDigimode::DIGITAL);
+            w.set_slew(PioSlew::STANDARD);
+            w.set_mode(PioMode::INACTIVE);
+            w.set_od(PioOd::NORMAL);
+        });
+
+        Self::configure(output, &config);
+        REF_COUNT.fetch_add(1, Ordering::Relaxed);
+        Self {
+            _pin: channel.into(),
+            output,
+        }
+    }
+
+    /// Create PWM driver with a single 'a' pin as output.
+    #[inline]
+    pub fn new_output<T: Output>(
+        output: Peri<'d, T>,
+        channel: Peri<'d, impl OutputChannelPin<T>>,
+        config: Config,
+    ) -> Self {
+        Self::new_inner(output.number(), channel, config)
+    }
+
+    /// Set the PWM config.
+    pub fn set_config(&mut self, config: &Config) {
+        Self::configure(self.output, config);
+    }
+
+    fn configure(output_number: usize, config: &Config) {
+        // Stop and reset the counter
+        SCT0.ctrl().modify(|w| {
+            if config.phase_correct {
+                w.set_bidir_l(vals::Bidir::UP_DOWN);
+            } else {
+                w.set_bidir_l(vals::Bidir::UP);
+            }
+            w.set_halt_l(true); // halt the counter to make new changes
+            w.set_clrctr_l(true); // clear the counter
+        });
+        // Divides clock by 1-255
+        SYSCON.sctclkdiv().modify(|w| w.set_div(config.divider));
+
+        SCT0.config().modify(|w| {
+            w.set_unify(vals::Unify::UNIFIED_COUNTER);
+            w.set_clkmode(vals::Clkmode::SYSTEM_CLOCK_MODE);
+            w.set_noreload_l(true);
+            w.set_autolimit_l(true);
+        });
+
+        // Before setting the match registers, we have to make sure that `compare` is lower or equal to `top`,
+        // otherwise the counter will not reach the match and, therefore, no events will happen.
+        assert!(config.compare <= config.top);
+
+        if TOP_VALUE.load(Ordering::Relaxed) == 0 {
+            // Match 0 will reset the timer using TOP value
+            SCT0.match_(0).modify(|w| {
+                w.set_matchn_l((config.top & 0xFFFF) as u16);
+                w.set_matchn_h((config.top >> 16) as u16);
+            });
+        } else {
+            panic!("The top value cannot be changed after the initialization.");
+        }
+        // The actual matches that are used for event logic
+        SCT0.match_(output_number + 1).modify(|w| {
+            w.set_matchn_l((config.compare & 0xFFFF) as u16);
+            w.set_matchn_h((config.compare >> 16) as u16);
+        });
+
+        SCT0.match_(15).modify(|w| {
+            w.set_matchn_l(0);
+            w.set_matchn_h(0);
+        });
+
+        // Event configuration
+        critical_section::with(|_cs| {
+            // If it is already set, don't change
+            if SCT0.ev(0).ev_ctrl().read().matchsel() != 15 {
+                SCT0.ev(0).ev_ctrl().modify(|w| {
+                    w.set_matchsel(15);
+                    w.set_combmode(vals::Combmode::MATCH);
+                    // STATE + statev, where STATE is a on-board variable.
+                    w.set_stateld(vals::Stateld::ADD);
+                    w.set_statev(0);
+                });
+            }
+        });
+        SCT0.ev(output_number + 1).ev_ctrl().modify(|w| {
+            w.set_matchsel((output_number + 1) as u8);
+            w.set_combmode(vals::Combmode::MATCH);
+            w.set_stateld(vals::Stateld::ADD);
+            // STATE + statev, where STATE is a on-board variable.
+            w.set_statev(0);
+        });
+
+        // Assign events to states
+        SCT0.ev(0).ev_state().modify(|w| w.set_statemskn(1 << 0));
+        SCT0.ev(output_number + 1)
+            .ev_state()
+            .modify(|w| w.set_statemskn(1 << 0));
+        // TODO(frihetselsker): optimize nxp-pac so that `set_clr` and `set_set` are turned into a bit array.
+        if config.invert {
+            // Low when event 0 is active
+            SCT0.out(output_number).out_clr().modify(|w| w.set_clr(1 << 0));
+            // High when event `output_number + 1` is active
+            SCT0.out(output_number)
+                .out_set()
+                .modify(|w| w.set_set(1 << (output_number + 1)));
+        } else {
+            // High when event 0 is active
+            SCT0.out(output_number).out_set().modify(|w| w.set_set(1 << 0));
+            // Low when event `output_number + 1` is active
+            SCT0.out(output_number)
+                .out_clr()
+                .modify(|w| w.set_clr(1 << (output_number + 1)));
+        }
+
+        if config.phase_correct {
+            // Take into account the set matches and reverse their actions while counting back.
+            SCT0.outputdirctrl()
+                .modify(|w| w.set_setclr(output_number, vals::Setclr::L_REVERSED));
+        }
+
+        // State 0 by default
+        SCT0.state().modify(|w| w.set_state_l(0));
+        // Remove halt and start the actual counter
+        SCT0.ctrl().modify(|w| {
+            w.set_halt_l(!config.enable);
+        });
+    }
+
+    /// Read PWM counter.
+    #[inline]
+    pub fn counter(&self) -> u32 {
+        SCT0.count().read().0
+    }
+}
+
+impl<'d> Drop for Pwm<'d> {
+    fn drop(&mut self) {
+        REF_COUNT.fetch_sub(1, Ordering::AcqRel);
+        if REF_COUNT.load(Ordering::Acquire) == 0 {
+            TOP_VALUE.store(0, Ordering::Release);
+        }
+    }
+}
+
+trait SealedOutput {
+    /// Output number.
+    fn number(&self) -> usize;
+}
+
+/// PWM Output.
+#[allow(private_bounds)]
+pub trait Output: PeripheralType + SealedOutput {}
+
+macro_rules! output {
+    ($name:ident, $num:expr) => {
+        impl SealedOutput for crate::peripherals::$name {
+            fn number(&self) -> usize {
+                $num
+            }
+        }
+        impl Output for crate::peripherals::$name {}
+    };
+}
+
+output!(PWM_OUTPUT0, 0);
+output!(PWM_OUTPUT1, 1);
+output!(PWM_OUTPUT2, 2);
+output!(PWM_OUTPUT3, 3);
+output!(PWM_OUTPUT4, 4);
+output!(PWM_OUTPUT5, 5);
+output!(PWM_OUTPUT6, 6);
+output!(PWM_OUTPUT7, 7);
+output!(PWM_OUTPUT8, 8);
+output!(PWM_OUTPUT9, 9);
+
+/// PWM Output Channel.
+pub trait OutputChannelPin<T: Output>: crate::gpio::Pin {
+    fn pin_func(&self) -> PioFunc;
+}
+
+macro_rules! impl_pin {
+    ($pin:ident, $output:ident, $func:ident) => {
+        impl crate::pwm::inner::OutputChannelPin<crate::peripherals::$output> for crate::peripherals::$pin {
+            fn pin_func(&self) -> PioFunc {
+                PioFunc::$func
+            }
+        }
+    };
+}
+
+impl_pin!(PIO0_2, PWM_OUTPUT0, ALT3);
+impl_pin!(PIO0_17, PWM_OUTPUT0, ALT4);
+impl_pin!(PIO1_4, PWM_OUTPUT0, ALT4);
+impl_pin!(PIO1_23, PWM_OUTPUT0, ALT2);
+
+impl_pin!(PIO0_3, PWM_OUTPUT1, ALT3);
+impl_pin!(PIO0_18, PWM_OUTPUT1, ALT4);
+impl_pin!(PIO1_8, PWM_OUTPUT1, ALT4);
+impl_pin!(PIO1_24, PWM_OUTPUT1, ALT2);
+
+impl_pin!(PIO0_10, PWM_OUTPUT2, ALT5);
+impl_pin!(PIO0_15, PWM_OUTPUT2, ALT4);
+impl_pin!(PIO0_19, PWM_OUTPUT2, ALT4);
+impl_pin!(PIO1_9, PWM_OUTPUT2, ALT4);
+impl_pin!(PIO1_25, PWM_OUTPUT2, ALT2);
+
+impl_pin!(PIO0_22, PWM_OUTPUT3, ALT4);
+impl_pin!(PIO0_31, PWM_OUTPUT3, ALT4);
+impl_pin!(PIO1_10, PWM_OUTPUT3, ALT4);
+impl_pin!(PIO1_26, PWM_OUTPUT3, ALT2);
+
+impl_pin!(PIO0_23, PWM_OUTPUT4, ALT4);
+impl_pin!(PIO1_3, PWM_OUTPUT4, ALT4);
+impl_pin!(PIO1_17, PWM_OUTPUT4, ALT4);
+
+impl_pin!(PIO0_26, PWM_OUTPUT5, ALT4);
+impl_pin!(PIO1_18, PWM_OUTPUT5, ALT4);
+
+impl_pin!(PIO0_27, PWM_OUTPUT6, ALT4);
+impl_pin!(PIO1_31, PWM_OUTPUT6, ALT4);
+
+impl_pin!(PIO0_28, PWM_OUTPUT7, ALT4);
+impl_pin!(PIO1_19, PWM_OUTPUT7, ALT2);
+
+impl_pin!(PIO0_29, PWM_OUTPUT8, ALT4);
+
+impl_pin!(PIO0_30, PWM_OUTPUT9, ALT4);
diff --git a/embassy-nxp/src/usart/lpc55.rs b/embassy-nxp/src/usart/lpc55.rs
index 0be5a8ce7..d54927b25 100644
--- a/embassy-nxp/src/usart/lpc55.rs
+++ b/embassy-nxp/src/usart/lpc55.rs
@@ -11,7 +11,7 @@ use embassy_sync::waitqueue::AtomicWaker;
 use embedded_io::{self, ErrorKind};
 
 use crate::dma::{AnyChannel, Channel};
-use crate::gpio::{AnyPin, Bank, SealedPin, match_iocon};
+use crate::gpio::{AnyPin, SealedPin};
 use crate::interrupt::Interrupt;
 use crate::interrupt::typelevel::{Binding, Interrupt as _};
 use crate::pac::flexcomm::Flexcomm as FlexcommReg;
@@ -146,7 +146,8 @@ impl<'d, M: Mode> UsartTx<'d, M> {
         tx_dma: Peri<'d, impl Channel>,
         config: Config,
     ) -> Self {
-        Usart::<M>::init::<T>(Some(tx.into()), None, config);
+        let tx_func = tx.pin_func();
+        Usart::<M>::init::<T>(Some((tx.into(), tx_func)), None, config);
         Self::new_inner(T::info(), Some(tx_dma.into()))
     }
 
@@ -179,7 +180,8 @@ impl<'d, M: Mode> UsartTx<'d, M> {
 
 impl<'d> UsartTx<'d, Blocking> {
     pub fn new_blocking<T: Instance>(_usart: Peri<'d, T>, tx: Peri<'d, impl TxPin<T>>, config: Config) -> Self {
-        Usart::<Blocking>::init::<T>(Some(tx.into()), None, config);
+        let tx_func = tx.pin_func();
+        Usart::<Blocking>::init::<T>(Some((tx.into(), tx_func)), None, config);
         Self::new_inner(T::info(), None)
     }
 }
@@ -208,7 +210,8 @@ impl<'d, M: Mode> UsartRx<'d, M> {
         rx_dma: Peri<'d, impl Channel>,
         config: Config,
     ) -> Self {
-        Usart::<M>::init::<T>(None, Some(rx.into()), config);
+        let rx_func = rx.pin_func();
+        Usart::<M>::init::<T>(None, Some((rx.into(), rx_func)), config);
         Self::new_inner(T::info(), T::dma_state(), has_irq, Some(rx_dma.into()))
     }
 
@@ -280,7 +283,8 @@ impl<'d, M: Mode> UsartRx<'d, M> {
 
 impl<'d> UsartRx<'d, Blocking> {
     pub fn new_blocking<T: Instance>(_usart: Peri<'d, T>, rx: Peri<'d, impl RxPin<T>>, config: Config) -> Self {
-        Usart::<Blocking>::init::<T>(None, Some(rx.into()), config);
+        let rx_func = rx.pin_func();
+        Usart::<Blocking>::init::<T>(None, Some((rx.into(), rx_func)), config);
         Self::new_inner(T::info(), T::dma_state(), false, None)
     }
 }
@@ -405,7 +409,10 @@ impl<'d> Usart<'d, Blocking> {
         rx: Peri<'d, impl RxPin<T>>,
         config: Config,
     ) -> Self {
-        Self::new_inner(usart, tx.into(), rx.into(), false, None, None, config)
+        let tx_func = tx.pin_func();
+        let rx_func = rx.pin_func();
+
+        Self::new_inner(usart, tx.into(), tx_func, rx.into(), rx_func, false, None, None, config)
     }
 }
 
@@ -419,10 +426,15 @@ impl<'d> Usart<'d, Async> {
         rx_dma: Peri<'d, impl RxChannel<T>>,
         config: Config,
     ) -> Self {
+        let tx_func = tx.pin_func();
+        let rx_func = rx.pin_func();
+
         Self::new_inner(
             uart,
             tx.into(),
+            tx_func,
             rx.into(),
+            rx_func,
             true,
             Some(tx_dma.into()),
             Some(rx_dma.into()),
@@ -435,20 +447,26 @@ impl<'d, M: Mode> Usart<'d, M> {
     fn new_inner<T: Instance>(
         _usart: Peri<'d, T>,
         mut tx: Peri<'d, AnyPin>,
+        tx_func: PioFunc,
         mut rx: Peri<'d, AnyPin>,
+        rx_func: PioFunc,
         has_irq: bool,
         tx_dma: Option<Peri<'d, AnyChannel>>,
         rx_dma: Option<Peri<'d, AnyChannel>>,
         config: Config,
     ) -> Self {
-        Self::init::<T>(Some(tx.reborrow()), Some(rx.reborrow()), config);
+        Self::init::<T>(Some((tx.reborrow(), tx_func)), Some((rx.reborrow(), rx_func)), config);
         Self {
             tx: UsartTx::new_inner(T::info(), tx_dma),
             rx: UsartRx::new_inner(T::info(), T::dma_state(), has_irq, rx_dma),
         }
     }
 
-    fn init<T: Instance>(tx: Option<Peri<'_, AnyPin>>, rx: Option<Peri<'_, AnyPin>>, config: Config) {
+    fn init<T: Instance>(
+        tx: Option<(Peri<'_, AnyPin>, PioFunc)>,
+        rx: Option<(Peri<'_, AnyPin>, PioFunc)>,
+        config: Config,
+    ) {
         Self::configure_flexcomm(T::info().fc_reg, T::instance_number());
         Self::configure_clock::<T>(&config);
         Self::pin_config::<T>(tx, rx);
@@ -553,31 +571,27 @@ impl<'d, M: Mode> Usart<'d, M> {
             .modify(|w| w.set_brgval((brg_value - 1) as u16));
     }
 
-    fn pin_config<T: Instance>(tx: Option<Peri<'_, AnyPin>>, rx: Option<Peri<'_, AnyPin>>) {
-        if let Some(tx_pin) = tx {
-            match_iocon!(register, tx_pin.pin_bank(), tx_pin.pin_number(), {
-                register.modify(|w| {
-                    w.set_func(T::tx_pin_func());
-                    w.set_mode(iocon::vals::PioMode::INACTIVE);
-                    w.set_slew(iocon::vals::PioSlew::STANDARD);
-                    w.set_invert(false);
-                    w.set_digimode(iocon::vals::PioDigimode::DIGITAL);
-                    w.set_od(iocon::vals::PioOd::NORMAL);
-                });
-            })
+    fn pin_config<T: Instance>(tx: Option<(Peri<'_, AnyPin>, PioFunc)>, rx: Option<(Peri<'_, AnyPin>, PioFunc)>) {
+        if let Some((tx_pin, func)) = tx {
+            tx_pin.pio().modify(|w| {
+                w.set_func(func);
+                w.set_mode(iocon::vals::PioMode::INACTIVE);
+                w.set_slew(iocon::vals::PioSlew::STANDARD);
+                w.set_invert(false);
+                w.set_digimode(iocon::vals::PioDigimode::DIGITAL);
+                w.set_od(iocon::vals::PioOd::NORMAL);
+            });
         }
 
-        if let Some(rx_pin) = rx {
-            match_iocon!(register, rx_pin.pin_bank(), rx_pin.pin_number(), {
-                register.modify(|w| {
-                    w.set_func(T::rx_pin_func());
-                    w.set_mode(iocon::vals::PioMode::INACTIVE);
-                    w.set_slew(iocon::vals::PioSlew::STANDARD);
-                    w.set_invert(false);
-                    w.set_digimode(iocon::vals::PioDigimode::DIGITAL);
-                    w.set_od(iocon::vals::PioOd::NORMAL);
-                });
-            })
+        if let Some((rx_pin, func)) = rx {
+            rx_pin.pio().modify(|w| {
+                w.set_func(func);
+                w.set_mode(iocon::vals::PioMode::INACTIVE);
+                w.set_slew(iocon::vals::PioSlew::STANDARD);
+                w.set_invert(false);
+                w.set_digimode(iocon::vals::PioDigimode::DIGITAL);
+                w.set_od(iocon::vals::PioOd::NORMAL);
+            });
         };
     }
 
@@ -814,8 +828,6 @@ trait SealedInstance {
     fn info() -> &'static Info;
     fn dma_state() -> &'static DmaState;
     fn instance_number() -> usize;
-    fn tx_pin_func() -> PioFunc;
-    fn rx_pin_func() -> PioFunc;
 }
 
 /// UART instance.
@@ -826,7 +838,7 @@ pub trait Instance: SealedInstance + PeripheralType {
 }
 
 macro_rules! impl_instance {
-    ($inst:ident, $fc:ident, $tx_pin:ident, $rx_pin:ident, $fc_num:expr) => {
+    ($inst:ident, $fc:ident, $fc_num:expr) => {
         impl $crate::usart::inner::SealedInstance for $crate::peripherals::$inst {
             fn info() -> &'static Info {
                 static INFO: Info = Info {
@@ -848,14 +860,6 @@ macro_rules! impl_instance {
             fn instance_number() -> usize {
                 $fc_num
             }
-            #[inline]
-            fn tx_pin_func() -> PioFunc {
-                PioFunc::$tx_pin
-            }
-            #[inline]
-            fn rx_pin_func() -> PioFunc {
-                PioFunc::$rx_pin
-            }
         }
         impl $crate::usart::Instance for $crate::peripherals::$inst {
             type Interrupt = crate::interrupt::typelevel::$fc;
@@ -863,45 +867,72 @@ macro_rules! impl_instance {
     };
 }
 
-impl_instance!(USART0, FLEXCOMM0, ALT1, ALT1, 0);
-impl_instance!(USART1, FLEXCOMM1, ALT2, ALT2, 1);
-impl_instance!(USART2, FLEXCOMM2, ALT1, ALT1, 2);
-impl_instance!(USART3, FLEXCOMM3, ALT1, ALT1, 3);
-impl_instance!(USART4, FLEXCOMM4, ALT1, ALT2, 4);
-impl_instance!(USART5, FLEXCOMM5, ALT3, ALT3, 5);
-impl_instance!(USART6, FLEXCOMM6, ALT2, ALT2, 6);
-impl_instance!(USART7, FLEXCOMM7, ALT7, ALT7, 7);
+impl_instance!(USART0, FLEXCOMM0, 0);
+impl_instance!(USART1, FLEXCOMM1, 1);
+impl_instance!(USART2, FLEXCOMM2, 2);
+impl_instance!(USART3, FLEXCOMM3, 3);
+impl_instance!(USART4, FLEXCOMM4, 4);
+impl_instance!(USART5, FLEXCOMM5, 5);
+impl_instance!(USART6, FLEXCOMM6, 6);
+impl_instance!(USART7, FLEXCOMM7, 7);
+
+pub(crate) trait SealedTxPin<T: Instance>: crate::gpio::Pin {
+    fn pin_func(&self) -> PioFunc;
+}
+
+pub(crate) trait SealedRxPin<T: Instance>: crate::gpio::Pin {
+    fn pin_func(&self) -> PioFunc;
+}
 
 /// Trait for TX pins.
-pub trait TxPin<T: Instance>: crate::gpio::Pin {}
+#[allow(private_bounds)]
+pub trait TxPin<T: Instance>: SealedTxPin<T> + crate::gpio::Pin {}
+
 /// Trait for RX pins.
-pub trait RxPin<T: Instance>: crate::gpio::Pin {}
+#[allow(private_bounds)]
+pub trait RxPin<T: Instance>: SealedRxPin<T> + crate::gpio::Pin {}
+
+macro_rules! impl_tx_pin {
+    ($pin:ident, $instance:ident, $func: ident) => {
+        impl SealedTxPin<crate::peripherals::$instance> for crate::peripherals::$pin {
+            fn pin_func(&self) -> PioFunc {
+                PioFunc::$func
+            }
+        }
 
-macro_rules! impl_pin {
-    ($pin:ident, $instance:ident, Tx) => {
         impl TxPin<crate::peripherals::$instance> for crate::peripherals::$pin {}
     };
-    ($pin:ident, $instance:ident, Rx) => {
+}
+
+macro_rules! impl_rx_pin {
+    ($pin:ident, $instance:ident, $func: ident) => {
+        impl SealedRxPin<crate::peripherals::$instance> for crate::peripherals::$pin {
+            fn pin_func(&self) -> PioFunc {
+                PioFunc::$func
+            }
+        }
+
         impl RxPin<crate::peripherals::$instance> for crate::peripherals::$pin {}
     };
 }
 
-impl_pin!(PIO1_6, USART0, Tx);
-impl_pin!(PIO1_5, USART0, Rx);
-impl_pin!(PIO1_11, USART1, Tx);
-impl_pin!(PIO1_10, USART1, Rx);
-impl_pin!(PIO0_27, USART2, Tx);
-impl_pin!(PIO1_24, USART2, Rx);
-impl_pin!(PIO0_2, USART3, Tx);
-impl_pin!(PIO0_3, USART3, Rx);
-impl_pin!(PIO0_16, USART4, Tx);
-impl_pin!(PIO0_5, USART4, Rx);
-impl_pin!(PIO0_9, USART5, Tx);
-impl_pin!(PIO0_8, USART5, Rx);
-impl_pin!(PIO1_16, USART6, Tx);
-impl_pin!(PIO1_13, USART6, Rx);
-impl_pin!(PIO0_19, USART7, Tx);
-impl_pin!(PIO0_20, USART7, Rx);
+impl_tx_pin!(PIO1_6, USART0, ALT1);
+impl_tx_pin!(PIO1_11, USART1, ALT2);
+impl_tx_pin!(PIO0_27, USART2, ALT1);
+impl_tx_pin!(PIO0_2, USART3, ALT1);
+impl_tx_pin!(PIO0_16, USART4, ALT1);
+impl_tx_pin!(PIO0_9, USART5, ALT3);
+impl_tx_pin!(PIO1_16, USART6, ALT2);
+impl_tx_pin!(PIO0_19, USART7, ALT7);
+
+impl_rx_pin!(PIO1_5, USART0, ALT1);
+impl_rx_pin!(PIO1_10, USART1, ALT2);
+impl_rx_pin!(PIO1_24, USART2, ALT1);
+impl_rx_pin!(PIO0_3, USART3, ALT1);
+impl_rx_pin!(PIO0_5, USART4, ALT2);
+impl_rx_pin!(PIO0_8, USART5, ALT3);
+impl_rx_pin!(PIO1_13, USART6, ALT2);
+impl_rx_pin!(PIO0_20, USART7, ALT7);
 
 /// Trait for TX DMA channels.
 pub trait TxChannel<T: Instance>: crate::dma::Channel {}
diff --git a/embassy-rp/CHANGELOG.md b/embassy-rp/CHANGELOG.md
index e932bcaa3..3b3cb5351 100644
--- a/embassy-rp/CHANGELOG.md
+++ b/embassy-rp/CHANGELOG.md
@@ -8,12 +8,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- Fix several minor typos in documentation
 - Add PIO SPI
 - Add PIO I2S input
 - Add PIO onewire parasite power strong pullup
 - add `wait_for_alarm` and `alarm_scheduled` methods to rtc module ([#4216](https://github.com/embassy-rs/embassy/pull/4216))
 - rp235x: use msplim for stack guard instead of MPU
 - Add reset_to_usb_boot for rp235x ([#4705](https://github.com/embassy-rs/embassy/pull/4705))
+- Add fix #4822 in PIO onewire. Change to disable the state machine before setting y register ([#4824](https://github.com/embassy-rs/embassy/pull/4824))
+- Add PIO::Ws2812 color order support
 
 ## 0.8.0 - 2025-08-26
 
diff --git a/embassy-rp/src/block.rs b/embassy-rp/src/block.rs
index a3e1ad925..745883b83 100644
--- a/embassy-rp/src/block.rs
+++ b/embassy-rp/src/block.rs
@@ -240,7 +240,7 @@ impl UnpartitionedSpace {
         }
     }
 
-    /// Create a new unpartition space from run-time values.
+    /// Create a new unpartitioned space from run-time values.
     ///
     /// Get these from the ROM function `get_partition_table_info` with an argument of `PT_INFO`.
     pub const fn from_raw(permissions_and_location: u32, permissions_and_flags: u32) -> Self {
@@ -714,7 +714,7 @@ impl PartitionTableBlock {
         new_table
     }
 
-    /// Add a a SHA256 hash of the Block
+    /// Add a SHA256 hash of the Block
     ///
     /// Adds a `HASH_DEF` covering all the previous items in the Block, and a
     /// `HASH_VALUE` with a SHA-256 hash of them.
diff --git a/embassy-rp/src/clocks.rs b/embassy-rp/src/clocks.rs
index 56892d7a2..8bfb5129a 100644
--- a/embassy-rp/src/clocks.rs
+++ b/embassy-rp/src/clocks.rs
@@ -267,7 +267,7 @@ impl CoreVoltage {
     }
 }
 
-/// CLock configuration.
+/// Clock configuration.
 #[non_exhaustive]
 pub struct ClockConfig {
     /// Ring oscillator configuration.
diff --git a/embassy-rp/src/gpio.rs b/embassy-rp/src/gpio.rs
index c15e0e41b..154fc1585 100644
--- a/embassy-rp/src/gpio.rs
+++ b/embassy-rp/src/gpio.rs
@@ -300,7 +300,7 @@ impl<'d> InputFuture<'d> {
 
         // Each INTR register is divided into 8 groups, one group for each
         // pin, and each group consists of LEVEL_LOW, LEVEL_HIGH, EDGE_LOW,
-        // and EGDE_HIGH.
+        // and EDGE_HIGH.
         pin.int_proc()
             .inte((pin.pin() / 8) as usize)
             .write_set(|w| match level {
diff --git a/embassy-rp/src/i2c_slave.rs b/embassy-rp/src/i2c_slave.rs
index 770087bc8..0853709df 100644
--- a/embassy-rp/src/i2c_slave.rs
+++ b/embassy-rp/src/i2c_slave.rs
@@ -52,7 +52,7 @@ pub enum ReadStatus {
     Done,
     /// Transaction Incomplete, controller trying to read more bytes than were provided
     NeedMoreBytes,
-    /// Transaction Complere, but controller stopped reading bytes before we ran out
+    /// Transaction Complete, but controller stopped reading bytes before we ran out
     LeftoverBytes(u16),
 }
 
@@ -240,7 +240,7 @@ impl<'d, T: Instance> I2cSlave<'d, T> {
 
                 if p.ic_rxflr().read().rxflr() > 0 || me.pending_byte.is_some() {
                     me.drain_fifo(buffer, &mut len);
-                    // we're recieving data, set rx fifo watermark to 12 bytes (3/4 full) to reduce interrupt noise
+                    // we're receiving data, set rx fifo watermark to 12 bytes (3/4 full) to reduce interrupt noise
                     p.ic_rx_tl().write(|w| w.set_rx_tl(11));
                 }
 
diff --git a/embassy-rp/src/multicore.rs b/embassy-rp/src/multicore.rs
index 3b120e349..572d8db91 100644
--- a/embassy-rp/src/multicore.rs
+++ b/embassy-rp/src/multicore.rs
@@ -58,7 +58,7 @@ const PAUSE_TOKEN: u32 = 0xDEADBEEF;
 const RESUME_TOKEN: u32 = !0xDEADBEEF;
 static IS_CORE1_INIT: AtomicBool = AtomicBool::new(false);
 
-/// Represents a partiticular CPU core (SIO_CPUID)
+/// Represents a particular CPU core (SIO_CPUID)
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[repr(u8)]
diff --git a/embassy-rp/src/pio/mod.rs b/embassy-rp/src/pio/mod.rs
index 38ee1f97c..92b2c603e 100644
--- a/embassy-rp/src/pio/mod.rs
+++ b/embassy-rp/src/pio/mod.rs
@@ -62,7 +62,7 @@ pub enum FifoJoin {
     #[cfg(feature = "_rp235x")]
     RxAsControl,
     /// FJOIN_RX_PUT | FJOIN_RX_GET: RX can be used as a scratch register,
-    /// not accesible from the CPU
+    /// not accessible from the CPU
     #[cfg(feature = "_rp235x")]
     PioScratch,
 }
diff --git a/embassy-rp/src/pio_programs/i2s.rs b/embassy-rp/src/pio_programs/i2s.rs
index 7e5f68ad6..5c49beecb 100644
--- a/embassy-rp/src/pio_programs/i2s.rs
+++ b/embassy-rp/src/pio_programs/i2s.rs
@@ -1,4 +1,4 @@
-//! Pio backed I2s output and output drivers
+//! Pio backed I2S output and output drivers
 
 use fixed::traits::ToFixed;
 
@@ -9,7 +9,7 @@ use crate::pio::{
     Common, Config, Direction, FifoJoin, Instance, LoadedProgram, PioPin, ShiftConfig, ShiftDirection, StateMachine,
 };
 
-/// This struct represents an i2s receiver & controller driver program
+/// This struct represents an I2S receiver & controller driver program
 pub struct PioI2sInProgram<'d, PIO: Instance> {
     prg: LoadedProgram<'d, PIO>,
 }
@@ -35,7 +35,7 @@ impl<'d, PIO: Instance> PioI2sInProgram<'d, PIO> {
     }
 }
 
-/// Pio backed I2s input driver
+/// Pio backed I2S input driver
 pub struct PioI2sIn<'d, P: Instance, const S: usize> {
     dma: Peri<'d, AnyChannel>,
     sm: StateMachine<'d, P, S>,
@@ -50,7 +50,7 @@ impl<'d, P: Instance, const S: usize> PioI2sIn<'d, P, S> {
         // Whether or not to use the MCU's internal pull-down resistor, as the
         // Pico 2 is known to have problems with the inbuilt pulldowns, many
         // opt to just use an external pull down resistor to meet requirements of common
-        // i2s microphones such as the INMP441
+        // I2S microphones such as the INMP441
         data_pulldown: bool,
         data_pin: Peri<'d, impl PioPin>,
         bit_clock_pin: Peri<'d, impl PioPin>,
@@ -90,13 +90,13 @@ impl<'d, P: Instance, const S: usize> PioI2sIn<'d, P, S> {
         Self { dma: dma.into(), sm }
     }
 
-    /// Return an in-prograss dma transfer future. Awaiting it will guarentee a complete transfer.
+    /// Return an in-progress dma transfer future. Awaiting it will guarantee a complete transfer.
     pub fn read<'b>(&'b mut self, buff: &'b mut [u32]) -> Transfer<'b, AnyChannel> {
         self.sm.rx().dma_pull(self.dma.reborrow(), buff, false)
     }
 }
 
-/// This struct represents an i2s output driver program
+/// This struct represents an I2S output driver program
 ///
 /// The sample bit-depth is set through scratch register `Y`.
 /// `Y` has to be set to sample bit-depth - 2.
@@ -128,14 +128,14 @@ impl<'d, PIO: Instance> PioI2sOutProgram<'d, PIO> {
     }
 }
 
-/// Pio backed I2s output driver
+/// Pio backed I2S output driver
 pub struct PioI2sOut<'d, P: Instance, const S: usize> {
     dma: Peri<'d, AnyChannel>,
     sm: StateMachine<'d, P, S>,
 }
 
 impl<'d, P: Instance, const S: usize> PioI2sOut<'d, P, S> {
-    /// Configure a state machine to output I2s
+    /// Configure a state machine to output I2S
     pub fn new(
         common: &mut Common<'d, P>,
         mut sm: StateMachine<'d, P, S>,
@@ -179,7 +179,7 @@ impl<'d, P: Instance, const S: usize> PioI2sOut<'d, P, S> {
         Self { dma: dma.into(), sm }
     }
 
-    /// Return an in-prograss dma transfer future. Awaiting it will guarentee a complete transfer.
+    /// Return an in-progress dma transfer future. Awaiting it will guarantee a complete transfer.
     pub fn write<'b>(&'b mut self, buff: &'b [u32]) -> Transfer<'b, AnyChannel> {
         self.sm.tx().dma_push(self.dma.reborrow(), buff, false)
     }
diff --git a/embassy-rp/src/pio_programs/onewire.rs b/embassy-rp/src/pio_programs/onewire.rs
index 09babc229..3adab3b79 100644
--- a/embassy-rp/src/pio_programs/onewire.rs
+++ b/embassy-rp/src/pio_programs/onewire.rs
@@ -163,7 +163,11 @@ impl<'d, PIO: Instance, const SM: usize> PioOneWire<'d, PIO, SM> {
 
     /// Write bytes to the onewire bus
     pub async fn write_bytes(&mut self, data: &[u8]) {
-        unsafe { self.sm.set_y(u32::MAX as u32) };
+        unsafe {
+            self.sm.set_enable(false);
+            self.sm.set_y(u32::MAX as u32);
+            self.sm.set_enable(true);
+        }
         let (rx, tx) = self.sm.rx_tx();
         for b in data {
             tx.wait_push(*b as u32).await;
@@ -175,7 +179,11 @@ impl<'d, PIO: Instance, const SM: usize> PioOneWire<'d, PIO, SM> {
 
     /// Write bytes to the onewire bus, then apply a strong pullup
     pub async fn write_bytes_pullup(&mut self, data: &[u8], pullup_time: embassy_time::Duration) {
-        unsafe { self.sm.set_y(data.len() as u32 * 8 - 1) };
+        unsafe {
+            self.sm.set_enable(false);
+            self.sm.set_y(data.len() as u32 * 8 - 1);
+            self.sm.set_enable(true);
+        };
         let (rx, tx) = self.sm.rx_tx();
         for b in data {
             tx.wait_push(*b as u32).await;
@@ -195,7 +203,11 @@ impl<'d, PIO: Instance, const SM: usize> PioOneWire<'d, PIO, SM> {
 
     /// Read bytes from the onewire bus
     pub async fn read_bytes(&mut self, data: &mut [u8]) {
-        unsafe { self.sm.set_y(u32::MAX as u32) };
+        unsafe {
+            self.sm.set_enable(false);
+            self.sm.set_y(u32::MAX as u32);
+            self.sm.set_enable(true);
+        };
         let (rx, tx) = self.sm.rx_tx();
         for b in data {
             // Write all 1's so that we can read what the device responds
diff --git a/embassy-rp/src/pio_programs/pwm.rs b/embassy-rp/src/pio_programs/pwm.rs
index ba06bb3c1..e4ad4a6f0 100644
--- a/embassy-rp/src/pio_programs/pwm.rs
+++ b/embassy-rp/src/pio_programs/pwm.rs
@@ -67,7 +67,7 @@ impl<'d, T: Instance, const SM: usize> PioPwm<'d, T, SM> {
         Self { sm, pin }
     }
 
-    /// Enable's the PIO program, continuing the wave generation from the PIO program.
+    /// Enables the PIO program, continuing the wave generation from the PIO program.
     pub fn start(&mut self) {
         self.sm.set_enable(true);
     }
diff --git a/embassy-rp/src/pio_programs/spi.rs b/embassy-rp/src/pio_programs/spi.rs
index b10fc6628..765ffaa06 100644
--- a/embassy-rp/src/pio_programs/spi.rs
+++ b/embassy-rp/src/pio_programs/spi.rs
@@ -1,4 +1,4 @@
-//! PIO backed SPi drivers
+//! PIO backed SPI drivers
 
 use core::marker::PhantomData;
 
@@ -83,7 +83,7 @@ pub enum Error {
     // No errors for now
 }
 
-/// PIO based Spi driver.
+/// PIO based SPI driver.
 /// Unlike other PIO programs, the PIO SPI driver owns and holds a reference to
 /// the PIO memory it uses. This is so that it can be reconfigured at runtime if
 /// desired.
diff --git a/embassy-rp/src/pio_programs/uart.rs b/embassy-rp/src/pio_programs/uart.rs
index 444efb5db..d59596dd1 100644
--- a/embassy-rp/src/pio_programs/uart.rs
+++ b/embassy-rp/src/pio_programs/uart.rs
@@ -130,7 +130,7 @@ impl<'d, PIO: Instance> PioUartRxProgram<'d, PIO> {
     }
 }
 
-/// PIO backed Uart reciever
+/// PIO backed Uart receiver
 pub struct PioUartRx<'d, PIO: Instance, const SM: usize> {
     sm_rx: StateMachine<'d, PIO, SM>,
 }
diff --git a/embassy-rp/src/pio_programs/ws2812.rs b/embassy-rp/src/pio_programs/ws2812.rs
index e6851b1a6..0b6035316 100644
--- a/embassy-rp/src/pio_programs/ws2812.rs
+++ b/embassy-rp/src/pio_programs/ws2812.rs
@@ -1,4 +1,4 @@
-//! [ws2812](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf)
+//! [ws2812](https://www.sparkfun.com/categories/tags/ws2812)
 
 use embassy_time::Timer;
 use fixed::types::U24F8;
@@ -16,6 +16,54 @@ const T2: u8 = 5; // data bit
 const T3: u8 = 3; // stop bit
 const CYCLES_PER_BIT: u32 = (T1 + T2 + T3) as u32;
 
+/// Color orders for WS2812B, type RGB8
+pub trait RgbColorOrder {
+    /// Pack an 8-bit RGB color into a u32
+    fn pack(color: RGB8) -> u32;
+}
+
+/// Green, Red, Blue order is the common default for WS2812B
+pub struct Grb;
+impl RgbColorOrder for Grb {
+    /// Pack an 8-bit RGB color into a u32 in GRB order
+    fn pack(color: RGB8) -> u32 {
+        (u32::from(color.g) << 24) | (u32::from(color.r) << 16) | (u32::from(color.b) << 8)
+    }
+}
+
+/// Red, Green, Blue is used by some WS2812B implementations
+pub struct Rgb;
+impl RgbColorOrder for Rgb {
+    /// Pack an 8-bit RGB color into a u32 in RGB order
+    fn pack(color: RGB8) -> u32 {
+        (u32::from(color.r) << 24) | (u32::from(color.g) << 16) | (u32::from(color.b) << 8)
+    }
+}
+
+/// Color orders RGBW strips
+pub trait RgbwColorOrder {
+    /// Pack an RGB+W color into a u32
+    fn pack(color: RGBW<u8>) -> u32;
+}
+
+/// Green, Red, Blue, White order is the common default for RGBW strips
+pub struct Grbw;
+impl RgbwColorOrder for Grbw {
+    /// Pack an RGB+W color into a u32 in GRBW order
+    fn pack(color: RGBW<u8>) -> u32 {
+        (u32::from(color.g) << 24) | (u32::from(color.r) << 16) | (u32::from(color.b) << 8) | u32::from(color.a.0)
+    }
+}
+
+/// Red, Green, Blue, White order
+pub struct Rgbw;
+impl RgbwColorOrder for Rgbw {
+    /// Pack an RGB+W color into a u32 in RGBW order
+    fn pack(color: RGBW<u8>) -> u32 {
+        (u32::from(color.r) << 24) | (u32::from(color.g) << 16) | (u32::from(color.b) << 8) | u32::from(color.a.0)
+    }
+}
+
 /// This struct represents a ws2812 program loaded into pio instruction memory.
 pub struct PioWs2812Program<'a, PIO: Instance> {
     prg: LoadedProgram<'a, PIO>,
@@ -52,15 +100,37 @@ impl<'a, PIO: Instance> PioWs2812Program<'a, PIO> {
 
 /// Pio backed RGB ws2812 driver
 /// Const N is the number of ws2812 leds attached to this pin
-pub struct PioWs2812<'d, P: Instance, const S: usize, const N: usize> {
+pub struct PioWs2812<'d, P: Instance, const S: usize, const N: usize, ORDER>
+where
+    ORDER: RgbColorOrder,
+{
     dma: Peri<'d, AnyChannel>,
     sm: StateMachine<'d, P, S>,
+    _order: core::marker::PhantomData<ORDER>,
 }
 
-impl<'d, P: Instance, const S: usize, const N: usize> PioWs2812<'d, P, S, N> {
+impl<'d, P: Instance, const S: usize, const N: usize> PioWs2812<'d, P, S, N, Grb> {
     /// Configure a pio state machine to use the loaded ws2812 program.
+    /// Uses the default GRB order.
     pub fn new(
         pio: &mut Common<'d, P>,
+        sm: StateMachine<'d, P, S>,
+        dma: Peri<'d, impl Channel>,
+        pin: Peri<'d, impl PioPin>,
+        program: &PioWs2812Program<'d, P>,
+    ) -> Self {
+        Self::with_color_order(pio, sm, dma, pin, program)
+    }
+}
+
+impl<'d, P: Instance, const S: usize, const N: usize, ORDER> PioWs2812<'d, P, S, N, ORDER>
+where
+    ORDER: RgbColorOrder,
+{
+    /// Configure a pio state machine to use the loaded ws2812 program.
+    /// Uses the specified color order.
+    pub fn with_color_order(
+        pio: &mut Common<'d, P>,
         mut sm: StateMachine<'d, P, S>,
         dma: Peri<'d, impl Channel>,
         pin: Peri<'d, impl PioPin>,
@@ -93,7 +163,11 @@ impl<'d, P: Instance, const S: usize, const N: usize> PioWs2812<'d, P, S, N> {
         sm.set_config(&cfg);
         sm.set_enable(true);
 
-        Self { dma: dma.into(), sm }
+        Self {
+            dma: dma.into(),
+            sm,
+            _order: core::marker::PhantomData,
+        }
     }
 
     /// Write a buffer of [smart_leds::RGB8] to the ws2812 string
@@ -101,8 +175,7 @@ impl<'d, P: Instance, const S: usize, const N: usize> PioWs2812<'d, P, S, N> {
         // Precompute the word bytes from the colors
         let mut words = [0u32; N];
         for i in 0..N {
-            let word = (u32::from(colors[i].g) << 24) | (u32::from(colors[i].r) << 16) | (u32::from(colors[i].b) << 8);
-            words[i] = word;
+            words[i] = ORDER::pack(colors[i]);
         }
 
         // DMA transfer
@@ -115,15 +188,37 @@ impl<'d, P: Instance, const S: usize, const N: usize> PioWs2812<'d, P, S, N> {
 /// Pio backed RGBW ws2812 driver
 /// This version is intended for ws2812 leds with 4 addressable lights
 /// Const N is the number of ws2812 leds attached to this pin
-pub struct RgbwPioWs2812<'d, P: Instance, const S: usize, const N: usize> {
+pub struct RgbwPioWs2812<'d, P: Instance, const S: usize, const N: usize, ORDER>
+where
+    ORDER: RgbwColorOrder,
+{
     dma: Peri<'d, AnyChannel>,
     sm: StateMachine<'d, P, S>,
+    _order: core::marker::PhantomData<ORDER>,
 }
 
-impl<'d, P: Instance, const S: usize, const N: usize> RgbwPioWs2812<'d, P, S, N> {
+impl<'d, P: Instance, const S: usize, const N: usize> RgbwPioWs2812<'d, P, S, N, Grbw> {
     /// Configure a pio state machine to use the loaded ws2812 program.
+    /// Uses the default GRBW color order
     pub fn new(
         pio: &mut Common<'d, P>,
+        sm: StateMachine<'d, P, S>,
+        dma: Peri<'d, impl Channel>,
+        pin: Peri<'d, impl PioPin>,
+        program: &PioWs2812Program<'d, P>,
+    ) -> Self {
+        Self::with_color_order(pio, sm, dma, pin, program)
+    }
+}
+
+impl<'d, P: Instance, const S: usize, const N: usize, ORDER> RgbwPioWs2812<'d, P, S, N, ORDER>
+where
+    ORDER: RgbwColorOrder,
+{
+    /// Configure a pio state machine to use the loaded ws2812 program.
+    /// Uses the specified color order
+    pub fn with_color_order(
+        pio: &mut Common<'d, P>,
         mut sm: StateMachine<'d, P, S>,
         dma: Peri<'d, impl Channel>,
         pin: Peri<'d, impl PioPin>,
@@ -156,7 +251,11 @@ impl<'d, P: Instance, const S: usize, const N: usize> RgbwPioWs2812<'d, P, S, N>
         sm.set_config(&cfg);
         sm.set_enable(true);
 
-        Self { dma: dma.into(), sm }
+        Self {
+            dma: dma.into(),
+            sm,
+            _order: core::marker::PhantomData,
+        }
     }
 
     /// Write a buffer of [smart_leds::RGBW] to the ws2812 string
@@ -164,11 +263,7 @@ impl<'d, P: Instance, const S: usize, const N: usize> RgbwPioWs2812<'d, P, S, N>
         // Precompute the word bytes from the colors
         let mut words = [0u32; N];
         for i in 0..N {
-            let word = (u32::from(colors[i].g) << 24)
-                | (u32::from(colors[i].r) << 16)
-                | (u32::from(colors[i].b) << 8)
-                | u32::from(colors[i].a.0);
-            words[i] = word;
+            words[i] = ORDER::pack(colors[i]);
         }
 
         // DMA transfer
diff --git a/embassy-rp/src/rom_data/rp2040.rs b/embassy-rp/src/rom_data/rp2040.rs
index 5a74eddd6..27a8d8981 100644
--- a/embassy-rp/src/rom_data/rp2040.rs
+++ b/embassy-rp/src/rom_data/rp2040.rs
@@ -30,7 +30,7 @@ const DATA_TABLE: *const u16 = 0x0000_0016 as _;
 /// Address of the version number of the ROM.
 const VERSION_NUMBER: *const u8 = 0x0000_0013 as _;
 
-/// Retrive rom content from a table using a code.
+/// Retrieve rom content from a table using a code.
 fn rom_table_lookup<T>(table: *const u16, tag: RomFnTableCode) -> T {
     unsafe {
         let rom_table_lookup_ptr: *const u32 = rom_hword_as_ptr(ROM_TABLE_LOOKUP_PTR);
diff --git a/embassy-rp/src/rtc/mod.rs b/embassy-rp/src/rtc/mod.rs
index 68fb3b765..054572903 100644
--- a/embassy-rp/src/rtc/mod.rs
+++ b/embassy-rp/src/rtc/mod.rs
@@ -47,7 +47,7 @@ impl<'d, T: Instance> Rtc<'d, T> {
         Self { inner }
     }
 
-    /// Enable or disable the leap year check. The rp2040 chip will always add a Feb 29th on every year that is divisable by 4, but this may be incorrect (e.g. on century years). This function allows you to disable this check.
+    /// Enable or disable the leap year check. The rp2040 chip will always add a Feb 29th on every year that is divisible by 4, but this may be incorrect (e.g. on century years). This function allows you to disable this check.
     ///
     /// Leap year checking is enabled by default.
     pub fn set_leap_year_check(&mut self, leap_year_check_enabled: bool) {
diff --git a/embassy-rp/src/spi.rs b/embassy-rp/src/spi.rs
index 559b3b909..d9410e78d 100644
--- a/embassy-rp/src/spi.rs
+++ b/embassy-rp/src/spi.rs
@@ -157,7 +157,7 @@ impl<'d, T: Instance, M: Mode> Spi<'d, T, M> {
 
     /// Private function to apply SPI configuration (phase, polarity, frequency) settings.
     ///
-    /// Driver should be disabled before making changes and reenabled after the modifications
+    /// Driver should be disabled before making changes and re-enabled after the modifications
     /// are applied.
     fn apply_config(inner: &Peri<'d, T>, config: &Config) {
         let p = inner.regs();
diff --git a/embassy-rp/src/uart/mod.rs b/embassy-rp/src/uart/mod.rs
index 43187df2d..8be87a5d2 100644
--- a/embassy-rp/src/uart/mod.rs
+++ b/embassy-rp/src/uart/mod.rs
@@ -315,7 +315,7 @@ impl<'d, M: Mode> UartRx<'d, M> {
     }
 
     /// Returns Ok(len) if no errors occurred. Returns Err((len, err)) if an error was
-    /// encountered. in both cases, `len` is the number of *good* bytes copied into
+    /// encountered. In both cases, `len` is the number of *good* bytes copied into
     /// `buffer`.
     fn drain_fifo(&mut self, buffer: &mut [u8]) -> Result<usize, (usize, Error)> {
         let r = self.info.regs;
diff --git a/embassy-stm32/CHANGELOG.md b/embassy-stm32/CHANGELOG.md
index a6ee5c4b8..f85fd82ef 100644
--- a/embassy-stm32/CHANGELOG.md
+++ b/embassy-stm32/CHANGELOG.md
@@ -5,9 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-<!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- feat: Add support for injected ADC measurements for g4 ([#4840](https://github.com/embassy-rs/embassy/pull/4840))
+- feat: Implement into_ring_buffered for g4 ([#4840](https://github.com/embassy-rs/embassy/pull/4840))
+- feat: Add support for 13-bit address and 16-bit data SDRAM chips
+- feat: stm32/hrtim add new_chx_with_config to provide pin configuration
+- fix flash erase on L4 & L5
 - fix: Fixed STM32H5 builds requiring time feature
 - feat: Derive Clone, Copy for QSPI Config
 - fix: stm32/i2c in master mode (blocking): subsequent transmissions failed after a NACK was received
@@ -31,10 +35,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - feat: stm32/usart: add `eager_reads` option to control if buffered readers return as soon as possible or after more data is available ([#4668](https://github.com/embassy-rs/embassy/pull/4668))
 - feat: stm32/usart: add `de_assertion_time` and `de_deassertion_time` config options
 - change: stm32/uart: BufferedUartRx now returns all available bytes from the internal buffer
+- fix: Prevent a HardFault crash on STM32H5 devices by changing `uid()` to return `[u8; 12]` by value instead of a reference. (Fixes #2696)
+- change: timer: added output compare values
+- feat: timer: add ability to set master mode
+- fix: sdmmc: don't wait for DBCKEND flag on sdmmc_v2 devices as it never fires (Fixes #4723)
+- fix: usart: fix race condition in ringbuffered usart
+- feat: Add backup_sram::init() for H5 devices to access BKPSRAM
+- feat: Add I2C MultiMaster (Slave) support for I2C v1
+- feat: stm32/fdcan: add ability to control automatic recovery from bus off ([#4821](https://github.com/embassy-rs/embassy/pull/4821))
+- low-power: update rtc api to allow reconfig
+- adc: consolidate ringbuffer
+- feat: Added RTC low-power support for STM32WLEx ([#4716](https://github.com/embassy-rs/embassy/pull/4716))
+- fix: Correct STM32WBA VREFBUFTRIM values
+- low_power: remove stop_with rtc and initialize in init if low-power feature enabled.
+- feat: stm32/dsi support zero parameter commands in `write_cmd` ([#4847](https://github.com/embassy-rs/embassy/pull/4847))
+- feat: stm32/spi: added support for slave mode ([#4388](https://github.com/embassy-rs/embassy/pull/4388))
+- chore: Updated stm32-metapac and stm32-data dependencies
 
 ## 0.4.0 - 2025-08-26
 
-- feat: stm32/sai: make NODIV independent of MCKDIV 
+- feat: stm32/sai: make NODIV independent of MCKDIV
 - fix: stm32/sai: fix WB MCKDIV
 - fix: stm32/i2c: pull-down was enabled instead of pull-none when no internal pull-up was needed.
 - feat: Improve blocking hash speed
@@ -43,6 +63,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - chore: Updated stm32-metapac and stm32-data dependencies
 - feat: stm32/adc/v3: allow DMA reads to loop through enable channels
 - fix: Fix XSPI not disabling alternate bytes when they were previously enabled
+- feat: stm32/adc/v3: added support for Continuous DMA configuration
 - fix: Fix stm32h7rs init when using external flash via XSPI
 - feat: Add Adc::new_with_clock() to configure analog clock
 - feat: Add GPDMA linked-list + ringbuffer support ([#3923](https://github.com/embassy-rs/embassy/pull/3923))
diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml
index 7c243b350..108321d0a 100644
--- a/embassy-stm32/Cargo.toml
+++ b/embassy-stm32/Cargo.toml
@@ -177,12 +177,10 @@ cortex-m = "0.7.6"
 futures-util = { version = "0.3.30", default-features = false }
 sdio-host = "0.9.0"
 critical-section = "1.1"
-#stm32-metapac = { version = "18" }
-stm32-metapac = { git = "https://github.com/embassy-rs/stm32-data-generated", tag = "stm32-data-b9f6b0c542d85ee695d71c35ced195e0cef51ac0" }
 
 vcell = "0.1.3"
 nb = "1.0.0"
-stm32-fmc = "0.3.0"
+stm32-fmc = "0.4.0"
 cfg-if = "1.0.0"
 embedded-io = { version = "0.6.0" }
 embedded-io-async = { version = "0.6.1" }
@@ -198,17 +196,23 @@ block-device-driver = { version = "0.2" }
 aligned = "0.4.1"
 heapless = "0.9.1"
 
+#stm32-metapac = { version = "18" }
+stm32-metapac = { git = "https://github.com/embassy-rs/stm32-data-generated", tag = "stm32-data-22374e3344a2c9150b9b3d4da45c03f398fdc54e" }
+
+[build-dependencies]
+#stm32-metapac = { version = "18", default-features = false, features = ["metadata"]}
+stm32-metapac = { git = "https://github.com/embassy-rs/stm32-data-generated", tag = "stm32-data-22374e3344a2c9150b9b3d4da45c03f398fdc54e", default-features = false, features = ["metadata"] }
+
+proc-macro2 = "1.0.36"
+quote = "1.0.15"
+
+
 [dev-dependencies]
 critical-section = { version = "1.1", features = ["std"] }
 proptest = "1.5.0"
 proptest-state-machine = "0.3.0"
 
-[build-dependencies]
-proc-macro2 = "1.0.36"
-quote = "1.0.15"
 
-#stm32-metapac = { version = "18", default-features = false, features = ["metadata"]}
-stm32-metapac = { git = "https://github.com/embassy-rs/stm32-data-generated", tag = "stm32-data-b9f6b0c542d85ee695d71c35ced195e0cef51ac0", default-features = false, features = ["metadata"] }
 
 [features]
 default = ["rt"]
@@ -313,6 +317,7 @@ single-bank = []
 
 ## internal use only
 _split-pins-enabled = []
+_allow-disable-rtc = []
 
 ## internal use only
 _dual-core = []
diff --git a/embassy-stm32/build.rs b/embassy-stm32/build.rs
index eea1acf68..940e29417 100644
--- a/embassy-stm32/build.rs
+++ b/embassy-stm32/build.rs
@@ -114,6 +114,8 @@ fn main() {
         }
     };
 
+    let has_bkpsram = memory.iter().any(|m| m.name == "BKPSRAM");
+
     // ========
     // Generate singletons
 
@@ -124,6 +126,13 @@ fn main() {
         singletons.push(p.name.to_string());
     }
 
+    cfgs.declare("backup_sram");
+
+    if has_bkpsram {
+        singletons.push("BKPSRAM".to_string());
+        cfgs.enable("backup_sram")
+    }
+
     // generate one singleton per peripheral (with many exceptions...)
     for p in METADATA.peripherals {
         if let Some(r) = &p.registers {
@@ -1985,6 +1994,18 @@ fn main() {
     ));
 
     // ========
+    // Generate backup sram constants
+    if let Some(m) = memory.iter().find(|m| m.name == "BKPSRAM") {
+        let bkpsram_base = m.address as usize;
+        let bkpsram_size = m.size as usize;
+
+        g.extend(quote!(
+            pub const BKPSRAM_BASE: usize = #bkpsram_base;
+            pub const BKPSRAM_SIZE: usize = #bkpsram_size;
+        ));
+    }
+
+    // ========
     // Generate flash constants
 
     let flash_regions: Vec<&MemoryRegion> = memory
@@ -2311,6 +2332,10 @@ fn mem_filter(chip: &str, region: &str) -> bool {
         return false;
     }
 
+    if region.starts_with("SDRAM_") || region.starts_with("FMC_") || region.starts_with("OCTOSPI_") {
+        return false;
+    }
+
     true
 }
 
diff --git a/embassy-stm32/src/adc/g4.rs b/embassy-stm32/src/adc/g4.rs
index 5098aadd8..3767820cf 100644
--- a/embassy-stm32/src/adc/g4.rs
+++ b/embassy-stm32/src/adc/g4.rs
@@ -1,11 +1,14 @@
+use core::mem;
+
 #[allow(unused)]
 #[cfg(stm32h7)]
 use pac::adc::vals::{Adcaldif, Difsel, Exten};
 #[allow(unused)]
 #[cfg(stm32g4)]
-use pac::adc::vals::{Adcaldif, Difsel, Exten, Rovsm, Trovs};
-use pac::adccommon::vals::Presc;
-use stm32_metapac::adc::vals::{Adstp, Dmacfg, Dmaen};
+pub use pac::adc::vals::{Adcaldif, Difsel, Exten, Rovsm, Trovs};
+pub use pac::adccommon::vals::Presc;
+pub use stm32_metapac::adc::vals::{Adstp, Dmacfg, Dmaen};
+pub use stm32_metapac::adccommon::vals::Dual;
 
 use super::{Adc, AdcChannel, AnyAdcChannel, Instance, Resolution, RxDma, SampleTime, blocking_delay_us};
 use crate::adc::SealedAdcChannel;
@@ -13,11 +16,19 @@ use crate::dma::Transfer;
 use crate::time::Hertz;
 use crate::{Peri, pac, rcc};
 
+mod ringbuffered;
+pub use ringbuffered::RingBufferedAdc;
+
+mod injected;
+pub use injected::InjectedAdc;
+
 /// Default VREF voltage used for sample conversion to millivolts.
 pub const VREF_DEFAULT_MV: u32 = 3300;
 /// VREF voltage used for factory calibration of VREFINTCAL register.
 pub const VREF_CALIB_MV: u32 = 3300;
 
+const NR_INJECTED_RANKS: usize = 4;
+
 /// Max single ADC operation clock frequency
 #[cfg(stm32g4)]
 const MAX_ADC_CLK_FREQ: Hertz = Hertz::mhz(60);
@@ -120,6 +131,24 @@ impl Prescaler {
     }
 }
 
+// Trigger source for ADC conversions¨
+#[derive(Copy, Clone)]
+pub struct ConversionTrigger {
+    // See Table 166 and 167 in RM0440 Rev 9 for ADC1/2 External triggers
+    // Note that Injected and Regular channels uses different mappings
+    pub channel: u8,
+    pub edge: Exten,
+}
+
+// Conversion mode for regular ADC channels
+#[derive(Copy, Clone)]
+pub enum RegularConversionMode {
+    // Samples as fast as possible
+    Continuous,
+    // Sample at rate determined by external trigger
+    Triggered(ConversionTrigger),
+}
+
 impl<'d, T: Instance> Adc<'d, T> {
     /// Create a new ADC driver.
     pub fn new(adc: Peri<'d, T>) -> Self {
@@ -357,7 +386,29 @@ impl<'d, T: Instance> Adc<'d, T> {
         self.read_channel(channel)
     }
 
-    /// Read one or multiple ADC channels using DMA.
+    /// Start regular adc conversion
+    pub(super) fn start() {
+        T::regs().cr().modify(|reg| {
+            reg.set_adstart(true);
+        });
+    }
+
+    /// Stop regular conversions
+    pub(super) fn stop() {
+        Self::stop_regular_conversions();
+    }
+
+    /// Teardown method for stopping regular ADC conversions
+    pub(super) fn teardown_adc() {
+        Self::stop_regular_conversions();
+
+        // Disable dma control
+        T::regs().cfgr().modify(|reg| {
+            reg.set_dmaen(Dmaen::DISABLE);
+        });
+    }
+
+    /// Read one or multiple ADC regular channels using DMA.
     ///
     /// `sequence` iterator and `readings` must have the same length.
     ///
@@ -382,6 +433,9 @@ impl<'d, T: Instance> Adc<'d, T> {
     /// .await;
     /// defmt::info!("measurements: {}", measurements);
     /// ```
+    ///
+    /// Note: This is not very efficient as the ADC needs to be reconfigured for each read. Use
+    /// `into_ring_buffered`, `into_ring_buffered_and_injected`
     pub async fn read(
         &mut self,
         rx_dma: Peri<'_, impl RxDma<T>>,
@@ -399,18 +453,16 @@ impl<'d, T: Instance> Adc<'d, T> {
         );
 
         // Ensure no conversions are ongoing and ADC is enabled.
-        Self::cancel_conversions();
+        Self::stop_regular_conversions();
         self.enable();
 
         // Set sequence length
         T::regs().sqr1().modify(|w| {
             w.set_l(sequence.len() as u8 - 1);
         });
-
         // Configure channels and ranks
         for (_i, (channel, sample_time)) in sequence.enumerate() {
             Self::configure_channel(channel, sample_time);
-
             match _i {
                 0..=3 => {
                     T::regs().sqr1().modify(|w| {
@@ -469,7 +521,7 @@ impl<'d, T: Instance> Adc<'d, T> {
         transfer.await;
 
         // Ensure conversions are finished.
-        Self::cancel_conversions();
+        Self::stop_regular_conversions();
 
         // Reset configuration.
         T::regs().cfgr().modify(|reg| {
@@ -477,6 +529,277 @@ impl<'d, T: Instance> Adc<'d, T> {
         });
     }
 
+    /// Set external trigger for regular conversion sequence
+    fn set_regular_conversion_trigger(&mut self, trigger: ConversionTrigger) {
+        T::regs().cfgr().modify(|r| {
+            r.set_extsel(trigger.channel);
+            r.set_exten(trigger.edge);
+        });
+        // Regular conversions uses DMA so no need to generate interrupt
+        T::regs().ier().modify(|r| r.set_eosie(false));
+    }
+
+    // Dual ADC mode selection
+    pub fn configure_dual_mode(&mut self, val: Dual) {
+        T::common_regs().ccr().modify(|reg| {
+            reg.set_dual(val);
+        })
+    }
+
+    /// Configures the ADC to use a DMA ring buffer for continuous data acquisition.
+    ///
+    /// Use the [`read`] method to retrieve measurements from the DMA ring buffer. The read buffer
+    /// should be exactly half the size of `dma_buf`. When using triggered mode, it is recommended
+    /// to configure `dma_buf` as a double buffer so that one half can be read while the other half
+    /// is being filled by the DMA, preventing data loss. The trigger period of the ADC effectively
+    /// defines the period at which the buffer should be read.
+    ///
+    /// If continous conversion mode is selected, the provided `dma_buf` must be large enough to prevent
+    /// DMA buffer overruns. Its length should be a multiple of the number of ADC channels being measured.
+    /// For example, if 3 channels are measured and you want to store 40 samples per channel,
+    /// the buffer length should be `3 * 40 = 120`.
+    ///
+    /// # Parameters
+    /// - `dma`: The DMA peripheral used to transfer ADC data into the buffer.
+    /// - `dma_buf`: The buffer where DMA stores ADC samples.
+    /// - `regular_sequence`: Sequence of channels and sample times for regular ADC conversions.
+    /// - `regular_conversion_mode`: Mode for regular conversions (continuous or triggered).
+    ///
+    /// # Returns
+    /// A `RingBufferedAdc<'a, T>` instance configured for continuous DMA-based sampling.
+    pub fn into_ring_buffered<'a>(
+        mut self,
+        dma: Peri<'a, impl RxDma<T>>,
+        dma_buf: &'a mut [u16],
+        sequence: impl ExactSizeIterator<Item = (AnyAdcChannel<T>, SampleTime)>,
+        mode: RegularConversionMode,
+    ) -> RingBufferedAdc<'a, T> {
+        assert!(!dma_buf.is_empty() && dma_buf.len() <= 0xFFFF);
+        assert!(sequence.len() != 0, "Asynchronous read sequence cannot be empty");
+        assert!(
+            sequence.len() <= 16,
+            "Asynchronous read sequence cannot be more than 16 in length"
+        );
+        // reset conversions and enable the adc
+        Self::stop_regular_conversions();
+        self.enable();
+
+        //adc side setup
+
+        // Set sequence length
+        T::regs().sqr1().modify(|w| {
+            w.set_l(sequence.len() as u8 - 1);
+        });
+
+        // Configure channels and ranks
+        for (_i, (mut channel, sample_time)) in sequence.enumerate() {
+            Self::configure_channel(&mut channel, sample_time);
+
+            match _i {
+                0..=3 => {
+                    T::regs().sqr1().modify(|w| {
+                        w.set_sq(_i, channel.channel());
+                    });
+                }
+                4..=8 => {
+                    T::regs().sqr2().modify(|w| {
+                        w.set_sq(_i - 4, channel.channel());
+                    });
+                }
+                9..=13 => {
+                    T::regs().sqr3().modify(|w| {
+                        w.set_sq(_i - 9, channel.channel());
+                    });
+                }
+                14..=15 => {
+                    T::regs().sqr4().modify(|w| {
+                        w.set_sq(_i - 14, channel.channel());
+                    });
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        // Clear overrun flag before starting transfer.
+        T::regs().isr().modify(|reg| {
+            reg.set_ovr(true);
+        });
+
+        T::regs().cfgr().modify(|reg| {
+            reg.set_discen(false); // Convert all channels for each trigger
+            reg.set_dmacfg(Dmacfg::CIRCULAR);
+            reg.set_dmaen(Dmaen::ENABLE);
+        });
+
+        match mode {
+            RegularConversionMode::Continuous => {
+                T::regs().cfgr().modify(|reg| {
+                    reg.set_cont(true);
+                });
+            }
+            RegularConversionMode::Triggered(trigger) => {
+                T::regs().cfgr().modify(|r| {
+                    r.set_cont(false); // New trigger is neede for each sample to be read
+                });
+                self.set_regular_conversion_trigger(trigger);
+            }
+        }
+
+        mem::forget(self);
+
+        RingBufferedAdc::new(dma, dma_buf)
+    }
+
+    /// Configures the ADC for injected conversions.
+    ///
+    /// Injected conversions are separate from the regular conversion sequence and are typically
+    /// triggered by software or an external event. This method sets up a fixed-length sequence of
+    /// injected channels with specified sample times, the trigger source, and whether the end-of-sequence
+    /// interrupt should be enabled.
+    ///
+    /// # Parameters
+    /// - `sequence`: An array of tuples containing the ADC channels and their sample times. The length
+    ///   `N` determines the number of injected ranks to configure (maximum 4 for STM32).
+    /// - `trigger`: The trigger source that starts the injected conversion sequence.
+    /// - `interrupt`: If `true`, enables the end-of-sequence (JEOS) interrupt for injected conversions.
+    ///
+    /// # Returns
+    /// An `InjectedAdc<T, N>` instance that represents the configured injected sequence. The returned
+    /// type encodes the sequence length `N` in its type, ensuring that reads return exactly `N` samples.
+    ///
+    /// # Panics
+    /// This function will panic if:
+    /// - `sequence` is empty.
+    /// - `sequence` length exceeds the maximum number of injected ranks (`NR_INJECTED_RANKS`).
+    ///
+    /// # Notes
+    /// - Injected conversions can run independently of regular ADC conversions.
+    /// - The order of channels in `sequence` determines the rank order in the injected sequence.
+    /// - Accessing samples beyond `N` will result in a panic; use the returned type
+    ///   `InjectedAdc<T, N>` to enforce bounds at compile time.
+    pub fn setup_injected_conversions<'a, const N: usize>(
+        mut self,
+        sequence: [(AnyAdcChannel<T>, SampleTime); N],
+        trigger: ConversionTrigger,
+        interrupt: bool,
+    ) -> InjectedAdc<T, N> {
+        assert!(N != 0, "Read sequence cannot be empty");
+        assert!(
+            N <= NR_INJECTED_RANKS,
+            "Read sequence cannot be more than {} in length",
+            NR_INJECTED_RANKS
+        );
+
+        Self::stop_regular_conversions();
+        self.enable();
+
+        T::regs().jsqr().modify(|w| w.set_jl(N as u8 - 1));
+
+        for (n, (mut channel, sample_time)) in sequence.into_iter().enumerate() {
+            Self::configure_channel(&mut channel, sample_time);
+
+            let idx = match n {
+                0..=3 => n,
+                4..=8 => n - 4,
+                9..=13 => n - 9,
+                14..=15 => n - 14,
+                _ => unreachable!(),
+            };
+
+            T::regs().jsqr().modify(|w| w.set_jsq(idx, channel.channel()));
+        }
+
+        T::regs().cfgr().modify(|reg| reg.set_jdiscen(false));
+
+        self.set_injected_conversion_trigger(trigger);
+        self.enable_injected_eos_interrupt(interrupt);
+        Self::start_injected_conversions();
+
+        InjectedAdc::new(sequence) // InjectedAdc<'a, T, N> now borrows the channels
+    }
+
+    /// Configures ADC for both regular conversions with a ring-buffered DMA and injected conversions.
+    ///
+    /// # Parameters
+    /// - `dma`: The DMA peripheral to use for the ring-buffered ADC transfers.
+    /// - `dma_buf`: The buffer to store DMA-transferred samples for regular conversions.
+    /// - `regular_sequence`: The sequence of channels and their sample times for regular conversions.
+    /// - `regular_conversion_mode`: The mode for regular conversions (e.g., continuous or triggered).
+    /// - `injected_sequence`: An array of channels and sample times for injected conversions (length `N`).
+    /// - `injected_trigger`: The trigger source for injected conversions.
+    /// - `injected_interrupt`: Whether to enable the end-of-sequence interrupt for injected conversions.
+    ///
+    /// Injected conversions are typically used with interrupts. If ADC1 and ADC2 are used in dual mode,
+    /// it is recommended to enable interrupts only for the ADC whose sequence takes the longest to complete.
+    ///
+    /// # Returns
+    /// A tuple containing:
+    /// 1. `RingBufferedAdc<'a, T>` — the configured ADC for regular conversions using DMA.
+    /// 2. `InjectedAdc<T, N>` — the configured ADC for injected conversions.
+    ///
+    /// # Safety
+    /// This function is `unsafe` because it clones the ADC peripheral handle unchecked. Both the
+    /// `RingBufferedAdc` and `InjectedAdc` take ownership of the handle and drop it independently.
+    /// Ensure no other code concurrently accesses the same ADC instance in a conflicting way.
+    pub fn into_ring_buffered_and_injected<'a, const N: usize>(
+        self,
+        dma: Peri<'a, impl RxDma<T>>,
+        dma_buf: &'a mut [u16],
+        regular_sequence: impl ExactSizeIterator<Item = (AnyAdcChannel<T>, SampleTime)>,
+        regular_conversion_mode: RegularConversionMode,
+        injected_sequence: [(AnyAdcChannel<T>, SampleTime); N],
+        injected_trigger: ConversionTrigger,
+        injected_interrupt: bool,
+    ) -> (RingBufferedAdc<'a, T>, InjectedAdc<T, N>) {
+        unsafe {
+            (
+                Self {
+                    adc: self.adc.clone_unchecked(),
+                    sample_time: self.sample_time,
+                }
+                .into_ring_buffered(dma, dma_buf, regular_sequence, regular_conversion_mode),
+                Self {
+                    adc: self.adc.clone_unchecked(),
+                    sample_time: self.sample_time,
+                }
+                .setup_injected_conversions(injected_sequence, injected_trigger, injected_interrupt),
+            )
+        }
+    }
+
+    /// Stop injected conversions
+    pub(super) fn stop_injected_conversions() {
+        if T::regs().cr().read().adstart() && !T::regs().cr().read().addis() {
+            T::regs().cr().modify(|reg| {
+                reg.set_jadstp(Adstp::STOP);
+            });
+            // The software must poll JADSTART until the bit is reset before assuming the
+            // ADC is completely stopped
+            while T::regs().cr().read().jadstart() {}
+        }
+    }
+
+    /// Start injected ADC conversion
+    pub(super) fn start_injected_conversions() {
+        T::regs().cr().modify(|reg| {
+            reg.set_jadstart(true);
+        });
+    }
+
+    /// Set external trigger for injected conversion sequence
+    /// Possible trigger values are seen in Table 167 in RM0440 Rev 9
+    fn set_injected_conversion_trigger(&mut self, trigger: ConversionTrigger) {
+        T::regs().jsqr().modify(|r| {
+            r.set_jextsel(trigger.channel);
+            r.set_jexten(trigger.edge);
+        });
+    }
+
+    /// Enable end of injected sequence interrupt
+    fn enable_injected_eos_interrupt(&mut self, enable: bool) {
+        T::regs().ier().modify(|r| r.set_jeosie(enable));
+    }
+
     fn configure_channel(channel: &mut impl AdcChannel<T>, sample_time: SampleTime) {
         // Configure channel
         Self::set_channel_sample_time(channel.channel(), sample_time);
@@ -509,16 +832,34 @@ impl<'d, T: Instance> Adc<'d, T> {
         }
     }
 
-    fn cancel_conversions() {
+    // Stop regular conversions
+    fn stop_regular_conversions() {
         if T::regs().cr().read().adstart() && !T::regs().cr().read().addis() {
             T::regs().cr().modify(|reg| {
                 reg.set_adstp(Adstp::STOP);
             });
+            // The software must poll ADSTART until the bit is reset before assuming the
+            // ADC is completely stopped
             while T::regs().cr().read().adstart() {}
         }
     }
 }
 
+impl<T: Instance, const N: usize> InjectedAdc<T, N> {
+    /// Read sampled data from all injected ADC injected ranks
+    /// Clear the JEOS flag to allow a new injected sequence
+    pub(super) fn read_injected_data() -> [u16; N] {
+        let mut data = [0u16; N];
+        for i in 0..N {
+            data[i] = T::regs().jdr(i).read().jdata();
+        }
+
+        // Clear JEOS by writing 1
+        T::regs().isr().modify(|r| r.set_jeos(true));
+        data
+    }
+}
+
 /// Implemented for ADCs that have a Temperature channel
 pub trait TemperatureChannel {
     const CHANNEL: u8;
diff --git a/embassy-stm32/src/adc/injected.rs b/embassy-stm32/src/adc/injected.rs
new file mode 100644
index 000000000..0e4fe5847
--- /dev/null
+++ b/embassy-stm32/src/adc/injected.rs
@@ -0,0 +1,44 @@
+use core::marker::PhantomData;
+use core::sync::atomic::{Ordering, compiler_fence};
+
+#[allow(unused_imports)]
+use embassy_hal_internal::Peri;
+
+use super::{AnyAdcChannel, SampleTime};
+use crate::adc::Adc;
+#[allow(unused_imports)]
+use crate::adc::Instance;
+
+/// Injected ADC sequence with owned channels.
+pub struct InjectedAdc<T: Instance, const N: usize> {
+    _channels: [(AnyAdcChannel<T>, SampleTime); N],
+    _phantom: PhantomData<T>,
+}
+
+impl<T: Instance, const N: usize> InjectedAdc<T, N> {
+    pub(crate) fn new(channels: [(AnyAdcChannel<T>, SampleTime); N]) -> Self {
+        Self {
+            _channels: channels,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub fn stop_injected_conversions(&mut self) {
+        Adc::<T>::stop_injected_conversions()
+    }
+
+    pub fn start_injected_conversions(&mut self) {
+        Adc::<T>::start_injected_conversions()
+    }
+
+    pub fn read_injected_samples(&mut self) -> [u16; N] {
+        InjectedAdc::<T, N>::read_injected_data()
+    }
+}
+
+impl<T: Instance, const N: usize> Drop for InjectedAdc<T, N> {
+    fn drop(&mut self) {
+        Adc::<T>::teardown_adc();
+        compiler_fence(Ordering::SeqCst);
+    }
+}
diff --git a/embassy-stm32/src/adc/mod.rs b/embassy-stm32/src/adc/mod.rs
index 22ed8295f..ea7341f75 100644
--- a/embassy-stm32/src/adc/mod.rs
+++ b/embassy-stm32/src/adc/mod.rs
@@ -87,14 +87,18 @@ pub(crate) trait SealedAdcChannel<T> {
 /// Performs a busy-wait delay for a specified number of microseconds.
 #[allow(unused)]
 pub(crate) fn blocking_delay_us(us: u32) {
-    #[cfg(feature = "time")]
-    embassy_time::block_for(embassy_time::Duration::from_micros(us as u64));
-    #[cfg(not(feature = "time"))]
-    {
-        let freq = unsafe { crate::rcc::get_freqs() }.sys.to_hertz().unwrap().0 as u64;
-        let us = us as u64;
-        let cycles = freq * us / 1_000_000;
-        cortex_m::asm::delay(cycles as u32);
+    cfg_if::cfg_if! {
+        // this does strange things on stm32wlx in low power mode depending on exactly when it's called
+        // as in sometimes 15 us (1 tick) would take > 20 seconds.
+        if #[cfg(all(feature = "time", all(not(feature = "low-power"), not(stm32wlex))))] {
+            let duration = embassy_time::Duration::from_micros(us as u64);
+            embassy_time::block_for(duration);
+        } else {
+            let freq = unsafe { crate::rcc::get_freqs() }.sys.to_hertz().unwrap().0 as u64;
+            let us = us as u64;
+            let cycles = freq * us / 1_000_000;
+            cortex_m::asm::delay(cycles as u32);
+        }
     }
 }
 
diff --git a/embassy-stm32/src/adc/ringbuffered.rs b/embassy-stm32/src/adc/ringbuffered.rs
new file mode 100644
index 000000000..971c8195c
--- /dev/null
+++ b/embassy-stm32/src/adc/ringbuffered.rs
@@ -0,0 +1,182 @@
+use core::marker::PhantomData;
+use core::sync::atomic::{Ordering, compiler_fence};
+
+#[allow(unused_imports)]
+use embassy_hal_internal::Peri;
+
+use crate::adc::Adc;
+#[allow(unused_imports)]
+use crate::adc::{Instance, RxDma};
+#[allow(unused_imports)]
+use crate::dma::{ReadableRingBuffer, TransferOptions};
+use crate::rcc;
+
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub struct OverrunError;
+
+pub struct RingBufferedAdc<'d, T: Instance> {
+    _phantom: PhantomData<T>,
+    ring_buf: ReadableRingBuffer<'d, u16>,
+}
+
+impl<'d, T: Instance> RingBufferedAdc<'d, T> {
+    pub(crate) fn new(dma: Peri<'d, impl RxDma<T>>, dma_buf: &'d mut [u16]) -> Self {
+        //dma side setup
+        let opts = TransferOptions {
+            half_transfer_ir: true,
+            circular: true,
+            ..Default::default()
+        };
+
+        // Safety: we forget the struct before this function returns.
+        let request = dma.request();
+
+        let ring_buf =
+            unsafe { ReadableRingBuffer::new(dma, request, T::regs().dr().as_ptr() as *mut u16, dma_buf, opts) };
+
+        Self {
+            _phantom: PhantomData,
+            ring_buf,
+        }
+    }
+
+    /// Turns on ADC if it is not already turned on and starts continuous DMA transfer.
+    pub fn start(&mut self) {
+        compiler_fence(Ordering::SeqCst);
+        self.ring_buf.start();
+
+        Adc::<T>::start();
+    }
+
+    pub fn stop(&mut self) {
+        Adc::<T>::stop();
+
+        self.ring_buf.request_pause();
+
+        compiler_fence(Ordering::SeqCst);
+    }
+
+    pub fn clear(&mut self) {
+        self.ring_buf.clear();
+    }
+
+    /// Reads measurements from the DMA ring buffer.
+    ///
+    /// This method fills the provided `measurements` array with ADC readings from the DMA buffer.
+    /// The length of the `measurements` array should be exactly half of the DMA buffer length.
+    /// Because interrupts are only generated if half or full DMA transfer completes.
+    ///
+    /// Each call to `read` will populate the `measurements` array in the same order as the channels
+    /// defined with `sequence`. There will be many sequences worth of measurements in this array
+    /// because it only returns if at least half of the DMA buffer is filled. For example if 2
+    /// channels are sampled `measurements` contain: `[sq0 sq1 sq0 sq1 sq0 sq1 ..]`.
+    ///
+    /// Note that the ADC Datarate can be very fast, it is suggested to use DMA mode inside tightly
+    /// running tasks. Otherwise, you'll see constant Overrun errors occurring, this means that
+    /// you're sampling too quickly for the task to handle, and you may need to increase the buffer size.
+    /// Example:
+    /// ```rust,ignore
+    /// const DMA_BUF_LEN: usize = 120;
+    /// use embassy_stm32::adc::{Adc, AdcChannel}
+    ///
+    /// let mut adc = Adc::new(p.ADC1);
+    /// let mut adc_pin0 = p.PA0.degrade_adc();
+    /// let mut adc_pin1 = p.PA1.degrade_adc();
+    /// let adc_dma_buf = [0u16; DMA_BUF_LEN];
+    ///
+    /// let mut ring_buffered_adc: RingBufferedAdc<embassy_stm32::peripherals::ADC1> = adc.into_ring_buffered(
+    ///     p.DMA2_CH0,
+    ///      adc_dma_buf, [
+    ///         (&mut *adc_pin0, SampleTime::CYCLES160_5),
+    ///         (&mut *adc_pin1, SampleTime::CYCLES160_5),
+    ///     ].into_iter());
+    ///
+    ///
+    /// let mut measurements = [0u16; DMA_BUF_LEN / 2];
+    /// loop {
+    ///     match ring_buffered_adc.read(&mut measurements).await {
+    ///         Ok(_) => {
+    ///             defmt::info!("adc1: {}", measurements);
+    ///         }
+    ///         Err(e) => {
+    ///             defmt::warn!("Error: {:?}", e);
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    ///
+    /// [`teardown_adc`]: #method.teardown_adc
+    /// [`start_continuous_sampling`]: #method.start_continuous_sampling
+    pub async fn read(&mut self, measurements: &mut [u16]) -> Result<usize, OverrunError> {
+        assert_eq!(
+            self.ring_buf.capacity() / 2,
+            measurements.len(),
+            "Buffer size must be half the size of the ring buffer"
+        );
+
+        if !self.ring_buf.is_running() {
+            self.start();
+        }
+
+        #[cfg(adc_v2)]
+        {
+            // Clear overrun flag if set.
+            if T::regs().sr().read().ovr() {
+                self.stop();
+
+                return Err(OverrunError);
+            }
+        }
+
+        self.ring_buf.read_exact(measurements).await.map_err(|_| OverrunError)
+    }
+
+    /// Read bytes that are readily available in the ring buffer.
+    /// If no bytes are currently available in the buffer the call waits until the some
+    /// bytes are available (at least one byte and at most half the buffer size)
+    ///
+    /// Background receive is started if `start_continuous_sampling()` has not been previously called.
+    ///
+    /// Receive in the background is terminated if an error is returned.
+    /// It must then manually be started again by calling `start_continuous_sampling()` or by re-calling `blocking_read()`.
+    pub fn blocking_read(&mut self, buf: &mut [u16]) -> Result<usize, OverrunError> {
+        if !self.ring_buf.is_running() {
+            self.start();
+        }
+
+        #[cfg(adc_v2)]
+        {
+            // Clear overrun flag if set.
+            if T::regs().sr().read().ovr() {
+                self.stop();
+
+                return Err(OverrunError);
+            }
+        }
+        loop {
+            match self.ring_buf.read(buf) {
+                Ok((0, _)) => {}
+                Ok((len, _)) => {
+                    return Ok(len);
+                }
+                Err(_) => {
+                    self.stop();
+
+                    return Err(OverrunError);
+                }
+            }
+        }
+    }
+}
+
+impl<T: Instance> Drop for RingBufferedAdc<'_, T> {
+    fn drop(&mut self) {
+        Adc::<T>::teardown_adc();
+
+        compiler_fence(Ordering::SeqCst);
+
+        self.ring_buf.request_pause();
+        rcc::disable::<T>();
+    }
+}
diff --git a/embassy-stm32/src/adc/ringbuffered_v2.rs b/embassy-stm32/src/adc/ringbuffered_v2.rs
deleted file mode 100644
index 9b2e5b8fe..000000000
--- a/embassy-stm32/src/adc/ringbuffered_v2.rs
+++ /dev/null
@@ -1,432 +0,0 @@
-use core::marker::PhantomData;
-use core::mem;
-use core::sync::atomic::{Ordering, compiler_fence};
-
-use stm32_metapac::adc::vals::SampleTime;
-
-use crate::adc::{Adc, AdcChannel, Instance, RxDma};
-use crate::dma::{Priority, ReadableRingBuffer, TransferOptions};
-use crate::pac::adc::vals;
-use crate::{Peri, rcc};
-
-#[cfg_attr(feature = "defmt", derive(defmt::Format))]
-pub struct OverrunError;
-
-fn clear_interrupt_flags(r: crate::pac::adc::Adc) {
-    r.sr().modify(|regs| {
-        regs.set_eoc(false);
-        regs.set_ovr(false);
-    });
-}
-
-#[derive(PartialOrd, PartialEq, Debug, Clone, Copy)]
-pub enum Sequence {
-    One,
-    Two,
-    Three,
-    Four,
-    Five,
-    Six,
-    Seven,
-    Eight,
-    Nine,
-    Ten,
-    Eleven,
-    Twelve,
-    Thirteen,
-    Fourteen,
-    Fifteen,
-    Sixteen,
-}
-
-impl From<Sequence> for u8 {
-    fn from(s: Sequence) -> u8 {
-        match s {
-            Sequence::One => 0,
-            Sequence::Two => 1,
-            Sequence::Three => 2,
-            Sequence::Four => 3,
-            Sequence::Five => 4,
-            Sequence::Six => 5,
-            Sequence::Seven => 6,
-            Sequence::Eight => 7,
-            Sequence::Nine => 8,
-            Sequence::Ten => 9,
-            Sequence::Eleven => 10,
-            Sequence::Twelve => 11,
-            Sequence::Thirteen => 12,
-            Sequence::Fourteen => 13,
-            Sequence::Fifteen => 14,
-            Sequence::Sixteen => 15,
-        }
-    }
-}
-
-impl From<u8> for Sequence {
-    fn from(val: u8) -> Self {
-        match val {
-            0 => Sequence::One,
-            1 => Sequence::Two,
-            2 => Sequence::Three,
-            3 => Sequence::Four,
-            4 => Sequence::Five,
-            5 => Sequence::Six,
-            6 => Sequence::Seven,
-            7 => Sequence::Eight,
-            8 => Sequence::Nine,
-            9 => Sequence::Ten,
-            10 => Sequence::Eleven,
-            11 => Sequence::Twelve,
-            12 => Sequence::Thirteen,
-            13 => Sequence::Fourteen,
-            14 => Sequence::Fifteen,
-            15 => Sequence::Sixteen,
-            _ => panic!("Invalid sequence number"),
-        }
-    }
-}
-
-pub struct RingBufferedAdc<'d, T: Instance> {
-    _phantom: PhantomData<T>,
-    ring_buf: ReadableRingBuffer<'d, u16>,
-}
-
-impl<'d, T: Instance> Adc<'d, T> {
-    /// Configures the ADC to use a DMA ring buffer for continuous data acquisition.
-    ///
-    /// The `dma_buf` should be large enough to prevent DMA buffer overrun.
-    /// The length of the `dma_buf` should be a multiple of the ADC channel count.
-    /// For example, if 3 channels are measured, its length can be 3 * 40 = 120 measurements.
-    ///
-    /// `read` method is used to read out measurements from the DMA ring buffer, and its buffer should be exactly half of the `dma_buf` length.
-    /// It is critical to call `read` frequently to prevent DMA buffer overrun.
-    ///
-    /// [`read`]: #method.read
-    pub fn into_ring_buffered(self, dma: Peri<'d, impl RxDma<T>>, dma_buf: &'d mut [u16]) -> RingBufferedAdc<'d, T> {
-        assert!(!dma_buf.is_empty() && dma_buf.len() <= 0xFFFF);
-
-        let opts: crate::dma::TransferOptions = TransferOptions {
-            half_transfer_ir: true,
-            priority: Priority::VeryHigh,
-            ..Default::default()
-        };
-
-        // Safety: we forget the struct before this function returns.
-        let rx_src = T::regs().dr().as_ptr() as *mut u16;
-        let request = dma.request();
-
-        let ring_buf = unsafe { ReadableRingBuffer::new(dma, request, rx_src, dma_buf, opts) };
-
-        // Don't disable the clock
-        mem::forget(self);
-
-        RingBufferedAdc {
-            _phantom: PhantomData,
-            ring_buf,
-        }
-    }
-}
-
-impl<'d, T: Instance> RingBufferedAdc<'d, T> {
-    fn is_on() -> bool {
-        T::regs().cr2().read().adon()
-    }
-
-    fn stop_adc() {
-        T::regs().cr2().modify(|reg| {
-            reg.set_adon(false);
-        });
-    }
-
-    fn start_adc() {
-        T::regs().cr2().modify(|reg| {
-            reg.set_adon(true);
-        });
-    }
-
-    /// Sets the channel sample time
-    ///
-    /// ## SAFETY:
-    /// - ADON == 0 i.e ADC must not be enabled when this is called.
-    unsafe fn set_channel_sample_time(ch: u8, sample_time: SampleTime) {
-        if ch <= 9 {
-            T::regs().smpr2().modify(|reg| reg.set_smp(ch as _, sample_time));
-        } else {
-            T::regs().smpr1().modify(|reg| reg.set_smp((ch - 10) as _, sample_time));
-        }
-    }
-
-    fn set_channels_sample_time(&mut self, ch: &[u8], sample_time: SampleTime) {
-        let ch_iter = ch.iter();
-        for idx in ch_iter {
-            unsafe {
-                Self::set_channel_sample_time(*idx, sample_time);
-            }
-        }
-    }
-
-    pub fn set_sample_sequence(
-        &mut self,
-        sequence: Sequence,
-        channel: &mut impl AdcChannel<T>,
-        sample_time: SampleTime,
-    ) {
-        let was_on = Self::is_on();
-        if !was_on {
-            Self::start_adc();
-        }
-
-        // Check the sequence is long enough
-        T::regs().sqr1().modify(|r| {
-            let prev: Sequence = r.l().into();
-            if prev < sequence {
-                let new_l: Sequence = sequence;
-                trace!("Setting sequence length from {:?} to {:?}", prev as u8, new_l as u8);
-                r.set_l(sequence.into())
-            } else {
-                r.set_l(prev.into())
-            }
-        });
-
-        // Set this GPIO as an analog input.
-        channel.setup();
-
-        // Set the channel in the right sequence field.
-        match sequence {
-            Sequence::One => T::regs().sqr3().modify(|w| w.set_sq(0, channel.channel())),
-            Sequence::Two => T::regs().sqr3().modify(|w| w.set_sq(1, channel.channel())),
-            Sequence::Three => T::regs().sqr3().modify(|w| w.set_sq(2, channel.channel())),
-            Sequence::Four => T::regs().sqr3().modify(|w| w.set_sq(3, channel.channel())),
-            Sequence::Five => T::regs().sqr3().modify(|w| w.set_sq(4, channel.channel())),
-            Sequence::Six => T::regs().sqr3().modify(|w| w.set_sq(5, channel.channel())),
-            Sequence::Seven => T::regs().sqr2().modify(|w| w.set_sq(0, channel.channel())),
-            Sequence::Eight => T::regs().sqr2().modify(|w| w.set_sq(1, channel.channel())),
-            Sequence::Nine => T::regs().sqr2().modify(|w| w.set_sq(2, channel.channel())),
-            Sequence::Ten => T::regs().sqr2().modify(|w| w.set_sq(3, channel.channel())),
-            Sequence::Eleven => T::regs().sqr2().modify(|w| w.set_sq(4, channel.channel())),
-            Sequence::Twelve => T::regs().sqr2().modify(|w| w.set_sq(5, channel.channel())),
-            Sequence::Thirteen => T::regs().sqr1().modify(|w| w.set_sq(0, channel.channel())),
-            Sequence::Fourteen => T::regs().sqr1().modify(|w| w.set_sq(1, channel.channel())),
-            Sequence::Fifteen => T::regs().sqr1().modify(|w| w.set_sq(2, channel.channel())),
-            Sequence::Sixteen => T::regs().sqr1().modify(|w| w.set_sq(3, channel.channel())),
-        };
-
-        if !was_on {
-            Self::stop_adc();
-        }
-
-        self.set_channels_sample_time(&[channel.channel()], sample_time);
-
-        Self::start_adc();
-    }
-
-    /// Turns on ADC if it is not already turned on and starts continuous DMA transfer.
-    pub fn start(&mut self) -> Result<(), OverrunError> {
-        self.setup_adc();
-        self.ring_buf.clear();
-
-        Ok(())
-    }
-
-    fn stop(&mut self, err: OverrunError) -> Result<usize, OverrunError> {
-        self.teardown_adc();
-        Err(err)
-    }
-
-    /// Stops DMA transfer.
-    /// It does not turn off ADC.
-    /// Calling `start` restarts continuous DMA transfer.
-    ///
-    /// [`start`]: #method.start
-    pub fn teardown_adc(&mut self) {
-        // Stop the DMA transfer
-        self.ring_buf.request_pause();
-
-        let r = T::regs();
-
-        // Stop ADC
-        r.cr2().modify(|reg| {
-            // Stop ADC
-            reg.set_swstart(false);
-            // Stop DMA
-            reg.set_dma(false);
-        });
-
-        r.cr1().modify(|w| {
-            // Disable interrupt for end of conversion
-            w.set_eocie(false);
-            // Disable interrupt for overrun
-            w.set_ovrie(false);
-        });
-
-        clear_interrupt_flags(r);
-
-        compiler_fence(Ordering::SeqCst);
-    }
-
-    fn setup_adc(&mut self) {
-        compiler_fence(Ordering::SeqCst);
-
-        self.ring_buf.start();
-
-        let r = T::regs();
-
-        // Enable ADC
-        let was_on = Self::is_on();
-        if !was_on {
-            r.cr2().modify(|reg| {
-                reg.set_adon(false);
-                reg.set_swstart(false);
-            });
-        }
-
-        // Clear all interrupts
-        r.sr().modify(|regs| {
-            regs.set_eoc(false);
-            regs.set_ovr(false);
-            regs.set_strt(false);
-        });
-
-        r.cr1().modify(|w| {
-            // Enable interrupt for end of conversion
-            w.set_eocie(true);
-            // Enable interrupt for overrun
-            w.set_ovrie(true);
-            // Scanning converisons of multiple channels
-            w.set_scan(true);
-            // Continuous conversion mode
-            w.set_discen(false);
-        });
-
-        r.cr2().modify(|w| {
-            // Enable DMA mode
-            w.set_dma(true);
-            // Enable continuous conversions
-            w.set_cont(true);
-            // DMA requests are issues as long as DMA=1 and data are converted.
-            w.set_dds(vals::Dds::CONTINUOUS);
-            // EOC flag is set at the end of each conversion.
-            w.set_eocs(vals::Eocs::EACH_CONVERSION);
-        });
-
-        // Begin ADC conversions
-        T::regs().cr2().modify(|reg| {
-            reg.set_adon(true);
-            reg.set_swstart(true);
-        });
-
-        super::blocking_delay_us(3);
-    }
-
-    /// Read bytes that are readily available in the ring buffer.
-    /// If no bytes are currently available in the buffer the call waits until the some
-    /// bytes are available (at least one byte and at most half the buffer size)
-    ///
-    /// Background receive is started if `start()` has not been previously called.
-    ///
-    /// Receive in the background is terminated if an error is returned.
-    /// It must then manually be started again by calling `start()` or by re-calling `read()`.
-    pub fn blocking_read<const N: usize>(&mut self, buf: &mut [u16; N]) -> Result<usize, OverrunError> {
-        let r = T::regs();
-
-        // Start background receive if it was not already started
-        if !r.cr2().read().dma() {
-            self.start()?;
-        }
-
-        // Clear overrun flag if set.
-        if r.sr().read().ovr() {
-            return self.stop(OverrunError);
-        }
-
-        loop {
-            match self.ring_buf.read(buf) {
-                Ok((0, _)) => {}
-                Ok((len, _)) => {
-                    return Ok(len);
-                }
-                Err(_) => {
-                    return self.stop(OverrunError);
-                }
-            }
-        }
-    }
-
-    /// Reads measurements from the DMA ring buffer.
-    ///
-    /// This method fills the provided `measurements` array with ADC readings from the DMA buffer.
-    /// The length of the `measurements` array should be exactly half of the DMA buffer length. Because interrupts are only generated if half or full DMA transfer completes.
-    ///
-    /// Each call to `read` will populate the `measurements` array in the same order as the channels defined with `set_sample_sequence`.
-    /// There will be many sequences worth of measurements in this array because it only returns if at least half of the DMA buffer is filled.
-    /// For example if 3 channels are sampled `measurements` contain: `[sq0 sq1 sq3 sq0 sq1 sq3 sq0 sq1 sq3 sq0 sq1 sq3..]`.
-    ///
-    /// If an error is returned, it indicates a DMA overrun, and the process must be restarted by calling `start` or `read` again.
-    ///
-    /// By default, the ADC fills the DMA buffer as quickly as possible. To control the sample rate, call `teardown_adc` after each readout, and then start the DMA again at the desired interval.
-    /// Note that even if using `teardown_adc` to control the sample rate, with each call to `read`, measurements equivalent to half the size of the DMA buffer are still collected.
-    ///
-    /// Example:
-    /// ```rust,ignore
-    /// const DMA_BUF_LEN: usize = 120;
-    /// let adc_dma_buf = [0u16; DMA_BUF_LEN];
-    /// let mut adc: RingBufferedAdc<embassy_stm32::peripherals::ADC1> = adc.into_ring_buffered(p.DMA2_CH0, adc_dma_buf);
-    ///
-    /// adc.set_sample_sequence(Sequence::One, &mut p.PA0, SampleTime::CYCLES112);
-    /// adc.set_sample_sequence(Sequence::Two, &mut p.PA1, SampleTime::CYCLES112);
-    /// adc.set_sample_sequence(Sequence::Three, &mut p.PA2, SampleTime::CYCLES112);
-    ///
-    /// let mut measurements = [0u16; DMA_BUF_LEN / 2];
-    /// loop {
-    ///     match adc.read(&mut measurements).await {
-    ///         Ok(_) => {
-    ///             defmt::info!("adc1: {}", measurements);
-    ///             // Only needed to manually control sample rate.
-    ///             adc.teardown_adc();
-    ///         }
-    ///         Err(e) => {
-    ///             defmt::warn!("Error: {:?}", e);
-    ///             // DMA overrun, next call to `read` restarts ADC.
-    ///         }
-    ///     }
-    ///
-    ///     // Manually control sample rate.
-    ///     Timer::after_millis(100).await;
-    /// }
-    /// ```
-    ///
-    ///
-    /// [`set_sample_sequence`]: #method.set_sample_sequence
-    /// [`teardown_adc`]: #method.teardown_adc
-    /// [`start`]: #method.start
-    pub async fn read<const N: usize>(&mut self, measurements: &mut [u16; N]) -> Result<usize, OverrunError> {
-        assert_eq!(
-            self.ring_buf.capacity() / 2,
-            N,
-            "Buffer size must be half the size of the ring buffer"
-        );
-
-        let r = T::regs();
-
-        // Start background receive if it was not already started
-        if !r.cr2().read().dma() {
-            self.start()?;
-        }
-
-        // Clear overrun flag if set.
-        if r.sr().read().ovr() {
-            return self.stop(OverrunError);
-        }
-        match self.ring_buf.read_exact(measurements).await {
-            Ok(len) => Ok(len),
-            Err(_) => self.stop(OverrunError),
-        }
-    }
-}
-
-impl<T: Instance> Drop for RingBufferedAdc<'_, T> {
-    fn drop(&mut self) {
-        self.teardown_adc();
-        rcc::disable::<T>();
-    }
-}
diff --git a/embassy-stm32/src/adc/v2.rs b/embassy-stm32/src/adc/v2.rs
index 93ec78548..90c6294d2 100644
--- a/embassy-stm32/src/adc/v2.rs
+++ b/embassy-stm32/src/adc/v2.rs
@@ -1,11 +1,22 @@
+use core::mem;
+use core::sync::atomic::{Ordering, compiler_fence};
+
 use super::blocking_delay_us;
-use crate::adc::{Adc, AdcChannel, Instance, Resolution, SampleTime};
+use crate::adc::{Adc, AdcChannel, AnyAdcChannel, Instance, Resolution, RxDma, SampleTime, SealedAdcChannel};
+use crate::pac::adc::vals;
 use crate::peripherals::ADC1;
 use crate::time::Hertz;
 use crate::{Peri, rcc};
 
-mod ringbuffered_v2;
-pub use ringbuffered_v2::{RingBufferedAdc, Sequence};
+mod ringbuffered;
+pub use ringbuffered::RingBufferedAdc;
+
+fn clear_interrupt_flags(r: crate::pac::adc::Adc) {
+    r.sr().modify(|regs| {
+        regs.set_eoc(false);
+        regs.set_ovr(false);
+    });
+}
 
 /// Default VREF voltage used for sample conversion to millivolts.
 pub const VREF_DEFAULT_MV: u32 = 3300;
@@ -112,6 +123,98 @@ where
         }
     }
 
+    /// Configures the ADC to use a DMA ring buffer for continuous data acquisition.
+    ///
+    /// The `dma_buf` should be large enough to prevent DMA buffer overrun.
+    /// The length of the `dma_buf` should be a multiple of the ADC channel count.
+    /// For example, if 3 channels are measured, its length can be 3 * 40 = 120 measurements.
+    ///
+    /// `read` method is used to read out measurements from the DMA ring buffer, and its buffer should be exactly half of the `dma_buf` length.
+    /// It is critical to call `read` frequently to prevent DMA buffer overrun.
+    ///
+    /// [`read`]: #method.read
+    pub fn into_ring_buffered<'a>(
+        self,
+        dma: Peri<'d, impl RxDma<T>>,
+        dma_buf: &'d mut [u16],
+        sequence: impl ExactSizeIterator<Item = (&'a mut AnyAdcChannel<T>, SampleTime)>,
+    ) -> RingBufferedAdc<'d, T> {
+        assert!(!dma_buf.is_empty() && dma_buf.len() <= 0xFFFF);
+
+        T::regs().cr2().modify(|reg| {
+            reg.set_adon(true);
+        });
+
+        // Check the sequence is long enough
+        T::regs().sqr1().modify(|r| {
+            r.set_l((sequence.len() - 1).try_into().unwrap());
+        });
+
+        for (i, (channel, sample_time)) in sequence.enumerate() {
+            // Set this GPIO as an analog input.
+            channel.setup();
+
+            // Set the channel in the right sequence field.
+            T::regs().sqr3().modify(|w| w.set_sq(i, channel.channel()));
+
+            Self::set_channel_sample_time(channel.channel(), sample_time);
+        }
+
+        compiler_fence(Ordering::SeqCst);
+
+        let r = T::regs();
+
+        // Clear all interrupts
+        r.sr().modify(|regs| {
+            regs.set_eoc(false);
+            regs.set_ovr(false);
+            regs.set_strt(false);
+        });
+
+        r.cr1().modify(|w| {
+            // Enable interrupt for end of conversion
+            w.set_eocie(true);
+            // Enable interrupt for overrun
+            w.set_ovrie(true);
+            // Scanning converisons of multiple channels
+            w.set_scan(true);
+            // Continuous conversion mode
+            w.set_discen(false);
+        });
+
+        r.cr2().modify(|w| {
+            // Enable DMA mode
+            w.set_dma(true);
+            // Enable continuous conversions
+            w.set_cont(true);
+            // DMA requests are issues as long as DMA=1 and data are converted.
+            w.set_dds(vals::Dds::CONTINUOUS);
+            // EOC flag is set at the end of each conversion.
+            w.set_eocs(vals::Eocs::EACH_CONVERSION);
+        });
+
+        // Don't disable the clock
+        mem::forget(self);
+
+        RingBufferedAdc::new(dma, dma_buf)
+    }
+
+    pub(super) fn start() {
+        // Begin ADC conversions
+        T::regs().cr2().modify(|reg| {
+            reg.set_adon(true);
+            reg.set_swstart(true);
+        });
+    }
+
+    pub(super) fn stop() {
+        // Stop ADC
+        T::regs().cr2().modify(|reg| {
+            // Stop ADC
+            reg.set_swstart(false);
+        });
+    }
+
     pub fn set_sample_time(&mut self, sample_time: SampleTime) {
         self.sample_time = sample_time;
     }
@@ -198,6 +301,31 @@ where
             T::regs().smpr1().modify(|reg| reg.set_smp((ch - 10) as _, sample_time));
         }
     }
+
+    pub(super) fn teardown_adc() {
+        let r = T::regs();
+
+        // Stop ADC
+        r.cr2().modify(|reg| {
+            // Stop ADC
+            reg.set_swstart(false);
+            // Stop ADC
+            reg.set_adon(false);
+            // Stop DMA
+            reg.set_dma(false);
+        });
+
+        r.cr1().modify(|w| {
+            // Disable interrupt for end of conversion
+            w.set_eocie(false);
+            // Disable interrupt for overrun
+            w.set_ovrie(false);
+        });
+
+        clear_interrupt_flags(r);
+
+        compiler_fence(Ordering::SeqCst);
+    }
 }
 
 impl<'d, T: Instance> Drop for Adc<'d, T> {
diff --git a/embassy-stm32/src/adc/v3.rs b/embassy-stm32/src/adc/v3.rs
index 47632263b..170b08a25 100644
--- a/embassy-stm32/src/adc/v3.rs
+++ b/embassy-stm32/src/adc/v3.rs
@@ -12,6 +12,13 @@ pub use pac::adc::vals::{Ovsr, Ovss, Presc};
 use super::{
     Adc, AdcChannel, AnyAdcChannel, Instance, Resolution, RxDma, SampleTime, SealedAdcChannel, blocking_delay_us,
 };
+
+#[cfg(any(adc_v3, adc_g0, adc_u0))]
+mod ringbuffered;
+
+#[cfg(any(adc_v3, adc_g0, adc_u0))]
+use ringbuffered::RingBufferedAdc;
+
 use crate::dma::Transfer;
 use crate::{Peri, pac, rcc};
 
@@ -174,6 +181,38 @@ impl<'d, T: Instance> Adc<'d, T> {
         blocking_delay_us(1);
     }
 
+    #[cfg(any(adc_v3, adc_g0, adc_u0))]
+    pub(super) fn start() {
+        // Start adc conversion
+        T::regs().cr().modify(|reg| {
+            reg.set_adstart(true);
+        });
+    }
+
+    #[cfg(any(adc_v3, adc_g0, adc_u0))]
+    pub(super) fn stop() {
+        // Stop adc conversion
+        if T::regs().cr().read().adstart() && !T::regs().cr().read().addis() {
+            T::regs().cr().modify(|reg| {
+                reg.set_adstp(true);
+            });
+            while T::regs().cr().read().adstart() {}
+        }
+    }
+
+    #[cfg(any(adc_v3, adc_g0, adc_u0))]
+    pub(super) fn teardown_adc() {
+        //disable dma control
+        #[cfg(not(any(adc_g0, adc_u0)))]
+        T::regs().cfgr().modify(|reg| {
+            reg.set_dmaen(false);
+        });
+        #[cfg(any(adc_g0, adc_u0))]
+        T::regs().cfgr1().modify(|reg| {
+            reg.set_dmaen(false);
+        });
+    }
+
     /// Initialize the ADC leaving any analog clock at reset value.
     /// For G0 and WL, this is the async clock without prescaler.
     pub fn new(adc: Peri<'d, T>) -> Self {
@@ -423,6 +462,9 @@ impl<'d, T: Instance> Adc<'d, T> {
             "Asynchronous read sequence cannot be more than 16 in length"
         );
 
+        #[cfg(all(feature = "low-power", stm32wlex))]
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
+
         // Ensure no conversions are ongoing and ADC is enabled.
         Self::cancel_conversions();
         self.enable();
@@ -559,6 +601,137 @@ impl<'d, T: Instance> Adc<'d, T> {
         });
     }
 
+    /// Configures the ADC to use a DMA ring buffer for continuous data acquisition.
+    ///
+    /// The `dma_buf` should be large enough to prevent DMA buffer overrun.
+    /// The length of the `dma_buf` should be a multiple of the ADC channel count.
+    /// For example, if 3 channels are measured, its length can be 3 * 40 = 120 measurements.
+    ///
+    /// `read` method is used to read out measurements from the DMA ring buffer, and its buffer should be exactly half of the `dma_buf` length.
+    /// It is critical to call `read` frequently to prevent DMA buffer overrun.
+    ///
+    /// [`read`]: #method.read
+    #[cfg(any(adc_v3, adc_g0, adc_u0))]
+    pub fn into_ring_buffered<'a>(
+        &mut self,
+        dma: Peri<'a, impl RxDma<T>>,
+        dma_buf: &'a mut [u16],
+        sequence: impl ExactSizeIterator<Item = (&'a mut AnyAdcChannel<T>, SampleTime)>,
+    ) -> RingBufferedAdc<'a, T> {
+        assert!(!dma_buf.is_empty() && dma_buf.len() <= 0xFFFF);
+        assert!(sequence.len() != 0, "Asynchronous read sequence cannot be empty");
+        assert!(
+            sequence.len() <= 16,
+            "Asynchronous read sequence cannot be more than 16 in length"
+        );
+        // reset conversions and enable the adc
+        Self::cancel_conversions();
+        self.enable();
+
+        //adc side setup
+
+        // Set sequence length
+        #[cfg(not(any(adc_g0, adc_u0)))]
+        T::regs().sqr1().modify(|w| {
+            w.set_l(sequence.len() as u8 - 1);
+        });
+
+        #[cfg(adc_g0)]
+        {
+            let mut sample_times = Vec::<SampleTime, SAMPLE_TIMES_CAPACITY>::new();
+
+            T::regs().chselr().write(|chselr| {
+                T::regs().smpr().write(|smpr| {
+                    for (channel, sample_time) in sequence {
+                        chselr.set_chsel(channel.channel.into(), true);
+                        if let Some(i) = sample_times.iter().position(|&t| t == sample_time) {
+                            smpr.set_smpsel(channel.channel.into(), (i as u8).into());
+                        } else {
+                            smpr.set_sample_time(sample_times.len(), sample_time);
+                            if let Err(_) = sample_times.push(sample_time) {
+                                panic!(
+                                    "Implementation is limited to {} unique sample times among all channels.",
+                                    SAMPLE_TIMES_CAPACITY
+                                );
+                            }
+                        }
+                    }
+                })
+            });
+        }
+        #[cfg(not(adc_g0))]
+        {
+            #[cfg(adc_u0)]
+            let mut channel_mask = 0;
+
+            // Configure channels and ranks
+            for (_i, (channel, sample_time)) in sequence.enumerate() {
+                Self::configure_channel(channel, sample_time);
+
+                // Each channel is sampled according to sequence
+                #[cfg(not(any(adc_g0, adc_u0)))]
+                match _i {
+                    0..=3 => {
+                        T::regs().sqr1().modify(|w| {
+                            w.set_sq(_i, channel.channel());
+                        });
+                    }
+                    4..=8 => {
+                        T::regs().sqr2().modify(|w| {
+                            w.set_sq(_i - 4, channel.channel());
+                        });
+                    }
+                    9..=13 => {
+                        T::regs().sqr3().modify(|w| {
+                            w.set_sq(_i - 9, channel.channel());
+                        });
+                    }
+                    14..=15 => {
+                        T::regs().sqr4().modify(|w| {
+                            w.set_sq(_i - 14, channel.channel());
+                        });
+                    }
+                    _ => unreachable!(),
+                }
+
+                #[cfg(adc_u0)]
+                {
+                    channel_mask |= 1 << channel.channel();
+                }
+            }
+
+            // On G0 and U0 enabled channels are sampled from 0 to last channel.
+            // It is possible to add up to 8 sequences if CHSELRMOD = 1.
+            // However for supporting more than 8 channels alternative CHSELRMOD = 0 approach is used.
+            #[cfg(adc_u0)]
+            T::regs().chselr().modify(|reg| {
+                reg.set_chsel(channel_mask);
+            });
+        }
+        // Set continuous mode with Circular dma.
+        // Clear overrun flag before starting transfer.
+        T::regs().isr().modify(|reg| {
+            reg.set_ovr(true);
+        });
+
+        #[cfg(not(any(adc_g0, adc_u0)))]
+        T::regs().cfgr().modify(|reg| {
+            reg.set_discen(false);
+            reg.set_cont(true);
+            reg.set_dmacfg(Dmacfg::CIRCULAR);
+            reg.set_dmaen(true);
+        });
+        #[cfg(any(adc_g0, adc_u0))]
+        T::regs().cfgr1().modify(|reg| {
+            reg.set_discen(false);
+            reg.set_cont(true);
+            reg.set_dmacfg(Dmacfg::CIRCULAR);
+            reg.set_dmaen(true);
+        });
+
+        RingBufferedAdc::new(dma, dma_buf)
+    }
+
     #[cfg(not(adc_g0))]
     fn configure_channel(channel: &mut impl AdcChannel<T>, sample_time: SampleTime) {
         // RM0492, RM0481, etc.
diff --git a/embassy-stm32/src/backup_sram.rs b/embassy-stm32/src/backup_sram.rs
new file mode 100644
index 000000000..31b373c6c
--- /dev/null
+++ b/embassy-stm32/src/backup_sram.rs
@@ -0,0 +1,28 @@
+//! Battary backed SRAM
+
+use core::slice;
+
+use embassy_hal_internal::Peri;
+
+use crate::_generated::{BKPSRAM_BASE, BKPSRAM_SIZE};
+use crate::peripherals::BKPSRAM;
+
+/// Struct used to initilize backup sram
+pub struct BackupMemory {}
+
+impl BackupMemory {
+    /// Setup battery backed sram
+    ///
+    /// Returns slice to sram and whether the sram was retained
+    pub fn new(_backup_sram: Peri<'static, BKPSRAM>) -> (&'static mut [u8], bool) {
+        // Assert bksram has been enabled in rcc
+        assert!(crate::pac::PWR.bdcr().read().bren() == crate::pac::pwr::vals::Retention::PRESERVED);
+
+        unsafe {
+            (
+                slice::from_raw_parts_mut(BKPSRAM_BASE as *mut u8, BKPSRAM_SIZE),
+                critical_section::with(|_| crate::rcc::BKSRAM_RETAINED),
+            )
+        }
+    }
+}
diff --git a/embassy-stm32/src/can/fd/config.rs b/embassy-stm32/src/can/fd/config.rs
index e08349f02..4fe634ce4 100644
--- a/embassy-stm32/src/can/fd/config.rs
+++ b/embassy-stm32/src/can/fd/config.rs
@@ -360,6 +360,8 @@ pub struct FdCanConfig {
     pub global_filter: GlobalFilter,
     /// TX buffer mode (FIFO or priority queue)
     pub tx_buffer_mode: TxBufferMode,
+    /// Automatic recovery from bus off state
+    pub automatic_bus_off_recovery: bool,
 }
 
 impl FdCanConfig {
@@ -456,6 +458,16 @@ impl FdCanConfig {
         self.tx_buffer_mode = txbm;
         self
     }
+
+    /// Enables or disables automatic recovery from bus off state
+    ///
+    /// Automatic recovery is performed by clearing the INIT bit in the CCCR register if
+    /// the BO bit is active in the IR register in the IT0 interrupt.
+    #[inline]
+    pub const fn set_automatic_bus_off_recovery(mut self, enabled: bool) -> Self {
+        self.automatic_bus_off_recovery = enabled;
+        self
+    }
 }
 
 impl Default for FdCanConfig {
@@ -474,6 +486,7 @@ impl Default for FdCanConfig {
             timestamp_source: TimestampSource::None,
             global_filter: GlobalFilter::default(),
             tx_buffer_mode: TxBufferMode::Priority,
+            automatic_bus_off_recovery: true,
         }
     }
 }
diff --git a/embassy-stm32/src/can/fdcan.rs b/embassy-stm32/src/can/fdcan.rs
index a142a6d63..9883aff57 100644
--- a/embassy-stm32/src/can/fdcan.rs
+++ b/embassy-stm32/src/can/fdcan.rs
@@ -53,7 +53,7 @@ impl<T: Instance> interrupt::typelevel::Handler<T::IT0Interrupt> for IT0Interrup
             regs.ir().write(|w| w.set_tefn(true));
         }
 
-        T::info().state.lock(|s| {
+        let recover_from_bo = T::info().state.lock(|s| {
             let state = s.borrow_mut();
             match &state.tx_mode {
                 TxMode::NonBuffered(waker) => waker.wake(),
@@ -85,11 +85,15 @@ impl<T: Instance> interrupt::typelevel::Handler<T::IT0Interrupt> for IT0Interrup
             if ir.rfn(1) {
                 state.rx_mode.on_interrupt::<T>(1, state.ns_per_timer_tick);
             }
+
+            state.automatic_bus_off_recovery
         });
 
         if ir.bo() {
             regs.ir().write(|w| w.set_bo(true));
-            if regs.psr().read().bo() {
+            if let Some(true) = recover_from_bo
+                && regs.psr().read().bo()
+            {
                 // Initiate bus-off recovery sequence by resetting CCCR.INIT
                 regs.cccr().modify(|w| w.set_init(false));
             }
@@ -263,7 +267,9 @@ impl<'d> CanConfigurator<'d> {
     pub fn start(self, mode: OperatingMode) -> Can<'d> {
         let ns_per_timer_tick = calc_ns_per_timer_tick(&self.info, self.periph_clock, self.config.frame_transmit);
         self.info.state.lock(|s| {
-            s.borrow_mut().ns_per_timer_tick = ns_per_timer_tick;
+            let mut state = s.borrow_mut();
+            state.ns_per_timer_tick = ns_per_timer_tick;
+            state.automatic_bus_off_recovery = Some(self.config.automatic_bus_off_recovery);
         });
         self.info.regs.into_mode(self.config, mode);
         Can {
@@ -861,7 +867,7 @@ struct State {
     sender_instance_count: usize,
     tx_pin_port: Option<u8>,
     rx_pin_port: Option<u8>,
-
+    automatic_bus_off_recovery: Option<bool>, // controlled by CanConfigurator::start()
     pub err_waker: AtomicWaker,
 }
 
@@ -876,6 +882,7 @@ impl State {
             sender_instance_count: 0,
             tx_pin_port: None,
             rx_pin_port: None,
+            automatic_bus_off_recovery: None,
         }
     }
 }
diff --git a/embassy-stm32/src/dsihost.rs b/embassy-stm32/src/dsihost.rs
index fd1682d2b..59a2cbcdb 100644
--- a/embassy-stm32/src/dsihost.rs
+++ b/embassy-stm32/src/dsihost.rs
@@ -121,17 +121,15 @@ impl<'d, T: Instance> DsiHost<'d, T> {
 
     /// DCS or Generic short/long write command
     pub fn write_cmd(&mut self, channel_id: u8, address: u8, data: &[u8]) -> Result<(), Error> {
-        assert!(data.len() > 0);
-
-        if data.len() == 1 {
-            self.short_write(channel_id, PacketType::DcsShortPktWriteP1, address, data[0])
-        } else {
-            self.long_write(
+        match data.len() {
+            0 => self.short_write(channel_id, PacketType::DcsShortPktWriteP0, address, 0),
+            1 => self.short_write(channel_id, PacketType::DcsShortPktWriteP1, address, data[0]),
+            _ => self.long_write(
                 channel_id,
                 PacketType::DcsLongPktWrite, // FIXME: This might be a generic long packet, as well...
                 address,
                 data,
-            )
+            ),
         }
     }
 
diff --git a/embassy-stm32/src/exti.rs b/embassy-stm32/src/exti.rs
index 12600d4eb..2f5c3406a 100644
--- a/embassy-stm32/src/exti.rs
+++ b/embassy-stm32/src/exti.rs
@@ -71,7 +71,7 @@ unsafe fn on_irq() {
     }
 
     #[cfg(feature = "low-power")]
-    crate::low_power::on_wakeup_irq();
+    crate::low_power::Executor::on_wakeup_irq();
 }
 
 struct BitIter(u32);
diff --git a/embassy-stm32/src/flash/l.rs b/embassy-stm32/src/flash/l.rs
index cd23cda5c..b3281f2d5 100644
--- a/embassy-stm32/src/flash/l.rs
+++ b/embassy-stm32/src/flash/l.rs
@@ -96,14 +96,20 @@ pub(crate) unsafe fn blocking_erase_sector(sector: &FlashSector) -> Result<(), E
     #[cfg(any(flash_wl, flash_wb, flash_l4, flash_l5))]
     {
         let idx = (sector.start - super::FLASH_BASE as u32) / super::BANK1_REGION.erase_size as u32;
+        #[cfg(any(flash_l4, flash_l5))]
+        let pgn = super::BANK1_REGION.size as u32 / super::BANK1_REGION.erase_size as u32;
 
         #[cfg(flash_l4)]
-        let (idx, bank) = if idx > 255 { (idx - 256, true) } else { (idx, false) };
+        let (idx, bank) = if idx > (pgn - 1) {
+            (idx - pgn, true)
+        } else {
+            (idx, false)
+        };
 
         #[cfg(flash_l5)]
         let (idx, bank) = if pac::FLASH.optr().read().dbank() {
-            if idx > 255 {
-                (idx - 256, Some(true))
+            if idx > (pgn - 1) {
+                (idx - pgn, Some(true))
             } else {
                 (idx, Some(false))
             }
diff --git a/embassy-stm32/src/fmc.rs b/embassy-stm32/src/fmc.rs
index 8ecfbc522..a7c6c90bb 100644
--- a/embassy-stm32/src/fmc.rs
+++ b/embassy-stm32/src/fmc.rs
@@ -236,6 +236,42 @@ impl<'d, T: Instance> Fmc<'d, T> {
             (sdcke: SDCKE1Pin), (sdclk: SDCLKPin), (sdncas: SDNCASPin), (sdne: SDNE1Pin), (sdnras: SDNRASPin), (sdnwe: SDNWEPin)
         ]
     ));
+
+    fmc_sdram_constructor!(sdram_a13bits_d16bits_4banks_bank1: (
+        bank: stm32_fmc::SdramTargetBank::Bank1,
+        addr: [
+            (a0: A0Pin), (a1: A1Pin), (a2: A2Pin), (a3: A3Pin), (a4: A4Pin), (a5: A5Pin), (a6: A6Pin), (a7: A7Pin), (a8: A8Pin), (a9: A9Pin), (a10: A10Pin), (a11: A11Pin), (a12: A12Pin)
+        ],
+        ba: [(ba0: BA0Pin), (ba1: BA1Pin)],
+        d: [
+            (d0: D0Pin), (d1: D1Pin), (d2: D2Pin), (d3: D3Pin), (d4: D4Pin), (d5: D5Pin), (d6: D6Pin), (d7: D7Pin),
+            (d8: D8Pin), (d9: D9Pin), (d10: D10Pin), (d11: D11Pin), (d12: D12Pin), (d13: D13Pin), (d14: D14Pin), (d15: D15Pin)
+        ],
+        nbl: [
+            (nbl0: NBL0Pin), (nbl1: NBL1Pin)
+        ],
+        ctrl: [
+            (sdcke: SDCKE0Pin), (sdclk: SDCLKPin), (sdncas: SDNCASPin), (sdne: SDNE0Pin), (sdnras: SDNRASPin), (sdnwe: SDNWEPin)
+        ]
+    ));
+
+    fmc_sdram_constructor!(sdram_a13bits_d16bits_4banks_bank2: (
+        bank: stm32_fmc::SdramTargetBank::Bank2,
+        addr: [
+            (a0: A0Pin), (a1: A1Pin), (a2: A2Pin), (a3: A3Pin), (a4: A4Pin), (a5: A5Pin), (a6: A6Pin), (a7: A7Pin), (a8: A8Pin), (a9: A9Pin), (a10: A10Pin), (a11: A11Pin), (a12: A12Pin)
+        ],
+        ba: [(ba0: BA0Pin), (ba1: BA1Pin)],
+        d: [
+            (d0: D0Pin), (d1: D1Pin), (d2: D2Pin), (d3: D3Pin), (d4: D4Pin), (d5: D5Pin), (d6: D6Pin), (d7: D7Pin),
+            (d8: D8Pin), (d9: D9Pin), (d10: D10Pin), (d11: D11Pin), (d12: D12Pin), (d13: D13Pin), (d14: D14Pin), (d15: D15Pin)
+        ],
+        nbl: [
+            (nbl0: NBL0Pin), (nbl1: NBL1Pin)
+        ],
+        ctrl: [
+            (sdcke: SDCKE1Pin), (sdclk: SDCLKPin), (sdncas: SDNCASPin), (sdne: SDNE1Pin), (sdnras: SDNRASPin), (sdnwe: SDNWEPin)
+        ]
+    ));
 }
 
 trait SealedInstance: crate::rcc::RccPeripheral {
diff --git a/embassy-stm32/src/hrtim/mod.rs b/embassy-stm32/src/hrtim/mod.rs
index 6fece5eb2..6c6807479 100644
--- a/embassy-stm32/src/hrtim/mod.rs
+++ b/embassy-stm32/src/hrtim/mod.rs
@@ -10,6 +10,7 @@ pub use traits::Instance;
 use crate::gpio::{AfType, AnyPin, OutputType, Speed};
 use crate::rcc;
 use crate::time::Hertz;
+pub use crate::timer::simple_pwm::PwmPinConfig;
 
 /// HRTIM burst controller instance.
 pub struct BurstController<T: Instance> {
@@ -73,7 +74,7 @@ pub struct ComplementaryPwmPin<'d, T, C> {
 }
 
 macro_rules! advanced_channel_impl {
-    ($new_chx:ident, $channel:tt, $ch_num:expr, $pin_trait:ident, $complementary_pin_trait:ident) => {
+    ($new_chx:ident, $new_chx_with_config:ident, $channel:tt, $ch_num:expr, $pin_trait:ident, $complementary_pin_trait:ident) => {
         impl<'d, T: Instance> PwmPin<'d, T, $channel<T>> {
             #[doc = concat!("Create a new ", stringify!($channel), " PWM pin instance.")]
             pub fn $new_chx(pin: Peri<'d, impl $pin_trait<T>>) -> Self {
@@ -86,6 +87,21 @@ macro_rules! advanced_channel_impl {
                     phantom: PhantomData,
                 }
             }
+
+            #[doc = concat!("Create a new ", stringify!($channel), " PWM pin instance with a specific configuration.")]
+            pub fn $new_chx_with_config(
+                pin: Peri<'d, impl $pin_trait<T>>,
+                pin_config: PwmPinConfig,
+            ) -> Self {
+                critical_section::with(|_| {
+                    pin.set_low();
+                    set_as_af!(pin, AfType::output(pin_config.output_type, pin_config.speed));
+                });
+                PwmPin {
+                    _pin: pin.into(),
+                    phantom: PhantomData,
+                }
+            }
         }
 
         impl<'d, T: Instance> ComplementaryPwmPin<'d, T, $channel<T>> {
@@ -100,6 +116,21 @@ macro_rules! advanced_channel_impl {
                     phantom: PhantomData,
                 }
             }
+
+            #[doc = concat!("Create a new ", stringify!($channel), " complementary PWM pin instance with a specific configuration.")]
+            pub fn $new_chx_with_config(
+                pin: Peri<'d, impl $complementary_pin_trait<T>>,
+                pin_config: PwmPinConfig,
+            ) -> Self {
+                critical_section::with(|_| {
+                    pin.set_low();
+                    set_as_af!(pin, AfType::output(pin_config.output_type, pin_config.speed));
+                });
+                ComplementaryPwmPin {
+                    _pin: pin.into(),
+                    phantom: PhantomData,
+                }
+            }
         }
 
         impl<T: Instance> SealedAdvancedChannel<T> for $channel<T> {
@@ -111,13 +142,55 @@ macro_rules! advanced_channel_impl {
     };
 }
 
-advanced_channel_impl!(new_cha, ChA, 0, ChannelAPin, ChannelAComplementaryPin);
-advanced_channel_impl!(new_chb, ChB, 1, ChannelBPin, ChannelBComplementaryPin);
-advanced_channel_impl!(new_chc, ChC, 2, ChannelCPin, ChannelCComplementaryPin);
-advanced_channel_impl!(new_chd, ChD, 3, ChannelDPin, ChannelDComplementaryPin);
-advanced_channel_impl!(new_che, ChE, 4, ChannelEPin, ChannelEComplementaryPin);
+advanced_channel_impl!(
+    new_cha,
+    new_cha_with_config,
+    ChA,
+    0,
+    ChannelAPin,
+    ChannelAComplementaryPin
+);
+advanced_channel_impl!(
+    new_chb,
+    new_chb_with_config,
+    ChB,
+    1,
+    ChannelBPin,
+    ChannelBComplementaryPin
+);
+advanced_channel_impl!(
+    new_chc,
+    new_chc_with_config,
+    ChC,
+    2,
+    ChannelCPin,
+    ChannelCComplementaryPin
+);
+advanced_channel_impl!(
+    new_chd,
+    new_chd_with_config,
+    ChD,
+    3,
+    ChannelDPin,
+    ChannelDComplementaryPin
+);
+advanced_channel_impl!(
+    new_che,
+    new_che_with_config,
+    ChE,
+    4,
+    ChannelEPin,
+    ChannelEComplementaryPin
+);
 #[cfg(hrtim_v2)]
-advanced_channel_impl!(new_chf, ChF, 5, ChannelFPin, ChannelFComplementaryPin);
+advanced_channel_impl!(
+    new_chf,
+    new_chf_with_config,
+    ChF,
+    5,
+    ChannelFPin,
+    ChannelFComplementaryPin
+);
 
 /// Struct used to divide a high resolution timer into multiple channels
 pub struct AdvancedPwm<'d, T: Instance> {
diff --git a/embassy-stm32/src/i2c/config.rs b/embassy-stm32/src/i2c/config.rs
index 4e3b736c7..74fac14b2 100644
--- a/embassy-stm32/src/i2c/config.rs
+++ b/embassy-stm32/src/i2c/config.rs
@@ -4,7 +4,7 @@ use crate::gpio::{AfType, OutputType, Speed};
 use crate::time::Hertz;
 
 #[repr(u8)]
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 /// Bits of the I2C OA2 register to mask out.
 pub enum AddrMask {
@@ -60,7 +60,7 @@ impl Address {
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 /// The second Own Address register.
 pub struct OA2 {
@@ -70,7 +70,7 @@ pub struct OA2 {
     pub mask: AddrMask,
 }
 
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 /// The Own Address(es) of the I2C peripheral.
 pub enum OwnAddresses {
@@ -88,7 +88,7 @@ pub enum OwnAddresses {
 }
 
 /// Slave Configuration
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct SlaveAddrConfig {
     /// Target Address(es)
diff --git a/embassy-stm32/src/i2c/mod.rs b/embassy-stm32/src/i2c/mod.rs
index f4bf55d34..ee60c3f44 100644
--- a/embassy-stm32/src/i2c/mod.rs
+++ b/embassy-stm32/src/i2c/mod.rs
@@ -219,6 +219,7 @@ impl<'d, M: Mode> I2c<'d, M, Master> {
                 sda,
             },
         };
+
         this.enable_and_init(config);
 
         this
@@ -437,15 +438,15 @@ impl<'d, IM: MasterMode> embedded_hal_async::i2c::I2c for I2c<'d, Async, IM> {
 
 /// Frame type in I2C transaction.
 ///
-/// This tells each method what kind of framing to use, to generate a (repeated) start condition (ST
+/// This tells each method what kind of frame to use, to generate a (repeated) start condition (ST
 /// or SR), and/or a stop condition (SP). For read operations, this also controls whether to send an
 /// ACK or NACK after the last byte received.
 ///
 /// For write operations, the following options are identical because they differ only in the (N)ACK
 /// treatment relevant for read operations:
 ///
-/// - `FirstFrame` and `FirstAndNextFrame`
-/// - `NextFrame` and `LastFrameNoStop`
+/// - `FirstFrame` and `FirstAndNextFrame` behave identically for writes
+/// - `NextFrame` and `LastFrameNoStop` behave identically for writes
 ///
 /// Abbreviations used below:
 ///
@@ -474,7 +475,7 @@ enum FrameOptions {
 
 #[allow(dead_code)]
 impl FrameOptions {
-    /// Sends start or repeated start condition before transfer.
+    /// Returns true if a start or repeated start condition should be generated before this operation.
     fn send_start(self) -> bool {
         match self {
             Self::FirstAndLastFrame | Self::FirstFrame | Self::FirstAndNextFrame => true,
@@ -482,7 +483,7 @@ impl FrameOptions {
         }
     }
 
-    /// Sends stop condition after transfer.
+    /// Returns true if a stop condition should be generated after this operation.
     fn send_stop(self) -> bool {
         match self {
             Self::FirstAndLastFrame | Self::LastFrame => true,
@@ -490,7 +491,10 @@ impl FrameOptions {
         }
     }
 
-    /// Sends NACK after last byte received, indicating end of read operation.
+    /// Returns true if NACK should be sent after the last byte received in a read operation.
+    ///
+    /// This signals the end of a read sequence and releases the bus for the master's
+    /// next transmission (or stop condition).
     fn send_nack(self) -> bool {
         match self {
             Self::FirstAndLastFrame | Self::FirstFrame | Self::LastFrame | Self::LastFrameNoStop => true,
@@ -499,24 +503,44 @@ impl FrameOptions {
     }
 }
 
-/// Iterates over operations in transaction.
+/// Analyzes I2C transaction operations and assigns appropriate frame to each.
+///
+/// This function processes a sequence of I2C operations and determines the correct
+/// frame configuration for each operation to ensure proper I2C protocol compliance.
+/// It handles the complex logic of:
+///
+/// - Generating start conditions for the first operation of each type (read/write)
+/// - Generating stop conditions for the final operation in the entire transaction
+/// - Managing ACK/NACK behavior for read operations, including merging consecutive reads
+/// - Ensuring proper bus handoff between different operation types
+///
+/// **Transaction Contract Compliance:**
+/// The frame assignments ensure compliance with the embedded-hal I2C transaction contract,
+/// where consecutive operations of the same type are logically merged while maintaining
+/// proper protocol boundaries.
 ///
-/// Returns necessary frame options for each operation to uphold the [transaction contract] and have
-/// the right start/stop/(N)ACK conditions on the wire.
+/// **Error Handling:**
+/// Returns an error if any read operation has an empty buffer, as this would create
+/// an invalid I2C transaction that could halt mid-execution.
+///
+/// # Arguments
+/// * `operations` - Mutable slice of I2C operations from embedded-hal
+///
+/// # Returns
+/// An iterator over (operation, frame) pairs, or an error if the transaction is invalid
 ///
-/// [transaction contract]: embedded_hal_1::i2c::I2c::transaction
 #[allow(dead_code)]
 fn operation_frames<'a, 'b: 'a>(
     operations: &'a mut [embedded_hal_1::i2c::Operation<'b>],
 ) -> Result<impl IntoIterator<Item = (&'a mut embedded_hal_1::i2c::Operation<'b>, FrameOptions)>, Error> {
     use embedded_hal_1::i2c::Operation::{Read, Write};
 
-    // Check empty read buffer before starting transaction. Otherwise, we would risk halting with an
-    // error in the middle of the transaction.
+    // Validate that no read operations have empty buffers before starting the transaction.
+    // Empty read operations would risk halting with an error mid-transaction.
     //
-    // In principle, we could allow empty read frames within consecutive read operations, as long as
-    // at least one byte remains in the final (merged) read operation, but that makes the logic more
-    // complicated and error-prone.
+    // Note: We could theoretically allow empty read operations within consecutive read
+    // sequences as long as the final merged read has at least one byte, but this would
+    // complicate the logic significantly and create error-prone edge cases.
     if operations.iter().any(|op| match op {
         Read(read) => read.is_empty(),
         Write(_) => false,
@@ -525,46 +549,52 @@ fn operation_frames<'a, 'b: 'a>(
     }
 
     let mut operations = operations.iter_mut().peekable();
-
-    let mut next_first_frame = true;
+    let mut next_first_operation = true;
 
     Ok(iter::from_fn(move || {
-        let op = operations.next()?;
+        let current_op = operations.next()?;
 
-        // Is `op` first frame of its type?
-        let first_frame = next_first_frame;
+        // Determine if this is the first operation of its type (read or write)
+        let is_first_of_type = next_first_operation;
         let next_op = operations.peek();
 
-        // Get appropriate frame options as combination of the following properties:
+        // Compute the appropriate frame based on three key properties:
         //
-        // - For each first operation of its type, generate a (repeated) start condition.
-        // - For the last operation overall in the entire transaction, generate a stop condition.
-        // - For read operations, check the next operation: if it is also a read operation, we merge
-        //   these and send ACK for all bytes in the current operation; send NACK only for the final
-        //   read operation's last byte (before write or end of entire transaction) to indicate last
-        //   byte read and release the bus for transmission of the bus master's next byte (or stop).
+        // 1. **Start Condition**: Generate (repeated) start for first operation of each type
+        // 2. **Stop Condition**: Generate stop for the final operation in the entire transaction
+        // 3. **ACK/NACK for Reads**: For read operations, send ACK if more reads follow in the
+        //    sequence, or NACK for the final read in a sequence (before write or transaction end)
         //
-        // We check the third property unconditionally, i.e. even for write opeartions. This is okay
-        // because the resulting frame options are identical for write operations.
-        let frame = match (first_frame, next_op) {
+        // The third property is checked for all operations since the resulting frame
+        // configurations are identical for write operations regardless of ACK/NACK treatment.
+        let frame = match (is_first_of_type, next_op) {
+            // First operation of type, and it's also the final operation overall
             (true, None) => FrameOptions::FirstAndLastFrame,
+            // First operation of type, next operation is also a read (continue read sequence)
             (true, Some(Read(_))) => FrameOptions::FirstAndNextFrame,
+            // First operation of type, next operation is write (end current sequence)
             (true, Some(Write(_))) => FrameOptions::FirstFrame,
-            //
+
+            // Continuation operation, and it's the final operation overall
             (false, None) => FrameOptions::LastFrame,
+            // Continuation operation, next operation is also a read (continue read sequence)
             (false, Some(Read(_))) => FrameOptions::NextFrame,
+            // Continuation operation, next operation is write (end current sequence, no stop)
             (false, Some(Write(_))) => FrameOptions::LastFrameNoStop,
         };
 
-        // Pre-calculate if `next_op` is the first operation of its type. We do this here and not at
-        // the beginning of the loop because we hand out `op` as iterator value and cannot access it
-        // anymore in the next iteration.
-        next_first_frame = match (&op, next_op) {
+        // Pre-calculate whether the next operation will be the first of its type.
+        // This is done here because we consume `current_op` as the iterator value
+        // and cannot access it in the next iteration.
+        next_first_operation = match (&current_op, next_op) {
+            // No next operation
             (_, None) => false,
+            // Operation type changes: next will be first of its type
             (Read(_), Some(Write(_))) | (Write(_), Some(Read(_))) => true,
+            // Operation type continues: next will not be first of its type
             (Read(_), Some(Read(_))) | (Write(_), Some(Write(_))) => false,
         };
 
-        Some((op, frame))
+        Some((current_op, frame))
     }))
 }
diff --git a/embassy-stm32/src/i2c/v1.rs b/embassy-stm32/src/i2c/v1.rs
index e6b6c7c42..128a58db7 100644
--- a/embassy-stm32/src/i2c/v1.rs
+++ b/embassy-stm32/src/i2c/v1.rs
@@ -30,6 +30,7 @@ use crate::pac::i2c;
 // hit a case like this!
 pub unsafe fn on_interrupt<T: Instance>() {
     let regs = T::info().regs;
+    trace!("I2C interrupt triggered");
     // i2c v2 only woke the task on transfer complete interrupts. v1 uses interrupts for a bunch of
     // other stuff, so we wake the task on every interrupt.
     T::state().waker.wake();
@@ -92,6 +93,7 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
         self.info.regs.cr1().modify(|reg| {
             reg.set_pe(true);
         });
+        trace!("i2c v1 init complete");
     }
 
     fn check_and_clear_error_flags(info: &'static Info) -> Result<i2c::regs::Sr1, Error> {
@@ -151,7 +153,13 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
         Ok(sr1)
     }
 
-    fn write_bytes(&mut self, addr: u8, bytes: &[u8], timeout: Timeout, frame: FrameOptions) -> Result<(), Error> {
+    fn write_bytes(
+        &mut self,
+        address: u8,
+        write_buffer: &[u8],
+        timeout: Timeout,
+        frame: FrameOptions,
+    ) -> Result<(), Error> {
         if frame.send_start() {
             // Send a START condition
 
@@ -170,7 +178,7 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
             }
 
             // Set up current address we're trying to talk to
-            self.info.regs.dr().write(|reg| reg.set_dr(addr << 1));
+            self.info.regs.dr().write(|reg| reg.set_dr(address << 1));
 
             // Wait until address was sent
             // Wait for the address to be acknowledged
@@ -184,7 +192,7 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
         }
 
         // Send bytes
-        for c in bytes {
+        for c in write_buffer {
             self.send_byte(*c, timeout)?;
         }
 
@@ -236,12 +244,12 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
 
     fn blocking_read_timeout(
         &mut self,
-        addr: u8,
-        buffer: &mut [u8],
+        address: u8,
+        read_buffer: &mut [u8],
         timeout: Timeout,
         frame: FrameOptions,
     ) -> Result<(), Error> {
-        let Some((last, buffer)) = buffer.split_last_mut() else {
+        let Some((last_byte, read_buffer)) = read_buffer.split_last_mut() else {
             return Err(Error::Overrun);
         };
 
@@ -263,7 +271,7 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
             }
 
             // Set up current address we're trying to talk to
-            self.info.regs.dr().write(|reg| reg.set_dr((addr << 1) + 1));
+            self.info.regs.dr().write(|reg| reg.set_dr((address << 1) + 1));
 
             // Wait until address was sent
             // Wait for the address to be acknowledged
@@ -276,7 +284,7 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
         }
 
         // Receive bytes into buffer
-        for c in buffer {
+        for c in read_buffer {
             *c = self.recv_byte(timeout)?;
         }
 
@@ -291,37 +299,42 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
         });
 
         // Receive last byte
-        *last = self.recv_byte(timeout)?;
+        *last_byte = self.recv_byte(timeout)?;
 
         // Fallthrough is success
         Ok(())
     }
 
     /// Blocking read.
-    pub fn blocking_read(&mut self, addr: u8, read: &mut [u8]) -> Result<(), Error> {
-        self.blocking_read_timeout(addr, read, self.timeout(), FrameOptions::FirstAndLastFrame)
+    pub fn blocking_read(&mut self, address: u8, read_buffer: &mut [u8]) -> Result<(), Error> {
+        self.blocking_read_timeout(address, read_buffer, self.timeout(), FrameOptions::FirstAndLastFrame)
     }
 
     /// Blocking write.
-    pub fn blocking_write(&mut self, addr: u8, write: &[u8]) -> Result<(), Error> {
-        self.write_bytes(addr, write, self.timeout(), FrameOptions::FirstAndLastFrame)?;
+    pub fn blocking_write(&mut self, address: u8, write_buffer: &[u8]) -> Result<(), Error> {
+        self.write_bytes(address, write_buffer, self.timeout(), FrameOptions::FirstAndLastFrame)?;
 
         // Fallthrough is success
         Ok(())
     }
 
     /// Blocking write, restart, read.
-    pub fn blocking_write_read(&mut self, addr: u8, write: &[u8], read: &mut [u8]) -> Result<(), Error> {
+    pub fn blocking_write_read(
+        &mut self,
+        address: u8,
+        write_buffer: &[u8],
+        read_buffer: &mut [u8],
+    ) -> Result<(), Error> {
         // Check empty read buffer before starting transaction. Otherwise, we would not generate the
         // stop condition below.
-        if read.is_empty() {
+        if read_buffer.is_empty() {
             return Err(Error::Overrun);
         }
 
         let timeout = self.timeout();
 
-        self.write_bytes(addr, write, timeout, FrameOptions::FirstFrame)?;
-        self.blocking_read_timeout(addr, read, timeout, FrameOptions::FirstAndLastFrame)?;
+        self.write_bytes(address, write_buffer, timeout, FrameOptions::FirstFrame)?;
+        self.blocking_read_timeout(address, read_buffer, timeout, FrameOptions::FirstAndLastFrame)?;
 
         Ok(())
     }
@@ -331,32 +344,43 @@ impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
     /// Consecutive operations of same type are merged. See [transaction contract] for details.
     ///
     /// [transaction contract]: embedded_hal_1::i2c::I2c::transaction
-    pub fn blocking_transaction(&mut self, addr: u8, operations: &mut [Operation<'_>]) -> Result<(), Error> {
+    pub fn blocking_transaction(&mut self, address: u8, operations: &mut [Operation<'_>]) -> Result<(), Error> {
         let timeout = self.timeout();
 
         for (op, frame) in operation_frames(operations)? {
             match op {
-                Operation::Read(read) => self.blocking_read_timeout(addr, read, timeout, frame)?,
-                Operation::Write(write) => self.write_bytes(addr, write, timeout, frame)?,
+                Operation::Read(read_buffer) => self.blocking_read_timeout(address, read_buffer, timeout, frame)?,
+                Operation::Write(write_buffer) => self.write_bytes(address, write_buffer, timeout, frame)?,
             }
         }
 
         Ok(())
     }
 
-    // Async
-
+    /// Can be used by both blocking and async implementations  
     #[inline] // pretty sure this should always be inlined
-    fn enable_interrupts(info: &'static Info) -> () {
-        info.regs.cr2().modify(|w| {
-            w.set_iterren(true);
-            w.set_itevten(true);
+    fn enable_interrupts(info: &'static Info) {
+        // The interrupt handler disables interrupts globally, so we need to re-enable them
+        // This must be done in a critical section to avoid races
+        critical_section::with(|_| {
+            info.regs.cr2().modify(|w| {
+                w.set_iterren(true);
+                w.set_itevten(true);
+            });
         });
     }
+
+    /// Can be used by both blocking and async implementations
+    fn clear_stop_flag(info: &'static Info) {
+        trace!("I2C slave: clearing STOPF flag (v1 sequence)");
+        // v1 requires: READ SR1 then WRITE CR1 to clear STOPF
+        let _ = info.regs.sr1().read();
+        info.regs.cr1().modify(|_| {}); // Dummy write to clear STOPF
+    }
 }
 
 impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
-    async fn write_frame(&mut self, address: u8, write: &[u8], frame: FrameOptions) -> Result<(), Error> {
+    async fn write_frame(&mut self, address: u8, write_buffer: &[u8], frame: FrameOptions) -> Result<(), Error> {
         self.info.regs.cr2().modify(|w| {
             // Note: Do not enable the ITBUFEN bit in the I2C_CR2 register if DMA is used for
             // reception.
@@ -439,7 +463,10 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
             // this address from the memory after each TxE event.
             let dst = self.info.regs.dr().as_ptr() as *mut u8;
 
-            self.tx_dma.as_mut().unwrap().write(write, dst, Default::default())
+            self.tx_dma
+                .as_mut()
+                .unwrap()
+                .write(write_buffer, dst, Default::default())
         };
 
         // Wait for bytes to be sent, or an error to occur.
@@ -501,28 +528,28 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     }
 
     /// Write.
-    pub async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Error> {
-        self.write_frame(address, write, FrameOptions::FirstAndLastFrame)
+    pub async fn write(&mut self, address: u8, write_buffer: &[u8]) -> Result<(), Error> {
+        self.write_frame(address, write_buffer, FrameOptions::FirstAndLastFrame)
             .await?;
 
         Ok(())
     }
 
     /// Read.
-    pub async fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Error> {
-        self.read_frame(address, buffer, FrameOptions::FirstAndLastFrame)
+    pub async fn read(&mut self, address: u8, read_buffer: &mut [u8]) -> Result<(), Error> {
+        self.read_frame(address, read_buffer, FrameOptions::FirstAndLastFrame)
             .await?;
 
         Ok(())
     }
 
-    async fn read_frame(&mut self, address: u8, buffer: &mut [u8], frame: FrameOptions) -> Result<(), Error> {
-        if buffer.is_empty() {
+    async fn read_frame(&mut self, address: u8, read_buffer: &mut [u8], frame: FrameOptions) -> Result<(), Error> {
+        if read_buffer.is_empty() {
             return Err(Error::Overrun);
         }
 
         // Some branches below depend on whether the buffer contains only a single byte.
-        let single_byte = buffer.len() == 1;
+        let single_byte = read_buffer.len() == 1;
 
         self.info.regs.cr2().modify(|w| {
             // Note: Do not enable the ITBUFEN bit in the I2C_CR2 register if DMA is used for
@@ -612,7 +639,7 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
             self.info.regs.sr2().read();
         } else {
             // Before starting reception of single byte (but without START condition, i.e. in case
-            // of continued frame), program NACK to emit at end of this byte.
+            // of merged operations), program NACK to emit at end of this byte.
             if frame.send_nack() && single_byte {
                 self.info.regs.cr1().modify(|w| {
                     w.set_ack(false);
@@ -634,7 +661,7 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
             // from this address from the memory after each RxE event.
             let src = self.info.regs.dr().as_ptr() as *mut u8;
 
-            self.rx_dma.as_mut().unwrap().read(src, buffer, Default::default())
+            self.rx_dma.as_mut().unwrap().read(src, read_buffer, Default::default())
         };
 
         // Wait for bytes to be received, or an error to occur.
@@ -673,15 +700,17 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     }
 
     /// Write, restart, read.
-    pub async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Error> {
+    pub async fn write_read(&mut self, address: u8, write_buffer: &[u8], read_buffer: &mut [u8]) -> Result<(), Error> {
         // Check empty read buffer before starting transaction. Otherwise, we would not generate the
         // stop condition below.
-        if read.is_empty() {
+        if read_buffer.is_empty() {
             return Err(Error::Overrun);
         }
 
-        self.write_frame(address, write, FrameOptions::FirstFrame).await?;
-        self.read_frame(address, read, FrameOptions::FirstAndLastFrame).await
+        self.write_frame(address, write_buffer, FrameOptions::FirstFrame)
+            .await?;
+        self.read_frame(address, read_buffer, FrameOptions::FirstAndLastFrame)
+            .await
     }
 
     /// Transaction with operations.
@@ -689,11 +718,11 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     /// Consecutive operations of same type are merged. See [transaction contract] for details.
     ///
     /// [transaction contract]: embedded_hal_1::i2c::I2c::transaction
-    pub async fn transaction(&mut self, addr: u8, operations: &mut [Operation<'_>]) -> Result<(), Error> {
+    pub async fn transaction(&mut self, address: u8, operations: &mut [Operation<'_>]) -> Result<(), Error> {
         for (op, frame) in operation_frames(operations)? {
             match op {
-                Operation::Read(read) => self.read_frame(addr, read, frame).await?,
-                Operation::Write(write) => self.write_frame(addr, write, frame).await?,
+                Operation::Read(read_buffer) => self.read_frame(address, read_buffer, frame).await?,
+                Operation::Write(write_buffer) => self.write_frame(address, write_buffer, frame).await?,
             }
         }
 
@@ -729,12 +758,956 @@ impl Duty {
     }
 }
 
+/// Result of attempting to send a byte in slave transmitter mode
+#[derive(Debug, PartialEq)]
+enum TransmitResult {
+    /// Byte sent and ACKed by master - continue transmission
+    Acknowledged,
+    /// Byte sent but NACKed by master - normal end of read transaction
+    NotAcknowledged,
+    /// STOP condition detected - master terminated transaction
+    Stopped,
+    /// RESTART condition detected - master starting new transaction
+    Restarted,
+}
+
+/// Result of attempting to receive a byte in slave receiver mode
+#[derive(Debug, PartialEq)]
+enum ReceiveResult {
+    /// Data byte successfully received
+    Data(u8),
+    /// STOP condition detected - end of write transaction
+    Stopped,
+    /// RESTART condition detected - master starting new transaction
+    Restarted,
+}
+
+/// Enumeration of slave transaction termination conditions
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+enum SlaveTermination {
+    /// STOP condition received - normal end of transaction
+    Stop,
+    /// RESTART condition received - master starting new transaction  
+    Restart,
+    /// NACK received - normal end of read transaction
+    Nack,
+}
+
+impl<'d, M: PeriMode> I2c<'d, M, Master> {
+    /// Configure the I2C driver for slave operations, allowing for the driver to be used as a slave and a master (multimaster)
+    pub fn into_slave_multimaster(mut self, slave_addr_config: SlaveAddrConfig) -> I2c<'d, M, MultiMaster> {
+        let mut slave = I2c {
+            info: self.info,
+            state: self.state,
+            kernel_clock: self.kernel_clock,
+            tx_dma: self.tx_dma.take(), // Use take() to move ownership
+            rx_dma: self.rx_dma.take(), // Use take() to move ownership
+            #[cfg(feature = "time")]
+            timeout: self.timeout,
+            _phantom: PhantomData,
+            _phantom2: PhantomData,
+            _drop_guard: self._drop_guard, // Move the drop guard
+        };
+        slave.init_slave(slave_addr_config);
+        slave
+    }
+}
+
+// Address configuration methods
+impl<'d, M: PeriMode, IM: MasterMode> I2c<'d, M, IM> {
+    /// Initialize slave mode with address configuration
+    pub(crate) fn init_slave(&mut self, config: SlaveAddrConfig) {
+        trace!("I2C slave: initializing with config={:?}", config);
+
+        // Disable peripheral for configuration
+        self.info.regs.cr1().modify(|reg| reg.set_pe(false));
+
+        // Configure slave addresses
+        self.apply_address_configuration(config);
+
+        // Enable peripheral with slave settings
+        self.info.regs.cr1().modify(|reg| {
+            reg.set_pe(true);
+            reg.set_ack(true); // Enable acknowledgment for slave mode
+            reg.set_nostretch(false); // Allow clock stretching for processing time
+        });
+
+        trace!("I2C slave: initialization complete");
+    }
+
+    /// Apply the complete address configuration for slave mode
+    fn apply_address_configuration(&mut self, config: SlaveAddrConfig) {
+        match config.addr {
+            OwnAddresses::OA1(addr) => {
+                self.configure_primary_address(addr);
+                self.disable_secondary_address();
+            }
+            OwnAddresses::OA2(oa2) => {
+                self.configure_default_primary_address();
+                self.configure_secondary_address(oa2.addr); // v1 ignores mask
+            }
+            OwnAddresses::Both { oa1, oa2 } => {
+                self.configure_primary_address(oa1);
+                self.configure_secondary_address(oa2.addr); // v1 ignores mask
+            }
+        }
+
+        // Configure general call detection
+        if config.general_call {
+            self.info.regs.cr1().modify(|w| w.set_engc(true));
+        }
+    }
+
+    /// Configure the primary address (OA1) register
+    fn configure_primary_address(&mut self, addr: Address) {
+        match addr {
+            Address::SevenBit(addr) => {
+                self.info.regs.oar1().write(|reg| {
+                    let hw_addr = (addr as u16) << 1; // Address in bits [7:1]
+                    reg.set_add(hw_addr);
+                    reg.set_addmode(i2c::vals::Addmode::BIT7);
+                });
+            }
+            Address::TenBit(addr) => {
+                self.info.regs.oar1().write(|reg| {
+                    reg.set_add(addr);
+                    reg.set_addmode(i2c::vals::Addmode::BIT10);
+                });
+            }
+        }
+
+        // Set required bit 14 as per reference manual
+        self.info.regs.oar1().modify(|reg| reg.0 |= 1 << 14);
+    }
+
+    /// Configure the secondary address (OA2) register  
+    fn configure_secondary_address(&mut self, addr: u8) {
+        self.info.regs.oar2().write(|reg| {
+            reg.set_add2(addr);
+            reg.set_endual(i2c::vals::Endual::DUAL);
+        });
+    }
+
+    /// Set a default primary address when using OA2-only mode
+    fn configure_default_primary_address(&mut self) {
+        self.info.regs.oar1().write(|reg| {
+            reg.set_add(0); // Reserved address, safe to use
+            reg.set_addmode(i2c::vals::Addmode::BIT7);
+        });
+        self.info.regs.oar1().modify(|reg| reg.0 |= 1 << 14);
+    }
+
+    /// Disable secondary address when not needed
+    fn disable_secondary_address(&mut self) {
+        self.info.regs.oar2().write(|reg| {
+            reg.set_endual(i2c::vals::Endual::SINGLE);
+        });
+    }
+}
+
+impl<'d, M: PeriMode> I2c<'d, M, MultiMaster> {
+    /// Listen for incoming I2C address match and return the command type
+    ///
+    /// This method blocks until the slave address is matched by a master.
+    /// Returns the command type (Read/Write) and the matched address.
+    pub fn blocking_listen(&mut self) -> Result<SlaveCommand, Error> {
+        trace!("I2C slave: starting blocking listen for address match");
+        let result = self.blocking_listen_with_timeout(self.timeout());
+        trace!("I2C slave: blocking listen complete, result={:?}", result);
+        result
+    }
+
+    /// Respond to a master read request by transmitting data
+    ///
+    /// Sends the provided data to the master. If the master requests more bytes
+    /// than available, padding bytes (0x00) are sent until the master terminates
+    /// the transaction with NACK.
+    ///
+    /// Returns the total number of bytes transmitted (including padding).
+    pub fn blocking_respond_to_read(&mut self, data: &[u8]) -> Result<usize, Error> {
+        trace!("I2C slave: starting blocking respond_to_read, data_len={}", data.len());
+
+        if let Some(zero_length_result) = self.detect_zero_length_read(self.timeout())? {
+            trace!("I2C slave: zero-length read detected");
+            return Ok(zero_length_result);
+        }
+
+        let result = self.transmit_to_master(data, self.timeout());
+        trace!("I2C slave: blocking respond_to_read complete, result={:?}", result);
+        result
+    }
+
+    /// Respond to a master write request by receiving data
+    ///
+    /// Receives data from the master into the provided buffer. If the master
+    /// sends more bytes than the buffer can hold, excess bytes are acknowledged
+    /// but discarded.
+    ///
+    /// Returns the number of bytes stored in the buffer (not total received).
+    pub fn blocking_respond_to_write(&mut self, buffer: &mut [u8]) -> Result<usize, Error> {
+        trace!(
+            "I2C slave: starting blocking respond_to_write, buffer_len={}",
+            buffer.len()
+        );
+        let result = self.receive_from_master(buffer, self.timeout());
+        trace!("I2C slave: blocking respond_to_write complete, result={:?}", result);
+        result
+    }
+
+    // Private implementation methods
+
+    /// Wait for address match and determine transaction type
+    fn blocking_listen_with_timeout(&mut self, timeout: Timeout) -> Result<SlaveCommand, Error> {
+        // Ensure interrupts are disabled for blocking operation
+        self.disable_i2c_interrupts();
+
+        // Wait for address match (ADDR flag)
+        loop {
+            let sr1 = Self::read_status_and_handle_errors(self.info)?;
+
+            if sr1.addr() {
+                // Address matched - read SR2 to get direction and clear ADDR flag
+                let sr2 = self.info.regs.sr2().read();
+                let direction = if sr2.tra() {
+                    SlaveCommandKind::Read
+                } else {
+                    SlaveCommandKind::Write
+                };
+
+                // Use the static method instead of the instance method
+                let matched_address = Self::decode_matched_address(sr2, self.info)?;
+                trace!(
+                    "I2C slave: address matched, direction={:?}, addr={:?}",
+                    direction, matched_address
+                );
+
+                return Ok(SlaveCommand {
+                    kind: direction,
+                    address: matched_address,
+                });
+            }
+
+            timeout.check()?;
+        }
+    }
+
+    /// Transmit data to master in response to read request
+    fn transmit_to_master(&mut self, data: &[u8], timeout: Timeout) -> Result<usize, Error> {
+        let mut bytes_transmitted = 0;
+        let mut padding_count = 0;
+
+        loop {
+            let byte_to_send = if bytes_transmitted < data.len() {
+                data[bytes_transmitted]
+            } else {
+                padding_count += 1;
+                0x00 // Send padding bytes when data is exhausted
+            };
+
+            match self.transmit_byte(byte_to_send, timeout)? {
+                TransmitResult::Acknowledged => {
+                    bytes_transmitted += 1;
+                }
+                TransmitResult::NotAcknowledged => {
+                    bytes_transmitted += 1; // Count the NACKed byte
+                    break;
+                }
+                TransmitResult::Stopped | TransmitResult::Restarted => {
+                    break;
+                }
+            }
+        }
+
+        if padding_count > 0 {
+            trace!(
+                "I2C slave: sent {} data bytes + {} padding bytes = {} total",
+                data.len(),
+                padding_count,
+                bytes_transmitted
+            );
+        }
+
+        Ok(bytes_transmitted)
+    }
+
+    /// Receive data from master during write request
+    fn receive_from_master(&mut self, buffer: &mut [u8], timeout: Timeout) -> Result<usize, Error> {
+        let mut bytes_stored = 0;
+
+        // Receive bytes that fit in buffer
+        while bytes_stored < buffer.len() {
+            match self.receive_byte(timeout)? {
+                ReceiveResult::Data(byte) => {
+                    buffer[bytes_stored] = byte;
+                    bytes_stored += 1;
+                }
+                ReceiveResult::Stopped | ReceiveResult::Restarted => {
+                    return Ok(bytes_stored);
+                }
+            }
+        }
+
+        // Handle buffer overflow by discarding excess bytes
+        if bytes_stored == buffer.len() {
+            trace!("I2C slave: buffer full, discarding excess bytes");
+            self.discard_excess_bytes(timeout)?;
+        }
+
+        Ok(bytes_stored)
+    }
+
+    /// Detect zero-length read pattern early
+    ///
+    /// Zero-length reads occur when a master sends START+ADDR+R followed immediately
+    /// by NACK+STOP without wanting any data. This must be detected before attempting
+    /// to transmit any bytes to avoid SDA line issues.
+    fn detect_zero_length_read(&mut self, _timeout: Timeout) -> Result<Option<usize>, Error> {
+        // Quick check for immediate termination signals
+        let sr1 = self.info.regs.sr1().read();
+
+        // Check for immediate NACK (fastest zero-length pattern)
+        if sr1.af() {
+            self.clear_acknowledge_failure();
+            return Ok(Some(0));
+        }
+
+        // Check for immediate STOP (alternative zero-length pattern)
+        if sr1.stopf() {
+            Self::clear_stop_flag(self.info);
+            return Ok(Some(0));
+        }
+
+        // Give a brief window for master to send termination signals
+        // This handles masters that have slight delays between address ACK and NACK
+        const ZERO_LENGTH_DETECTION_CYCLES: u32 = 20; // ~5-10µs window
+
+        for _ in 0..ZERO_LENGTH_DETECTION_CYCLES {
+            let sr1 = self.info.regs.sr1().read();
+
+            // Immediate NACK indicates zero-length read
+            if sr1.af() {
+                self.clear_acknowledge_failure();
+                return Ok(Some(0));
+            }
+
+            // Immediate STOP indicates zero-length read
+            if sr1.stopf() {
+                Self::clear_stop_flag(self.info);
+                return Ok(Some(0));
+            }
+
+            // If TXE becomes ready, master is waiting for data - not zero-length
+            if sr1.txe() {
+                return Ok(None); // Proceed with normal transmission
+            }
+
+            // If RESTART detected, handle as zero-length
+            if sr1.addr() {
+                return Ok(Some(0));
+            }
+        }
+
+        // No zero-length pattern detected within the window
+        Ok(None)
+    }
+
+    /// Discard excess bytes when buffer is full
+    fn discard_excess_bytes(&mut self, timeout: Timeout) -> Result<(), Error> {
+        let mut discarded_count = 0;
+
+        loop {
+            match self.receive_byte(timeout)? {
+                ReceiveResult::Data(_) => {
+                    discarded_count += 1;
+                    continue;
+                }
+                ReceiveResult::Stopped | ReceiveResult::Restarted => {
+                    if discarded_count > 0 {
+                        trace!("I2C slave: discarded {} excess bytes", discarded_count);
+                    }
+                    break;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Send a single byte and wait for master's response
+    fn transmit_byte(&mut self, byte: u8, timeout: Timeout) -> Result<TransmitResult, Error> {
+        // Wait for transmit buffer ready
+        self.wait_for_transmit_ready(timeout)?;
+
+        // Send the byte
+        self.info.regs.dr().write(|w| w.set_dr(byte));
+
+        // Wait for transmission completion or master response
+        self.wait_for_transmit_completion(timeout)
+    }
+
+    /// Wait until transmit buffer is ready (TXE flag set)
+    fn wait_for_transmit_ready(&mut self, timeout: Timeout) -> Result<(), Error> {
+        loop {
+            let sr1 = Self::read_status_and_handle_errors(self.info)?;
+
+            // Check for early termination conditions
+            if let Some(result) = Self::check_early_termination(sr1) {
+                return Err(self.handle_early_termination(result));
+            }
+
+            if sr1.txe() {
+                return Ok(()); // Ready to transmit
+            }
+
+            timeout.check()?;
+        }
+    }
+
+    /// Wait for byte transmission completion or master response
+    fn wait_for_transmit_completion(&mut self, timeout: Timeout) -> Result<TransmitResult, Error> {
+        loop {
+            let sr1 = self.info.regs.sr1().read();
+
+            // Check flags in priority order
+            if sr1.af() {
+                self.clear_acknowledge_failure();
+                return Ok(TransmitResult::NotAcknowledged);
+            }
+
+            if sr1.btf() {
+                return Ok(TransmitResult::Acknowledged);
+            }
+
+            if sr1.stopf() {
+                Self::clear_stop_flag(self.info);
+                return Ok(TransmitResult::Stopped);
+            }
+
+            if sr1.addr() {
+                return Ok(TransmitResult::Restarted);
+            }
+
+            // Check for other error conditions
+            self.check_for_hardware_errors(sr1)?;
+
+            timeout.check()?;
+        }
+    }
+
+    /// Receive a single byte or detect transaction termination
+    fn receive_byte(&mut self, timeout: Timeout) -> Result<ReceiveResult, Error> {
+        loop {
+            let sr1 = Self::read_status_and_handle_errors(self.info)?;
+
+            // Check for received data first (prioritize data over control signals)
+            if sr1.rxne() {
+                let byte = self.info.regs.dr().read().dr();
+                return Ok(ReceiveResult::Data(byte));
+            }
+
+            // Check for transaction termination
+            if sr1.addr() {
+                return Ok(ReceiveResult::Restarted);
+            }
+
+            if sr1.stopf() {
+                Self::clear_stop_flag(self.info);
+                return Ok(ReceiveResult::Stopped);
+            }
+
+            timeout.check()?;
+        }
+    }
+
+    /// Determine which slave address was matched based on SR2 flags
+    fn decode_matched_address(sr2: i2c::regs::Sr2, info: &'static Info) -> Result<Address, Error> {
+        if sr2.gencall() {
+            Ok(Address::SevenBit(0x00)) // General call address
+        } else if sr2.dualf() {
+            // OA2 (secondary address) was matched
+            let oar2 = info.regs.oar2().read();
+            if oar2.endual() != i2c::vals::Endual::DUAL {
+                return Err(Error::Bus); // Hardware inconsistency
+            }
+            Ok(Address::SevenBit(oar2.add2()))
+        } else {
+            // OA1 (primary address) was matched
+            let oar1 = info.regs.oar1().read();
+            match oar1.addmode() {
+                i2c::vals::Addmode::BIT7 => {
+                    let addr = (oar1.add() >> 1) as u8;
+                    Ok(Address::SevenBit(addr))
+                }
+                i2c::vals::Addmode::BIT10 => Ok(Address::TenBit(oar1.add())),
+            }
+        }
+    }
+
+    // Helper methods for hardware interaction
+
+    /// Read status register and handle I2C errors (except NACK in slave mode)
+    fn read_status_and_handle_errors(info: &'static Info) -> Result<i2c::regs::Sr1, Error> {
+        match Self::check_and_clear_error_flags(info) {
+            Ok(sr1) => Ok(sr1),
+            Err(Error::Nack) => {
+                // In slave mode, NACK is normal protocol behavior, not an error
+                Ok(info.regs.sr1().read())
+            }
+            Err(other_error) => Err(other_error),
+        }
+    }
+
+    /// Check for conditions that cause early termination of operations
+    fn check_early_termination(sr1: i2c::regs::Sr1) -> Option<TransmitResult> {
+        if sr1.stopf() {
+            Some(TransmitResult::Stopped)
+        } else if sr1.addr() {
+            Some(TransmitResult::Restarted)
+        } else if sr1.af() {
+            Some(TransmitResult::NotAcknowledged)
+        } else {
+            None
+        }
+    }
+
+    /// Convert early termination to appropriate error
+    fn handle_early_termination(&mut self, result: TransmitResult) -> Error {
+        match result {
+            TransmitResult::Stopped => {
+                Self::clear_stop_flag(self.info);
+                Error::Bus // Unexpected STOP during setup
+            }
+            TransmitResult::Restarted => {
+                Error::Bus // Unexpected RESTART during setup
+            }
+            TransmitResult::NotAcknowledged => {
+                self.clear_acknowledge_failure();
+                Error::Bus // Unexpected NACK during setup
+            }
+            TransmitResult::Acknowledged => {
+                unreachable!() // This should never be passed to this function
+            }
+        }
+    }
+
+    /// Check for hardware-level I2C errors during transmission
+    fn check_for_hardware_errors(&self, sr1: i2c::regs::Sr1) -> Result<(), Error> {
+        if sr1.timeout() || sr1.ovr() || sr1.arlo() || sr1.berr() {
+            // Delegate to existing error handling
+            Self::check_and_clear_error_flags(self.info)?;
+        }
+        Ok(())
+    }
+
+    /// Disable I2C event and error interrupts for blocking operations
+    fn disable_i2c_interrupts(&mut self) {
+        self.info.regs.cr2().modify(|w| {
+            w.set_itevten(false);
+            w.set_iterren(false);
+        });
+    }
+
+    /// Clear the acknowledge failure flag
+    fn clear_acknowledge_failure(&mut self) {
+        self.info.regs.sr1().write(|reg| {
+            reg.0 = !0;
+            reg.set_af(false);
+        });
+    }
+
+    /// Configure DMA settings for slave operations (shared between read/write)
+    fn setup_slave_dma_base(&mut self) {
+        self.info.regs.cr2().modify(|w| {
+            w.set_itbufen(false); // Always disable buffer interrupts when using DMA
+            w.set_dmaen(true); // Enable DMA requests
+            w.set_last(false); // LAST bit not used in slave mode for v1 hardware
+        });
+    }
+
+    /// Disable DMA and interrupts in a critical section
+    fn disable_dma_and_interrupts(info: &'static Info) {
+        critical_section::with(|_| {
+            info.regs.cr2().modify(|w| {
+                w.set_dmaen(false);
+                w.set_iterren(false);
+                w.set_itevten(false);
+            });
+        });
+    }
+
+    /// Check for early termination conditions during slave operations
+    /// Returns Some(result) if termination detected, None to continue
+    fn check_slave_termination_conditions(sr1: i2c::regs::Sr1) -> Option<SlaveTermination> {
+        if sr1.stopf() {
+            Some(SlaveTermination::Stop)
+        } else if sr1.addr() {
+            Some(SlaveTermination::Restart)
+        } else if sr1.af() {
+            Some(SlaveTermination::Nack)
+        } else {
+            None
+        }
+    }
+}
+
+impl<'d> I2c<'d, Async, MultiMaster> {
+    /// Async listen for incoming I2C messages using interrupts
+    ///
+    /// Waits for a master to address this slave and returns the command type
+    /// (Read/Write) and the matched address. This method will suspend until
+    /// an address match occurs.
+    pub async fn listen(&mut self) -> Result<SlaveCommand, Error> {
+        trace!("I2C slave: starting async listen for address match");
+        let state = self.state;
+        let info = self.info;
+
+        Self::enable_interrupts(info);
+
+        let on_drop = OnDrop::new(|| {
+            Self::disable_dma_and_interrupts(info);
+        });
+
+        let result = poll_fn(|cx| {
+            state.waker.register(cx.waker());
+
+            match Self::check_and_clear_error_flags(info) {
+                Err(e) => {
+                    error!("I2C slave: error during listen: {:?}", e);
+                    Poll::Ready(Err(e))
+                }
+                Ok(sr1) => {
+                    if sr1.addr() {
+                        let sr2 = info.regs.sr2().read();
+                        let direction = if sr2.tra() {
+                            SlaveCommandKind::Read
+                        } else {
+                            SlaveCommandKind::Write
+                        };
+
+                        let matched_address = match Self::decode_matched_address(sr2, info) {
+                            Ok(addr) => {
+                                trace!("I2C slave: address matched, direction={:?}, addr={:?}", direction, addr);
+                                addr
+                            }
+                            Err(e) => {
+                                error!("I2C slave: failed to decode matched address: {:?}", e);
+                                return Poll::Ready(Err(e));
+                            }
+                        };
+
+                        Poll::Ready(Ok(SlaveCommand {
+                            kind: direction,
+                            address: matched_address,
+                        }))
+                    } else {
+                        Self::enable_interrupts(info);
+                        Poll::Pending
+                    }
+                }
+            }
+        })
+        .await;
+
+        drop(on_drop);
+        trace!("I2C slave: listen complete, result={:?}", result);
+        result
+    }
+
+    /// Async respond to write command using RX DMA
+    ///
+    /// Receives data from the master into the provided buffer using DMA.
+    /// If the master sends more bytes than the buffer can hold, excess bytes
+    /// are acknowledged but discarded to prevent interrupt flooding.
+    ///
+    /// Returns the number of bytes stored in the buffer (not total received).
+    pub async fn respond_to_write(&mut self, buffer: &mut [u8]) -> Result<usize, Error> {
+        trace!("I2C slave: starting respond_to_write, buffer_len={}", buffer.len());
+
+        if buffer.is_empty() {
+            warn!("I2C slave: respond_to_write called with empty buffer");
+            return Err(Error::Overrun);
+        }
+
+        let state = self.state;
+        let info = self.info;
+
+        self.setup_slave_dma_base();
+
+        let on_drop = OnDrop::new(|| {
+            Self::disable_dma_and_interrupts(info);
+        });
+
+        info.regs.sr2().read();
+
+        let result = self.execute_slave_receive_transfer(buffer, state, info).await;
+
+        drop(on_drop);
+        trace!("I2C slave: respond_to_write complete, result={:?}", result);
+        result
+    }
+
+    /// Async respond to read command using TX DMA
+    ///
+    /// Transmits data to the master using DMA. If the master requests more bytes
+    /// than available in the data buffer, padding bytes (0x00) are sent until
+    /// the master terminates the transaction with NACK, STOP, or RESTART.
+    ///
+    /// Returns the total number of bytes transmitted (data + padding).
+    pub async fn respond_to_read(&mut self, data: &[u8]) -> Result<usize, Error> {
+        trace!("I2C slave: starting respond_to_read, data_len={}", data.len());
+
+        if data.is_empty() {
+            warn!("I2C slave: respond_to_read called with empty data");
+            return Err(Error::Overrun);
+        }
+
+        let state = self.state;
+        let info = self.info;
+
+        self.setup_slave_dma_base();
+
+        let on_drop = OnDrop::new(|| {
+            Self::disable_dma_and_interrupts(info);
+        });
+
+        info.regs.sr2().read();
+
+        let result = self.execute_slave_transmit_transfer(data, state, info).await;
+
+        drop(on_drop);
+        trace!("I2C slave: respond_to_read complete, result={:?}", result);
+        result
+    }
+
+    // === Private Transfer Execution Methods ===
+
+    /// Execute complete slave receive transfer with excess byte handling
+    async fn execute_slave_receive_transfer(
+        &mut self,
+        buffer: &mut [u8],
+        state: &'static State,
+        info: &'static Info,
+    ) -> Result<usize, Error> {
+        let dma_transfer = unsafe {
+            let src = info.regs.dr().as_ptr() as *mut u8;
+            self.rx_dma.as_mut().unwrap().read(src, buffer, Default::default())
+        };
+
+        let i2c_monitor =
+            Self::create_termination_monitor(state, info, &[SlaveTermination::Stop, SlaveTermination::Restart]);
+
+        match select(dma_transfer, i2c_monitor).await {
+            Either::Second(Err(e)) => {
+                error!("I2C slave: error during receive transfer: {:?}", e);
+                Self::disable_dma_and_interrupts(info);
+                Err(e)
+            }
+            Either::First(_) => {
+                trace!("I2C slave: DMA receive completed, handling excess bytes");
+                Self::disable_dma_and_interrupts(info);
+                self.handle_excess_bytes(state, info).await?;
+                Ok(buffer.len())
+            }
+            Either::Second(Ok(termination)) => {
+                trace!("I2C slave: receive terminated by I2C event: {:?}", termination);
+                Self::disable_dma_and_interrupts(info);
+                Ok(buffer.len())
+            }
+        }
+    }
+
+    /// Execute complete slave transmit transfer with padding byte handling
+    async fn execute_slave_transmit_transfer(
+        &mut self,
+        data: &[u8],
+        state: &'static State,
+        info: &'static Info,
+    ) -> Result<usize, Error> {
+        let dma_transfer = unsafe {
+            let dst = info.regs.dr().as_ptr() as *mut u8;
+            self.tx_dma.as_mut().unwrap().write(data, dst, Default::default())
+        };
+
+        let i2c_monitor = Self::create_termination_monitor(
+            state,
+            info,
+            &[
+                SlaveTermination::Stop,
+                SlaveTermination::Restart,
+                SlaveTermination::Nack,
+            ],
+        );
+
+        match select(dma_transfer, i2c_monitor).await {
+            Either::Second(Err(e)) => {
+                error!("I2C slave: error during transmit transfer: {:?}", e);
+                Self::disable_dma_and_interrupts(info);
+                Err(e)
+            }
+            Either::First(_) => {
+                trace!("I2C slave: DMA transmit completed, handling padding bytes");
+                Self::disable_dma_and_interrupts(info);
+                let padding_count = self.handle_padding_bytes(state, info).await?;
+                let total_bytes = data.len() + padding_count;
+                trace!(
+                    "I2C slave: sent {} data bytes + {} padding bytes = {} total",
+                    data.len(),
+                    padding_count,
+                    total_bytes
+                );
+                Ok(total_bytes)
+            }
+            Either::Second(Ok(termination)) => {
+                trace!("I2C slave: transmit terminated by I2C event: {:?}", termination);
+                Self::disable_dma_and_interrupts(info);
+                Ok(data.len())
+            }
+        }
+    }
+
+    /// Create a future that monitors for specific slave termination conditions
+    fn create_termination_monitor(
+        state: &'static State,
+        info: &'static Info,
+        allowed_terminations: &'static [SlaveTermination],
+    ) -> impl Future<Output = Result<SlaveTermination, Error>> {
+        poll_fn(move |cx| {
+            state.waker.register(cx.waker());
+
+            match Self::check_and_clear_error_flags(info) {
+                Err(Error::Nack) if allowed_terminations.contains(&SlaveTermination::Nack) => {
+                    Poll::Ready(Ok(SlaveTermination::Nack))
+                }
+                Err(e) => Poll::Ready(Err(e)),
+                Ok(sr1) => {
+                    if let Some(termination) = Self::check_slave_termination_conditions(sr1) {
+                        if allowed_terminations.contains(&termination) {
+                            // Handle the specific termination condition
+                            match termination {
+                                SlaveTermination::Stop => Self::clear_stop_flag(info),
+                                SlaveTermination::Nack => {
+                                    info.regs.sr1().write(|reg| {
+                                        reg.0 = !0;
+                                        reg.set_af(false);
+                                    });
+                                }
+                                SlaveTermination::Restart => {
+                                    // ADDR flag will be handled by next listen() call
+                                }
+                            }
+                            Poll::Ready(Ok(termination))
+                        } else {
+                            // Unexpected termination condition
+                            Poll::Ready(Err(Error::Bus))
+                        }
+                    } else {
+                        Self::enable_interrupts(info);
+                        Poll::Pending
+                    }
+                }
+            }
+        })
+    }
+
+    /// Handle excess bytes after DMA buffer is full
+    ///
+    /// Reads and discards bytes until transaction termination to prevent interrupt flooding
+    async fn handle_excess_bytes(&mut self, state: &'static State, info: &'static Info) -> Result<(), Error> {
+        let mut discarded_count = 0;
+
+        poll_fn(|cx| {
+            state.waker.register(cx.waker());
+
+            match Self::check_and_clear_error_flags(info) {
+                Err(e) => {
+                    error!("I2C slave: error while discarding excess bytes: {:?}", e);
+                    Poll::Ready(Err(e))
+                }
+                Ok(sr1) => {
+                    if let Some(termination) = Self::check_slave_termination_conditions(sr1) {
+                        match termination {
+                            SlaveTermination::Stop => Self::clear_stop_flag(info),
+                            SlaveTermination::Restart => {}
+                            SlaveTermination::Nack => unreachable!("NACK not expected during receive"),
+                        }
+                        if discarded_count > 0 {
+                            trace!("I2C slave: discarded {} excess bytes", discarded_count);
+                        }
+                        return Poll::Ready(Ok(()));
+                    }
+
+                    if sr1.rxne() {
+                        let _discarded_byte = info.regs.dr().read().dr();
+                        discarded_count += 1;
+                        Self::enable_interrupts(info);
+                        return Poll::Pending;
+                    }
+
+                    Self::enable_interrupts(info);
+                    Poll::Pending
+                }
+            }
+        })
+        .await
+    }
+
+    /// Handle padding bytes after DMA data is exhausted
+    ///
+    /// Sends 0x00 bytes until transaction termination to prevent interrupt flooding
+    async fn handle_padding_bytes(&mut self, state: &'static State, info: &'static Info) -> Result<usize, Error> {
+        let mut padding_count = 0;
+
+        poll_fn(|cx| {
+            state.waker.register(cx.waker());
+
+            match Self::check_and_clear_error_flags(info) {
+                Err(Error::Nack) => Poll::Ready(Ok(padding_count)),
+                Err(e) => {
+                    error!("I2C slave: error while sending padding bytes: {:?}", e);
+                    Poll::Ready(Err(e))
+                }
+                Ok(sr1) => {
+                    if let Some(termination) = Self::check_slave_termination_conditions(sr1) {
+                        match termination {
+                            SlaveTermination::Stop => Self::clear_stop_flag(info),
+                            SlaveTermination::Restart => {}
+                            SlaveTermination::Nack => {
+                                info.regs.sr1().write(|reg| {
+                                    reg.0 = !0;
+                                    reg.set_af(false);
+                                });
+                            }
+                        }
+                        return Poll::Ready(Ok(padding_count));
+                    }
+
+                    if sr1.txe() {
+                        info.regs.dr().write(|w| w.set_dr(0x00));
+                        padding_count += 1;
+                        Self::enable_interrupts(info);
+                        return Poll::Pending;
+                    }
+
+                    Self::enable_interrupts(info);
+                    Poll::Pending
+                }
+            }
+        })
+        .await
+    }
+}
+
+/// Timing configuration for I2C v1 hardware
+///
+/// This struct encapsulates the complex timing calculations required for STM32 I2C v1
+/// peripherals, which use three separate registers (CR2.FREQ, CCR, TRISE) instead of
+/// the unified TIMINGR register found in v2 hardware.
 struct Timings {
-    freq: u8,
-    mode: Mode,
-    trise: u8,
-    ccr: u16,
-    duty: Duty,
+    freq: u8,   // APB frequency in MHz for CR2.FREQ register
+    mode: Mode, // Standard or Fast mode selection
+    trise: u8,  // Rise time compensation value
+    ccr: u16,   // Clock control register value
+    duty: Duty, // Fast mode duty cycle selection
 }
 
 impl Timings {
@@ -771,14 +1744,10 @@ impl Timings {
                 duty = Duty::Duty2_1;
                 ccr = clock / (frequency * 3);
                 ccr = if ccr < 1 { 1 } else { ccr };
-
-                // Set clock to fast mode with appropriate parameters for selected speed (2:1 duty cycle)
             } else {
                 duty = Duty::Duty16_9;
                 ccr = clock / (frequency * 25);
                 ccr = if ccr < 1 { 1 } else { ccr };
-
-                // Set clock to fast mode with appropriate parameters for selected speed (16:9 duty cycle)
             }
         }
 
@@ -788,11 +1757,6 @@ impl Timings {
             ccr: ccr as u16,
             duty,
             mode,
-            //prescale: presc_reg,
-            //scll,
-            //sclh,
-            //sdadel,
-            //scldel,
         }
     }
 }
diff --git a/embassy-stm32/src/i2c/v2.rs b/embassy-stm32/src/i2c/v2.rs
index 01b6b8800..57a7acee7 100644
--- a/embassy-stm32/src/i2c/v2.rs
+++ b/embassy-stm32/src/i2c/v2.rs
@@ -70,6 +70,11 @@ fn debug_print_interrupts(isr: stm32_metapac::i2c::regs::Isr) {
 }
 
 pub(crate) unsafe fn on_interrupt<T: Instance>() {
+    // restore the clocks to their last configured state as
+    // much is lost in STOP modes
+    #[cfg(all(feature = "low-power", stm32wlex))]
+    crate::low_power::Executor::on_wakeup_irq();
+
     let regs = T::info().regs;
     let isr = regs.isr().read();
 
@@ -814,6 +819,8 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
 
     /// Write.
     pub async fn write(&mut self, address: u8, write: &[u8]) -> Result<(), Error> {
+        #[cfg(all(feature = "low-power", stm32wlex))]
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let timeout = self.timeout();
         if write.is_empty() {
             self.write_internal(address.into(), write, true, timeout)
@@ -828,6 +835,8 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     ///
     /// The buffers are concatenated in a single write transaction.
     pub async fn write_vectored(&mut self, address: Address, write: &[&[u8]]) -> Result<(), Error> {
+        #[cfg(all(feature = "low-power", stm32wlex))]
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let timeout = self.timeout();
 
         if write.is_empty() {
@@ -851,6 +860,8 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
 
     /// Read.
     pub async fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Error> {
+        #[cfg(all(feature = "low-power", stm32wlex))]
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let timeout = self.timeout();
 
         if buffer.is_empty() {
@@ -863,6 +874,8 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
 
     /// Write, restart, read.
     pub async fn write_read(&mut self, address: u8, write: &[u8], read: &mut [u8]) -> Result<(), Error> {
+        #[cfg(all(feature = "low-power", stm32wlex))]
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let timeout = self.timeout();
 
         if write.is_empty() {
@@ -888,6 +901,8 @@ impl<'d, IM: MasterMode> I2c<'d, Async, IM> {
     ///
     /// [transaction contract]: embedded_hal_1::i2c::I2c::transaction
     pub async fn transaction(&mut self, addr: u8, operations: &mut [Operation<'_>]) -> Result<(), Error> {
+        #[cfg(all(feature = "low-power", stm32wlex))]
+        let _device_busy = crate::low_power::DeviceBusy::new_stop1();
         let _ = addr;
         let _ = operations;
         todo!()
@@ -1181,7 +1196,7 @@ impl<'d> I2c<'d, Async, MultiMaster> {
 
         let regs = self.info.regs;
 
-        let dma_transfer = unsafe {
+        let mut dma_transfer = unsafe {
             regs.cr1().modify(|w| {
                 w.set_rxdmaen(true);
                 w.set_stopie(true);
@@ -1229,6 +1244,7 @@ impl<'d> I2c<'d, Async, MultiMaster> {
         })
         .await?;
 
+        dma_transfer.request_pause();
         dma_transfer.await;
 
         drop(on_drop);
@@ -1294,6 +1310,7 @@ impl<'d> I2c<'d, Async, MultiMaster> {
         })
         .await?;
 
+        dma_transfer.request_pause();
         dma_transfer.await;
 
         drop(on_drop);
diff --git a/embassy-stm32/src/i2s.rs b/embassy-stm32/src/i2s.rs
index db22cfa11..df077a3ae 100644
--- a/embassy-stm32/src/i2s.rs
+++ b/embassy-stm32/src/i2s.rs
@@ -7,6 +7,7 @@ use crate::Peri;
 use crate::dma::{ChannelAndRequest, ReadableRingBuffer, TransferOptions, WritableRingBuffer, ringbuffer};
 use crate::gpio::{AfType, AnyPin, OutputType, SealedPin, Speed};
 use crate::mode::Async;
+use crate::spi::mode::Master;
 use crate::spi::{Config as SpiConfig, RegsExt as _, *};
 use crate::time::Hertz;
 
@@ -225,7 +226,7 @@ impl<'s, 'd, W: Word> Reader<'s, 'd, W> {
 pub struct I2S<'d, W: Word> {
     #[allow(dead_code)]
     mode: Mode,
-    spi: Spi<'d, Async>,
+    spi: Spi<'d, Async, Master>,
     txsd: Option<Peri<'d, AnyPin>>,
     rxsd: Option<Peri<'d, AnyPin>>,
     ws: Option<Peri<'d, AnyPin>>,
diff --git a/embassy-stm32/src/lib.rs b/embassy-stm32/src/lib.rs
index dbf0fe620..e08ab30e6 100644
--- a/embassy-stm32/src/lib.rs
+++ b/embassy-stm32/src/lib.rs
@@ -54,6 +54,8 @@ pub mod timer;
 
 #[cfg(adc)]
 pub mod adc;
+#[cfg(backup_sram)]
+pub mod backup_sram;
 #[cfg(can)]
 pub mod can;
 // FIXME: Cordic driver cause stm32u5a5zj crash
@@ -241,6 +243,14 @@ pub struct Config {
     /// RCC config.
     pub rcc: rcc::Config,
 
+    #[cfg(feature = "low-power")]
+    /// RTC config
+    pub rtc: rtc::RtcConfig,
+
+    #[cfg(feature = "low-power")]
+    /// Minimum time to stop
+    pub min_stop_pause: embassy_time::Duration,
+
     /// Enable debug during sleep and stop.
     ///
     /// May increase power consumption. Defaults to true.
@@ -294,6 +304,10 @@ impl Default for Config {
     fn default() -> Self {
         Self {
             rcc: Default::default(),
+            #[cfg(feature = "low-power")]
+            rtc: Default::default(),
+            #[cfg(feature = "low-power")]
+            min_stop_pause: embassy_time::Duration::from_millis(250),
             #[cfg(dbgmcu)]
             enable_debug_during_sleep: true,
             #[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba))]
@@ -623,6 +637,12 @@ fn init_hw(config: Config) -> Peripherals {
             exti::init(cs);
 
             rcc::init_rcc(cs, config.rcc);
+
+            #[cfg(feature = "low-power")]
+            crate::rtc::init_rtc(cs, config.rtc);
+
+            #[cfg(feature = "low-power")]
+            crate::time_driver::get_driver().set_min_stop_pause(cs, config.min_stop_pause);
         }
 
         p
diff --git a/embassy-stm32/src/low_power.rs b/embassy-stm32/src/low_power.rs
index 1b66ca680..696dfe83f 100644
--- a/embassy-stm32/src/low_power.rs
+++ b/embassy-stm32/src/low_power.rs
@@ -41,12 +41,6 @@
 //!     config.enable_debug_during_sleep = false;
 //!     let p = embassy_stm32::init(config);
 //!
-//!     // give the RTC to the executor...
-//!     let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
-//!     static RTC: StaticCell<Rtc> = StaticCell::new();
-//!     let rtc = RTC.init(rtc);
-//!     embassy_stm32::low_power::stop_with_rtc(rtc);
-//!
 //!     // your application here...
 //! }
 //! ```
@@ -59,24 +53,69 @@ use core::marker::PhantomData;
 use core::sync::atomic::{Ordering, compiler_fence};
 
 use cortex_m::peripheral::SCB;
+use critical_section::CriticalSection;
 use embassy_executor::*;
 
 use crate::interrupt;
-use crate::time_driver::{RtcDriver, get_driver};
+use crate::time_driver::get_driver;
 
 const THREAD_PENDER: usize = usize::MAX;
 
-use crate::rtc::Rtc;
-
 static mut EXECUTOR: Option<Executor> = None;
 
+/// Prevent the device from going into the stop mode if held
+pub struct DeviceBusy(StopMode);
+
+impl DeviceBusy {
+    /// Create a new DeviceBusy with stop1.
+    pub fn new_stop1() -> Self {
+        Self::new(StopMode::Stop1)
+    }
+
+    /// Create a new DeviceBusy with stop2.
+    pub fn new_stop2() -> Self {
+        Self::new(StopMode::Stop2)
+    }
+
+    /// Create a new DeviceBusy.
+    pub fn new(stop_mode: StopMode) -> Self {
+        critical_section::with(|_| unsafe {
+            match stop_mode {
+                StopMode::Stop1 => {
+                    crate::rcc::REFCOUNT_STOP1 += 1;
+                }
+                StopMode::Stop2 => {
+                    crate::rcc::REFCOUNT_STOP2 += 1;
+                }
+            }
+        });
+
+        Self(stop_mode)
+    }
+}
+
+impl Drop for DeviceBusy {
+    fn drop(&mut self) {
+        critical_section::with(|_| unsafe {
+            match self.0 {
+                StopMode::Stop1 => {
+                    crate::rcc::REFCOUNT_STOP1 -= 1;
+                }
+                StopMode::Stop2 => {
+                    crate::rcc::REFCOUNT_STOP2 -= 1;
+                }
+            }
+        });
+    }
+}
+
 #[cfg(not(stm32u0))]
 foreach_interrupt! {
     (RTC, rtc, $block:ident, WKUP, $irq:ident) => {
         #[interrupt]
         #[allow(non_snake_case)]
         unsafe fn $irq() {
-            EXECUTOR.as_mut().unwrap().on_wakeup_irq();
+            Executor::on_wakeup_irq();
         }
     };
 }
@@ -87,31 +126,21 @@ foreach_interrupt! {
         #[interrupt]
         #[allow(non_snake_case)]
         unsafe fn $irq() {
-            EXECUTOR.as_mut().unwrap().on_wakeup_irq();
+            Executor::on_wakeup_irq();
         }
     };
 }
 
-#[allow(dead_code)]
-pub(crate) unsafe fn on_wakeup_irq() {
-    EXECUTOR.as_mut().unwrap().on_wakeup_irq();
-}
-
-/// Configure STOP mode with RTC.
-pub fn stop_with_rtc(rtc: &'static Rtc) {
-    unsafe { EXECUTOR.as_mut().unwrap() }.stop_with_rtc(rtc)
-}
-
 /// Get whether the core is ready to enter the given stop mode.
 ///
 /// This will return false if some peripheral driver is in use that
 /// prevents entering the given stop mode.
 pub fn stop_ready(stop_mode: StopMode) -> bool {
-    match unsafe { EXECUTOR.as_mut().unwrap() }.stop_mode() {
+    critical_section::with(|cs| match Executor::stop_mode(cs) {
         Some(StopMode::Stop2) => true,
         Some(StopMode::Stop1) => stop_mode == StopMode::Stop1,
         None => false,
-    }
+    })
 }
 
 /// Available Stop modes.
@@ -124,10 +153,10 @@ pub enum StopMode {
     Stop2,
 }
 
-#[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba, stm32u0))]
+#[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba, stm32wlex, stm32u0))]
 use stm32_metapac::pwr::vals::Lpms;
 
-#[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba, stm32u0))]
+#[cfg(any(stm32l4, stm32l5, stm32u5, stm32wba, stm32wlex, stm32u0))]
 impl Into<Lpms> for StopMode {
     fn into(self) -> Lpms {
         match self {
@@ -154,7 +183,6 @@ pub struct Executor {
     inner: raw::Executor,
     not_send: PhantomData<*mut ()>,
     scb: SCB,
-    time_driver: &'static RtcDriver,
 }
 
 impl Executor {
@@ -167,7 +195,6 @@ impl Executor {
                 inner: raw::Executor::new(THREAD_PENDER as *mut ()),
                 not_send: PhantomData,
                 scb: cortex_m::Peripherals::steal().SCB,
-                time_driver: get_driver(),
             });
 
             let executor = EXECUTOR.as_mut().unwrap();
@@ -176,21 +203,31 @@ impl Executor {
         })
     }
 
-    unsafe fn on_wakeup_irq(&mut self) {
-        self.time_driver.resume_time();
-        trace!("low power: resume");
-    }
-
-    pub(self) fn stop_with_rtc(&mut self, rtc: &'static Rtc) {
-        self.time_driver.set_rtc(rtc);
-
-        rtc.enable_wakeup_line();
-
-        trace!("low power: stop with rtc configured");
+    pub(crate) unsafe fn on_wakeup_irq() {
+        critical_section::with(|cs| {
+            #[cfg(stm32wlex)]
+            {
+                let extscr = crate::pac::PWR.extscr().read();
+                if extscr.c1stop2f() || extscr.c1stopf() {
+                    // when we wake from any stop mode we need to re-initialize the rcc
+                    crate::rcc::apply_resume_config();
+                    if extscr.c1stop2f() {
+                        // when we wake from STOP2, we need to re-initialize the time driver
+                        crate::time_driver::init_timer(cs);
+                        // reset the refcounts for STOP2 and STOP1 (initializing the time driver will increment one of them for the timer)
+                        // and given that we just woke from STOP2, we can reset them
+                        crate::rcc::REFCOUNT_STOP2 = 0;
+                        crate::rcc::REFCOUNT_STOP1 = 0;
+                    }
+                }
+            }
+            get_driver().resume_time(cs);
+            trace!("low power: resume");
+        });
     }
 
-    fn stop_mode(&self) -> Option<StopMode> {
-        if unsafe { crate::rcc::REFCOUNT_STOP2 == 0 } && unsafe { crate::rcc::REFCOUNT_STOP1 == 0 } {
+    fn stop_mode(_cs: CriticalSection) -> Option<StopMode> {
+        if unsafe { crate::rcc::REFCOUNT_STOP2 == 0 && crate::rcc::REFCOUNT_STOP1 == 0 } {
             Some(StopMode::Stop2)
         } else if unsafe { crate::rcc::REFCOUNT_STOP1 == 0 } {
             Some(StopMode::Stop1)
@@ -201,7 +238,7 @@ impl Executor {
 
     #[allow(unused_variables)]
     fn configure_stop(&mut self, stop_mode: StopMode) {
-        #[cfg(any(stm32l4, stm32l5, stm32u5, stm32u0, stm32wba))]
+        #[cfg(any(stm32l4, stm32l5, stm32u5, stm32u0, stm32wba, stm32wlex))]
         crate::pac::PWR.cr1().modify(|m| m.set_lpms(stop_mode.into()));
         #[cfg(stm32h5)]
         crate::pac::PWR.pmcr().modify(|v| {
@@ -213,17 +250,22 @@ impl Executor {
 
     fn configure_pwr(&mut self) {
         self.scb.clear_sleepdeep();
+        // Clear any previous stop flags
+        #[cfg(stm32wlex)]
+        crate::pac::PWR.extscr().modify(|w| {
+            w.set_c1cssf(true);
+        });
 
         compiler_fence(Ordering::SeqCst);
 
-        let stop_mode = self.stop_mode();
+        let stop_mode = critical_section::with(|cs| Self::stop_mode(cs));
 
         if stop_mode.is_none() {
             trace!("low power: not ready to stop");
             return;
         }
 
-        if self.time_driver.pause_time().is_err() {
+        if get_driver().pause_time().is_err() {
             trace!("low power: failed to pause time");
             return;
         }
@@ -266,6 +308,19 @@ impl Executor {
                 executor.inner.poll();
                 self.configure_pwr();
                 asm!("wfe");
+                #[cfg(stm32wlex)]
+                {
+                    let es = crate::pac::PWR.extscr().read();
+                    match (es.c1stopf(), es.c1stop2f()) {
+                        (true, false) => debug!("low power: wake from STOP1"),
+                        (false, true) => debug!("low power: wake from STOP2"),
+                        (true, true) => debug!("low power: wake from STOP1 and STOP2 ???"),
+                        (false, false) => trace!("low power: stop mode not entered"),
+                    };
+                    crate::pac::PWR.extscr().modify(|w| {
+                        w.set_c1cssf(false);
+                    });
+                }
             };
         }
     }
diff --git a/embassy-stm32/src/rcc/bd.rs b/embassy-stm32/src/rcc/bd.rs
index 3b2a10581..5b367c043 100644
--- a/embassy-stm32/src/rcc/bd.rs
+++ b/embassy-stm32/src/rcc/bd.rs
@@ -1,6 +1,8 @@
 use core::sync::atomic::{Ordering, compiler_fence};
 
 use crate::pac::common::{RW, Reg};
+#[cfg(backup_sram)]
+use crate::pac::pwr::vals::Retention;
 pub use crate::pac::rcc::vals::Rtcsel as RtcClockSource;
 use crate::time::Hertz;
 
@@ -89,6 +91,8 @@ pub struct LsConfig {
     pub rtc: RtcClockSource,
     pub lsi: bool,
     pub lse: Option<LseConfig>,
+    #[cfg(backup_sram)]
+    pub enable_backup_sram: bool,
 }
 
 impl LsConfig {
@@ -113,6 +117,8 @@ impl LsConfig {
                 peripherals_clocked: false,
             }),
             lsi: false,
+            #[cfg(backup_sram)]
+            enable_backup_sram: false,
         }
     }
 
@@ -121,6 +127,8 @@ impl LsConfig {
             rtc: RtcClockSource::LSI,
             lsi: true,
             lse: None,
+            #[cfg(backup_sram)]
+            enable_backup_sram: false,
         }
     }
 
@@ -129,6 +137,8 @@ impl LsConfig {
             rtc: RtcClockSource::DISABLE,
             lsi: false,
             lse: None,
+            #[cfg(backup_sram)]
+            enable_backup_sram: false,
         }
     }
 }
@@ -193,6 +203,22 @@ impl LsConfig {
             while !csr.read().lsi1rdy() {}
         }
 
+        // Enable backup regulator for peristent battery backed sram
+        #[cfg(backup_sram)]
+        {
+            unsafe { super::BKSRAM_RETAINED = crate::pac::PWR.bdcr().read().bren() == Retention::PRESERVED };
+
+            crate::pac::PWR.bdcr().modify(|w| {
+                w.set_bren(match self.enable_backup_sram {
+                    true => Retention::PRESERVED,
+                    false => Retention::LOST,
+                });
+            });
+
+            // Wait for backup regulator voltage to stabilize
+            while self.enable_backup_sram && !crate::pac::PWR.bdsr().read().brrdy() {}
+        }
+
         // backup domain configuration (LSEON, RTCEN, RTCSEL) is kept across resets.
         // once set, changing it requires a backup domain reset.
         // first check if the configuration matches what we want.
diff --git a/embassy-stm32/src/rcc/l.rs b/embassy-stm32/src/rcc/l.rs
index 2e1cbd702..584957c6d 100644
--- a/embassy-stm32/src/rcc/l.rs
+++ b/embassy-stm32/src/rcc/l.rs
@@ -1,3 +1,6 @@
+#[cfg(all(feature = "low-power", stm32wlex))]
+use core::mem::MaybeUninit;
+
 #[cfg(any(stm32l0, stm32l1))]
 pub use crate::pac::pwr::vals::Vos as VoltageScale;
 use crate::pac::rcc::regs::Cfgr;
@@ -11,6 +14,42 @@ use crate::time::Hertz;
 /// HSI speed
 pub const HSI_FREQ: Hertz = Hertz(16_000_000);
 
+/// Saved RCC Config
+///
+/// Used when exiting STOP2 to re-enable clocks to their last configured state
+/// for chips that need it.
+#[cfg(all(feature = "low-power", stm32wlex))]
+static mut RESUME_RCC_CONFIG: MaybeUninit<Config> = MaybeUninit::uninit();
+
+/// Set the rcc config to be restored when exiting STOP2
+///
+/// Safety: Sets a mutable global.
+#[cfg(all(feature = "low-power", stm32wlex))]
+pub(crate) unsafe fn set_resume_config(config: Config) {
+    trace!("rcc set_resume_config()");
+    RESUME_RCC_CONFIG = MaybeUninit::new(config);
+}
+
+/// Get the rcc config to be restored when exiting STOP2
+///
+/// Safety: Reads a mutable global.
+#[cfg(all(feature = "low-power", stm32wlex))]
+pub(crate) unsafe fn get_resume_config() -> Config {
+    *(*core::ptr::addr_of_mut!(RESUME_RCC_CONFIG)).assume_init_ref()
+}
+
+#[cfg(all(feature = "low-power", stm32wlex))]
+/// Safety: should only be called from low power executable just after resuming from STOP2
+pub(crate) unsafe fn apply_resume_config() {
+    trace!("rcc apply_resume_config()");
+
+    while RCC.cfgr().read().sws() != Sysclk::MSI {}
+
+    let config = get_resume_config();
+
+    init(config);
+}
+
 #[derive(Clone, Copy, Eq, PartialEq)]
 pub enum HseMode {
     /// crystal/ceramic oscillator (HSEBYP=0)
@@ -154,6 +193,10 @@ fn msi_enable(range: MSIRange) {
 }
 
 pub(crate) unsafe fn init(config: Config) {
+    // save the rcc config because if we enter stop 2 we need to re-apply it on wakeup
+    #[cfg(all(feature = "low-power", stm32wlex))]
+    set_resume_config(config);
+
     // Switch to MSI to prevent problems with PLL configuration.
     if !RCC.cr().read().msion() {
         // Turn on MSI and configure it to 4MHz.
diff --git a/embassy-stm32/src/rcc/mod.rs b/embassy-stm32/src/rcc/mod.rs
index addfca3c3..01fa3a475 100644
--- a/embassy-stm32/src/rcc/mod.rs
+++ b/embassy-stm32/src/rcc/mod.rs
@@ -48,6 +48,9 @@ pub(crate) static mut REFCOUNT_STOP1: u32 = 0;
 /// May be read without a critical section
 pub(crate) static mut REFCOUNT_STOP2: u32 = 0;
 
+#[cfg(backup_sram)]
+pub(crate) static mut BKSRAM_RETAINED: bool = false;
+
 #[cfg(not(feature = "_dual-core"))]
 /// Frozen clock frequencies
 ///
@@ -390,7 +393,7 @@ pub fn disable<T: RccPeripheral>() {
 ///
 /// This should only be called after `init`.
 #[cfg(not(feature = "_dual-core"))]
-pub fn reinit<'a>(config: Config, _rcc: &'a mut crate::Peri<'a, crate::peripherals::RCC>) {
+pub fn reinit(config: Config, _rcc: &'_ mut crate::Peri<'_, crate::peripherals::RCC>) {
     critical_section::with(|cs| init_rcc(cs, config))
 }
 
diff --git a/embassy-stm32/src/rtc/low_power.rs b/embassy-stm32/src/rtc/low_power.rs
index 999f24714..e5bf30927 100644
--- a/embassy-stm32/src/rtc/low_power.rs
+++ b/embassy-stm32/src/rtc/low_power.rs
@@ -4,7 +4,7 @@ use embassy_time::{Duration, TICK_HZ};
 use super::{DateTimeError, Rtc, RtcError, bcd2_to_byte};
 use crate::interrupt::typelevel::Interrupt;
 use crate::peripherals::RTC;
-use crate::rtc::SealedInstance;
+use crate::rtc::{RtcTimeProvider, SealedInstance};
 
 /// Represents an instant in time that can be substracted to compute a duration
 pub(super) struct RtcInstant {
@@ -68,7 +68,7 @@ pub(crate) enum WakeupPrescaler {
 }
 
 #[cfg(any(
-    stm32f4, stm32l0, stm32g4, stm32l4, stm32l5, stm32wb, stm32h5, stm32g0, stm32u5, stm32u0, stm32wba
+    stm32f4, stm32l0, stm32g4, stm32l4, stm32l5, stm32wb, stm32h5, stm32g0, stm32u5, stm32u0, stm32wba, stm32wlex
 ))]
 impl From<WakeupPrescaler> for crate::pac::rtc::vals::Wucksel {
     fn from(val: WakeupPrescaler) -> Self {
@@ -84,7 +84,7 @@ impl From<WakeupPrescaler> for crate::pac::rtc::vals::Wucksel {
 }
 
 #[cfg(any(
-    stm32f4, stm32l0, stm32g4, stm32l4, stm32l5, stm32wb, stm32h5, stm32g0, stm32u5, stm32u0, stm32wba
+    stm32f4, stm32l0, stm32g4, stm32l4, stm32l5, stm32wb, stm32h5, stm32g0, stm32u5, stm32u0, stm32wba, stm32wlex
 ))]
 impl From<crate::pac::rtc::vals::Wucksel> for WakeupPrescaler {
     fn from(val: crate::pac::rtc::vals::Wucksel) -> Self {
@@ -117,7 +117,7 @@ impl WakeupPrescaler {
 impl Rtc {
     /// Return the current instant.
     fn instant(&self) -> Result<RtcInstant, RtcError> {
-        self.time_provider().read(|_, tr, ss| {
+        RtcTimeProvider::new().read(|_, tr, ss| {
             let second = bcd2_to_byte((tr.st(), tr.su()));
 
             RtcInstant::from(second, ss).map_err(RtcError::InvalidDateTime)
@@ -127,7 +127,7 @@ impl Rtc {
     /// start the wakeup alarm and with a duration that is as close to but less than
     /// the requested duration, and record the instant the wakeup alarm was started
     pub(crate) fn start_wakeup_alarm(
-        &self,
+        &mut self,
         requested_duration: embassy_time::Duration,
         cs: critical_section::CriticalSection,
     ) {
@@ -179,7 +179,10 @@ impl Rtc {
 
     /// stop the wakeup alarm and return the time elapsed since `start_wakeup_alarm`
     /// was called, otherwise none
-    pub(crate) fn stop_wakeup_alarm(&self, cs: critical_section::CriticalSection) -> Option<embassy_time::Duration> {
+    pub(crate) fn stop_wakeup_alarm(
+        &mut self,
+        cs: critical_section::CriticalSection,
+    ) -> Option<embassy_time::Duration> {
         let instant = self.instant().unwrap();
         if RTC::regs().cr().read().wute() {
             trace!("rtc: stop wakeup alarm at {}", instant);
diff --git a/embassy-stm32/src/rtc/mod.rs b/embassy-stm32/src/rtc/mod.rs
index bc6df528b..116b3c7ed 100644
--- a/embassy-stm32/src/rtc/mod.rs
+++ b/embassy-stm32/src/rtc/mod.rs
@@ -5,9 +5,13 @@ mod datetime;
 mod low_power;
 
 #[cfg(feature = "low-power")]
-use core::cell::Cell;
+use core::cell::{Cell, RefCell, RefMut};
+#[cfg(feature = "low-power")]
+use core::ops;
 
 #[cfg(feature = "low-power")]
+use critical_section::CriticalSection;
+#[cfg(feature = "low-power")]
 use embassy_sync::blocking_mutex::Mutex;
 #[cfg(feature = "low-power")]
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
@@ -44,11 +48,17 @@ pub enum RtcError {
 }
 
 /// Provides immutable access to the current time of the RTC.
+#[derive(Clone)]
 pub struct RtcTimeProvider {
     _private: (),
 }
 
 impl RtcTimeProvider {
+    /// Create a new RTC time provider instance.
+    pub(self) const fn new() -> Self {
+        Self { _private: () }
+    }
+
     /// Return the current datetime.
     ///
     /// # Errors
@@ -106,6 +116,50 @@ impl RtcTimeProvider {
     }
 }
 
+#[cfg(feature = "low-power")]
+/// Contains an RTC driver.
+pub struct RtcContainer {
+    pub(self) mutex: &'static Mutex<CriticalSectionRawMutex, RefCell<Option<Rtc>>>,
+}
+
+#[cfg(feature = "low-power")]
+impl RtcContainer {
+    pub(self) const fn new() -> Self {
+        Self {
+            mutex: &crate::time_driver::get_driver().rtc,
+        }
+    }
+
+    /// Acquire an RTC borrow.
+    pub fn borrow_mut<'a>(&self, cs: CriticalSection<'a>) -> RtcBorrow<'a> {
+        RtcBorrow {
+            ref_mut: self.mutex.borrow(cs).borrow_mut(),
+        }
+    }
+}
+
+#[cfg(feature = "low-power")]
+/// Contains an RTC borrow.
+pub struct RtcBorrow<'a> {
+    pub(self) ref_mut: RefMut<'a, Option<Rtc>>,
+}
+
+#[cfg(feature = "low-power")]
+impl<'a> ops::Deref for RtcBorrow<'a> {
+    type Target = Rtc;
+
+    fn deref(&self) -> &Self::Target {
+        self.ref_mut.as_ref().unwrap()
+    }
+}
+
+#[cfg(feature = "low-power")]
+impl<'a> ops::DerefMut for RtcBorrow<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.ref_mut.as_mut().unwrap()
+    }
+}
+
 /// RTC driver.
 pub struct Rtc {
     #[cfg(feature = "low-power")]
@@ -121,13 +175,21 @@ pub struct RtcConfig {
     ///
     /// A high counter frequency may impact stop power consumption
     pub frequency: Hertz,
+
+    #[cfg(feature = "_allow-disable-rtc")]
+    /// Allow disabling the rtc, even when stop is configured
+    pub _disable_rtc: bool,
 }
 
 impl Default for RtcConfig {
     /// LSI with prescalers assuming 32.768 kHz.
     /// Raw sub-seconds in 1/256.
     fn default() -> Self {
-        RtcConfig { frequency: Hertz(256) }
+        RtcConfig {
+            frequency: Hertz(256),
+            #[cfg(feature = "_allow-disable-rtc")]
+            _disable_rtc: false,
+        }
     }
 }
 
@@ -145,8 +207,19 @@ pub enum RtcCalibrationCyclePeriod {
 }
 
 impl Rtc {
+    #[cfg(not(feature = "low-power"))]
+    /// Create a new RTC instance.
+    pub fn new(_rtc: Peri<'static, RTC>, rtc_config: RtcConfig) -> (Self, RtcTimeProvider) {
+        (Self::new_inner(rtc_config), RtcTimeProvider::new())
+    }
+
+    #[cfg(feature = "low-power")]
     /// Create a new RTC instance.
-    pub fn new(_rtc: Peri<'static, RTC>, rtc_config: RtcConfig) -> Self {
+    pub fn new(_rtc: Peri<'static, RTC>) -> (RtcContainer, RtcTimeProvider) {
+        (RtcContainer::new(), RtcTimeProvider::new())
+    }
+
+    pub(self) fn new_inner(rtc_config: RtcConfig) -> Self {
         #[cfg(not(any(stm32l0, stm32f3, stm32l1, stm32f0, stm32f2)))]
         crate::rcc::enable_and_reset::<RTC>();
 
@@ -165,10 +238,13 @@ impl Rtc {
         // Wait for the clock to update after initialization
         #[cfg(not(rtc_v2_f2))]
         {
-            let now = this.time_provider().read(|_, _, ss| Ok(ss)).unwrap();
-            while now == this.time_provider().read(|_, _, ss| Ok(ss)).unwrap() {}
+            let now = RtcTimeProvider::new().read(|_, _, ss| Ok(ss)).unwrap();
+            while now == RtcTimeProvider::new().read(|_, _, ss| Ok(ss)).unwrap() {}
         }
 
+        #[cfg(feature = "low-power")]
+        this.enable_wakeup_line();
+
         this
     }
 
@@ -177,11 +253,6 @@ impl Rtc {
         freqs.rtc.to_hertz().unwrap()
     }
 
-    /// Acquire a [`RtcTimeProvider`] instance.
-    pub const fn time_provider(&self) -> RtcTimeProvider {
-        RtcTimeProvider { _private: () }
-    }
-
     /// Set the datetime to a new value.
     ///
     /// # Errors
@@ -225,15 +296,6 @@ impl Rtc {
         Ok(())
     }
 
-    /// Return the current datetime.
-    ///
-    /// # Errors
-    ///
-    /// Will return an `RtcError::InvalidDateTime` if the stored value in the system is not a valid [`DayOfWeek`].
-    pub fn now(&self) -> Result<DateTime, RtcError> {
-        self.time_provider().now()
-    }
-
     /// Check if daylight savings time is active.
     pub fn get_daylight_savings(&self) -> bool {
         let cr = RTC::regs().cr().read();
@@ -315,3 +377,15 @@ trait SealedInstance {
 
     // fn apply_config(&mut self, rtc_config: RtcConfig);
 }
+
+#[cfg(feature = "low-power")]
+pub(crate) fn init_rtc(cs: CriticalSection, config: RtcConfig) {
+    #[cfg(feature = "_allow-disable-rtc")]
+    if config._disable_rtc {
+        return;
+    }
+
+    crate::time_driver::get_driver().set_rtc(cs, Rtc::new_inner(config));
+
+    trace!("low power: stop with rtc configured");
+}
diff --git a/embassy-stm32/src/rtc/v2.rs b/embassy-stm32/src/rtc/v2.rs
index 23f6ccb0c..8ac022536 100644
--- a/embassy-stm32/src/rtc/v2.rs
+++ b/embassy-stm32/src/rtc/v2.rs
@@ -93,7 +93,7 @@ impl super::Rtc {
         })
     }
 
-    pub(super) fn write<F, R>(&self, init_mode: bool, f: F) -> R
+    pub(super) fn write<F, R>(&mut self, init_mode: bool, f: F) -> R
     where
         F: FnOnce(crate::pac::rtc::Rtc) -> R,
     {
diff --git a/embassy-stm32/src/rtc/v3.rs b/embassy-stm32/src/rtc/v3.rs
index 01da5d70a..f7ebea73e 100644
--- a/embassy-stm32/src/rtc/v3.rs
+++ b/embassy-stm32/src/rtc/v3.rs
@@ -95,7 +95,7 @@ impl super::Rtc {
         })
     }
 
-    pub(super) fn write<F, R>(&self, init_mode: bool, f: F) -> R
+    pub(super) fn write<F, R>(&mut self, init_mode: bool, f: F) -> R
     where
         F: FnOnce(crate::pac::rtc::Rtc) -> R,
     {
@@ -131,7 +131,7 @@ impl SealedInstance for crate::peripherals::RTC {
 
     #[cfg(feature = "low-power")]
     cfg_if::cfg_if!(
-        if #[cfg(stm32g4)] {
+        if #[cfg(any(stm32g4, stm32wlex))] {
             const EXTI_WAKEUP_LINE: usize = 20;
         } else if #[cfg(stm32g0)] {
             const EXTI_WAKEUP_LINE: usize = 19;
@@ -142,7 +142,7 @@ impl SealedInstance for crate::peripherals::RTC {
 
     #[cfg(feature = "low-power")]
     cfg_if::cfg_if!(
-        if #[cfg(stm32g4)] {
+        if #[cfg(any(stm32g4, stm32wlex))] {
             type WakeupInterrupt = crate::interrupt::typelevel::RTC_WKUP;
         } else if #[cfg(any(stm32g0, stm32u0))] {
             type WakeupInterrupt = crate::interrupt::typelevel::RTC_TAMP;
diff --git a/embassy-stm32/src/sdmmc/mod.rs b/embassy-stm32/src/sdmmc/mod.rs
index 408d1b764..e05131040 100644
--- a/embassy-stm32/src/sdmmc/mod.rs
+++ b/embassy-stm32/src/sdmmc/mod.rs
@@ -1032,12 +1032,13 @@ impl<'d, T: Instance> Sdmmc<'d, T> {
 
     /// Wait for a previously started datapath transfer to complete from an interrupt.
     #[inline]
+    #[allow(unused)]
     async fn complete_datapath_transfer(block: bool) -> Result<(), Error> {
-        let regs = T::regs();
-
         let res = poll_fn(|cx| {
+            // Compiler might not be sufficiently constrained here
+            // https://github.com/embassy-rs/embassy/issues/4723
             T::state().register(cx.waker());
-            let status = regs.star().read();
+            let status = T::regs().star().read();
 
             if status.dcrcfail() {
                 return Poll::Ready(Err(Error::Crc));
@@ -1052,10 +1053,13 @@ impl<'d, T: Instance> Sdmmc<'d, T> {
             if status.stbiterr() {
                 return Poll::Ready(Err(Error::StBitErr));
             }
+            #[cfg(sdmmc_v1)]
             let done = match block {
                 true => status.dbckend(),
                 false => status.dataend(),
             };
+            #[cfg(sdmmc_v2)]
+            let done = status.dataend();
             if done {
                 return Poll::Ready(Ok(()));
             }
diff --git a/embassy-stm32/src/spi/mod.rs b/embassy-stm32/src/spi/mod.rs
index c27d09ea7..abb80ed26 100644
--- a/embassy-stm32/src/spi/mod.rs
+++ b/embassy-stm32/src/spi/mod.rs
@@ -125,26 +125,69 @@ impl Config {
         )
     }
 }
+
+/// SPI communication mode
+pub mod mode {
+    use stm32_metapac::spi::vals;
+
+    trait SealedMode {}
+
+    /// Trait for SPI communication mode operations.
+    #[allow(private_bounds)]
+    pub trait CommunicationMode: SealedMode {
+        /// Spi communication mode
+        #[cfg(not(any(spi_v4, spi_v5, spi_v6)))]
+        const MASTER: vals::Mstr;
+        /// Spi communication mode
+        #[cfg(any(spi_v4, spi_v5, spi_v6))]
+        const MASTER: vals::Master;
+    }
+
+    /// Mode allowing for SPI master operations.
+    pub struct Master;
+    /// Mode allowing for SPI slave operations.
+    pub struct Slave;
+
+    impl SealedMode for Master {}
+    impl CommunicationMode for Master {
+        #[cfg(not(any(spi_v4, spi_v5, spi_v6)))]
+        const MASTER: vals::Mstr = vals::Mstr::MASTER;
+        #[cfg(any(spi_v4, spi_v5, spi_v6))]
+        const MASTER: vals::Master = vals::Master::MASTER;
+    }
+
+    impl SealedMode for Slave {}
+    impl CommunicationMode for Slave {
+        #[cfg(not(any(spi_v4, spi_v5, spi_v6)))]
+        const MASTER: vals::Mstr = vals::Mstr::SLAVE;
+        #[cfg(any(spi_v4, spi_v5, spi_v6))]
+        const MASTER: vals::Master = vals::Master::SLAVE;
+    }
+}
+use mode::{CommunicationMode, Master, Slave};
+
 /// SPI driver.
-pub struct Spi<'d, M: PeriMode> {
+pub struct Spi<'d, M: PeriMode, CM: CommunicationMode> {
     pub(crate) info: &'static Info,
     kernel_clock: Hertz,
     sck: Option<Peri<'d, AnyPin>>,
     mosi: Option<Peri<'d, AnyPin>>,
     miso: Option<Peri<'d, AnyPin>>,
+    nss: Option<Peri<'d, AnyPin>>,
     tx_dma: Option<ChannelAndRequest<'d>>,
     rx_dma: Option<ChannelAndRequest<'d>>,
-    _phantom: PhantomData<M>,
+    _phantom: PhantomData<(M, CM)>,
     current_word_size: word_impl::Config,
     gpio_speed: Speed,
 }
 
-impl<'d, M: PeriMode> Spi<'d, M> {
+impl<'d, M: PeriMode, CM: CommunicationMode> Spi<'d, M, CM> {
     fn new_inner<T: Instance>(
         _peri: Peri<'d, T>,
         sck: Option<Peri<'d, AnyPin>>,
         mosi: Option<Peri<'d, AnyPin>>,
         miso: Option<Peri<'d, AnyPin>>,
+        nss: Option<Peri<'d, AnyPin>>,
         tx_dma: Option<ChannelAndRequest<'d>>,
         rx_dma: Option<ChannelAndRequest<'d>>,
         config: Config,
@@ -155,6 +198,7 @@ impl<'d, M: PeriMode> Spi<'d, M> {
             sck,
             mosi,
             miso,
+            nss,
             tx_dma,
             rx_dma,
             current_word_size: <u8 as SealedWord>::CONFIG,
@@ -183,12 +227,12 @@ impl<'d, M: PeriMode> Spi<'d, M> {
                 w.set_cpha(cpha);
                 w.set_cpol(cpol);
 
-                w.set_mstr(vals::Mstr::MASTER);
+                w.set_mstr(CM::MASTER);
                 w.set_br(br);
                 w.set_spe(true);
                 w.set_lsbfirst(lsbfirst);
-                w.set_ssi(true);
-                w.set_ssm(true);
+                w.set_ssi(CM::MASTER == vals::Mstr::MASTER);
+                w.set_ssm(CM::MASTER == vals::Mstr::MASTER);
                 w.set_crcen(false);
                 w.set_bidimode(vals::Bidimode::UNIDIRECTIONAL);
                 // we're doing "fake rxonly", by actually writing one
@@ -210,11 +254,11 @@ impl<'d, M: PeriMode> Spi<'d, M> {
                 w.set_cpha(cpha);
                 w.set_cpol(cpol);
 
-                w.set_mstr(vals::Mstr::MASTER);
+                w.set_mstr(CM::MASTER);
                 w.set_br(br);
                 w.set_lsbfirst(lsbfirst);
-                w.set_ssi(true);
-                w.set_ssm(true);
+                w.set_ssi(CM::MASTER == vals::Mstr::MASTER);
+                w.set_ssm(CM::MASTER == vals::Mstr::MASTER);
                 w.set_crcen(false);
                 w.set_bidimode(vals::Bidimode::UNIDIRECTIONAL);
                 w.set_spe(true);
@@ -229,8 +273,8 @@ impl<'d, M: PeriMode> Spi<'d, M> {
                 w.set_cpha(cpha);
                 w.set_cpol(cpol);
                 w.set_lsbfirst(lsbfirst);
-                w.set_ssm(true);
-                w.set_master(vals::Master::MASTER);
+                w.set_ssm(CM::MASTER == vals::Master::MASTER);
+                w.set_master(CM::MASTER);
                 w.set_comm(vals::Comm::FULL_DUPLEX);
                 w.set_ssom(vals::Ssom::ASSERTED);
                 w.set_midi(0);
@@ -469,7 +513,30 @@ impl<'d, M: PeriMode> Spi<'d, M> {
     }
 }
 
-impl<'d> Spi<'d, Blocking> {
+impl<'d> Spi<'d, Blocking, Slave> {
+    /// Create a new blocking SPI slave driver.
+    pub fn new_blocking_slave<T: Instance, #[cfg(afio)] A>(
+        peri: Peri<'d, T>,
+        sck: Peri<'d, if_afio!(impl SckPin<T, A>)>,
+        mosi: Peri<'d, if_afio!(impl MosiPin<T, A>)>,
+        miso: Peri<'d, if_afio!(impl MisoPin<T, A>)>,
+        cs: Peri<'d, if_afio!(impl CsPin<T, A>)>,
+        config: Config,
+    ) -> Self {
+        Self::new_inner(
+            peri,
+            new_pin!(sck, config.sck_af()),
+            new_pin!(mosi, AfType::output(OutputType::PushPull, config.gpio_speed)),
+            new_pin!(miso, AfType::input(config.miso_pull)),
+            new_pin!(cs, AfType::input(Pull::None)),
+            None,
+            None,
+            config,
+        )
+    }
+}
+
+impl<'d> Spi<'d, Blocking, Master> {
     /// Create a new blocking SPI driver.
     pub fn new_blocking<T: Instance, #[cfg(afio)] A>(
         peri: Peri<'d, T>,
@@ -485,6 +552,7 @@ impl<'d> Spi<'d, Blocking> {
             new_pin!(miso, AfType::input(config.miso_pull)),
             None,
             None,
+            None,
             config,
         )
     }
@@ -503,6 +571,7 @@ impl<'d> Spi<'d, Blocking> {
             new_pin!(miso, AfType::input(config.miso_pull)),
             None,
             None,
+            None,
             config,
         )
     }
@@ -521,6 +590,7 @@ impl<'d> Spi<'d, Blocking> {
             None,
             None,
             None,
+            None,
             config,
         )
     }
@@ -540,12 +610,38 @@ impl<'d> Spi<'d, Blocking> {
             None,
             None,
             None,
+            None,
+            config,
+        )
+    }
+}
+
+impl<'d> Spi<'d, Async, Slave> {
+    /// Create a new SPI slave driver.
+    pub fn new_slave<T: Instance, #[cfg(afio)] A>(
+        peri: Peri<'d, T>,
+        sck: Peri<'d, if_afio!(impl SckPin<T, A>)>,
+        mosi: Peri<'d, if_afio!(impl MosiPin<T, A>)>,
+        miso: Peri<'d, if_afio!(impl MisoPin<T, A>)>,
+        cs: Peri<'d, if_afio!(impl CsPin<T, A>)>,
+        tx_dma: Peri<'d, impl TxDma<T>>,
+        rx_dma: Peri<'d, impl RxDma<T>>,
+        config: Config,
+    ) -> Self {
+        Self::new_inner(
+            peri,
+            new_pin!(sck, config.sck_af()),
+            new_pin!(mosi, AfType::output(OutputType::PushPull, config.gpio_speed)),
+            new_pin!(miso, AfType::input(config.miso_pull)),
+            new_pin!(cs, AfType::input(Pull::None)),
+            new_dma!(tx_dma),
+            new_dma!(rx_dma),
             config,
         )
     }
 }
 
-impl<'d> Spi<'d, Async> {
+impl<'d> Spi<'d, Async, Master> {
     /// Create a new SPI driver.
     pub fn new<T: Instance, #[cfg(afio)] A>(
         peri: Peri<'d, T>,
@@ -561,6 +657,7 @@ impl<'d> Spi<'d, Async> {
             new_pin!(sck, config.sck_af()),
             new_pin!(mosi, AfType::output(OutputType::PushPull, config.gpio_speed)),
             new_pin!(miso, AfType::input(config.miso_pull)),
+            None,
             new_dma!(tx_dma),
             new_dma!(rx_dma),
             config,
@@ -581,6 +678,7 @@ impl<'d> Spi<'d, Async> {
             new_pin!(sck, config.sck_af()),
             None,
             new_pin!(miso, AfType::input(config.miso_pull)),
+            None,
             #[cfg(any(spi_v1, spi_v2, spi_v3))]
             new_dma!(tx_dma),
             #[cfg(any(spi_v4, spi_v5, spi_v6))]
@@ -603,6 +701,7 @@ impl<'d> Spi<'d, Async> {
             new_pin!(sck, config.sck_af()),
             new_pin!(mosi, AfType::output(OutputType::PushPull, config.gpio_speed)),
             None,
+            None,
             new_dma!(tx_dma),
             None,
             config,
@@ -623,6 +722,7 @@ impl<'d> Spi<'d, Async> {
             None,
             new_pin!(mosi, AfType::output(OutputType::PushPull, config.gpio_speed)),
             None,
+            None,
             new_dma!(tx_dma),
             None,
             config,
@@ -646,7 +746,7 @@ impl<'d> Spi<'d, Async> {
         config.bit_order = BitOrder::MsbFirst;
         config.frequency = freq;
 
-        Self::new_inner(peri, None, None, None, new_dma!(tx_dma), new_dma!(rx_dma), config)
+        Self::new_inner(peri, None, None, None, None, new_dma!(tx_dma), new_dma!(rx_dma), config)
     }
 
     #[allow(dead_code)]
@@ -656,9 +756,11 @@ impl<'d> Spi<'d, Async> {
         rx_dma: Option<ChannelAndRequest<'d>>,
         config: Config,
     ) -> Self {
-        Self::new_inner(peri, None, None, None, tx_dma, rx_dma, config)
+        Self::new_inner(peri, None, None, None, None, tx_dma, rx_dma, config)
     }
+}
 
+impl<'d, CM: CommunicationMode> Spi<'d, Async, CM> {
     /// SPI write, using DMA.
     pub async fn write<W: Word>(&mut self, data: &[W]) -> Result<(), Error> {
         if data.is_empty() {
@@ -888,11 +990,12 @@ impl<'d> Spi<'d, Async> {
     }
 }
 
-impl<'d, M: PeriMode> Drop for Spi<'d, M> {
+impl<'d, M: PeriMode, CM: CommunicationMode> Drop for Spi<'d, M, CM> {
     fn drop(&mut self) {
         self.sck.as_ref().map(|x| x.set_as_disconnected());
         self.mosi.as_ref().map(|x| x.set_as_disconnected());
         self.miso.as_ref().map(|x| x.set_as_disconnected());
+        self.nss.as_ref().map(|x| x.set_as_disconnected());
 
         self.info.rcc.disable();
     }
@@ -1127,7 +1230,7 @@ fn write_word<W: Word>(regs: Regs, tx_word: W) -> Result<(), Error> {
 // some marker traits. For details, see https://github.com/rust-embedded/embedded-hal/pull/289
 macro_rules! impl_blocking {
     ($w:ident) => {
-        impl<'d, M: PeriMode> embedded_hal_02::blocking::spi::Write<$w> for Spi<'d, M> {
+        impl<'d, M: PeriMode, CM: CommunicationMode> embedded_hal_02::blocking::spi::Write<$w> for Spi<'d, M, CM> {
             type Error = Error;
 
             fn write(&mut self, words: &[$w]) -> Result<(), Self::Error> {
@@ -1135,7 +1238,7 @@ macro_rules! impl_blocking {
             }
         }
 
-        impl<'d, M: PeriMode> embedded_hal_02::blocking::spi::Transfer<$w> for Spi<'d, M> {
+        impl<'d, M: PeriMode, CM: CommunicationMode> embedded_hal_02::blocking::spi::Transfer<$w> for Spi<'d, M, CM> {
             type Error = Error;
 
             fn transfer<'w>(&mut self, words: &'w mut [$w]) -> Result<&'w [$w], Self::Error> {
@@ -1149,11 +1252,11 @@ macro_rules! impl_blocking {
 impl_blocking!(u8);
 impl_blocking!(u16);
 
-impl<'d, M: PeriMode> embedded_hal_1::spi::ErrorType for Spi<'d, M> {
+impl<'d, M: PeriMode, CM: CommunicationMode> embedded_hal_1::spi::ErrorType for Spi<'d, M, CM> {
     type Error = Error;
 }
 
-impl<'d, W: Word, M: PeriMode> embedded_hal_1::spi::SpiBus<W> for Spi<'d, M> {
+impl<'d, W: Word, M: PeriMode, CM: CommunicationMode> embedded_hal_1::spi::SpiBus<W> for Spi<'d, M, CM> {
     fn flush(&mut self) -> Result<(), Self::Error> {
         Ok(())
     }
@@ -1186,7 +1289,7 @@ impl embedded_hal_1::spi::Error for Error {
     }
 }
 
-impl<'d, W: Word> embedded_hal_async::spi::SpiBus<W> for Spi<'d, Async> {
+impl<'d, W: Word, CM: CommunicationMode> embedded_hal_async::spi::SpiBus<W> for Spi<'d, Async, CM> {
     async fn flush(&mut self) -> Result<(), Self::Error> {
         Ok(())
     }
@@ -1328,7 +1431,7 @@ foreach_peripheral!(
     };
 );
 
-impl<'d, M: PeriMode> SetConfig for Spi<'d, M> {
+impl<'d, M: PeriMode, CM: CommunicationMode> SetConfig for Spi<'d, M, CM> {
     type Config = Config;
     type ConfigError = ();
     fn set_config(&mut self, config: &Self::Config) -> Result<(), ()> {
diff --git a/embassy-stm32/src/time_driver.rs b/embassy-stm32/src/time_driver.rs
index 74b10a183..7db51d72e 100644
--- a/embassy-stm32/src/time_driver.rs
+++ b/embassy-stm32/src/time_driver.rs
@@ -1,6 +1,8 @@
 #![allow(non_snake_case)]
 
 use core::cell::{Cell, RefCell};
+#[cfg(all(feature = "low-power", stm32wlex))]
+use core::sync::atomic::AtomicU16;
 use core::sync::atomic::{AtomicU32, Ordering, compiler_fence};
 
 use critical_section::CriticalSection;
@@ -213,7 +215,13 @@ pub(crate) struct RtcDriver {
     period: AtomicU32,
     alarm: Mutex<CriticalSectionRawMutex, AlarmState>,
     #[cfg(feature = "low-power")]
-    rtc: Mutex<CriticalSectionRawMutex, Cell<Option<&'static Rtc>>>,
+    pub(crate) rtc: Mutex<CriticalSectionRawMutex, RefCell<Option<Rtc>>>,
+    #[cfg(feature = "low-power")]
+    /// The minimum pause time beyond which the executor will enter a low-power state.
+    min_stop_pause: Mutex<CriticalSectionRawMutex, Cell<embassy_time::Duration>>,
+    /// Saved count for the timer (its value is lost when entering STOP2)
+    #[cfg(all(feature = "low-power", stm32wlex))]
+    saved_count: AtomicU16,
     queue: Mutex<CriticalSectionRawMutex, RefCell<Queue>>,
 }
 
@@ -221,12 +229,18 @@ embassy_time_driver::time_driver_impl!(static DRIVER: RtcDriver = RtcDriver {
     period: AtomicU32::new(0),
     alarm: Mutex::const_new(CriticalSectionRawMutex::new(), AlarmState::new()),
     #[cfg(feature = "low-power")]
-    rtc: Mutex::const_new(CriticalSectionRawMutex::new(), Cell::new(None)),
+    rtc: Mutex::const_new(CriticalSectionRawMutex::new(), RefCell::new(None)),
+    #[cfg(feature = "low-power")]
+    min_stop_pause: Mutex::const_new(CriticalSectionRawMutex::new(), Cell::new(embassy_time::Duration::from_millis(0))),
+    #[cfg(all(feature = "low-power", stm32wlex))]
+    saved_count: AtomicU16::new(0),
     queue: Mutex::new(RefCell::new(Queue::new()))
 });
 
 impl RtcDriver {
-    fn init(&'static self, cs: critical_section::CriticalSection) {
+    /// initialize the timer, but don't start it.  Used for chips like stm32wle5
+    /// for low power where the timer config is lost in STOP2.
+    fn init_timer(&'static self, cs: critical_section::CriticalSection) {
         let r = regs_gp16();
 
         rcc::enable_and_reset_with_cs::<T>(cs);
@@ -259,10 +273,16 @@ impl RtcDriver {
             w.set_ccie(0, true);
         });
 
+        #[cfg(all(feature = "low-power", stm32wlex))]
+        r.cnt().write(|w| w.set_cnt(self.saved_count.load(Ordering::SeqCst)));
+
         <T as GeneralInstance1Channel>::CaptureCompareInterrupt::unpend();
         unsafe { <T as GeneralInstance1Channel>::CaptureCompareInterrupt::enable() };
+    }
 
-        r.cr1().modify(|w| w.set_cen(true));
+    fn init(&'static self, cs: CriticalSection) {
+        self.init_timer(cs);
+        regs_gp16().cr1().modify(|w| w.set_cen(true));
     }
 
     fn on_interrupt(&self) {
@@ -379,27 +399,26 @@ impl RtcDriver {
     #[cfg(feature = "low-power")]
     /// Stop the wakeup alarm, if enabled, and add the appropriate offset
     fn stop_wakeup_alarm(&self, cs: CriticalSection) {
-        if let Some(offset) = self.rtc.borrow(cs).get().unwrap().stop_wakeup_alarm(cs) {
+        if let Some(offset) = self.rtc.borrow(cs).borrow_mut().as_mut().unwrap().stop_wakeup_alarm(cs) {
             self.add_time(offset, cs);
         }
     }
 
     /*
-        Low-power public functions: all create a critical section
+        Low-power public functions: all create or require a critical section
     */
     #[cfg(feature = "low-power")]
-    /// Set the rtc but panic if it's already been set
-    pub(crate) fn set_rtc(&self, rtc: &'static Rtc) {
-        critical_section::with(|cs| {
-            rtc.stop_wakeup_alarm(cs);
-
-            assert!(self.rtc.borrow(cs).replace(Some(rtc)).is_none())
-        });
+    pub(crate) fn set_min_stop_pause(&self, cs: CriticalSection, min_stop_pause: embassy_time::Duration) {
+        self.min_stop_pause.borrow(cs).replace(min_stop_pause);
     }
 
     #[cfg(feature = "low-power")]
-    /// The minimum pause time beyond which the executor will enter a low-power state.
-    pub(crate) const MIN_STOP_PAUSE: embassy_time::Duration = embassy_time::Duration::from_millis(250);
+    /// Set the rtc but panic if it's already been set
+    pub(crate) fn set_rtc(&self, cs: CriticalSection, mut rtc: Rtc) {
+        rtc.stop_wakeup_alarm(cs);
+
+        assert!(self.rtc.borrow(cs).replace(Some(rtc)).is_none());
+    }
 
     #[cfg(feature = "low-power")]
     /// Pause the timer if ready; return err if not
@@ -413,17 +432,25 @@ impl RtcDriver {
             self.stop_wakeup_alarm(cs);
 
             let time_until_next_alarm = self.time_until_next_alarm(cs);
-            if time_until_next_alarm < Self::MIN_STOP_PAUSE {
+            if time_until_next_alarm < self.min_stop_pause.borrow(cs).get() {
+                trace!(
+                    "time_until_next_alarm < self.min_stop_pause ({})",
+                    time_until_next_alarm
+                );
                 Err(())
             } else {
                 self.rtc
                     .borrow(cs)
-                    .get()
+                    .borrow_mut()
+                    .as_mut()
                     .unwrap()
                     .start_wakeup_alarm(time_until_next_alarm, cs);
 
                 regs_gp16().cr1().modify(|w| w.set_cen(false));
-
+                // save the count for the timer as its lost in STOP2 for stm32wlex
+                #[cfg(stm32wlex)]
+                self.saved_count
+                    .store(regs_gp16().cnt().read().cnt() as u16, Ordering::SeqCst);
                 Ok(())
             }
         })
@@ -431,18 +458,16 @@ impl RtcDriver {
 
     #[cfg(feature = "low-power")]
     /// Resume the timer with the given offset
-    pub(crate) fn resume_time(&self) {
+    pub(crate) fn resume_time(&self, cs: CriticalSection) {
         if regs_gp16().cr1().read().cen() {
             // Time isn't currently stopped
 
             return;
         }
 
-        critical_section::with(|cs| {
-            self.stop_wakeup_alarm(cs);
+        self.stop_wakeup_alarm(cs);
 
-            regs_gp16().cr1().modify(|w| w.set_cen(true));
-        })
+        regs_gp16().cr1().modify(|w| w.set_cen(true));
     }
 
     fn set_alarm(&self, cs: CriticalSection, timestamp: u64) -> bool {
@@ -514,10 +539,15 @@ impl Driver for RtcDriver {
 }
 
 #[cfg(feature = "low-power")]
-pub(crate) fn get_driver() -> &'static RtcDriver {
+pub(crate) const fn get_driver() -> &'static RtcDriver {
     &DRIVER
 }
 
 pub(crate) fn init(cs: CriticalSection) {
     DRIVER.init(cs)
 }
+
+#[cfg(all(feature = "low-power", stm32wlex))]
+pub(crate) fn init_timer(cs: CriticalSection) {
+    DRIVER.init_timer(cs)
+}
diff --git a/embassy-stm32/src/timer/complementary_pwm.rs b/embassy-stm32/src/timer/complementary_pwm.rs
index 75a83629c..9a56a41fb 100644
--- a/embassy-stm32/src/timer/complementary_pwm.rs
+++ b/embassy-stm32/src/timer/complementary_pwm.rs
@@ -2,7 +2,7 @@
 
 use core::marker::PhantomData;
 
-pub use stm32_metapac::timer::vals::{Ckd, Ossi, Ossr};
+pub use stm32_metapac::timer::vals::{Ckd, Mms2, Ossi, Ossr};
 
 use super::low_level::{CountingMode, OutputPolarity, Timer};
 use super::simple_pwm::PwmPin;
@@ -136,6 +136,16 @@ impl<'d, T: AdvancedInstance4Channel> ComplementaryPwm<'d, T> {
         self.inner.get_moe()
     }
 
+    /// Set Master Slave Mode 2
+    pub fn set_mms2(&mut self, mms2: Mms2) {
+        self.inner.set_mms2_selection(mms2);
+    }
+
+    /// Set Repetition Counter
+    pub fn set_repetition_counter(&mut self, val: u16) {
+        self.inner.set_repetition_counter(val);
+    }
+
     /// Enable the given channel.
     pub fn enable(&mut self, channel: Channel) {
         self.inner.enable_channel(channel, true);
diff --git a/embassy-stm32/src/timer/low_level.rs b/embassy-stm32/src/timer/low_level.rs
index ac039bb0d..0122fe4f7 100644
--- a/embassy-stm32/src/timer/low_level.rs
+++ b/embassy-stm32/src/timer/low_level.rs
@@ -10,7 +10,7 @@ use core::mem::ManuallyDrop;
 
 use embassy_hal_internal::Peri;
 // Re-export useful enums
-pub use stm32_metapac::timer::vals::{FilterValue, Sms as SlaveMode, Ts as TriggerSource};
+pub use stm32_metapac::timer::vals::{FilterValue, Mms as MasterMode, Sms as SlaveMode, Ts as TriggerSource};
 
 use super::*;
 use crate::pac::timer::vals;
@@ -143,20 +143,69 @@ pub enum OutputCompareMode {
     /// TIMx_CNT<TIMx_CCRx else active. In downcounting, channel is active as long as
     /// TIMx_CNT>TIMx_CCRx else inactive.
     PwmMode2,
-    // TODO: there's more modes here depending on the chip family.
+
+    #[cfg(timer_v2)]
+    /// In up-counting mode, the channel is active until a trigger
+    /// event is detected (on tim_trgi signal). Then, a comparison is performed as in PWM
+    /// mode 1 and the channels becomes active again at the next update. In down-counting
+    /// mode, the channel is inactive until a trigger event is detected (on tim_trgi signal).
+    /// Then, a comparison is performed as in PWM mode 1 and the channels becomes
+    /// inactive again at the next update.
+    OnePulseMode1,
+
+    #[cfg(timer_v2)]
+    /// In up-counting mode, the channel is inactive until a
+    /// trigger event is detected (on tim_trgi signal). Then, a comparison is performed as in
+    /// PWM mode 2 and the channels becomes inactive again at the next update. In down
+    /// counting mode, the channel is active until a trigger event is detected (on tim_trgi
+    /// signal). Then, a comparison is performed as in PWM mode 1 and the channels
+    /// becomes active again at the next update.
+    OnePulseMode2,
+
+    #[cfg(timer_v2)]
+    /// Combined PWM mode 1 - tim_oc1ref has the same behavior as in PWM mode 1.
+    /// tim_oc1refc is the logical OR between tim_oc1ref and tim_oc2ref.
+    CombinedPwmMode1,
+
+    #[cfg(timer_v2)]
+    /// Combined PWM mode 2 - tim_oc1ref has the same behavior as in PWM mode 2.
+    /// tim_oc1refc is the logical AND between tim_oc1ref and tim_oc2ref.
+    CombinedPwmMode2,
+
+    #[cfg(timer_v2)]
+    /// tim_oc1ref has the same behavior as in PWM mode 1. tim_oc1refc outputs tim_oc1ref
+    /// when the counter is counting up, tim_oc2ref when it is counting down.
+    AsymmetricPwmMode1,
+
+    #[cfg(timer_v2)]
+    /// tim_oc1ref has the same behavior as in PWM mode 2. tim_oc1refc outputs tim_oc1ref
+    /// when the counter is counting up, tim_oc2ref when it is counting down.
+    AsymmetricPwmMode2,
 }
 
-impl From<OutputCompareMode> for stm32_metapac::timer::vals::Ocm {
+impl From<OutputCompareMode> for crate::pac::timer::vals::Ocm {
     fn from(mode: OutputCompareMode) -> Self {
         match mode {
-            OutputCompareMode::Frozen => stm32_metapac::timer::vals::Ocm::FROZEN,
-            OutputCompareMode::ActiveOnMatch => stm32_metapac::timer::vals::Ocm::ACTIVE_ON_MATCH,
-            OutputCompareMode::InactiveOnMatch => stm32_metapac::timer::vals::Ocm::INACTIVE_ON_MATCH,
-            OutputCompareMode::Toggle => stm32_metapac::timer::vals::Ocm::TOGGLE,
-            OutputCompareMode::ForceInactive => stm32_metapac::timer::vals::Ocm::FORCE_INACTIVE,
-            OutputCompareMode::ForceActive => stm32_metapac::timer::vals::Ocm::FORCE_ACTIVE,
-            OutputCompareMode::PwmMode1 => stm32_metapac::timer::vals::Ocm::PWM_MODE1,
-            OutputCompareMode::PwmMode2 => stm32_metapac::timer::vals::Ocm::PWM_MODE2,
+            OutputCompareMode::Frozen => crate::pac::timer::vals::Ocm::FROZEN,
+            OutputCompareMode::ActiveOnMatch => crate::pac::timer::vals::Ocm::ACTIVE_ON_MATCH,
+            OutputCompareMode::InactiveOnMatch => crate::pac::timer::vals::Ocm::INACTIVE_ON_MATCH,
+            OutputCompareMode::Toggle => crate::pac::timer::vals::Ocm::TOGGLE,
+            OutputCompareMode::ForceInactive => crate::pac::timer::vals::Ocm::FORCE_INACTIVE,
+            OutputCompareMode::ForceActive => crate::pac::timer::vals::Ocm::FORCE_ACTIVE,
+            OutputCompareMode::PwmMode1 => crate::pac::timer::vals::Ocm::PWM_MODE1,
+            OutputCompareMode::PwmMode2 => crate::pac::timer::vals::Ocm::PWM_MODE2,
+            #[cfg(timer_v2)]
+            OutputCompareMode::OnePulseMode1 => crate::pac::timer::vals::Ocm::RETRIGERRABLE_OPM_MODE_1,
+            #[cfg(timer_v2)]
+            OutputCompareMode::OnePulseMode2 => crate::pac::timer::vals::Ocm::RETRIGERRABLE_OPM_MODE_2,
+            #[cfg(timer_v2)]
+            OutputCompareMode::CombinedPwmMode1 => crate::pac::timer::vals::Ocm::COMBINED_PWM_MODE_1,
+            #[cfg(timer_v2)]
+            OutputCompareMode::CombinedPwmMode2 => crate::pac::timer::vals::Ocm::COMBINED_PWM_MODE_2,
+            #[cfg(timer_v2)]
+            OutputCompareMode::AsymmetricPwmMode1 => crate::pac::timer::vals::Ocm::ASYMMETRIC_PWM_MODE_1,
+            #[cfg(timer_v2)]
+            OutputCompareMode::AsymmetricPwmMode2 => crate::pac::timer::vals::Ocm::ASYMMETRIC_PWM_MODE_2,
         }
     }
 }
@@ -640,6 +689,11 @@ impl<'d, T: GeneralInstance4Channel> Timer<'d, T> {
         self.regs_gp16().dier().modify(|w| w.set_ccde(channel.index(), ccde))
     }
 
+    /// Set Timer Master Mode
+    pub fn set_master_mode(&self, mms: MasterMode) {
+        self.regs_gp16().cr2().modify(|w| w.set_mms(mms));
+    }
+
     /// Set Timer Slave Mode
     pub fn set_slave_mode(&self, sms: SlaveMode) {
         self.regs_gp16().smcr().modify(|r| r.set_sms(sms));
@@ -760,6 +814,16 @@ impl<'d, T: AdvancedInstance4Channel> Timer<'d, T> {
         self.regs_advanced().cr2().modify(|w| w.set_oisn(channel.index(), val));
     }
 
+    /// Set master mode selection 2
+    pub fn set_mms2_selection(&self, mms2: vals::Mms2) {
+        self.regs_advanced().cr2().modify(|w| w.set_mms2(mms2));
+    }
+
+    /// Set repetition counter
+    pub fn set_repetition_counter(&self, val: u16) {
+        self.regs_advanced().rcr().modify(|w| w.set_rep(val));
+    }
+
     /// Trigger software break 1 or 2
     /// Setting this bit generates a break event. This bit is automatically cleared by the hardware.
     pub fn trigger_software_break(&self, n: usize) {
diff --git a/embassy-stm32/src/timer/mod.rs b/embassy-stm32/src/timer/mod.rs
index b09bc7166..804d1ef37 100644
--- a/embassy-stm32/src/timer/mod.rs
+++ b/embassy-stm32/src/timer/mod.rs
@@ -399,7 +399,7 @@ pub struct UpdateInterruptHandler<T: CoreInstance> {
 impl<T: CoreInstance> interrupt::typelevel::Handler<T::UpdateInterrupt> for UpdateInterruptHandler<T> {
     unsafe fn on_interrupt() {
         #[cfg(feature = "low-power")]
-        crate::low_power::on_wakeup_irq();
+        crate::low_power::Executor::on_wakeup_irq();
 
         let regs = crate::pac::timer::TimCore::from_ptr(T::regs());
 
@@ -429,7 +429,7 @@ impl<T: GeneralInstance1Channel> interrupt::typelevel::Handler<T::CaptureCompare
 {
     unsafe fn on_interrupt() {
         #[cfg(feature = "low-power")]
-        crate::low_power::on_wakeup_irq();
+        crate::low_power::Executor::on_wakeup_irq();
 
         let regs = crate::pac::timer::TimGp16::from_ptr(T::regs());
 
diff --git a/embassy-stm32/src/uid.rs b/embassy-stm32/src/uid.rs
index 5e38532bd..2d3e2b972 100644
--- a/embassy-stm32/src/uid.rs
+++ b/embassy-stm32/src/uid.rs
@@ -1,8 +1,8 @@
 //! Unique ID (UID)
 
 /// Get this device's unique 96-bit ID.
-pub fn uid() -> &'static [u8; 12] {
-    unsafe { &*crate::pac::UID.uid(0).as_ptr().cast::<[u8; 12]>() }
+pub fn uid() -> [u8; 12] {
+    unsafe { *crate::pac::UID.uid(0).as_ptr().cast::<[u8; 12]>() }
 }
 
 /// Get this device's unique 96-bit ID, encoded into a string of 24 hexadecimal ASCII digits.
diff --git a/embassy-stm32/src/usart/ringbuffered.rs b/embassy-stm32/src/usart/ringbuffered.rs
index 20bfefd9e..bac570d27 100644
--- a/embassy-stm32/src/usart/ringbuffered.rs
+++ b/embassy-stm32/src/usart/ringbuffered.rs
@@ -7,7 +7,9 @@ use embassy_embedded_hal::SetConfig;
 use embedded_io_async::ReadReady;
 use futures_util::future::{Either, select};
 
-use super::{Config, ConfigError, Error, Info, State, UartRx, rdr, reconfigure, set_baudrate, sr};
+use super::{
+    Config, ConfigError, Error, Info, State, UartRx, clear_interrupt_flags, rdr, reconfigure, set_baudrate, sr,
+};
 use crate::Peri;
 use crate::dma::ReadableRingBuffer;
 use crate::gpio::{AnyPin, SealedPin as _};
@@ -338,26 +340,16 @@ impl Drop for RingBufferedUartRx<'_> {
 /// For usart_v1 and usart_v2, all status flags must be handled together anyway because all flags
 /// are cleared by a single read to the RDR register.
 fn check_idle_and_errors(r: Regs) -> Result<bool, Error> {
-    // Critical section is required so that the flags aren't set after read and before clear
-    let sr = critical_section::with(|_| {
-        // SAFETY: read only and we only use Rx related flags
-        let sr = sr(r).read();
-
-        #[cfg(any(usart_v3, usart_v4))]
-        r.icr().write(|w| {
-            w.set_idle(true);
-            w.set_pe(true);
-            w.set_fe(true);
-            w.set_ne(true);
-            w.set_ore(true);
-        });
-        #[cfg(not(any(usart_v3, usart_v4)))]
-        unsafe {
-            // This read also clears the error and idle interrupt flags on v1 (TODO and v2?)
-            rdr(r).read_volatile()
-        };
-        sr
-    });
+    // SAFETY: read only and we only use Rx related flags
+    let sr = sr(r).read();
+
+    #[cfg(not(any(usart_v3, usart_v4)))]
+    unsafe {
+        // This read also clears the error and idle interrupt flags on v1 (TODO and v2?)
+        rdr(r).read_volatile()
+    };
+    clear_interrupt_flags(r, sr);
+
     if sr.pe() {
         Err(Error::Parity)
     } else if sr.fe() {
diff --git a/embassy-stm32/src/vrefbuf/mod.rs b/embassy-stm32/src/vrefbuf/mod.rs
index b061306a0..43dd9c800 100644
--- a/embassy-stm32/src/vrefbuf/mod.rs
+++ b/embassy-stm32/src/vrefbuf/mod.rs
@@ -14,10 +14,10 @@ pub struct VoltageReferenceBuffer<'d, T: Instance> {
 #[cfg(rcc_wba)]
 fn get_refbuf_trim(voltage_scale: Vrs) -> usize {
     match voltage_scale {
-        Vrs::VREF0 => 0x0BFA_07A8usize,
-        Vrs::VREF1 => 0x0BFA_07A9usize,
-        Vrs::VREF2 => 0x0BFA_07AAusize,
-        Vrs::VREF3 => 0x0BFA_07ABusize,
+        Vrs::VREF0 => 0x0BFA_07ABusize,
+        Vrs::VREF1 => 0x0BFA_07AAusize,
+        Vrs::VREF2 => 0x0BFA_07A9usize,
+        Vrs::VREF3 => 0x0BFA_07A8usize,
         _ => panic!("Incorrect Vrs setting!"),
     }
 }
diff --git a/embassy-usb-logger/CHANGELOG.md b/embassy-usb-logger/CHANGELOG.md
index 4ea0e8871..3ba140b1f 100644
--- a/embassy-usb-logger/CHANGELOG.md
+++ b/embassy-usb-logger/CHANGELOG.md
@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- next-header -->
 ## Unreleased - ReleaseDate
 
+- Fixed panic in `UsbLogger` when usb is disconnected
+
 ## 0.5.1 - 2025-08-26
 
 ## 0.5.0 - 2025-07-22
diff --git a/embassy-usb-logger/src/lib.rs b/embassy-usb-logger/src/lib.rs
index de25abce1..7c3c5e709 100644
--- a/embassy-usb-logger/src/lib.rs
+++ b/embassy-usb-logger/src/lib.rs
@@ -8,7 +8,7 @@ use core::future::Future;
 use embassy_futures::join::join;
 use embassy_sync::pipe::Pipe;
 use embassy_usb::class::cdc_acm::{CdcAcmClass, Receiver, Sender, State};
-use embassy_usb::driver::Driver;
+use embassy_usb::driver::{Driver, EndpointError};
 use embassy_usb::{Builder, Config};
 use log::{Metadata, Record};
 
@@ -133,17 +133,25 @@ impl<const N: usize, T: ReceiverHandler + Send + Sync> UsbLogger<N, T> {
             sender.wait_connection().await;
             loop {
                 let len = self.buffer.read(&mut rx[..]).await;
-                let _ = sender.write_packet(&rx[..len]).await;
-                if len as u8 == MAX_PACKET_SIZE {
-                    let _ = sender.write_packet(&[]).await;
-                }
+                if Err(EndpointError::Disabled) == sender.write_packet(&rx[..len]).await
+                    || len as u8 == MAX_PACKET_SIZE && Err(EndpointError::Disabled) == sender.write_packet(&[]).await
+                {
+                    sender.wait_connection().await;
+                };
             }
         };
         let reciever_fut = async {
             let mut reciever_buf: [u8; MAX_PACKET_SIZE as usize] = [0; MAX_PACKET_SIZE as usize];
             receiver.wait_connection().await;
             loop {
-                let n = receiver.read_packet(&mut reciever_buf).await.unwrap();
+                let n = match receiver.read_packet(&mut reciever_buf).await {
+                    Err(EndpointError::Disabled) => {
+                        receiver.wait_connection().await;
+                        continue;
+                    }
+                    Err(_) => continue,
+                    Ok(n) => n,
+                };
                 match &self.recieve_handler {
                     Some(handler) => {
                         let data = &reciever_buf[..n];
diff --git a/examples/lpc55s69/src/bin/pwm.rs b/examples/lpc55s69/src/bin/pwm.rs
new file mode 100644
index 000000000..93b898b9d
--- /dev/null
+++ b/examples/lpc55s69/src/bin/pwm.rs
@@ -0,0 +1,18 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nxp::pwm::{Config, Pwm};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_halt as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nxp::init(Default::default());
+    let pwm = Pwm::new_output(p.PWM_OUTPUT1, p.PIO0_18, Config::new(1_000_000_000, 2_000_000_000));
+    loop {
+        info!("Counter: {}", pwm.counter());
+        Timer::after_millis(50).await;
+    }
+}
diff --git a/examples/mspm0g3507/src/bin/i2c_target.rs b/examples/mspm0g3507/src/bin/i2c_target.rs
new file mode 100644
index 000000000..5dd718eaf
--- /dev/null
+++ b/examples/mspm0g3507/src/bin/i2c_target.rs
@@ -0,0 +1,63 @@
+//! Example of using async I2C target
+//!
+//! This uses the virtual COM port provided on the LP-MSPM0G3507 board.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_mspm0::i2c::Config;
+use embassy_mspm0::i2c_target::{Command, Config as TargetConfig, I2cTarget, ReadStatus};
+use embassy_mspm0::peripherals::I2C1;
+use embassy_mspm0::{bind_interrupts, i2c};
+use {defmt_rtt as _, panic_halt as _};
+
+bind_interrupts!(struct Irqs {
+    I2C1 => i2c::InterruptHandler<I2C1>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) -> ! {
+    let p = embassy_mspm0::init(Default::default());
+
+    let instance = p.I2C1;
+    let scl = p.PB2;
+    let sda = p.PB3;
+
+    let config = Config::default();
+    let mut target_config = TargetConfig::default();
+    target_config.target_addr = 0x48;
+    target_config.general_call = true;
+    let mut i2c = I2cTarget::new(instance, scl, sda, Irqs, config, target_config).unwrap();
+
+    let mut read = [0u8; 8];
+    let data = [8u8; 2];
+    let data_wr = [9u8; 2];
+
+    loop {
+        match i2c.listen(&mut read).await {
+            Ok(Command::GeneralCall(_)) => info!("General call received"),
+            Ok(Command::Read) => {
+                info!("Read command received");
+                match i2c.respond_to_read(&data).await.unwrap() {
+                    ReadStatus::Done => info!("Finished reading"),
+                    ReadStatus::NeedMoreBytes => {
+                        info!("Read needs more bytes - will reset");
+                        i2c.reset().unwrap();
+                    }
+                    ReadStatus::LeftoverBytes(_) => {
+                        info!("Leftover bytes received");
+                        i2c.flush_tx_fifo();
+                    }
+                }
+            }
+            Ok(Command::Write(_)) => info!("Write command received"),
+            Ok(Command::WriteRead(_)) => {
+                info!("Write-Read command received");
+                i2c.respond_and_fill(&data_wr, 0xFE).await.unwrap();
+            }
+            Err(e) => info!("Got error {}", e),
+        }
+    }
+}
diff --git a/examples/mspm0l1306/src/bin/i2c_target.rs b/examples/mspm0l1306/src/bin/i2c_target.rs
new file mode 100644
index 000000000..4d147d08b
--- /dev/null
+++ b/examples/mspm0l1306/src/bin/i2c_target.rs
@@ -0,0 +1,63 @@
+//! Example of using async I2C target
+//!
+//! This uses the virtual COM port provided on the LP-MSPM0L1306 board.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_mspm0::i2c::Config;
+use embassy_mspm0::i2c_target::{Command, Config as TargetConfig, I2cTarget, ReadStatus};
+use embassy_mspm0::peripherals::I2C0;
+use embassy_mspm0::{bind_interrupts, i2c};
+use {defmt_rtt as _, panic_halt as _};
+
+bind_interrupts!(struct Irqs {
+    I2C0 => i2c::InterruptHandler<I2C0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) -> ! {
+    let p = embassy_mspm0::init(Default::default());
+
+    let instance = p.I2C0;
+    let scl = p.PA1;
+    let sda = p.PA0;
+
+    let config = Config::default();
+    let mut target_config = TargetConfig::default();
+    target_config.target_addr = 0x48;
+    target_config.general_call = true;
+    let mut i2c = I2cTarget::new(instance, scl, sda, Irqs, config, target_config).unwrap();
+
+    let mut read = [0u8; 8];
+    let data = [8u8; 2];
+    let data_wr = [9u8; 2];
+
+    loop {
+        match i2c.listen(&mut read).await {
+            Ok(Command::GeneralCall(_)) => info!("General call received"),
+            Ok(Command::Read) => {
+                info!("Read command received");
+                match i2c.respond_to_read(&data).await.unwrap() {
+                    ReadStatus::Done => info!("Finished reading"),
+                    ReadStatus::NeedMoreBytes => {
+                        info!("Read needs more bytes - will reset");
+                        i2c.reset().unwrap();
+                    }
+                    ReadStatus::LeftoverBytes(_) => {
+                        info!("Leftover bytes received");
+                        i2c.flush_tx_fifo();
+                    }
+                }
+            }
+            Ok(Command::Write(_)) => info!("Write command received"),
+            Ok(Command::WriteRead(_)) => {
+                info!("Write-Read command received");
+                i2c.respond_and_fill(&data_wr, 0xFE).await.unwrap();
+            }
+            Err(e) => info!("Got error {}", e),
+        }
+    }
+}
diff --git a/examples/nrf52840/src/bin/egu.rs b/examples/nrf52840/src/bin/egu.rs
index 8bf712697..36eba8084 100644
--- a/examples/nrf52840/src/bin/egu.rs
+++ b/examples/nrf52840/src/bin/egu.rs
@@ -6,7 +6,7 @@
 
 use embassy_executor::Spawner;
 use embassy_nrf::egu::{Egu, TriggerNumber};
-use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
+use embassy_nrf::gpio::{Level, OutputDrive, Pull};
 use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity, OutputChannel, OutputChannelPolarity};
 use embassy_nrf::peripherals::{PPI_CH0, PPI_CH1, PPI_CH2};
 use embassy_nrf::ppi::Ppi;
@@ -17,12 +17,15 @@ use {defmt_rtt as _, panic_probe as _};
 async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
 
-    let led1 = Output::new(p.P0_13, Level::High, OutputDrive::Standard);
-    let btn1 = Input::new(p.P0_11, Pull::Up);
-
     let mut egu1 = Egu::new(p.EGU0);
-    let led1 = OutputChannel::new(p.GPIOTE_CH0, led1, OutputChannelPolarity::Toggle);
-    let btn1 = InputChannel::new(p.GPIOTE_CH1, btn1, InputChannelPolarity::LoToHi);
+    let led1 = OutputChannel::new(
+        p.GPIOTE_CH0,
+        p.P0_13,
+        Level::High,
+        OutputDrive::Standard,
+        OutputChannelPolarity::Toggle,
+    );
+    let btn1 = InputChannel::new(p.GPIOTE_CH1, p.P0_11, Pull::Up, InputChannelPolarity::LoToHi);
 
     let trigger0 = egu1.trigger(TriggerNumber::Trigger0);
     let trigger1 = egu1.trigger(TriggerNumber::Trigger1);
diff --git a/examples/nrf52840/src/bin/gpiote_channel.rs b/examples/nrf52840/src/bin/gpiote_channel.rs
index dcfe7723a..c7ddc1d8d 100644
--- a/examples/nrf52840/src/bin/gpiote_channel.rs
+++ b/examples/nrf52840/src/bin/gpiote_channel.rs
@@ -3,7 +3,7 @@
 
 use defmt::info;
 use embassy_executor::Spawner;
-use embassy_nrf::gpio::{Input, Pull};
+use embassy_nrf::gpio::Pull;
 use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity};
 use {defmt_rtt as _, panic_probe as _};
 
@@ -12,26 +12,10 @@ async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
     info!("Starting!");
 
-    let ch1 = InputChannel::new(
-        p.GPIOTE_CH0,
-        Input::new(p.P0_11, Pull::Up),
-        InputChannelPolarity::HiToLo,
-    );
-    let ch2 = InputChannel::new(
-        p.GPIOTE_CH1,
-        Input::new(p.P0_12, Pull::Up),
-        InputChannelPolarity::LoToHi,
-    );
-    let ch3 = InputChannel::new(
-        p.GPIOTE_CH2,
-        Input::new(p.P0_24, Pull::Up),
-        InputChannelPolarity::Toggle,
-    );
-    let ch4 = InputChannel::new(
-        p.GPIOTE_CH3,
-        Input::new(p.P0_25, Pull::Up),
-        InputChannelPolarity::Toggle,
-    );
+    let ch1 = InputChannel::new(p.GPIOTE_CH0, p.P0_11, Pull::Up, InputChannelPolarity::HiToLo);
+    let ch2 = InputChannel::new(p.GPIOTE_CH1, p.P0_12, Pull::Up, InputChannelPolarity::LoToHi);
+    let ch3 = InputChannel::new(p.GPIOTE_CH2, p.P0_24, Pull::Up, InputChannelPolarity::Toggle);
+    let ch4 = InputChannel::new(p.GPIOTE_CH3, p.P0_25, Pull::Up, InputChannelPolarity::Toggle);
 
     let button1 = async {
         loop {
diff --git a/examples/nrf52840/src/bin/i2s_monitor.rs b/examples/nrf52840/src/bin/i2s_monitor.rs
index 66b429b09..a54659101 100644
--- a/examples/nrf52840/src/bin/i2s_monitor.rs
+++ b/examples/nrf52840/src/bin/i2s_monitor.rs
@@ -4,7 +4,7 @@
 use defmt::{debug, error, info};
 use embassy_executor::Spawner;
 use embassy_nrf::i2s::{self, Channels, Config, DoubleBuffering, I2S, MasterClock, Sample as _, SampleWidth};
-use embassy_nrf::pwm::{Prescaler, SimplePwm};
+use embassy_nrf::pwm::{DutyCycle, Prescaler, SimplePwm};
 use embassy_nrf::{bind_interrupts, peripherals};
 use {defmt_rtt as _, panic_probe as _};
 
@@ -34,7 +34,7 @@ async fn main(_spawner: Spawner) {
         I2S::new_master(p.I2S, Irqs, p.P0_25, p.P0_26, p.P0_27, master_clock, config).input(p.P0_29, buffers);
 
     // Configure the PWM to use the pins corresponding to the RGB leds
-    let mut pwm = SimplePwm::new_3ch(p.PWM0, p.P0_23, p.P0_22, p.P0_24);
+    let mut pwm = SimplePwm::new_3ch(p.PWM0, p.P0_23, p.P0_22, p.P0_24, &Default::default());
     pwm.set_prescaler(Prescaler::Div1);
     pwm.set_max_duty(255);
 
@@ -47,9 +47,8 @@ async fn main(_spawner: Spawner) {
         let rgb = rgb_from_rms(rms);
 
         debug!("RMS: {}, RGB: {:?}", rms, rgb);
-        for i in 0..3 {
-            pwm.set_duty(i, rgb[i].into());
-        }
+        let duties = rgb.map(|byte| DutyCycle::normal(u16::from(byte)));
+        pwm.set_all_duties([duties[0], duties[1], duties[2], DutyCycle::normal(0)]);
 
         if let Err(err) = input_stream.receive().await {
             error!("{}", err);
diff --git a/examples/nrf52840/src/bin/ppi.rs b/examples/nrf52840/src/bin/ppi.rs
index 129ad06e7..177f6a06d 100644
--- a/examples/nrf52840/src/bin/ppi.rs
+++ b/examples/nrf52840/src/bin/ppi.rs
@@ -5,7 +5,7 @@ use core::future::pending;
 
 use defmt::info;
 use embassy_executor::Spawner;
-use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
+use embassy_nrf::gpio::{Level, OutputDrive, Pull};
 use embassy_nrf::gpiote::{self, InputChannel, InputChannelPolarity};
 use embassy_nrf::ppi::Ppi;
 use gpiote::{OutputChannel, OutputChannelPolarity};
@@ -16,36 +16,24 @@ async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
     info!("Starting!");
 
-    let button1 = InputChannel::new(
-        p.GPIOTE_CH0,
-        Input::new(p.P0_11, Pull::Up),
-        InputChannelPolarity::HiToLo,
-    );
-    let button2 = InputChannel::new(
-        p.GPIOTE_CH1,
-        Input::new(p.P0_12, Pull::Up),
-        InputChannelPolarity::HiToLo,
-    );
-    let button3 = InputChannel::new(
-        p.GPIOTE_CH2,
-        Input::new(p.P0_24, Pull::Up),
-        InputChannelPolarity::HiToLo,
-    );
-    let button4 = InputChannel::new(
-        p.GPIOTE_CH3,
-        Input::new(p.P0_25, Pull::Up),
-        InputChannelPolarity::HiToLo,
-    );
+    let button1 = InputChannel::new(p.GPIOTE_CH0, p.P0_11, Pull::Up, InputChannelPolarity::HiToLo);
+    let button2 = InputChannel::new(p.GPIOTE_CH1, p.P0_12, Pull::Up, InputChannelPolarity::HiToLo);
+    let button3 = InputChannel::new(p.GPIOTE_CH2, p.P0_24, Pull::Up, InputChannelPolarity::HiToLo);
+    let button4 = InputChannel::new(p.GPIOTE_CH3, p.P0_25, Pull::Up, InputChannelPolarity::HiToLo);
 
     let led1 = OutputChannel::new(
         p.GPIOTE_CH4,
-        Output::new(p.P0_13, Level::Low, OutputDrive::Standard),
+        p.P0_13,
+        Level::Low,
+        OutputDrive::Standard,
         OutputChannelPolarity::Toggle,
     );
 
     let led2 = OutputChannel::new(
         p.GPIOTE_CH5,
-        Output::new(p.P0_14, Level::Low, OutputDrive::Standard),
+        p.P0_14,
+        Level::Low,
+        OutputDrive::Standard,
         OutputChannelPolarity::Toggle,
     );
 
diff --git a/examples/nrf52840/src/bin/pwm.rs b/examples/nrf52840/src/bin/pwm.rs
index a5bb1347a..02f9b4191 100644
--- a/examples/nrf52840/src/bin/pwm.rs
+++ b/examples/nrf52840/src/bin/pwm.rs
@@ -3,7 +3,7 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_nrf::pwm::{Prescaler, SimplePwm};
+use embassy_nrf::pwm::{DutyCycle, Prescaler, SimplePwm};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -71,7 +71,7 @@ static DUTY: [u16; 1024] = [
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
-    let mut pwm = SimplePwm::new_4ch(p.PWM0, p.P0_13, p.P0_14, p.P0_16, p.P0_15);
+    let mut pwm = SimplePwm::new_4ch(p.PWM0, p.P0_13, p.P0_14, p.P0_16, p.P0_15, &Default::default());
     pwm.set_prescaler(Prescaler::Div1);
     pwm.set_max_duty(32767);
     info!("pwm initialized!");
@@ -79,10 +79,12 @@ async fn main(_spawner: Spawner) {
     let mut i = 0;
     loop {
         i += 1;
-        pwm.set_duty(0, DUTY[i % 1024]);
-        pwm.set_duty(1, DUTY[(i + 256) % 1024]);
-        pwm.set_duty(2, DUTY[(i + 512) % 1024]);
-        pwm.set_duty(3, DUTY[(i + 768) % 1024]);
+        pwm.set_all_duties([
+            DutyCycle::normal(DUTY[i % 1024]),
+            DutyCycle::normal(DUTY[(i + 256) % 1024]),
+            DutyCycle::normal(DUTY[(i + 512) % 1024]),
+            DutyCycle::normal(DUTY[(i + 768) % 1024]),
+        ]);
         Timer::after_millis(3).await;
     }
 }
diff --git a/examples/nrf52840/src/bin/pwm_sequence_ppi.rs b/examples/nrf52840/src/bin/pwm_sequence_ppi.rs
index 60ea712b5..fff7decb2 100644
--- a/examples/nrf52840/src/bin/pwm_sequence_ppi.rs
+++ b/examples/nrf52840/src/bin/pwm_sequence_ppi.rs
@@ -5,7 +5,7 @@ use core::future::pending;
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_nrf::gpio::{Input, Pull};
+use embassy_nrf::gpio::Pull;
 use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity};
 use embassy_nrf::ppi::Ppi;
 use embassy_nrf::pwm::{Config, Prescaler, SequenceConfig, SequencePwm, SingleSequenceMode, SingleSequencer};
@@ -30,17 +30,9 @@ async fn main(_spawner: Spawner) {
     // pwm.stop() deconfigures pins, and then the task_start_seq0 task cant work
     // so its going to have to start running in order load the configuration
 
-    let button1 = InputChannel::new(
-        p.GPIOTE_CH0,
-        Input::new(p.P0_11, Pull::Up),
-        InputChannelPolarity::HiToLo,
-    );
+    let button1 = InputChannel::new(p.GPIOTE_CH0, p.P0_11, Pull::Up, InputChannelPolarity::HiToLo);
 
-    let button2 = InputChannel::new(
-        p.GPIOTE_CH1,
-        Input::new(p.P0_12, Pull::Up),
-        InputChannelPolarity::HiToLo,
-    );
+    let button2 = InputChannel::new(p.GPIOTE_CH1, p.P0_12, Pull::Up, InputChannelPolarity::HiToLo);
 
     // messing with the pwm tasks is ill advised
     // Times::Ininite and Times even are seq0, Times odd is seq1
diff --git a/examples/nrf52840/src/bin/pwm_servo.rs b/examples/nrf52840/src/bin/pwm_servo.rs
index d772d2f5d..93cb984e6 100644
--- a/examples/nrf52840/src/bin/pwm_servo.rs
+++ b/examples/nrf52840/src/bin/pwm_servo.rs
@@ -3,14 +3,14 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_nrf::pwm::{Prescaler, SimplePwm};
+use embassy_nrf::pwm::{DutyCycle, Prescaler, SimplePwm};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
-    let mut pwm = SimplePwm::new_1ch(p.PWM0, p.P0_05);
+    let mut pwm = SimplePwm::new_1ch(p.PWM0, p.P0_05, &Default::default());
     // sg90 microervo requires 50hz or 20ms period
     // set_period can only set down to 125khz so we cant use it directly
     // Div128 is 125khz or 0.000008s or 0.008ms, 20/0.008 is 2500 is top
@@ -24,23 +24,23 @@ async fn main(_spawner: Spawner) {
     loop {
         info!("45 deg");
         // poor mans inverting, subtract our value from max_duty
-        pwm.set_duty(0, 2500 - 156);
+        pwm.set_duty(0, DutyCycle::normal(2500 - 156));
         Timer::after_millis(5000).await;
 
         info!("90 deg");
-        pwm.set_duty(0, 2500 - 187);
+        pwm.set_duty(0, DutyCycle::normal(2500 - 187));
         Timer::after_millis(5000).await;
 
         info!("135 deg");
-        pwm.set_duty(0, 2500 - 218);
+        pwm.set_duty(0, DutyCycle::normal(2500 - 218));
         Timer::after_millis(5000).await;
 
         info!("180 deg");
-        pwm.set_duty(0, 2500 - 250);
+        pwm.set_duty(0, DutyCycle::normal(2500 - 250));
         Timer::after_millis(5000).await;
 
         info!("0 deg");
-        pwm.set_duty(0, 2500 - 125);
+        pwm.set_duty(0, DutyCycle::normal(2500 - 125));
         Timer::after_millis(5000).await;
     }
 }
diff --git a/examples/nrf52840/src/bin/wifi_esp_hosted.rs b/examples/nrf52840/src/bin/wifi_esp_hosted.rs
index 07752ffc4..2f9c06b56 100644
--- a/examples/nrf52840/src/bin/wifi_esp_hosted.rs
+++ b/examples/nrf52840/src/bin/wifi_esp_hosted.rs
@@ -27,14 +27,12 @@ bind_interrupts!(struct Irqs {
 async fn wifi_task(
     runner: hosted::Runner<
         'static,
-        ExclusiveDevice<Spim<'static>, Output<'static>, Delay>,
-        Input<'static>,
+        hosted::SpiInterface<ExclusiveDevice<Spim<'static>, Output<'static>, Delay>, Input<'static>>,
         Output<'static>,
     >,
 ) -> ! {
     runner.run().await
 }
-
 #[embassy_executor::task]
 async fn net_task(mut runner: embassy_net::Runner<'static, hosted::NetDriver<'static>>) -> ! {
     runner.run().await
@@ -60,15 +58,11 @@ async fn main(spawner: Spawner) {
     let spi = spim::Spim::new(p.SPI3, Irqs, sck, miso, mosi, config);
     let spi = ExclusiveDevice::new(spi, cs, Delay);
 
+    let iface = hosted::SpiInterface::new(spi, handshake, ready);
+
     static ESP_STATE: StaticCell<embassy_net_esp_hosted::State> = StaticCell::new();
-    let (device, mut control, runner) = embassy_net_esp_hosted::new(
-        ESP_STATE.init(embassy_net_esp_hosted::State::new()),
-        spi,
-        handshake,
-        ready,
-        reset,
-    )
-    .await;
+    let (device, mut control, runner) =
+        embassy_net_esp_hosted::new(ESP_STATE.init(embassy_net_esp_hosted::State::new()), iface, reset).await;
 
     spawner.spawn(unwrap!(wifi_task(runner)));
 
diff --git a/examples/nrf5340/src/bin/gpiote_channel.rs b/examples/nrf5340/src/bin/gpiote_channel.rs
index 23f6fca98..a085310ce 100644
--- a/examples/nrf5340/src/bin/gpiote_channel.rs
+++ b/examples/nrf5340/src/bin/gpiote_channel.rs
@@ -3,7 +3,7 @@
 
 use defmt::info;
 use embassy_executor::Spawner;
-use embassy_nrf::gpio::{Input, Pull};
+use embassy_nrf::gpio::Pull;
 use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity};
 use {defmt_rtt as _, panic_probe as _};
 
@@ -12,26 +12,10 @@ async fn main(_spawner: Spawner) {
     let p = embassy_nrf::init(Default::default());
     info!("Starting!");
 
-    let ch1 = InputChannel::new(
-        p.GPIOTE_CH0,
-        Input::new(p.P0_23, Pull::Up),
-        InputChannelPolarity::HiToLo,
-    );
-    let ch2 = InputChannel::new(
-        p.GPIOTE_CH1,
-        Input::new(p.P0_24, Pull::Up),
-        InputChannelPolarity::LoToHi,
-    );
-    let ch3 = InputChannel::new(
-        p.GPIOTE_CH2,
-        Input::new(p.P0_08, Pull::Up),
-        InputChannelPolarity::Toggle,
-    );
-    let ch4 = InputChannel::new(
-        p.GPIOTE_CH3,
-        Input::new(p.P0_09, Pull::Up),
-        InputChannelPolarity::Toggle,
-    );
+    let ch1 = InputChannel::new(p.GPIOTE_CH0, p.P0_23, Pull::Up, InputChannelPolarity::HiToLo);
+    let ch2 = InputChannel::new(p.GPIOTE_CH1, p.P0_24, Pull::Up, InputChannelPolarity::LoToHi);
+    let ch3 = InputChannel::new(p.GPIOTE_CH2, p.P0_08, Pull::Up, InputChannelPolarity::Toggle);
+    let ch4 = InputChannel::new(p.GPIOTE_CH3, p.P0_09, Pull::Up, InputChannelPolarity::Toggle);
 
     let button1 = async {
         loop {
diff --git a/examples/nrf54l15/Cargo.toml b/examples/nrf54l15/Cargo.toml
index a053dd0ec..4ef77279f 100644
--- a/examples/nrf54l15/Cargo.toml
+++ b/examples/nrf54l15/Cargo.toml
@@ -6,9 +6,15 @@ license = "MIT OR Apache-2.0"
 publish = false
 
 [dependencies]
+embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
 embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "executor-interrupt", "defmt"] }
 embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime"] }
+embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["defmt"] }
 embassy-nrf = { version = "0.8.0", path = "../../embassy-nrf", features = ["defmt", "nrf54l15-app-s", "time-driver-rtc1", "gpiote", "unstable-pac", "time"] }
+embedded-io = { version = "0.6.0", features = ["defmt-03"]  }
+embedded-io-async = { version = "0.6.1", features = ["defmt-03"] }
+
+rand = { version = "0.9.0", default-features = false }
 
 defmt = "1.0.1"
 defmt-rtt = "1.0.0"
@@ -18,6 +24,9 @@ cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-sing
 cortex-m-rt = "0.7.0"
 
 embedded-storage = "0.3.1"
+portable-atomic = "1"
+
+static_cell = "2"
 
 [profile.release]
 debug = 2
diff --git a/examples/nrf54l15/src/bin/buffered_uart.rs b/examples/nrf54l15/src/bin/buffered_uart.rs
new file mode 100644
index 000000000..41fa1ca4e
--- /dev/null
+++ b/examples/nrf54l15/src/bin/buffered_uart.rs
@@ -0,0 +1,49 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::buffered_uarte::{self, BufferedUarte};
+use embassy_nrf::{bind_interrupts, peripherals, uarte};
+use embedded_io_async::Write;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    SERIAL20 => buffered_uarte::InterruptHandler<peripherals::SERIAL20>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD115200;
+
+    let mut tx_buffer = [0u8; 4096];
+    let mut rx_buffer = [0u8; 4096];
+
+    let mut u = BufferedUarte::new(
+        p.SERIAL20,
+        p.P1_12,
+        p.P1_13,
+        Irqs,
+        config,
+        &mut rx_buffer,
+        &mut tx_buffer,
+    );
+
+    info!("uarte initialized!");
+
+    unwrap!(u.write_all(b"Hello!\r\n").await);
+    info!("wrote hello in uart!");
+
+    loop {
+        info!("reading...");
+        let buf = unwrap!(u.fill_buf().await);
+        info!("read done, got {}", buf);
+
+        // Read bytes have to be explicitly consumed, otherwise fill_buf() will return them again
+        let n = buf.len();
+        u.consume(n);
+    }
+}
diff --git a/examples/nrf54l15/src/bin/gpiote_channel.rs b/examples/nrf54l15/src/bin/gpiote_channel.rs
new file mode 100644
index 000000000..6333250ba
--- /dev/null
+++ b/examples/nrf54l15/src/bin/gpiote_channel.rs
@@ -0,0 +1,49 @@
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::Pull;
+use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Starting!");
+
+    let ch1 = InputChannel::new(p.GPIOTE20_CH0, p.P1_13, Pull::Up, InputChannelPolarity::HiToLo);
+    let ch2 = InputChannel::new(p.GPIOTE20_CH1, p.P1_09, Pull::Up, InputChannelPolarity::LoToHi);
+    let ch3 = InputChannel::new(p.GPIOTE20_CH2, p.P1_08, Pull::Up, InputChannelPolarity::Toggle);
+    let ch4 = InputChannel::new(p.GPIOTE30_CH0, p.P0_04, Pull::Up, InputChannelPolarity::Toggle);
+
+    let button1 = async {
+        loop {
+            ch1.wait().await;
+            info!("Button 1 pressed")
+        }
+    };
+
+    let button2 = async {
+        loop {
+            ch2.wait().await;
+            info!("Button 2 released")
+        }
+    };
+
+    let button3 = async {
+        loop {
+            ch3.wait().await;
+            info!("Button 3 toggled")
+        }
+    };
+
+    let button4 = async {
+        loop {
+            ch4.wait().await;
+            info!("Button 4 toggled")
+        }
+    };
+
+    embassy_futures::join::join4(button1, button2, button3, button4).await;
+}
diff --git a/examples/nrf54l15/src/bin/gpiote_port.rs b/examples/nrf54l15/src/bin/gpiote_port.rs
new file mode 100644
index 000000000..620cb2435
--- /dev/null
+++ b/examples/nrf54l15/src/bin/gpiote_port.rs
@@ -0,0 +1,33 @@
+#![no_std]
+#![no_main]
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Input, Pull};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task(pool_size = 4)]
+async fn button_task(n: usize, mut pin: Input<'static>) {
+    loop {
+        pin.wait_for_low().await;
+        info!("Button {:?} pressed!", n);
+        pin.wait_for_high().await;
+        info!("Button {:?} released!", n);
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Starting!");
+
+    let btn1 = Input::new(p.P1_13, Pull::Up);
+    let btn2 = Input::new(p.P1_09, Pull::Up);
+    let btn3 = Input::new(p.P1_08, Pull::Up);
+    let btn4 = Input::new(p.P0_04, Pull::Up);
+
+    spawner.spawn(unwrap!(button_task(1, btn1)));
+    spawner.spawn(unwrap!(button_task(2, btn2)));
+    spawner.spawn(unwrap!(button_task(3, btn3)));
+    spawner.spawn(unwrap!(button_task(4, btn4)));
+}
diff --git a/examples/nrf54l15/src/bin/pwm.rs b/examples/nrf54l15/src/bin/pwm.rs
new file mode 100644
index 000000000..b438978f1
--- /dev/null
+++ b/examples/nrf54l15/src/bin/pwm.rs
@@ -0,0 +1,86 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::pwm::{DutyCycle, Prescaler, SimplePwm};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+// for i in range(1024): print(int((math.sin(i/512*math.pi)*0.4+0.5)**2*32767), ', ', end='')
+static DUTY: [u16; 1024] = [
+    8191, 8272, 8353, 8434, 8516, 8598, 8681, 8764, 8847, 8931, 9015, 9099, 9184, 9269, 9354, 9440, 9526, 9613, 9700,
+    9787, 9874, 9962, 10050, 10139, 10227, 10316, 10406, 10495, 10585, 10675, 10766, 10857, 10948, 11039, 11131, 11223,
+    11315, 11407, 11500, 11592, 11685, 11779, 11872, 11966, 12060, 12154, 12248, 12343, 12438, 12533, 12628, 12723,
+    12818, 12914, 13010, 13106, 13202, 13298, 13394, 13491, 13587, 13684, 13781, 13878, 13975, 14072, 14169, 14266,
+    14364, 14461, 14558, 14656, 14754, 14851, 14949, 15046, 15144, 15242, 15339, 15437, 15535, 15632, 15730, 15828,
+    15925, 16023, 16120, 16218, 16315, 16412, 16510, 16607, 16704, 16801, 16898, 16995, 17091, 17188, 17284, 17380,
+    17477, 17572, 17668, 17764, 17859, 17955, 18050, 18145, 18239, 18334, 18428, 18522, 18616, 18710, 18803, 18896,
+    18989, 19082, 19174, 19266, 19358, 19449, 19540, 19631, 19722, 19812, 19902, 19991, 20081, 20169, 20258, 20346,
+    20434, 20521, 20608, 20695, 20781, 20867, 20952, 21037, 21122, 21206, 21290, 21373, 21456, 21538, 21620, 21701,
+    21782, 21863, 21943, 22022, 22101, 22179, 22257, 22335, 22412, 22488, 22564, 22639, 22714, 22788, 22861, 22934,
+    23007, 23079, 23150, 23220, 23290, 23360, 23429, 23497, 23564, 23631, 23698, 23763, 23828, 23892, 23956, 24019,
+    24081, 24143, 24204, 24264, 24324, 24383, 24441, 24499, 24555, 24611, 24667, 24721, 24775, 24828, 24881, 24933,
+    24983, 25034, 25083, 25132, 25180, 25227, 25273, 25319, 25363, 25407, 25451, 25493, 25535, 25575, 25615, 25655,
+    25693, 25731, 25767, 25803, 25838, 25873, 25906, 25939, 25971, 26002, 26032, 26061, 26089, 26117, 26144, 26170,
+    26195, 26219, 26242, 26264, 26286, 26307, 26327, 26346, 26364, 26381, 26397, 26413, 26427, 26441, 26454, 26466,
+    26477, 26487, 26496, 26505, 26512, 26519, 26525, 26530, 26534, 26537, 26539, 26540, 26541, 26540, 26539, 26537,
+    26534, 26530, 26525, 26519, 26512, 26505, 26496, 26487, 26477, 26466, 26454, 26441, 26427, 26413, 26397, 26381,
+    26364, 26346, 26327, 26307, 26286, 26264, 26242, 26219, 26195, 26170, 26144, 26117, 26089, 26061, 26032, 26002,
+    25971, 25939, 25906, 25873, 25838, 25803, 25767, 25731, 25693, 25655, 25615, 25575, 25535, 25493, 25451, 25407,
+    25363, 25319, 25273, 25227, 25180, 25132, 25083, 25034, 24983, 24933, 24881, 24828, 24775, 24721, 24667, 24611,
+    24555, 24499, 24441, 24383, 24324, 24264, 24204, 24143, 24081, 24019, 23956, 23892, 23828, 23763, 23698, 23631,
+    23564, 23497, 23429, 23360, 23290, 23220, 23150, 23079, 23007, 22934, 22861, 22788, 22714, 22639, 22564, 22488,
+    22412, 22335, 22257, 22179, 22101, 22022, 21943, 21863, 21782, 21701, 21620, 21538, 21456, 21373, 21290, 21206,
+    21122, 21037, 20952, 20867, 20781, 20695, 20608, 20521, 20434, 20346, 20258, 20169, 20081, 19991, 19902, 19812,
+    19722, 19631, 19540, 19449, 19358, 19266, 19174, 19082, 18989, 18896, 18803, 18710, 18616, 18522, 18428, 18334,
+    18239, 18145, 18050, 17955, 17859, 17764, 17668, 17572, 17477, 17380, 17284, 17188, 17091, 16995, 16898, 16801,
+    16704, 16607, 16510, 16412, 16315, 16218, 16120, 16023, 15925, 15828, 15730, 15632, 15535, 15437, 15339, 15242,
+    15144, 15046, 14949, 14851, 14754, 14656, 14558, 14461, 14364, 14266, 14169, 14072, 13975, 13878, 13781, 13684,
+    13587, 13491, 13394, 13298, 13202, 13106, 13010, 12914, 12818, 12723, 12628, 12533, 12438, 12343, 12248, 12154,
+    12060, 11966, 11872, 11779, 11685, 11592, 11500, 11407, 11315, 11223, 11131, 11039, 10948, 10857, 10766, 10675,
+    10585, 10495, 10406, 10316, 10227, 10139, 10050, 9962, 9874, 9787, 9700, 9613, 9526, 9440, 9354, 9269, 9184, 9099,
+    9015, 8931, 8847, 8764, 8681, 8598, 8516, 8434, 8353, 8272, 8191, 8111, 8031, 7952, 7873, 7794, 7716, 7638, 7561,
+    7484, 7407, 7331, 7255, 7180, 7105, 7031, 6957, 6883, 6810, 6738, 6665, 6594, 6522, 6451, 6381, 6311, 6241, 6172,
+    6104, 6036, 5968, 5901, 5834, 5767, 5702, 5636, 5571, 5507, 5443, 5379, 5316, 5253, 5191, 5130, 5068, 5008, 4947,
+    4888, 4828, 4769, 4711, 4653, 4596, 4539, 4482, 4426, 4371, 4316, 4261, 4207, 4153, 4100, 4047, 3995, 3943, 3892,
+    3841, 3791, 3741, 3691, 3642, 3594, 3546, 3498, 3451, 3404, 3358, 3312, 3267, 3222, 3178, 3134, 3090, 3047, 3005,
+    2962, 2921, 2879, 2839, 2798, 2758, 2719, 2680, 2641, 2603, 2565, 2528, 2491, 2454, 2418, 2382, 2347, 2312, 2278,
+    2244, 2210, 2177, 2144, 2112, 2080, 2048, 2017, 1986, 1956, 1926, 1896, 1867, 1838, 1810, 1781, 1754, 1726, 1699,
+    1673, 1646, 1620, 1595, 1570, 1545, 1520, 1496, 1472, 1449, 1426, 1403, 1380, 1358, 1336, 1315, 1294, 1273, 1252,
+    1232, 1212, 1192, 1173, 1154, 1135, 1117, 1099, 1081, 1063, 1046, 1029, 1012, 996, 980, 964, 948, 933, 918, 903,
+    888, 874, 860, 846, 833, 819, 806, 793, 781, 768, 756, 744, 733, 721, 710, 699, 688, 677, 667, 657, 647, 637, 627,
+    618, 609, 599, 591, 582, 574, 565, 557, 549, 541, 534, 526, 519, 512, 505, 498, 492, 485, 479, 473, 467, 461, 455,
+    450, 444, 439, 434, 429, 424, 419, 415, 410, 406, 402, 398, 394, 390, 386, 383, 379, 376, 373, 370, 367, 364, 361,
+    359, 356, 354, 351, 349, 347, 345, 343, 342, 340, 338, 337, 336, 334, 333, 332, 331, 330, 330, 329, 328, 328, 328,
+    327, 327, 327, 327, 327, 328, 328, 328, 329, 330, 330, 331, 332, 333, 334, 336, 337, 338, 340, 342, 343, 345, 347,
+    349, 351, 354, 356, 359, 361, 364, 367, 370, 373, 376, 379, 383, 386, 390, 394, 398, 402, 406, 410, 415, 419, 424,
+    429, 434, 439, 444, 450, 455, 461, 467, 473, 479, 485, 492, 498, 505, 512, 519, 526, 534, 541, 549, 557, 565, 574,
+    582, 591, 599, 609, 618, 627, 637, 647, 657, 667, 677, 688, 699, 710, 721, 733, 744, 756, 768, 781, 793, 806, 819,
+    833, 846, 860, 874, 888, 903, 918, 933, 948, 964, 980, 996, 1012, 1029, 1046, 1063, 1081, 1099, 1117, 1135, 1154,
+    1173, 1192, 1212, 1232, 1252, 1273, 1294, 1315, 1336, 1358, 1380, 1403, 1426, 1449, 1472, 1496, 1520, 1545, 1570,
+    1595, 1620, 1646, 1673, 1699, 1726, 1754, 1781, 1810, 1838, 1867, 1896, 1926, 1956, 1986, 2017, 2048, 2080, 2112,
+    2144, 2177, 2210, 2244, 2278, 2312, 2347, 2382, 2418, 2454, 2491, 2528, 2565, 2603, 2641, 2680, 2719, 2758, 2798,
+    2839, 2879, 2921, 2962, 3005, 3047, 3090, 3134, 3178, 3222, 3267, 3312, 3358, 3404, 3451, 3498, 3546, 3594, 3642,
+    3691, 3741, 3791, 3841, 3892, 3943, 3995, 4047, 4100, 4153, 4207, 4261, 4316, 4371, 4426, 4482, 4539, 4596, 4653,
+    4711, 4769, 4828, 4888, 4947, 5008, 5068, 5130, 5191, 5253, 5316, 5379, 5443, 5507, 5571, 5636, 5702, 5767, 5834,
+    5901, 5968, 6036, 6104, 6172, 6241, 6311, 6381, 6451, 6522, 6594, 6665, 6738, 6810, 6883, 6957, 7031, 7105, 7180,
+    7255, 7331, 7407, 7484, 7561, 7638, 7716, 7794, 7873, 7952, 8031, 8111,
+];
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut pwm = SimplePwm::new_2ch(p.PWM20, p.P1_10, p.P1_14, &Default::default());
+    pwm.set_prescaler(Prescaler::Div1);
+    pwm.set_max_duty(32767);
+    info!("pwm initialized!");
+
+    let mut i = 0;
+    loop {
+        i += 1;
+        pwm.set_duty(0, DutyCycle::normal(DUTY[i % 1024]));
+        pwm.set_duty(1, DutyCycle::normal(DUTY[(i + 512) % 1024]));
+        Timer::after_millis(3).await;
+    }
+}
diff --git a/examples/nrf54l15/src/bin/rng.rs b/examples/nrf54l15/src/bin/rng.rs
new file mode 100644
index 000000000..b2d7f906b
--- /dev/null
+++ b/examples/nrf54l15/src/bin/rng.rs
@@ -0,0 +1,28 @@
+#![no_std]
+#![no_main]
+
+use embassy_executor::Spawner;
+use embassy_nrf::cracen::Cracen;
+use rand::Rng as _;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut rng = Cracen::new_blocking(p.CRACEN);
+
+    // Async API
+    let mut bytes = [0; 4];
+    rng.blocking_fill_bytes(&mut bytes);
+    defmt::info!("Some random bytes: {:?}", bytes);
+
+    // Sync API with `rand`
+    defmt::info!("A random number from 1 to 10: {:?}", rng.random_range(1..=10));
+
+    let mut bytes = [0; 1024];
+    rng.blocking_fill_bytes(&mut bytes);
+    let zero_count: u32 = bytes.iter().fold(0, |acc, val| acc + val.count_zeros());
+    let one_count: u32 = bytes.iter().fold(0, |acc, val| acc + val.count_ones());
+    defmt::info!("Chance of zero: {}%", zero_count * 100 / (bytes.len() as u32 * 8));
+    defmt::info!("Chance of one: {}%", one_count * 100 / (bytes.len() as u32 * 8));
+}
diff --git a/examples/nrf54l15/src/bin/rtc.rs b/examples/nrf54l15/src/bin/rtc.rs
new file mode 100644
index 000000000..a45aaca52
--- /dev/null
+++ b/examples/nrf54l15/src/bin/rtc.rs
@@ -0,0 +1,56 @@
+#![no_std]
+#![no_main]
+
+use core::cell::RefCell;
+
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Level, Output, OutputDrive};
+use embassy_nrf::interrupt;
+use embassy_nrf::rtc::Rtc;
+use embassy_sync::blocking_mutex::Mutex;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use portable_atomic::AtomicU64;
+use {defmt_rtt as _, panic_probe as _};
+
+// 64 bit counter which will never overflow.
+static TICK_COUNTER: AtomicU64 = AtomicU64::new(0);
+static RTC: Mutex<CriticalSectionRawMutex, RefCell<Option<Rtc<'static>>>> = Mutex::new(RefCell::new(None));
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    defmt::println!("nRF54L15 RTC example");
+    let p = embassy_nrf::init(Default::default());
+    let mut led = Output::new(p.P2_09, Level::High, OutputDrive::Standard);
+    // Counter resolution is 125 ms.
+    let mut rtc = Rtc::new(p.RTC10, (1 << 12) - 1).unwrap();
+    rtc.enable_interrupt(embassy_nrf::rtc::Interrupt::Tick, true);
+    rtc.enable_event(embassy_nrf::rtc::Interrupt::Tick);
+    rtc.enable();
+    RTC.lock(|r| {
+        let mut rtc_borrow = r.borrow_mut();
+        *rtc_borrow = Some(rtc);
+    });
+
+    let mut last_counter_val = 0;
+    loop {
+        let current = TICK_COUNTER.load(core::sync::atomic::Ordering::Relaxed);
+        if current != last_counter_val {
+            led.toggle();
+            last_counter_val = current;
+        }
+    }
+}
+
+#[interrupt]
+fn RTC10() {
+    // For 64-bit, we do not need to worry about overflowing, at least not for realistic program
+    // lifetimes.
+    TICK_COUNTER.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
+    RTC.lock(|r| {
+        let mut rtc_borrow = r.borrow_mut();
+        rtc_borrow
+            .as_mut()
+            .unwrap()
+            .reset_event(embassy_nrf::rtc::Interrupt::Tick);
+    });
+}
diff --git a/examples/nrf54l15/src/bin/saadc.rs b/examples/nrf54l15/src/bin/saadc.rs
new file mode 100644
index 000000000..567177894
--- /dev/null
+++ b/examples/nrf54l15/src/bin/saadc.rs
@@ -0,0 +1,28 @@
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::saadc::{ChannelConfig, Config, Saadc};
+use embassy_nrf::{bind_interrupts, saadc};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    SAADC => saadc::InterruptHandler;
+});
+
+#[embassy_executor::main]
+async fn main(_p: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let config = Config::default();
+    let channel_config = ChannelConfig::single_ended(p.P1_04.reborrow());
+    let mut saadc = Saadc::new(p.SAADC, Irqs, config, [channel_config]);
+
+    loop {
+        let mut buf = [0; 1];
+        saadc.sample(&mut buf).await;
+        info!("sample: {=i16}", &buf[0]);
+        Timer::after_millis(100).await;
+    }
+}
diff --git a/examples/nrf54l15/src/bin/spim.rs b/examples/nrf54l15/src/bin/spim.rs
new file mode 100644
index 000000000..3f5980647
--- /dev/null
+++ b/examples/nrf54l15/src/bin/spim.rs
@@ -0,0 +1,30 @@
+#![no_std]
+#![no_main]
+
+use embassy_executor::Spawner;
+use embassy_nrf::{bind_interrupts, peripherals, spim};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    SERIAL00 => spim::InterruptHandler<peripherals::SERIAL00>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut config = spim::Config::default();
+    config.frequency = spim::Frequency::M32;
+    let mut spim = spim::Spim::new(p.SERIAL00, Irqs, p.P2_05, p.P2_09, p.P2_08, config.clone());
+    let data = [
+        0x42, 0x43, 0x44, 0x45, 0x66, 0x12, 0x23, 0x34, 0x45, 0x19, 0x91, 0xaa, 0xff, 0xa5, 0x5a, 0x77,
+    ];
+    let mut buf = [0u8; 16];
+
+    buf.fill(0);
+    spim.blocking_transfer(&mut buf, &data).unwrap();
+    assert_eq!(data, buf);
+
+    buf.fill(0);
+    spim.transfer(&mut buf, &data).await.unwrap();
+    assert_eq!(data, buf);
+}
diff --git a/examples/nrf54l15/src/bin/twim.rs b/examples/nrf54l15/src/bin/twim.rs
new file mode 100644
index 000000000..53b85034e
--- /dev/null
+++ b/examples/nrf54l15/src/bin/twim.rs
@@ -0,0 +1,37 @@
+//! Example on how to read a 24C/24LC i2c eeprom.
+//!
+//! Connect SDA to P0.03, SCL to P0.04
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::twim::{self, Twim};
+use embassy_nrf::{bind_interrupts, peripherals};
+use static_cell::ConstStaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+const ADDRESS: u8 = 0x18;
+const WHOAMI: u8 = 0x0F;
+
+bind_interrupts!(struct Irqs {
+    SERIAL20 => twim::InterruptHandler<peripherals::SERIAL20>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Initializing TWI...");
+    let config = twim::Config::default();
+    static RAM_BUFFER: ConstStaticCell<[u8; 16]> = ConstStaticCell::new([0; 16]);
+    let mut twi = Twim::new(p.SERIAL20, Irqs, p.P1_13, p.P1_12, config, RAM_BUFFER.take());
+
+    info!("Reading...");
+
+    let mut data = [0u8; 1];
+    match twi.write_read(ADDRESS, &[WHOAMI], &mut data).await {
+        Ok(()) => info!("Whoami: {}", data[0]),
+        Err(e) => error!("I2c Error: {:?}", e),
+    }
+}
diff --git a/examples/nrf54l15/src/bin/twis.rs b/examples/nrf54l15/src/bin/twis.rs
new file mode 100644
index 000000000..34c04aee3
--- /dev/null
+++ b/examples/nrf54l15/src/bin/twis.rs
@@ -0,0 +1,47 @@
+//! TWIS example
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::twis::{self, Command, Twis};
+use embassy_nrf::{bind_interrupts, peripherals};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    SERIAL20 => twis::InterruptHandler<peripherals::SERIAL20>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+
+    let mut config = twis::Config::default();
+    config.address0 = 0x55; // Set i2c address
+    let mut i2c = Twis::new(p.SERIAL20, Irqs, p.P0_03, p.P0_04, config);
+
+    info!("Listening...");
+    loop {
+        let response = [1, 2, 3, 4, 5, 6, 7, 8];
+        // This buffer is used if the i2c master performs a Write or WriteRead
+        let mut buf = [0u8; 16];
+        match i2c.listen(&mut buf).await {
+            Ok(Command::Read) => {
+                info!("Got READ command. Respond with data:\n{:?}\n", response);
+                if let Err(e) = i2c.respond_to_read(&response).await {
+                    error!("{:?}", e);
+                }
+            }
+            Ok(Command::Write(n)) => info!("Got WRITE command with data:\n{:?}\n", buf[..n]),
+            Ok(Command::WriteRead(n)) => {
+                info!("Got WRITE/READ command with data:\n{:?}", buf[..n]);
+                info!("Respond with data:\n{:?}\n", response);
+                if let Err(e) = i2c.respond_to_read(&response).await {
+                    error!("{:?}", e);
+                }
+            }
+            Err(e) => error!("{:?}", e),
+        }
+    }
+}
diff --git a/examples/nrf54l15/src/bin/uart.rs b/examples/nrf54l15/src/bin/uart.rs
new file mode 100644
index 000000000..cc6528a6f
--- /dev/null
+++ b/examples/nrf54l15/src/bin/uart.rs
@@ -0,0 +1,37 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::{bind_interrupts, peripherals, uarte};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    SERIAL20 => uarte::InterruptHandler<peripherals::SERIAL20>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD115200;
+
+    let mut uart = uarte::Uarte::new(p.SERIAL20, p.P1_12, p.P1_13, Irqs, config);
+
+    info!("uarte initialized!");
+
+    // Message must be in SRAM
+    let mut buf = [0; 8];
+    buf.copy_from_slice(b"Hello!\r\n");
+
+    unwrap!(uart.write(&buf).await);
+    info!("wrote hello in uart!");
+
+    loop {
+        info!("reading...");
+        unwrap!(uart.read(&mut buf).await);
+        info!("writing...");
+        unwrap!(uart.write(&buf).await);
+    }
+}
diff --git a/examples/rp/src/bin/pio_onewire.rs b/examples/rp/src/bin/pio_onewire.rs
index 102f13c45..6432edb8a 100644
--- a/examples/rp/src/bin/pio_onewire.rs
+++ b/examples/rp/src/bin/pio_onewire.rs
@@ -61,7 +61,7 @@ async fn main(_spawner: Spawner) {
             let mut data = [0; 9];
             onewire.read_bytes(&mut data).await;
             if crc8(&data) == 0 {
-                let temp = ((data[1] as u32) << 8 | data[0] as u32) as f32 / 16.;
+                let temp = ((data[1] as i16) << 8 | data[0] as i16) as f32 / 16.;
                 info!("Read device {:x}: {} deg C", device, temp);
             } else {
                 warn!("Reading device {:x} failed", device);
diff --git a/examples/rp/src/bin/pio_onewire_parasite.rs b/examples/rp/src/bin/pio_onewire_parasite.rs
index fd076dee0..78fb94b18 100644
--- a/examples/rp/src/bin/pio_onewire_parasite.rs
+++ b/examples/rp/src/bin/pio_onewire_parasite.rs
@@ -63,7 +63,7 @@ async fn main(_spawner: Spawner) {
             let mut data = [0; 9];
             onewire.read_bytes(&mut data).await;
             if crc8(&data) == 0 {
-                let temp = ((data[1] as u32) << 8 | data[0] as u32) as f32 / 16.;
+                let temp = ((data[1] as i16) << 8 | data[0] as i16) as f32 / 16.;
                 info!("Read device {:x}: {} deg C", device, temp);
             } else {
                 warn!("Reading device {:x} failed. {:02x}", device, data);
diff --git a/examples/rp235x/src/bin/pio_onewire.rs b/examples/rp235x/src/bin/pio_onewire.rs
index 102f13c45..6432edb8a 100644
--- a/examples/rp235x/src/bin/pio_onewire.rs
+++ b/examples/rp235x/src/bin/pio_onewire.rs
@@ -61,7 +61,7 @@ async fn main(_spawner: Spawner) {
             let mut data = [0; 9];
             onewire.read_bytes(&mut data).await;
             if crc8(&data) == 0 {
-                let temp = ((data[1] as u32) << 8 | data[0] as u32) as f32 / 16.;
+                let temp = ((data[1] as i16) << 8 | data[0] as i16) as f32 / 16.;
                 info!("Read device {:x}: {} deg C", device, temp);
             } else {
                 warn!("Reading device {:x} failed", device);
diff --git a/examples/rp235x/src/bin/pio_onewire_parasite.rs b/examples/rp235x/src/bin/pio_onewire_parasite.rs
index fd076dee0..78fb94b18 100644
--- a/examples/rp235x/src/bin/pio_onewire_parasite.rs
+++ b/examples/rp235x/src/bin/pio_onewire_parasite.rs
@@ -63,7 +63,7 @@ async fn main(_spawner: Spawner) {
             let mut data = [0; 9];
             onewire.read_bytes(&mut data).await;
             if crc8(&data) == 0 {
-                let temp = ((data[1] as u32) << 8 | data[0] as u32) as f32 / 16.;
+                let temp = ((data[1] as i16) << 8 | data[0] as i16) as f32 / 16.;
                 info!("Read device {:x}: {} deg C", device, temp);
             } else {
                 warn!("Reading device {:x} failed. {:02x}", device, data);
diff --git a/examples/stm32c0/src/bin/rtc.rs b/examples/stm32c0/src/bin/rtc.rs
index feb27f6d9..5ff705ca2 100644
--- a/examples/stm32c0/src/bin/rtc.rs
+++ b/examples/stm32c0/src/bin/rtc.rs
@@ -21,12 +21,12 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
 
     rtc.set_datetime(now.into()).expect("datetime not set");
 
     loop {
-        let now: NaiveDateTime = rtc.now().unwrap().into();
+        let now: NaiveDateTime = time_provider.now().unwrap().into();
 
         info!("{}", now.and_utc().timestamp());
 
diff --git a/examples/stm32f4/src/bin/adc_dma.rs b/examples/stm32f4/src/bin/adc_dma.rs
index c24f01753..f8da91336 100644
--- a/examples/stm32f4/src/bin/adc_dma.rs
+++ b/examples/stm32f4/src/bin/adc_dma.rs
@@ -4,7 +4,7 @@ use cortex_m::singleton;
 use defmt::*;
 use embassy_executor::Spawner;
 use embassy_stm32::Peripherals;
-use embassy_stm32::adc::{Adc, RingBufferedAdc, SampleTime, Sequence};
+use embassy_stm32::adc::{Adc, AdcChannel, RingBufferedAdc, SampleTime};
 use embassy_time::Instant;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -15,7 +15,7 @@ async fn main(spawner: Spawner) {
 }
 
 #[embassy_executor::task]
-async fn adc_task(mut p: Peripherals) {
+async fn adc_task(p: Peripherals) {
     const ADC_BUF_SIZE: usize = 1024;
     let adc_data: &mut [u16; ADC_BUF_SIZE] = singleton!(ADCDAT : [u16; ADC_BUF_SIZE] = [0u16; ADC_BUF_SIZE]).unwrap();
     let adc_data2: &mut [u16; ADC_BUF_SIZE] = singleton!(ADCDAT2 : [u16; ADC_BUF_SIZE] = [0u16; ADC_BUF_SIZE]).unwrap();
@@ -23,13 +23,24 @@ async fn adc_task(mut p: Peripherals) {
     let adc = Adc::new(p.ADC1);
     let adc2 = Adc::new(p.ADC2);
 
-    let mut adc: RingBufferedAdc<embassy_stm32::peripherals::ADC1> = adc.into_ring_buffered(p.DMA2_CH0, adc_data);
-    let mut adc2: RingBufferedAdc<embassy_stm32::peripherals::ADC2> = adc2.into_ring_buffered(p.DMA2_CH2, adc_data2);
-
-    adc.set_sample_sequence(Sequence::One, &mut p.PA0, SampleTime::CYCLES112);
-    adc.set_sample_sequence(Sequence::Two, &mut p.PA2, SampleTime::CYCLES112);
-    adc2.set_sample_sequence(Sequence::One, &mut p.PA1, SampleTime::CYCLES112);
-    adc2.set_sample_sequence(Sequence::Two, &mut p.PA3, SampleTime::CYCLES112);
+    let mut adc: RingBufferedAdc<embassy_stm32::peripherals::ADC1> = adc.into_ring_buffered(
+        p.DMA2_CH0,
+        adc_data,
+        [
+            (&mut p.PA0.degrade_adc(), SampleTime::CYCLES112),
+            (&mut p.PA2.degrade_adc(), SampleTime::CYCLES112),
+        ]
+        .into_iter(),
+    );
+    let mut adc2: RingBufferedAdc<embassy_stm32::peripherals::ADC2> = adc2.into_ring_buffered(
+        p.DMA2_CH2,
+        adc_data2,
+        [
+            (&mut p.PA1.degrade_adc(), SampleTime::CYCLES112),
+            (&mut p.PA3.degrade_adc(), SampleTime::CYCLES112),
+        ]
+        .into_iter(),
+    );
 
     // Note that overrun is a big consideration in this implementation. Whatever task is running the adc.read() calls absolutely must circle back around
     // to the adc.read() call before the DMA buffer is wrapped around > 1 time. At this point, the overrun is so significant that the context of
diff --git a/examples/stm32f4/src/bin/eth_w5500.rs b/examples/stm32f4/src/bin/eth_w5500.rs
index cccf20949..0adcda614 100644
--- a/examples/stm32f4/src/bin/eth_w5500.rs
+++ b/examples/stm32f4/src/bin/eth_w5500.rs
@@ -12,6 +12,7 @@ use embassy_stm32::gpio::{Level, Output, Pull, Speed};
 use embassy_stm32::mode::Async;
 use embassy_stm32::rng::Rng;
 use embassy_stm32::spi::Spi;
+use embassy_stm32::spi::mode::Master;
 use embassy_stm32::time::Hertz;
 use embassy_stm32::{Config, bind_interrupts, peripherals, rng, spi};
 use embassy_time::{Delay, Timer};
@@ -24,7 +25,7 @@ bind_interrupts!(struct Irqs {
     HASH_RNG => rng::InterruptHandler<peripherals::RNG>;
 });
 
-type EthernetSPI = ExclusiveDevice<Spi<'static, Async>, Output<'static>, Delay>;
+type EthernetSPI = ExclusiveDevice<Spi<'static, Async, Master>, Output<'static>, Delay>;
 #[embassy_executor::task]
 async fn ethernet_task(runner: Runner<'static, W5500, EthernetSPI, ExtiInput<'static>, Output<'static>>) -> ! {
     runner.run().await
diff --git a/examples/stm32f4/src/bin/i2c_slave_async.rs b/examples/stm32f4/src/bin/i2c_slave_async.rs
new file mode 100644
index 000000000..5065bcdd8
--- /dev/null
+++ b/examples/stm32f4/src/bin/i2c_slave_async.rs
@@ -0,0 +1,135 @@
+//! I2C slave example using async operations with DMA
+//!
+//! This example demonstrates DMA-accelerated I2C slave operations,
+//! which provide better performance and lower CPU overhead for
+//! high-frequency I2C transactions.
+
+#![no_std]
+#![no_main]
+
+use defmt::{error, info};
+use embassy_executor::Spawner;
+use embassy_stm32::i2c::{self, Address, I2c, SlaveAddrConfig, SlaveCommand, SlaveCommandKind};
+use embassy_stm32::time::Hertz;
+use embassy_stm32::{bind_interrupts, peripherals};
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+pub const I2C_SLAVE_ADDR: u8 = 0x42;
+pub const BUFFER_SIZE: usize = 8;
+static I2C_BUFFER: Mutex<ThreadModeRawMutex, [u8; BUFFER_SIZE]> = Mutex::new([0; BUFFER_SIZE]);
+
+bind_interrupts!(struct Irqs {
+    I2C1_EV => i2c::EventInterruptHandler<peripherals::I2C1>;
+    I2C1_ER => i2c::ErrorInterruptHandler<peripherals::I2C1>;
+});
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_stm32::init(Default::default());
+
+    // Configure I2C
+    let mut i2c_config = i2c::Config::default();
+    i2c_config.sda_pullup = false;
+    i2c_config.scl_pullup = false;
+    i2c_config.frequency = Hertz(100_000); // 100kHz I2C speed
+
+    // Initialize I2C as master first
+    let i2c_master = I2c::new(
+        p.I2C1, p.PB8, // SCL
+        p.PB9, // SDA
+        Irqs, p.DMA1_CH6, // TX DMA
+        p.DMA1_CH0, // RX DMA
+        i2c_config,
+    );
+
+    // Convert to MultiMaster mode
+    let slave_config = SlaveAddrConfig::basic(I2C_SLAVE_ADDR);
+    let i2c_slave = i2c_master.into_slave_multimaster(slave_config);
+
+    spawner.spawn(i2c_slave_task(i2c_slave).unwrap());
+}
+
+#[embassy_executor::task]
+pub async fn i2c_slave_task(mut i2c_slave: I2c<'static, embassy_stm32::mode::Async, i2c::mode::MultiMaster>) {
+    info!("Async I2C slave ready at address 0x{:02X}", I2C_SLAVE_ADDR);
+
+    loop {
+        match i2c_slave.listen().await {
+            Ok(SlaveCommand {
+                kind: SlaveCommandKind::Write,
+                address,
+            }) => {
+                let addr_val = match address {
+                    Address::SevenBit(addr) => addr,
+                    Address::TenBit(addr) => (addr & 0xFF) as u8,
+                };
+
+                info!("I2C: Received write command - Address 0x{:02X}", addr_val);
+
+                let mut data_buffer = I2C_BUFFER.lock().await;
+
+                match i2c_slave.respond_to_write(&mut *data_buffer).await {
+                    Ok(_) => {
+                        info!(
+                            "I2C: Data received - Buffer now contains: 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}",
+                            data_buffer[0],
+                            data_buffer[1],
+                            data_buffer[2],
+                            data_buffer[3],
+                            data_buffer[4],
+                            data_buffer[5],
+                            data_buffer[6],
+                            data_buffer[7]
+                        );
+                    }
+                    Err(e) => {
+                        error!("I2C: Write error: {}", format_i2c_error(&e));
+                    }
+                }
+            }
+
+            Ok(SlaveCommand {
+                kind: SlaveCommandKind::Read,
+                address,
+            }) => {
+                let addr_val = match address {
+                    Address::SevenBit(addr) => addr,
+                    Address::TenBit(addr) => (addr & 0xFF) as u8, // Show low byte for 10-bit
+                };
+
+                info!("I2C: Received read command - Address 0x{:02X}", addr_val);
+
+                let data_buffer = I2C_BUFFER.lock().await;
+
+                match i2c_slave.respond_to_read(&data_buffer[..BUFFER_SIZE]).await {
+                    Ok(_) => {
+                        info!("I2C: Responded to read command");
+                    }
+                    Err(e) => {
+                        error!("I2C: Read error: {}", format_i2c_error(&e));
+                    }
+                }
+            }
+
+            Err(e) => {
+                error!("I2C: Listen error: {}", format_i2c_error(&e));
+                Timer::after(Duration::from_millis(100)).await;
+            }
+        }
+    }
+}
+
+fn format_i2c_error(e: &embassy_stm32::i2c::Error) -> &'static str {
+    match e {
+        embassy_stm32::i2c::Error::Bus => "Bus",
+        embassy_stm32::i2c::Error::Arbitration => "Arbitration",
+        embassy_stm32::i2c::Error::Nack => "Nack",
+        embassy_stm32::i2c::Error::Timeout => "Timeout",
+        embassy_stm32::i2c::Error::Crc => "Crc",
+        embassy_stm32::i2c::Error::Overrun => "Overrun",
+        embassy_stm32::i2c::Error::ZeroLengthTransfer => "ZeroLengthTransfer",
+    }
+}
diff --git a/examples/stm32f4/src/bin/i2c_slave_blocking.rs b/examples/stm32f4/src/bin/i2c_slave_blocking.rs
new file mode 100644
index 000000000..ee06d4ac4
--- /dev/null
+++ b/examples/stm32f4/src/bin/i2c_slave_blocking.rs
@@ -0,0 +1,132 @@
+//! Complete I2C slave example using blocking operations
+//!
+//! This example shows how to set up an STM32F4 as an I2C slave device
+//! that can handle both read and write transactions from master devices.
+
+#![no_std]
+#![no_main]
+
+use defmt::{error, info};
+use embassy_executor::Spawner;
+use embassy_stm32::i2c::{self, Address, I2c, SlaveAddrConfig, SlaveCommand, SlaveCommandKind};
+use embassy_stm32::time::Hertz;
+use embassy_stm32::{bind_interrupts, peripherals};
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+pub const I2C_SLAVE_ADDR: u8 = 0x42;
+pub const BUFFER_SIZE: usize = 8;
+static I2C_BUFFER: Mutex<ThreadModeRawMutex, [u8; BUFFER_SIZE]> = Mutex::new([0; BUFFER_SIZE]);
+
+bind_interrupts!(struct Irqs {
+    I2C1_EV => i2c::EventInterruptHandler<peripherals::I2C1>;
+    I2C1_ER => i2c::ErrorInterruptHandler<peripherals::I2C1>;
+});
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_stm32::init(Default::default());
+
+    // Configure I2C
+    let mut i2c_config = i2c::Config::default();
+    i2c_config.sda_pullup = false;
+    i2c_config.scl_pullup = false;
+    i2c_config.frequency = Hertz(100_000);
+    i2c_config.timeout = embassy_time::Duration::from_millis(30000);
+
+    // Initialize I2C as master first
+    let i2c_master = I2c::new_blocking(
+        p.I2C1, p.PB8, // SCL
+        p.PB9, // SDA
+        i2c_config,
+    );
+
+    // Convert to slave+master mode
+    let slave_config = SlaveAddrConfig::basic(I2C_SLAVE_ADDR);
+    let i2c_slave = i2c_master.into_slave_multimaster(slave_config);
+
+    spawner.spawn(i2c_slave_task(i2c_slave).unwrap());
+}
+
+#[embassy_executor::task]
+pub async fn i2c_slave_task(mut i2c_slave: I2c<'static, embassy_stm32::mode::Blocking, i2c::mode::MultiMaster>) {
+    info!("Blocking I2C slave ready at address 0x{:02X}", I2C_SLAVE_ADDR);
+
+    loop {
+        match i2c_slave.blocking_listen() {
+            Ok(SlaveCommand {
+                kind: SlaveCommandKind::Write,
+                address,
+            }) => {
+                let addr_val = match address {
+                    Address::SevenBit(addr) => addr,
+                    Address::TenBit(addr) => (addr & 0xFF) as u8,
+                };
+
+                info!("I2C: Received write command - Address 0x{:02X}", addr_val);
+                let mut data_buffer = I2C_BUFFER.lock().await;
+
+                match i2c_slave.blocking_respond_to_write(&mut *data_buffer) {
+                    Ok(bytes_received) => {
+                        info!(
+                            "I2C: Received {} bytes - Buffer now contains: 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}, 0x{:02X}",
+                            bytes_received,
+                            data_buffer[0],
+                            data_buffer[1],
+                            data_buffer[2],
+                            data_buffer[3],
+                            data_buffer[4],
+                            data_buffer[5],
+                            data_buffer[6],
+                            data_buffer[7]
+                        );
+                    }
+                    Err(e) => {
+                        error!("I2C: Write error: {}", format_i2c_error(&e));
+                    }
+                }
+            }
+
+            Ok(SlaveCommand {
+                kind: SlaveCommandKind::Read,
+                address,
+            }) => {
+                let addr_val = match address {
+                    Address::SevenBit(addr) => addr,
+                    Address::TenBit(addr) => (addr & 0xFF) as u8, // Show low byte for 10-bit
+                };
+
+                info!("I2C: Received read command - Address 0x{:02X}", addr_val);
+                let data_buffer = I2C_BUFFER.lock().await;
+
+                match i2c_slave.blocking_respond_to_read(&data_buffer[..BUFFER_SIZE]) {
+                    Ok(bytes_sent) => {
+                        info!("I2C: Responded to read - {} bytes sent", bytes_sent);
+                    }
+                    Err(e) => {
+                        error!("I2C: Read error: {}", format_i2c_error(&e));
+                    }
+                }
+            }
+
+            Err(e) => {
+                error!("I2C: Listen error: {}", format_i2c_error(&e));
+                Timer::after(Duration::from_millis(100)).await;
+            }
+        }
+    }
+}
+
+fn format_i2c_error(e: &embassy_stm32::i2c::Error) -> &'static str {
+    match e {
+        embassy_stm32::i2c::Error::Bus => "Bus",
+        embassy_stm32::i2c::Error::Arbitration => "Arbitration",
+        embassy_stm32::i2c::Error::Nack => "Nack",
+        embassy_stm32::i2c::Error::Timeout => "Timeout",
+        embassy_stm32::i2c::Error::Crc => "Crc",
+        embassy_stm32::i2c::Error::Overrun => "Overrun",
+        embassy_stm32::i2c::Error::ZeroLengthTransfer => "ZeroLengthTransfer",
+    }
+}
diff --git a/examples/stm32f4/src/bin/rtc.rs b/examples/stm32f4/src/bin/rtc.rs
index feb27f6d9..5ff705ca2 100644
--- a/examples/stm32f4/src/bin/rtc.rs
+++ b/examples/stm32f4/src/bin/rtc.rs
@@ -21,12 +21,12 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
 
     rtc.set_datetime(now.into()).expect("datetime not set");
 
     loop {
-        let now: NaiveDateTime = rtc.now().unwrap().into();
+        let now: NaiveDateTime = time_provider.now().unwrap().into();
 
         info!("{}", now.and_utc().timestamp());
 
diff --git a/examples/stm32g0/src/bin/onewire_ds18b20.rs b/examples/stm32g0/src/bin/onewire_ds18b20.rs
index 62f8711a6..43ecca8c4 100644
--- a/examples/stm32g0/src/bin/onewire_ds18b20.rs
+++ b/examples/stm32g0/src/bin/onewire_ds18b20.rs
@@ -267,7 +267,7 @@ where
         }
 
         match Self::crc8(&data) == 0 {
-            true => Ok(((data[1] as u16) << 8 | data[0] as u16) as f32 / 16.),
+            true => Ok(((data[1] as i16) << 8 | data[0] as i16) as f32 / 16.),
             false => Err(()),
         }
     }
diff --git a/examples/stm32g0/src/bin/rtc.rs b/examples/stm32g0/src/bin/rtc.rs
index 21da204cc..d8b58de22 100644
--- a/examples/stm32g0/src/bin/rtc.rs
+++ b/examples/stm32g0/src/bin/rtc.rs
@@ -17,12 +17,12 @@ async fn main(_spawner: Spawner) {
 
     let now = DateTime::from(2023, 6, 14, DayOfWeek::Friday, 15, 59, 10, 0);
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
 
     rtc.set_datetime(now.unwrap()).expect("datetime not set");
 
     loop {
-        let now: DateTime = rtc.now().unwrap().into();
+        let now: DateTime = time_provider.now().unwrap().into();
 
         info!("{}:{}:{}", now.hour(), now.minute(), now.second());
 
diff --git a/examples/stm32g4/Cargo.toml b/examples/stm32g4/Cargo.toml
index 6fd282d6d..8bbeb594c 100644
--- a/examples/stm32g4/Cargo.toml
+++ b/examples/stm32g4/Cargo.toml
@@ -7,12 +7,12 @@ publish = false
 
 [dependencies]
 # Change stm32g491re to your chip name, if necessary.
-embassy-stm32 = { version = "0.4.0", path = "../../embassy-stm32", features = [ "defmt", "time-driver-any", "stm32g491re", "memory-x", "unstable-pac", "exti"]  }
-embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["defmt"] }
-embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt"] }
-embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
-embassy-usb = { version = "0.5.1", path = "../../embassy-usb", features = ["defmt"] }
-embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
+embassy-stm32 = { path = "../../embassy-stm32", features = [ "defmt", "time-driver-any", "stm32g491re", "memory-x", "unstable-pac", "exti"]  }
+embassy-sync = { path = "../../embassy-sync", features = ["defmt"] }
+embassy-executor = { path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt"] }
+embassy-time = { path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
+embassy-usb = { path = "../../embassy-usb", features = ["defmt"] }
+embassy-futures = { path = "../../embassy-futures" }
 usbd-hid = "0.8.1"
 
 defmt = "1.0.1"
@@ -25,6 +25,7 @@ embedded-can = { version = "0.4" }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 static_cell = "2.0.0"
+critical-section = "1.1"
 
 [profile.release]
 debug = 2
diff --git a/examples/stm32g4/src/bin/adc_dma.rs b/examples/stm32g4/src/bin/adc_dma.rs
index a82067049..ef8b0c3c2 100644
--- a/examples/stm32g4/src/bin/adc_dma.rs
+++ b/examples/stm32g4/src/bin/adc_dma.rs
@@ -12,7 +12,7 @@ static mut DMA_BUF: [u16; 2] = [0; 2];
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let mut read_buffer = unsafe { &mut DMA_BUF[..] };
+    let read_buffer = unsafe { &mut DMA_BUF[..] };
 
     let mut config = Config::default();
     {
@@ -47,7 +47,7 @@ async fn main(_spawner: Spawner) {
                 (&mut pa0, SampleTime::CYCLES247_5),
             ]
             .into_iter(),
-            &mut read_buffer,
+            read_buffer,
         )
         .await;
 
diff --git a/examples/stm32g4/src/bin/adc_injected_and_regular.rs b/examples/stm32g4/src/bin/adc_injected_and_regular.rs
new file mode 100644
index 000000000..3ae2ff064
--- /dev/null
+++ b/examples/stm32g4/src/bin/adc_injected_and_regular.rs
@@ -0,0 +1,154 @@
+//! adc injected and regular conversions
+//!
+//! This example both regular and injected ADC conversions at the same time
+//! p:pa0 n:pa2
+
+#![no_std]
+#![no_main]
+
+use core::cell::RefCell;
+
+use defmt::info;
+use embassy_stm32::adc::{
+    Adc, AdcChannel as _, ConversionTrigger, Exten, InjectedAdc, RegularConversionMode, SampleTime,
+};
+use embassy_stm32::interrupt::typelevel::{ADC1_2, Interrupt};
+use embassy_stm32::peripherals::ADC1;
+use embassy_stm32::time::Hertz;
+use embassy_stm32::timer::complementary_pwm::{ComplementaryPwm, Mms2};
+use embassy_stm32::timer::low_level::CountingMode;
+use embassy_stm32::{Config, interrupt};
+use embassy_sync::blocking_mutex::CriticalSectionMutex;
+use {defmt_rtt as _, panic_probe as _};
+
+static ADC1_HANDLE: CriticalSectionMutex<RefCell<Option<InjectedAdc<ADC1, 1>>>> =
+    CriticalSectionMutex::new(RefCell::new(None));
+
+/// This example showcases how to use both regular ADC conversions with DMA and injected ADC
+/// conversions with ADC interrupt simultaneously. Both conversion types can be configured with
+/// different triggers and thanks to DMA it is possible to use the measurements in different task
+/// without needing to access the ADC peripheral.
+///
+/// If you don't need both regular and injected conversions the example code can easily be reworked
+/// to only include one of the ADC conversion types.
+#[embassy_executor::main]
+async fn main(_spawner: embassy_executor::Spawner) {
+    // See Table 166 and 167 in RM0440 Rev 9 for ADC1/2 External triggers
+    // Note: Regular and Injected channels use different tables!!
+    const ADC1_INJECTED_TRIGGER_TIM1_TRGO2: u8 = 8;
+    const ADC1_REGULAR_TRIGGER_TIM1_TRGO2: u8 = 10;
+
+    // --- RCC config ---
+    let mut config = Config::default();
+    {
+        use embassy_stm32::rcc::*;
+        config.rcc.pll = Some(Pll {
+            source: PllSource::HSI,
+            prediv: PllPreDiv::DIV4,
+            mul: PllMul::MUL85,
+            divp: None,
+            divq: None,
+            divr: Some(PllRDiv::DIV2),
+        });
+        config.rcc.mux.adc12sel = mux::Adcsel::SYS;
+        config.rcc.sys = Sysclk::PLL1_R;
+    }
+    let p = embassy_stm32::init(config);
+
+    // In this example we use tim1_trgo2 event to trigger the ADC conversions
+    let tim1 = p.TIM1;
+    let pwm_freq = 1;
+    let mut pwm = ComplementaryPwm::new(
+        tim1,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        None,
+        Hertz::hz(pwm_freq),
+        CountingMode::EdgeAlignedUp,
+    );
+    pwm.set_master_output_enable(false);
+    // Mms2 is used to configure which timer event that is connected to tim1_trgo2.
+    // In this case we use the update event of the timer.
+    pwm.set_mms2(Mms2::UPDATE);
+
+    // Configure regular conversions with DMA
+    let adc1 = Adc::new(p.ADC1);
+
+    let vrefint_channel = adc1.enable_vrefint().degrade_adc();
+    let pa0 = p.PC1.degrade_adc();
+    let regular_sequence = [
+        (vrefint_channel, SampleTime::CYCLES247_5),
+        (pa0, SampleTime::CYCLES247_5),
+    ]
+    .into_iter();
+
+    // Configurations of Injected ADC measurements
+    let pa2 = p.PA2.degrade_adc();
+    let injected_sequence = [(pa2, SampleTime::CYCLES247_5)];
+
+    // Configure DMA for retrieving regular ADC measurements
+    let dma1_ch1 = p.DMA1_CH1;
+    // Using buffer of double size means the half-full interrupts will generate at the expected rate
+    let mut readings = [0u16; 4];
+
+    let injected_trigger = ConversionTrigger {
+        channel: ADC1_INJECTED_TRIGGER_TIM1_TRGO2,
+        edge: Exten::RISING_EDGE,
+    };
+    let regular_trigger = ConversionTrigger {
+        channel: ADC1_REGULAR_TRIGGER_TIM1_TRGO2,
+        edge: Exten::RISING_EDGE,
+    };
+
+    let (mut ring_buffered_adc, injected_adc) = adc1.into_ring_buffered_and_injected(
+        dma1_ch1,
+        &mut readings,
+        regular_sequence,
+        RegularConversionMode::Triggered(regular_trigger),
+        injected_sequence,
+        injected_trigger,
+        true,
+    );
+
+    // Store ADC globally to allow access from ADC interrupt
+    critical_section::with(|cs| {
+        ADC1_HANDLE.borrow(cs).replace(Some(injected_adc));
+    });
+    // Enable interrupt for ADC1_2
+    unsafe { ADC1_2::enable() };
+
+    // Main loop for reading regular ADC measurements periodically
+    let mut data = [0u16; 2];
+    loop {
+        {
+            match ring_buffered_adc.read(&mut data).await {
+                Ok(n) => {
+                    defmt::info!("Regular ADC reading, VrefInt: {}, PA0: {}", data[0], data[1]);
+                    defmt::info!("Remaining samples: {}", n,);
+                }
+                Err(e) => {
+                    defmt::error!("DMA error: {:?}", e);
+                    ring_buffered_adc.clear();
+                }
+            }
+        }
+    }
+}
+
+/// Use ADC1_2 interrupt to retrieve injected ADC measurements
+/// Interrupt must be unsafe as hardware can invoke it any-time. Critical sections ensure safety
+/// within the interrupt.
+#[interrupt]
+unsafe fn ADC1_2() {
+    critical_section::with(|cs| {
+        if let Some(injected_adc) = ADC1_HANDLE.borrow(cs).borrow_mut().as_mut() {
+            let injected_data = injected_adc.read_injected_samples();
+            info!("Injected reading of PA2: {}", injected_data[0]);
+        }
+    });
+}
diff --git a/examples/stm32h5/Cargo.toml b/examples/stm32h5/Cargo.toml
index 475ba7e8a..512186c3d 100644
--- a/examples/stm32h5/Cargo.toml
+++ b/examples/stm32h5/Cargo.toml
@@ -29,7 +29,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
 micromath = "2.0.0"
-stm32-fmc = "0.3.0"
+stm32-fmc = "0.4.0"
 embedded-storage = "0.3.1"
 static_cell = "2"
 
diff --git a/examples/stm32h5/src/bin/backup_sram.rs b/examples/stm32h5/src/bin/backup_sram.rs
new file mode 100644
index 000000000..f8db1853e
--- /dev/null
+++ b/examples/stm32h5/src/bin/backup_sram.rs
@@ -0,0 +1,31 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_stm32::Config;
+use embassy_stm32::backup_sram::BackupMemory;
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut config = Config::default();
+    config.rcc.ls.enable_backup_sram = true;
+
+    let p = embassy_stm32::init(config);
+    info!("Started!");
+
+    let (bytes, status) = BackupMemory::new(p.BKPSRAM);
+
+    match status {
+        false => info!("BKPSRAM just enabled"),
+        true => info!("BKPSRAM already enabled"),
+    }
+
+    loop {
+        info!("byte0: {}", bytes[0]);
+        bytes[0] = bytes[0].wrapping_add(1);
+        Timer::after_millis(500).await;
+    }
+}
diff --git a/examples/stm32h5/src/bin/stop.rs b/examples/stm32h5/src/bin/stop.rs
index 3c4f49f64..caebc9daf 100644
--- a/examples/stm32h5/src/bin/stop.rs
+++ b/examples/stm32h5/src/bin/stop.rs
@@ -9,10 +9,8 @@ use embassy_executor::Spawner;
 use embassy_stm32::gpio::{AnyPin, Level, Output, Speed};
 use embassy_stm32::low_power::Executor;
 use embassy_stm32::rcc::{HSIPrescaler, LsConfig};
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_stm32::{Config, Peri};
 use embassy_time::Timer;
-use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
 #[cortex_m_rt::entry]
@@ -37,12 +35,6 @@ async fn async_main(spawner: Spawner) {
     // config.enable_debug_during_sleep = false;
     let p = embassy_stm32::init(config);
 
-    // give the RTC to the executor...
-    let rtc = Rtc::new(p.RTC, RtcConfig::default());
-    static RTC: StaticCell<Rtc> = StaticCell::new();
-    let rtc = RTC.init(rtc);
-    embassy_stm32::low_power::stop_with_rtc(rtc);
-
     spawner.spawn(unwrap!(blinky(p.PB4.into())));
     spawner.spawn(unwrap!(timeout()));
 }
diff --git a/examples/stm32h7/Cargo.toml b/examples/stm32h7/Cargo.toml
index 5993110de..09b734054 100644
--- a/examples/stm32h7/Cargo.toml
+++ b/examples/stm32h7/Cargo.toml
@@ -30,7 +30,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
 micromath = "2.0.0"
-stm32-fmc = "0.3.0"
+stm32-fmc = "0.4.0"
 embedded-storage = "0.3.1"
 static_cell = "2"
 chrono = { version = "^0.4", default-features = false }
diff --git a/examples/stm32h7/src/bin/rtc.rs b/examples/stm32h7/src/bin/rtc.rs
index 1bd71637b..965716d23 100644
--- a/examples/stm32h7/src/bin/rtc.rs
+++ b/examples/stm32h7/src/bin/rtc.rs
@@ -23,7 +23,7 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
     info!("Got RTC! {:?}", now.and_utc().timestamp());
 
     rtc.set_datetime(now.into()).expect("datetime not set");
@@ -31,6 +31,6 @@ async fn main(_spawner: Spawner) {
     // In reality the delay would be much longer
     Timer::after_millis(20000).await;
 
-    let then: NaiveDateTime = rtc.now().unwrap().into();
+    let then: NaiveDateTime = time_provider.now().unwrap().into();
     info!("Got RTC! {:?}", then.and_utc().timestamp());
 }
diff --git a/examples/stm32h7/src/bin/spi.rs b/examples/stm32h7/src/bin/spi.rs
index 61f31be24..f7ab20cdd 100644
--- a/examples/stm32h7/src/bin/spi.rs
+++ b/examples/stm32h7/src/bin/spi.rs
@@ -15,7 +15,7 @@ use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::task]
-async fn main_task(mut spi: spi::Spi<'static, Blocking>) {
+async fn main_task(mut spi: spi::Spi<'static, Blocking, spi::mode::Master>) {
     for n in 0u32.. {
         let mut write: String<128> = String::new();
         core::write!(&mut write, "Hello DMA World {}!\r\n", n).unwrap();
diff --git a/examples/stm32h7/src/bin/spi_bdma.rs b/examples/stm32h7/src/bin/spi_bdma.rs
index be6a26d82..cd9d6c789 100644
--- a/examples/stm32h7/src/bin/spi_bdma.rs
+++ b/examples/stm32h7/src/bin/spi_bdma.rs
@@ -20,7 +20,7 @@ use {defmt_rtt as _, panic_probe as _};
 static mut RAM_D3: GroundedArrayCell<u8, 256> = GroundedArrayCell::uninit();
 
 #[embassy_executor::task]
-async fn main_task(mut spi: spi::Spi<'static, Async>) {
+async fn main_task(mut spi: spi::Spi<'static, Async, spi::mode::Master>) {
     let (read_buffer, write_buffer) = unsafe {
         let ram = &mut *core::ptr::addr_of_mut!(RAM_D3);
         ram.initialize_all_copied(0);
diff --git a/examples/stm32h7/src/bin/spi_dma.rs b/examples/stm32h7/src/bin/spi_dma.rs
index 20cb67ba0..3d3c2f43e 100644
--- a/examples/stm32h7/src/bin/spi_dma.rs
+++ b/examples/stm32h7/src/bin/spi_dma.rs
@@ -15,7 +15,7 @@ use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::task]
-async fn main_task(mut spi: spi::Spi<'static, Async>) {
+async fn main_task(mut spi: spi::Spi<'static, Async, spi::mode::Master>) {
     for n in 0u32.. {
         let mut write: String<128> = String::new();
         let mut read = [0; 128];
diff --git a/examples/stm32h755cm4/Cargo.toml b/examples/stm32h755cm4/Cargo.toml
index b5c313523..d69f0228e 100644
--- a/examples/stm32h755cm4/Cargo.toml
+++ b/examples/stm32h755cm4/Cargo.toml
@@ -30,7 +30,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
 micromath = "2.0.0"
-stm32-fmc = "0.3.0"
+stm32-fmc = "0.4.0"
 embedded-storage = "0.3.1"
 static_cell = "2"
 chrono = { version = "^0.4", default-features = false }
diff --git a/examples/stm32h755cm7/Cargo.toml b/examples/stm32h755cm7/Cargo.toml
index 7a1519aae..f4e1e53b7 100644
--- a/examples/stm32h755cm7/Cargo.toml
+++ b/examples/stm32h755cm7/Cargo.toml
@@ -30,7 +30,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
 micromath = "2.0.0"
-stm32-fmc = "0.3.0"
+stm32-fmc = "0.4.0"
 embedded-storage = "0.3.1"
 static_cell = "2"
 chrono = { version = "^0.4", default-features = false }
diff --git a/examples/stm32h7b0/Cargo.toml b/examples/stm32h7b0/Cargo.toml
index 4cd7b84e5..0509d394d 100644
--- a/examples/stm32h7b0/Cargo.toml
+++ b/examples/stm32h7b0/Cargo.toml
@@ -29,7 +29,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
 micromath = "2.0.0"
-stm32-fmc = "0.3.0"
+stm32-fmc = "0.4.0"
 embedded-storage = "0.3.1"
 static_cell = "2"
 chrono = { version = "^0.4", default-features = false }
diff --git a/examples/stm32h7rs/Cargo.toml b/examples/stm32h7rs/Cargo.toml
index 445916972..ab525ad91 100644
--- a/examples/stm32h7rs/Cargo.toml
+++ b/examples/stm32h7rs/Cargo.toml
@@ -29,7 +29,7 @@ panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 heapless = { version = "0.8", default-features = false }
 critical-section = "1.1"
 micromath = "2.0.0"
-stm32-fmc = "0.3.0"
+stm32-fmc = "0.4.0"
 embedded-storage = "0.3.1"
 static_cell = "2"
 chrono = { version = "^0.4", default-features = false }
diff --git a/examples/stm32h7rs/src/bin/rtc.rs b/examples/stm32h7rs/src/bin/rtc.rs
index 1bd71637b..965716d23 100644
--- a/examples/stm32h7rs/src/bin/rtc.rs
+++ b/examples/stm32h7rs/src/bin/rtc.rs
@@ -23,7 +23,7 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
     info!("Got RTC! {:?}", now.and_utc().timestamp());
 
     rtc.set_datetime(now.into()).expect("datetime not set");
@@ -31,6 +31,6 @@ async fn main(_spawner: Spawner) {
     // In reality the delay would be much longer
     Timer::after_millis(20000).await;
 
-    let then: NaiveDateTime = rtc.now().unwrap().into();
+    let then: NaiveDateTime = time_provider.now().unwrap().into();
     info!("Got RTC! {:?}", then.and_utc().timestamp());
 }
diff --git a/examples/stm32h7rs/src/bin/spi.rs b/examples/stm32h7rs/src/bin/spi.rs
index 8c280fdae..3253304eb 100644
--- a/examples/stm32h7rs/src/bin/spi.rs
+++ b/examples/stm32h7rs/src/bin/spi.rs
@@ -15,7 +15,7 @@ use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::task]
-async fn main_task(mut spi: spi::Spi<'static, Blocking>) {
+async fn main_task(mut spi: spi::Spi<'static, Blocking, spi::mode::Master>) {
     for n in 0u32.. {
         let mut write: String<128> = String::new();
         core::write!(&mut write, "Hello DMA World {}!\r\n", n).unwrap();
diff --git a/examples/stm32h7rs/src/bin/spi_dma.rs b/examples/stm32h7rs/src/bin/spi_dma.rs
index 3fa69fd15..ca644c6a8 100644
--- a/examples/stm32h7rs/src/bin/spi_dma.rs
+++ b/examples/stm32h7rs/src/bin/spi_dma.rs
@@ -15,7 +15,7 @@ use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::task]
-async fn main_task(mut spi: spi::Spi<'static, Async>) {
+async fn main_task(mut spi: spi::Spi<'static, Async, spi::mode::Master>) {
     for n in 0u32.. {
         let mut write: String<128> = String::new();
         let mut read = [0; 128];
diff --git a/examples/stm32l4/src/bin/adc_dma.rs b/examples/stm32l4/src/bin/adc_dma.rs
new file mode 100644
index 000000000..7a9200edd
--- /dev/null
+++ b/examples/stm32l4/src/bin/adc_dma.rs
@@ -0,0 +1,51 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_stm32::Config;
+use embassy_stm32::adc::{Adc, AdcChannel, SampleTime};
+use {defmt_rtt as _, panic_probe as _};
+
+const DMA_BUF_LEN: usize = 512;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    info!("Hello World!");
+
+    let mut config = Config::default();
+    {
+        use embassy_stm32::rcc::*;
+        config.rcc.mux.adcsel = mux::Adcsel::SYS;
+    }
+    let p = embassy_stm32::init(config);
+
+    let mut adc = Adc::new(p.ADC1);
+    let mut adc_pin0 = p.PA0.degrade_adc();
+    let mut adc_pin1 = p.PA1.degrade_adc();
+    let mut adc_dma_buf = [0u16; DMA_BUF_LEN];
+    let mut measurements = [0u16; DMA_BUF_LEN / 2];
+    let mut ring_buffered_adc = adc.into_ring_buffered(
+        p.DMA1_CH1,
+        &mut adc_dma_buf,
+        [
+            (&mut adc_pin0, SampleTime::CYCLES640_5),
+            (&mut adc_pin1, SampleTime::CYCLES640_5),
+        ]
+        .into_iter(),
+    );
+
+    info!("starting measurement loop");
+    loop {
+        match ring_buffered_adc.read(&mut measurements).await {
+            Ok(_) => {
+                //note: originally there was a print here showing all the samples,
+                //but even that takes too much time and would cause adc overruns
+                info!("adc1 first 10 samples: {}", measurements[0..10]);
+            }
+            Err(e) => {
+                warn!("Error: {:?}", e);
+            }
+        }
+    }
+}
diff --git a/examples/stm32l4/src/bin/rtc.rs b/examples/stm32l4/src/bin/rtc.rs
index 1d26cd008..8b92075cc 100644
--- a/examples/stm32l4/src/bin/rtc.rs
+++ b/examples/stm32l4/src/bin/rtc.rs
@@ -39,7 +39,7 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
     info!("Got RTC! {:?}", now.and_utc().timestamp());
 
     rtc.set_datetime(now.into()).expect("datetime not set");
@@ -47,6 +47,6 @@ async fn main(_spawner: Spawner) {
     // In reality the delay would be much longer
     Timer::after_millis(20000).await;
 
-    let then: NaiveDateTime = rtc.now().unwrap().into();
+    let then: NaiveDateTime = time_provider.now().unwrap().into();
     info!("Got RTC! {:?}", then.and_utc().timestamp());
 }
diff --git a/examples/stm32l4/src/bin/spe_adin1110_http_server.rs b/examples/stm32l4/src/bin/spe_adin1110_http_server.rs
index 8e54938d1..0dbf515cf 100644
--- a/examples/stm32l4/src/bin/spe_adin1110_http_server.rs
+++ b/examples/stm32l4/src/bin/spe_adin1110_http_server.rs
@@ -28,6 +28,7 @@ use embassy_stm32::gpio::{Input, Level, Output, Pull, Speed};
 use embassy_stm32::i2c::{self, Config as I2C_Config, I2c};
 use embassy_stm32::mode::Async;
 use embassy_stm32::rng::{self, Rng};
+use embassy_stm32::spi::mode::Master;
 use embassy_stm32::spi::{Config as SPI_Config, Spi};
 use embassy_stm32::time::Hertz;
 use embassy_stm32::{bind_interrupts, exti, pac, peripherals};
@@ -54,7 +55,7 @@ const IP_ADDRESS: Ipv4Cidr = Ipv4Cidr::new(Ipv4Address::new(192, 168, 1, 5), 24)
 // Listen port for the webserver
 const HTTP_LISTEN_PORT: u16 = 80;
 
-pub type SpeSpi = Spi<'static, Async>;
+pub type SpeSpi = Spi<'static, Async, Master>;
 pub type SpeSpiCs = ExclusiveDevice<SpeSpi, Output<'static>, Delay>;
 pub type SpeInt = exti::ExtiInput<'static>;
 pub type SpeRst = Output<'static>;
diff --git a/examples/stm32l5/src/bin/stop.rs b/examples/stm32l5/src/bin/stop.rs
index c34053190..3d119f90f 100644
--- a/examples/stm32l5/src/bin/stop.rs
+++ b/examples/stm32l5/src/bin/stop.rs
@@ -6,10 +6,8 @@ use embassy_executor::Spawner;
 use embassy_stm32::gpio::{AnyPin, Level, Output, Speed};
 use embassy_stm32::low_power::Executor;
 use embassy_stm32::rcc::LsConfig;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_stm32::{Config, Peri};
 use embassy_time::Timer;
-use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
 #[cortex_m_rt::entry]
@@ -28,12 +26,6 @@ async fn async_main(spawner: Spawner) {
     // config.enable_debug_during_sleep = false;
     let p = embassy_stm32::init(config);
 
-    // give the RTC to the executor...
-    let rtc = Rtc::new(p.RTC, RtcConfig::default());
-    static RTC: StaticCell<Rtc> = StaticCell::new();
-    let rtc = RTC.init(rtc);
-    embassy_stm32::low_power::stop_with_rtc(rtc);
-
     spawner.spawn(unwrap!(blinky(p.PC7.into())));
     spawner.spawn(unwrap!(timeout()));
 }
diff --git a/examples/stm32u0/src/bin/rtc.rs b/examples/stm32u0/src/bin/rtc.rs
index d071cfbc7..56d16ccf7 100644
--- a/examples/stm32u0/src/bin/rtc.rs
+++ b/examples/stm32u0/src/bin/rtc.rs
@@ -36,7 +36,7 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
     info!("Got RTC! {:?}", now.and_utc().timestamp());
 
     rtc.set_datetime(now.into()).expect("datetime not set");
@@ -44,6 +44,6 @@ async fn main(_spawner: Spawner) {
     // In reality the delay would be much longer
     Timer::after_millis(20000).await;
 
-    let then: NaiveDateTime = rtc.now().unwrap().into();
+    let then: NaiveDateTime = time_provider.now().unwrap().into();
     info!("Got RTC! {:?}", then.and_utc().timestamp());
 }
diff --git a/examples/stm32wl/src/bin/rtc.rs b/examples/stm32wl/src/bin/rtc.rs
index d3709120f..2185142c9 100644
--- a/examples/stm32wl/src/bin/rtc.rs
+++ b/examples/stm32wl/src/bin/rtc.rs
@@ -44,7 +44,7 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
     info!("Got RTC! {:?}", now.and_utc().timestamp());
 
     rtc.set_datetime(now.into()).expect("datetime not set");
@@ -52,6 +52,6 @@ async fn main(_spawner: Spawner) {
     // In reality the delay would be much longer
     Timer::after_millis(20000).await;
 
-    let then: NaiveDateTime = rtc.now().unwrap().into();
+    let then: NaiveDateTime = time_provider.now().unwrap().into();
     info!("Got RTC! {:?}", then.and_utc().timestamp());
 }
diff --git a/examples/stm32wle5/.cargo/config.toml b/examples/stm32wle5/.cargo/config.toml
new file mode 100644
index 000000000..0178d377c
--- /dev/null
+++ b/examples/stm32wle5/.cargo/config.toml
@@ -0,0 +1,9 @@
+[target.'cfg(all(target_arch = "arm", target_os = "none"))']
+# replace your chip as listed in `probe-rs chip list`
+runner = "probe-rs run --chip STM32WLE5JCIx --connect-under-reset"
+
+[build]
+target = "thumbv7em-none-eabi"
+
+[env]
+DEFMT_LOG = "info"
diff --git a/examples/stm32wle5/Cargo.toml b/examples/stm32wle5/Cargo.toml
new file mode 100644
index 000000000..f2fc4dd3d
--- /dev/null
+++ b/examples/stm32wle5/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+edition = "2024"
+name = "embassy-stm32wl-examples"
+version = "0.1.0"
+license = "MIT OR Apache-2.0"
+publish = false
+
+[dependencies]
+# Change stm32wl55jc-cm4 to your chip name, if necessary.
+embassy-stm32 = { version = "0.4.0", path = "../../embassy-stm32", features = ["defmt", "stm32wle5jc", "time-driver-any", "memory-x", "unstable-pac", "exti", "low-power"] }
+embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["defmt"] }
+embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt"] }
+embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-1_000"] }
+embassy-embedded-hal = { version = "0.5.0", path = "../../embassy-embedded-hal" }
+
+defmt = "1.0.1"
+defmt-rtt = { version = "1.1.0", optional = true }
+defmt-serial = { version = "0.10.0", optional = true }
+
+cortex-m = { version = "0.7.6", features = ["inline-asm", "critical-section-single-core"] }
+cortex-m-rt = "0.7.0"
+embedded-hal = "1.0.0"
+embedded-storage = "0.3.1"
+panic-probe = { version = "1.0.0", features = ["print-defmt"] }
+static_cell = { version = "2.1.1", default-features = false }
+
+[profile.release]
+debug = 2
+
+[package.metadata.embassy]
+build = [
+  { target = "thumbv7em-none-eabi", artifact-dir = "out/examples/stm32wl" }
+]
+
+[features]
+default = ["defmt-serial"]
+defmt-rtt = ["dep:defmt-rtt"]
+defmt-serial = ["dep:defmt-serial"]
diff --git a/examples/stm32wle5/README.md b/examples/stm32wle5/README.md
new file mode 100644
index 000000000..18c3b5071
--- /dev/null
+++ b/examples/stm32wle5/README.md
@@ -0,0 +1,52 @@
+# Low Power Examples for STM32WLEx family
+
+Examples in this repo should work with [LoRa-E5 Dev Board](https://www.st.com/en/partner-products-and-services/lora-e5-development-kit.html) board.
+
+## Prerequsits
+
+- Connect a usb serial adapter to LPUart1 (this is where ALL logging will go)
+- Optional: Connect an amp meter that ran measure down to 0.1uA to the power test pins
+- `cargo install defmt-print` so you can print log messahes from LPUart1
+
+## Example Notes
+
+All examples will set all pins to analog mode before configuring pins for the example, if any. This saves about 500uA!!!!
+
+- the `adc` example will sleep in STOP1 betwen samples and the chip will only draw about 13uA while sleeping
+- the `blinky` example will sleep in STOP2 and the chip will only draw 1uA or less while sleeping
+- the `button_exti` example will sleep in STOP2 and the chip will only draw 1uA or less while sleeping
+- the `i2c` examples will sleep in STOP1 between reads and the chip only draw about 10uA while sleeping
+
+For each example you will need to start `defmt-print` with the example binary and the correct serial port in a seperate terminal.  Example:
+```
+defmt-print -w -v -e target/thumbv7em-none-eabi/debug/<module-name> serial --path /dev/cu.usbserial-00000000 --baud 115200
+```
+
+Run individual examples with
+```
+cargo flash --chip STM32WLE5JCIx --connect-under-reset --bin <module-name>
+```
+for example
+```
+cargo flash --chip STM32WLE5JCIx --connect-under-reset --bin blinky
+```
+
+You can also run them with with `run`.  However in this case expect probe-rs to be disconnected as soon as flashing is done as all IO pins are set to analog input!
+```
+cargo run --bin blinky
+```
+
+## Checklist before running examples
+You might need to adjust `.cargo/config.toml`, `Cargo.toml` and possibly update pin numbers or peripherals to match the specific MCU or board you are using.
+
+* [ ] Update .cargo/config.toml with the correct probe-rs command to use your specific MCU. For example for L432KCU6 it should be `probe-rs run --chip STM32L432KCUx`. (use `probe-rs chip list` to find your chip)
+* [ ] Update Cargo.toml to have the correct `embassy-stm32` feature. For example for L432KCU6 it should be `stm32l432kc`. Look in the `Cargo.toml` file of the `embassy-stm32` project to find the correct feature flag for your chip.
+* [ ] If your board has a special clock or power configuration, make sure that it is set up appropriately.
+* [ ] If your board has different pin mapping, update any pin numbers or peripherals in the given example code to match your schematic
+
+If you are unsure, please drop by the Embassy Matrix chat for support, and let us know:
+
+* Which example you are trying to run
+* Which chip and board you are using
+
+Embassy Chat: https://matrix.to/#/#embassy-rs:matrix.org
diff --git a/examples/stm32wle5/build.rs b/examples/stm32wle5/build.rs
new file mode 100644
index 000000000..8cd32d7ed
--- /dev/null
+++ b/examples/stm32wle5/build.rs
@@ -0,0 +1,5 @@
+fn main() {
+    println!("cargo:rustc-link-arg-bins=--nmagic");
+    println!("cargo:rustc-link-arg-bins=-Tlink.x");
+    println!("cargo:rustc-link-arg-bins=-Tdefmt.x");
+}
diff --git a/examples/stm32wle5/src/bin/adc.rs b/examples/stm32wle5/src/bin/adc.rs
new file mode 100644
index 000000000..8b830a1e6
--- /dev/null
+++ b/examples/stm32wle5/src/bin/adc.rs
@@ -0,0 +1,94 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+#[cfg(feature = "defmt-rtt")]
+use defmt_rtt as _;
+use embassy_executor::Spawner;
+use embassy_stm32::adc::{Adc, SampleTime};
+use embassy_stm32::low_power::Executor;
+use embassy_time::Timer;
+use panic_probe as _;
+use static_cell::StaticCell;
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    info!("main: Starting!");
+    Executor::take().run(|spawner| {
+        spawner.spawn(unwrap!(async_main(spawner)));
+    });
+}
+
+#[embassy_executor::task]
+async fn async_main(_spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    // enable HSI clock
+    config.rcc.hsi = true;
+    // enable LSI clock for RTC
+    config.rcc.ls = embassy_stm32::rcc::LsConfig::default_lsi();
+    config.rcc.msi = Some(embassy_stm32::rcc::MSIRange::RANGE4M);
+    config.rcc.sys = embassy_stm32::rcc::Sysclk::MSI;
+    // enable ADC with HSI clock
+    config.rcc.mux.adcsel = embassy_stm32::pac::rcc::vals::Adcsel::HSI;
+    #[cfg(feature = "defmt-serial")]
+    {
+        // disable debug during sleep to reduce power consumption since we are
+        // using defmt-serial on LPUART1.
+        config.enable_debug_during_sleep = false;
+        // if we are using defmt-serial on LPUART1, we need to use HSI for the clock
+        // so that its registers are preserved during STOP modes.
+        config.rcc.mux.lpuart1sel = embassy_stm32::pac::rcc::vals::Lpuart1sel::HSI;
+    }
+    // Initialize STM32WL peripherals (use default config like wio-e5-async example)
+    let p = embassy_stm32::init(config);
+
+    // start with all GPIOs as analog to reduce power consumption
+    for r in [
+        embassy_stm32::pac::GPIOA,
+        embassy_stm32::pac::GPIOB,
+        embassy_stm32::pac::GPIOC,
+        embassy_stm32::pac::GPIOH,
+    ] {
+        r.moder().modify(|w| {
+            for i in 0..16 {
+                // don't reset these if probe-rs should stay connected!
+                #[cfg(feature = "defmt-rtt")]
+                if config.enable_debug_during_sleep && r == embassy_stm32::pac::GPIOA && [13, 14].contains(&i) {
+                    continue;
+                }
+                w.set_moder(i, embassy_stm32::pac::gpio::vals::Moder::ANALOG);
+            }
+        });
+    }
+    #[cfg(feature = "defmt-serial")]
+    {
+        use embassy_stm32::mode::Blocking;
+        use embassy_stm32::usart::Uart;
+        let config = embassy_stm32::usart::Config::default();
+        let uart = Uart::new_blocking(p.LPUART1, p.PC0, p.PC1, config).expect("failed to configure UART!");
+        static SERIAL: StaticCell<Uart<'static, Blocking>> = StaticCell::new();
+        defmt_serial::defmt_serial(SERIAL.init(uart));
+    }
+
+    info!("Hello World!");
+
+    let mut adc = Adc::new(p.ADC1);
+    adc.set_sample_time(SampleTime::CYCLES79_5);
+    let mut pin = p.PA10;
+
+    let mut vrefint = adc.enable_vrefint();
+    let vrefint_sample = adc.blocking_read(&mut vrefint);
+    let convert_to_millivolts = |sample| {
+        // From https://www.st.com/resource/en/datasheet/stm32g031g8.pdf
+        // 6.3.3 Embedded internal reference voltage
+        const VREFINT_MV: u32 = 1212; // mV
+
+        (u32::from(sample) * VREFINT_MV / u32::from(vrefint_sample)) as u16
+    };
+
+    loop {
+        let v = adc.blocking_read(&mut pin);
+        info!("--> {} - {} mV", v, convert_to_millivolts(v));
+        Timer::after_secs(1).await;
+    }
+}
diff --git a/examples/stm32wle5/src/bin/blinky.rs b/examples/stm32wle5/src/bin/blinky.rs
new file mode 100644
index 000000000..b2745fdaf
--- /dev/null
+++ b/examples/stm32wle5/src/bin/blinky.rs
@@ -0,0 +1,84 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+#[cfg(feature = "defmt-rtt")]
+use defmt_rtt as _;
+use embassy_executor::Spawner;
+use embassy_stm32::gpio::{Level, Output, Speed};
+use embassy_stm32::low_power::Executor;
+use embassy_time::Timer;
+use panic_probe as _;
+use static_cell::StaticCell;
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    info!("main: Starting!");
+    Executor::take().run(|spawner| {
+        spawner.spawn(unwrap!(async_main(spawner)));
+    });
+}
+
+#[embassy_executor::task]
+async fn async_main(_spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    // enable HSI clock
+    config.rcc.hsi = true;
+    // enable LSI clock for RTC
+    config.rcc.ls = embassy_stm32::rcc::LsConfig::default_lsi();
+    config.rcc.msi = Some(embassy_stm32::rcc::MSIRange::RANGE4M);
+    config.rcc.sys = embassy_stm32::rcc::Sysclk::MSI;
+    #[cfg(feature = "defmt-serial")]
+    {
+        // disable debug during sleep to reduce power consumption since we are
+        // using defmt-serial on LPUART1.
+        config.enable_debug_during_sleep = false;
+        // if we are using defmt-serial on LPUART1, we need to use HSI for the clock
+        // so that its registers are preserved during STOP modes.
+        config.rcc.mux.lpuart1sel = embassy_stm32::pac::rcc::vals::Lpuart1sel::HSI;
+    }
+    // Initialize STM32WL peripherals (use default config like wio-e5-async example)
+    let p = embassy_stm32::init(config);
+
+    // start with all GPIOs as analog to reduce power consumption
+    for r in [
+        embassy_stm32::pac::GPIOA,
+        embassy_stm32::pac::GPIOB,
+        embassy_stm32::pac::GPIOC,
+        embassy_stm32::pac::GPIOH,
+    ] {
+        r.moder().modify(|w| {
+            for i in 0..16 {
+                // don't reset these if probe-rs should stay connected!
+                #[cfg(feature = "defmt-rtt")]
+                if config.enable_debug_during_sleep && r == embassy_stm32::pac::GPIOA && [13, 14].contains(&i) {
+                    continue;
+                }
+                w.set_moder(i, embassy_stm32::pac::gpio::vals::Moder::ANALOG);
+            }
+        });
+    }
+    #[cfg(feature = "defmt-serial")]
+    {
+        use embassy_stm32::mode::Blocking;
+        use embassy_stm32::usart::Uart;
+        let config = embassy_stm32::usart::Config::default();
+        let uart = Uart::new_blocking(p.LPUART1, p.PC0, p.PC1, config).expect("failed to configure UART!");
+        static SERIAL: StaticCell<Uart<'static, Blocking>> = StaticCell::new();
+        defmt_serial::defmt_serial(SERIAL.init(uart));
+    }
+
+    info!("Hello World!");
+
+    let mut led = Output::new(p.PB5, Level::High, Speed::Low);
+
+    loop {
+        info!("low");
+        led.set_low();
+        Timer::after_millis(500).await;
+
+        info!("high");
+        led.set_high();
+        Timer::after_millis(500).await;
+    }
+}
diff --git a/examples/stm32wle5/src/bin/button_exti.rs b/examples/stm32wle5/src/bin/button_exti.rs
new file mode 100644
index 000000000..db1bff0be
--- /dev/null
+++ b/examples/stm32wle5/src/bin/button_exti.rs
@@ -0,0 +1,85 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+#[cfg(feature = "defmt-rtt")]
+use defmt_rtt as _;
+use embassy_executor::Spawner;
+use embassy_stm32::exti::ExtiInput;
+use embassy_stm32::gpio::Pull;
+use embassy_stm32::low_power::Executor;
+use panic_probe as _;
+use static_cell::StaticCell;
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    info!("main: Starting!");
+    Executor::take().run(|spawner| {
+        spawner.spawn(unwrap!(async_main(spawner)));
+    });
+}
+
+#[embassy_executor::task]
+async fn async_main(_spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    // enable HSI clock
+    config.rcc.hsi = true;
+    // enable LSI clock for RTC
+    config.rcc.ls = embassy_stm32::rcc::LsConfig::default_lsi();
+    config.rcc.msi = Some(embassy_stm32::rcc::MSIRange::RANGE4M);
+    config.rcc.sys = embassy_stm32::rcc::Sysclk::MSI;
+    // enable ADC with HSI clock
+    config.rcc.mux.adcsel = embassy_stm32::pac::rcc::vals::Adcsel::HSI;
+    #[cfg(feature = "defmt-serial")]
+    {
+        // disable debug during sleep to reduce power consumption since we are
+        // using defmt-serial on LPUART1.
+        config.enable_debug_during_sleep = false;
+        // if we are using defmt-serial on LPUART1, we need to use HSI for the clock
+        // so that its registers are preserved during STOP modes.
+        config.rcc.mux.lpuart1sel = embassy_stm32::pac::rcc::vals::Lpuart1sel::HSI;
+    }
+    // Initialize STM32WL peripherals (use default config like wio-e5-async example)
+    let p = embassy_stm32::init(config);
+
+    // start with all GPIOs as analog to reduce power consumption
+    for r in [
+        embassy_stm32::pac::GPIOA,
+        embassy_stm32::pac::GPIOB,
+        embassy_stm32::pac::GPIOC,
+        embassy_stm32::pac::GPIOH,
+    ] {
+        r.moder().modify(|w| {
+            for i in 0..16 {
+                // don't reset these if probe-rs should stay connected!
+                #[cfg(feature = "defmt-rtt")]
+                if config.enable_debug_during_sleep && r == embassy_stm32::pac::GPIOA && [13, 14].contains(&i) {
+                    continue;
+                }
+                w.set_moder(i, embassy_stm32::pac::gpio::vals::Moder::ANALOG);
+            }
+        });
+    }
+    #[cfg(feature = "defmt-serial")]
+    {
+        use embassy_stm32::mode::Blocking;
+        use embassy_stm32::usart::Uart;
+        let config = embassy_stm32::usart::Config::default();
+        let uart = Uart::new_blocking(p.LPUART1, p.PC0, p.PC1, config).expect("failed to configure UART!");
+        static SERIAL: StaticCell<Uart<'static, Blocking>> = StaticCell::new();
+        defmt_serial::defmt_serial(SERIAL.init(uart));
+    }
+
+    info!("Hello World!");
+
+    let mut button = ExtiInput::new(p.PA0, p.EXTI0, Pull::Up);
+
+    info!("Press the USER button...");
+
+    loop {
+        button.wait_for_falling_edge().await;
+        info!("Pressed!");
+        button.wait_for_rising_edge().await;
+        info!("Released!");
+    }
+}
diff --git a/examples/stm32wle5/src/bin/i2c.rs b/examples/stm32wle5/src/bin/i2c.rs
new file mode 100644
index 000000000..c31c673c9
--- /dev/null
+++ b/examples/stm32wle5/src/bin/i2c.rs
@@ -0,0 +1,104 @@
+#![no_std]
+#![no_main]
+
+use defmt::*;
+#[cfg(feature = "defmt-rtt")]
+use defmt_rtt as _;
+use embassy_executor::Spawner;
+use embassy_stm32::i2c::I2c;
+use embassy_stm32::low_power::Executor;
+use embassy_stm32::time::Hertz;
+use embassy_stm32::{bind_interrupts, i2c, peripherals};
+use embassy_time::{Duration, Timer};
+use panic_probe as _;
+use static_cell::StaticCell;
+
+bind_interrupts!(struct IrqsI2C{
+    I2C2_EV => i2c::EventInterruptHandler<peripherals::I2C2>;
+    I2C2_ER => i2c::ErrorInterruptHandler<peripherals::I2C2>;
+});
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    info!("main: Starting!");
+    Executor::take().run(|spawner| {
+        spawner.spawn(unwrap!(async_main(spawner)));
+    });
+}
+
+#[embassy_executor::task]
+async fn async_main(_spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    // enable HSI clock
+    config.rcc.hsi = true;
+    // enable LSI clock for RTC
+    config.rcc.ls = embassy_stm32::rcc::LsConfig::default_lsi();
+    config.rcc.msi = Some(embassy_stm32::rcc::MSIRange::RANGE4M);
+    config.rcc.sys = embassy_stm32::rcc::Sysclk::MSI;
+    // enable ADC with HSI clock
+    config.rcc.mux.i2c2sel = embassy_stm32::pac::rcc::vals::I2c2sel::HSI;
+    #[cfg(feature = "defmt-serial")]
+    {
+        // disable debug during sleep to reduce power consumption since we are
+        // using defmt-serial on LPUART1.
+        config.enable_debug_during_sleep = false;
+        // if we are using defmt-serial on LPUART1, we need to use HSI for the clock
+        // so that its registers are preserved during STOP modes.
+        config.rcc.mux.lpuart1sel = embassy_stm32::pac::rcc::vals::Lpuart1sel::HSI;
+    }
+    // Initialize STM32WL peripherals (use default config like wio-e5-async example)
+    let p = embassy_stm32::init(config);
+
+    // start with all GPIOs as analog to reduce power consumption
+    for r in [
+        embassy_stm32::pac::GPIOA,
+        embassy_stm32::pac::GPIOB,
+        embassy_stm32::pac::GPIOC,
+        embassy_stm32::pac::GPIOH,
+    ] {
+        r.moder().modify(|w| {
+            for i in 0..16 {
+                // don't reset these if probe-rs should stay connected!
+                #[cfg(feature = "defmt-rtt")]
+                if config.enable_debug_during_sleep && r == embassy_stm32::pac::GPIOA && [13, 14].contains(&i) {
+                    continue;
+                }
+                w.set_moder(i, embassy_stm32::pac::gpio::vals::Moder::ANALOG);
+            }
+        });
+    }
+    #[cfg(feature = "defmt-serial")]
+    {
+        use embassy_stm32::mode::Blocking;
+        use embassy_stm32::usart::Uart;
+        let config = embassy_stm32::usart::Config::default();
+        let uart = Uart::new_blocking(p.LPUART1, p.PC0, p.PC1, config).expect("failed to configure UART!");
+        static SERIAL: StaticCell<Uart<'static, Blocking>> = StaticCell::new();
+        defmt_serial::defmt_serial(SERIAL.init(uart));
+    }
+
+    info!("Hello World!");
+    let en3v3 = embassy_stm32::gpio::Output::new(
+        p.PA9,
+        embassy_stm32::gpio::Level::High,
+        embassy_stm32::gpio::Speed::High,
+    );
+    core::mem::forget(en3v3); // keep the output pin enabled
+
+    let mut i2c = I2c::new(p.I2C2, p.PB15, p.PA15, IrqsI2C, p.DMA1_CH6, p.DMA1_CH7, {
+        let mut config = i2c::Config::default();
+        config.frequency = Hertz::khz(100);
+        config.timeout = Duration::from_millis(500);
+        config
+    });
+
+    loop {
+        let mut buffer = [0; 2];
+        // read the temperature register of the onboard lm75
+        match i2c.read(0x48, &mut buffer).await {
+            Ok(_) => info!("--> {:?}", buffer),
+            Err(e) => info!("--> Error: {:?}", e),
+        }
+        Timer::after_secs(5).await;
+    }
+}
diff --git a/examples/stm32wle5/stm32wle5.code-workspace b/examples/stm32wle5/stm32wle5.code-workspace
new file mode 100644
index 000000000..a7c4a0ebd
--- /dev/null
+++ b/examples/stm32wle5/stm32wle5.code-workspace
@@ -0,0 +1,13 @@
+{
+        "folders": [
+                {
+                        "path": "."
+                }
+        ],
+        "settings": {
+                "rust-analyzer.cargo.target": "thumbv7em-none-eabi",
+                "rust-analyzer.cargo.allTargets": false,
+                "rust-analyzer.cargo.targetDir": "target/rust-analyzer",
+                "rust-analyzer.checkOnSave": true,
+        }
+}
diff --git a/tests/nrf/.cargo/config.toml b/tests/nrf/.cargo/config.toml
index 8f9bccbc0..0192c10ae 100644
--- a/tests/nrf/.cargo/config.toml
+++ b/tests/nrf/.cargo/config.toml
@@ -1,6 +1,6 @@
 [target.'cfg(all(target_arch = "arm", target_os = "none"))']
-#runner = "teleprobe local run --chip nRF52840_xxAA --elf"
-runner = "teleprobe client run"
+runner = "teleprobe local run --chip nRF52840_xxAA --elf"
+#runner = "teleprobe client run"
 
 [build]
 #target = "thumbv6m-none-eabi"
diff --git a/tests/nrf/src/bin/buffered_uart_spam.rs b/tests/nrf/src/bin/buffered_uart_spam.rs
index 24ddd06f3..6d862e19d 100644
--- a/tests/nrf/src/bin/buffered_uart_spam.rs
+++ b/tests/nrf/src/bin/buffered_uart_spam.rs
@@ -55,14 +55,14 @@ async fn main(_spawner: Spawner) {
     static mut TX_BUF: [u8; NSPAM] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
     let _spam = UarteTx::new(peri!(p, UART1), irqs!(UART1), peri!(p, PIN_A), config.clone());
     let spam_peri = pac::UARTE1;
-    let event = unsafe { Event::new_unchecked(NonNull::new_unchecked(spam_peri.events_endtx().as_ptr())) };
-    let task = unsafe { Task::new_unchecked(NonNull::new_unchecked(spam_peri.tasks_starttx().as_ptr())) };
+    let event = unsafe { Event::new_unchecked(NonNull::new_unchecked(spam_peri.events_dma().tx().end().as_ptr())) };
+    let task = unsafe { Task::new_unchecked(NonNull::new_unchecked(spam_peri.tasks_dma().tx().start().as_ptr())) };
     let mut spam_ppi = Ppi::new_one_to_one(p.PPI_CH2, event, task);
     spam_ppi.enable();
     let p = (&raw mut TX_BUF) as *mut u8;
-    spam_peri.txd().ptr().write_value(p as u32);
-    spam_peri.txd().maxcnt().write(|w| w.set_maxcnt(NSPAM as _));
-    spam_peri.tasks_starttx().write_value(1);
+    spam_peri.dma().tx().ptr().write_value(p as u32);
+    spam_peri.dma().tx().maxcnt().write(|w| w.set_maxcnt(NSPAM as _));
+    spam_peri.tasks_dma().tx().start().write_value(1);
 
     let mut i = 0;
     let mut total = 0;
diff --git a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
index 091a70ce9..ac082dbb8 100644
--- a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
+++ b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
@@ -29,8 +29,7 @@ const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
 async fn wifi_task(
     runner: hosted::Runner<
         'static,
-        ExclusiveDevice<Spim<'static>, Output<'static>, Delay>,
-        Input<'static>,
+        hosted::SpiInterface<ExclusiveDevice<Spim<'static>, Output<'static>, Delay>, Input<'static>>,
         Output<'static>,
     >,
 ) -> ! {
@@ -64,15 +63,11 @@ async fn main(spawner: Spawner) {
     let spi = spim::Spim::new(p.SPI3, Irqs, sck, miso, mosi, config);
     let spi = ExclusiveDevice::new(spi, cs, Delay);
 
+    let iface = hosted::SpiInterface::new(spi, handshake, ready);
+
     static STATE: StaticCell<embassy_net_esp_hosted::State> = StaticCell::new();
-    let (device, mut control, runner) = embassy_net_esp_hosted::new(
-        STATE.init(embassy_net_esp_hosted::State::new()),
-        spi,
-        handshake,
-        ready,
-        reset,
-    )
-    .await;
+    let (device, mut control, runner) =
+        embassy_net_esp_hosted::new(STATE.init(embassy_net_esp_hosted::State::new()), iface, reset).await;
 
     spawner.spawn(unwrap!(wifi_task(runner)));
 
diff --git a/tests/stm32/Cargo.toml b/tests/stm32/Cargo.toml
index 1161e827b..b92b47be2 100644
--- a/tests/stm32/Cargo.toml
+++ b/tests/stm32/Cargo.toml
@@ -73,7 +73,7 @@ teleprobe-meta = "1"
 embassy-sync = { version = "0.7.2", path = "../../embassy-sync", features = ["defmt"] }
 embassy-executor = { version = "0.9.0", path = "../../embassy-executor", features = ["arch-cortex-m", "executor-thread", "defmt"] }
 embassy-time = { version = "0.5.0", path = "../../embassy-time", features = ["defmt", "tick-hz-131_072", "defmt-timestamp-uptime"] }
-embassy-stm32 = { version = "0.4.0", path = "../../embassy-stm32", features = [ "defmt", "unstable-pac", "memory-x", "time-driver-any"]  }
+embassy-stm32 = { version = "0.4.0", path = "../../embassy-stm32", features = [ "defmt", "unstable-pac", "memory-x", "time-driver-any", "_allow-disable-rtc"]  }
 embassy-futures = { version = "0.1.2", path = "../../embassy-futures" }
 embassy-stm32-wpan = { version = "0.1.0", path = "../../embassy-stm32-wpan", optional = true, features = ["defmt", "stm32wb55rg", "ble"] }
 embassy-net = { version = "0.7.1", path = "../../embassy-net", features = ["defmt",  "tcp", "udp", "dhcpv4", "medium-ethernet"] }
@@ -94,6 +94,7 @@ rand_core = { version = "0.9.1", default-features = false }
 rand_chacha = { version = "0.9.0", default-features = false }
 static_cell = "2"
 portable-atomic = { version = "1.5", features = [] }
+critical-section = "1.1"
 
 chrono = { version = "^0.4", default-features = false, optional = true}
 sha2 = { version = "0.10.8", default-features = false }
diff --git a/tests/stm32/src/bin/rtc.rs b/tests/stm32/src/bin/rtc.rs
index 5fe98d807..eb27af4ca 100644
--- a/tests/stm32/src/bin/rtc.rs
+++ b/tests/stm32/src/bin/rtc.rs
@@ -10,13 +10,19 @@ use common::*;
 use defmt::assert;
 use embassy_executor::Spawner;
 use embassy_stm32::rcc::LsConfig;
+#[cfg(feature = "stop")]
+use embassy_stm32::rtc::Rtc;
+#[cfg(not(feature = "stop"))]
 use embassy_stm32::rtc::{Rtc, RtcConfig};
 use embassy_time::Timer;
-
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut config = config();
     config.rcc.ls = LsConfig::default_lse();
+    #[cfg(feature = "stop")]
+    {
+        config.rtc._disable_rtc = false;
+    }
 
     let p = init_with_config(config);
     info!("Hello World!");
@@ -26,14 +32,25 @@ async fn main(_spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    #[cfg(not(feature = "stop"))]
+    let (mut rtc, time_provider) = Rtc::new(p.RTC, RtcConfig::default());
+
+    #[cfg(feature = "stop")]
+    let (rtc, time_provider) = Rtc::new(p.RTC);
 
+    #[cfg(not(feature = "stop"))]
     rtc.set_datetime(now.into()).expect("datetime not set");
 
+    #[cfg(feature = "stop")]
+    critical_section::with(|cs| {
+        rtc.borrow_mut(cs).set_datetime(now.into()).expect("datetime not set");
+    });
+
     info!("Waiting 5 seconds");
     Timer::after_millis(5000).await;
 
-    let then: NaiveDateTime = rtc.now().unwrap().into();
+    let then: NaiveDateTime = time_provider.now().unwrap().into();
+
     let seconds = (then - now).num_seconds();
 
     info!("measured = {}", seconds);
diff --git a/tests/stm32/src/bin/spi.rs b/tests/stm32/src/bin/spi.rs
index e8310866a..cedff772c 100644
--- a/tests/stm32/src/bin/spi.rs
+++ b/tests/stm32/src/bin/spi.rs
@@ -8,6 +8,7 @@ use defmt::assert_eq;
 use embassy_executor::Spawner;
 use embassy_stm32::gpio::{Level, Output, Speed};
 use embassy_stm32::mode::Blocking;
+use embassy_stm32::spi::mode::Master;
 use embassy_stm32::spi::{self, Spi, Word};
 use embassy_stm32::time::Hertz;
 
@@ -65,7 +66,7 @@ async fn main(_spawner: Spawner) {
     cortex_m::asm::bkpt();
 }
 
-fn test_txrx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking>)
+fn test_txrx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking, Master>)
 where
     W: core::ops::Not<Output = W>,
 {
@@ -109,7 +110,7 @@ where
     spi.blocking_write::<u8>(&[]).unwrap();
 }
 
-fn test_rx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking>, mosi_out: &mut Output<'_>)
+fn test_rx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking, Master>, mosi_out: &mut Output<'_>)
 where
     W: core::ops::Not<Output = W>,
 {
@@ -125,7 +126,7 @@ where
     spi.blocking_read::<u8>(&mut []).unwrap();
 }
 
-fn test_tx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking>)
+fn test_tx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Blocking, Master>)
 where
     W: core::ops::Not<Output = W>,
 {
diff --git a/tests/stm32/src/bin/spi_dma.rs b/tests/stm32/src/bin/spi_dma.rs
index b4fdb8faa..c8cd92401 100644
--- a/tests/stm32/src/bin/spi_dma.rs
+++ b/tests/stm32/src/bin/spi_dma.rs
@@ -8,6 +8,7 @@ use defmt::assert_eq;
 use embassy_executor::Spawner;
 use embassy_stm32::gpio::{Level, Output, Speed};
 use embassy_stm32::mode::Async;
+use embassy_stm32::spi::mode::Master;
 use embassy_stm32::spi::{self, Spi, Word};
 use embassy_stm32::time::Hertz;
 
@@ -78,7 +79,7 @@ async fn main(_spawner: Spawner) {
     cortex_m::asm::bkpt();
 }
 
-async fn test_txrx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async>)
+async fn test_txrx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async, Master>)
 where
     W: core::ops::Not<Output = W>,
 {
@@ -142,7 +143,7 @@ where
     spi.write(&buf).await.unwrap();
 }
 
-async fn test_rx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async>, mosi_out: &mut Output<'_>)
+async fn test_rx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async, Master>, mosi_out: &mut Output<'_>)
 where
     W: core::ops::Not<Output = W>,
 {
@@ -168,7 +169,7 @@ where
     spi.blocking_read::<u8>(&mut []).unwrap();
 }
 
-async fn test_tx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async>)
+async fn test_tx<W: Word + From<u8> + defmt::Format + Eq>(spi: &mut Spi<'_, Async, Master>)
 where
     W: core::ops::Not<Output = W>,
 {
diff --git a/tests/stm32/src/bin/stop.rs b/tests/stm32/src/bin/stop.rs
index 833ca05d0..1fe65d867 100644
--- a/tests/stm32/src/bin/stop.rs
+++ b/tests/stm32/src/bin/stop.rs
@@ -10,11 +10,10 @@ use common::*;
 use cortex_m_rt::entry;
 use embassy_executor::Spawner;
 use embassy_stm32::Config;
-use embassy_stm32::low_power::{Executor, StopMode, stop_ready, stop_with_rtc};
+use embassy_stm32::low_power::{Executor, StopMode, stop_ready};
 use embassy_stm32::rcc::LsConfig;
-use embassy_stm32::rtc::{Rtc, RtcConfig};
+use embassy_stm32::rtc::Rtc;
 use embassy_time::Timer;
-use static_cell::StaticCell;
 
 #[entry]
 fn main() -> ! {
@@ -50,6 +49,7 @@ async fn async_main(spawner: Spawner) {
 
     let mut config = Config::default();
     config.rcc.ls = LsConfig::default_lse();
+    config.rtc._disable_rtc = false;
 
     // System Clock seems cannot be greater than 16 MHz
     #[cfg(any(feature = "stm32h563zi", feature = "stm32h503rb"))]
@@ -66,14 +66,11 @@ async fn async_main(spawner: Spawner) {
         .and_hms_opt(10, 30, 15)
         .unwrap();
 
-    let mut rtc = Rtc::new(p.RTC, RtcConfig::default());
+    let (rtc, _time_provider) = Rtc::new(p.RTC);
 
-    rtc.set_datetime(now.into()).expect("datetime not set");
-
-    static RTC: StaticCell<Rtc> = StaticCell::new();
-    let rtc = RTC.init(rtc);
-
-    stop_with_rtc(rtc);
+    critical_section::with(|cs| {
+        rtc.borrow_mut(cs).set_datetime(now.into()).expect("datetime not set");
+    });
 
     spawner.spawn(task_1().unwrap());
     spawner.spawn(task_2().unwrap());
diff --git a/tests/stm32/src/common.rs b/tests/stm32/src/common.rs
index 2bd934d6f..096cce947 100644
--- a/tests/stm32/src/common.rs
+++ b/tests/stm32/src/common.rs
@@ -468,6 +468,8 @@ pub fn config() -> Config {
         config.rcc.apb3_pre = APBPrescaler::DIV1;
         config.rcc.sys = Sysclk::PLL1_P;
         config.rcc.voltage_scale = VoltageScale::Scale0;
+
+        config.rtc._disable_rtc = true;
     }
 
     #[cfg(feature = "stm32h503rb")]