Merge branch 'embassy-rs:main' into main

108 files changed, 18830 insertions, 1741 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/embassy-executor/Cargo.toml b/embassy-executor/Cargo.toml
index ecc4b6338..e500833c0 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"]},
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 b846f21b1..d9910a7ab 100644
--- a/embassy-mspm0/CHANGELOG.md
+++ b/embassy-mspm0/CHANGELOG.md
@@ -7,9 +7,14 @@ 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)
 - feat: Add MSPM0C1105/C1106 support
 - feat: Add adc implementation (#4646)
+- 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)
diff --git a/embassy-mspm0/Cargo.toml b/embassy-mspm0/Cargo.toml
index 65019eb7c..df6176ff6 100644
--- a/embassy-mspm0/Cargo.toml
+++ b/embassy-mspm0/Cargo.toml
@@ -15,17 +15,19 @@ publish = false
 [package.metadata.embassy]
 build = [
     {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0c1104dgs20", "time-driver-any"]},
+    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0c1106rgz", "time-driver-any"]},
+    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g1107ycj", "time-driver-any"]},
+    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g1505pt", "time-driver-any"]},
+    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g1519rhb", "time-driver-any"]},
+    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g3105rhb", "time-driver-any"]},
     {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g3507pm", "time-driver-any"]},
     {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g3519pz", "time-driver-any"]},
+    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0h3216pt", "time-driver-any"]},
     {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0l1306rhb", "time-driver-any"]},
     {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0l2228pn", "time-driver-any"]},
     {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0l1345dgs28", "time-driver-any"]},
     {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0l1106dgs28", "time-driver-any"]},
-    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0l1228pm", "time-driver-any"]},
-    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g1107ycj", "time-driver-any"]},
-    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g3105rhb", "time-driver-any"]},
-    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g1505pt", "time-driver-any"]},
-    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0g1519rhb", "time-driver-any"]},
+    {target = "thumbv6m-none-eabi", features = ["defmt", "mspm0l1228pt", "time-driver-any"]},
 ]
 
 [package.metadata.embassy_docs]
@@ -37,6 +39,7 @@ flavors = [
     { regex_feature = "mspm0c.*", target = "thumbv6m-none-eabi" },
     { regex_feature = "mspm0l.*", target = "thumbv6m-none-eabi" },
     { regex_feature = "mspm0g.*", target = "thumbv6m-none-eabi" },
+    { regex_feature = "mspm0h.*", target = "thumbv6m-none-eabi" },
 ]
 
 [package.metadata.docs.rs]
@@ -69,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-d7bf3d01ac0780e716a45b0474234d39443dc5cf" }
+mspm0-metapac = { git = "https://github.com/mspm0-rs/mspm0-data-generated/", tag = "mspm0-data-e7de4103a0713772695ffcad52c3c2f07414dc29" }
 
 [build-dependencies]
 proc-macro2 = "1.0.94"
@@ -77,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-d7bf3d01ac0780e716a45b0474234d39443dc5cf", 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"] }
 
 [features]
 default = ["rt"]
@@ -243,6 +246,7 @@ mspm0g3519pn = ["mspm0-metapac/mspm0g3519pn"]
 mspm0g3519pz = ["mspm0-metapac/mspm0g3519pz"]
 mspm0g3519rgz = ["mspm0-metapac/mspm0g3519rgz"]
 mspm0g3519rhb = ["mspm0-metapac/mspm0g3519rhb"]
+mspm0h3216pt = ["mspm0-metapac/mspm0h3216pt"]
 mspm0l1105dgs20 = ["mspm0-metapac/mspm0l1105dgs20"]
 mspm0l1105dgs28 = ["mspm0-metapac/mspm0l1105dgs28"]
 mspm0l1105dyy = ["mspm0-metapac/mspm0l1105dyy"]
diff --git a/embassy-mspm0/build.rs b/embassy-mspm0/build.rs
index 93ea81ac3..4942364aa 100644
--- a/embassy-mspm0/build.rs
+++ b/embassy-mspm0/build.rs
@@ -16,14 +16,15 @@ use quote::{format_ident, quote};
 mod common;
 
 fn main() {
-    generate_code();
-    interrupt_group_linker_magic();
-}
-
-fn generate_code() {
     let mut cfgs = common::CfgSet::new();
     common::set_target_cfgs(&mut cfgs);
 
+    generate_code(&mut cfgs);
+    select_gpio_features(&mut cfgs);
+    interrupt_group_linker_magic();
+}
+
+fn generate_code(cfgs: &mut CfgSet) {
     #[cfg(any(feature = "rt"))]
     println!(
         "cargo:rustc-link-search={}",
@@ -53,9 +54,9 @@ fn generate_code() {
         cfgs.declare_all(&get_chip_cfgs(&chip));
     }
 
-    let mut singletons = get_singletons(&mut cfgs);
+    let mut singletons = get_singletons(cfgs);
 
-    time_driver(&mut singletons, &mut cfgs);
+    time_driver(&mut singletons, cfgs);
 
     let mut g = TokenStream::new();
 
@@ -68,7 +69,7 @@ fn generate_code() {
     g.extend(generate_pin_trait_impls());
     g.extend(generate_groups());
     g.extend(generate_dma_channel_count());
-    g.extend(generate_adc_constants(&mut cfgs));
+    g.extend(generate_adc_constants(cfgs));
 
     let out_dir = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
     let out_file = out_dir.join("_generated.rs").to_string_lossy().to_string();
@@ -115,6 +116,10 @@ fn get_chip_cfgs(chip_name: &str) -> Vec<String> {
         cfgs.push("mspm0g351x".to_string());
     }
 
+    if chip_name.starts_with("mspm0h321") {
+        cfgs.push("mspm0h321x".to_string());
+    }
+
     if chip_name.starts_with("mspm0l110") {
         cfgs.push("mspm0l110x".to_string());
     }
@@ -189,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;
@@ -646,6 +658,35 @@ fn generate_pin_trait_impls() -> TokenStream {
     }
 }
 
+fn select_gpio_features(cfgs: &mut CfgSet) {
+    cfgs.declare_all(&[
+        "gpioa_interrupt",
+        "gpioa_group",
+        "gpiob_interrupt",
+        "gpiob_group",
+        "gpioc_group",
+    ]);
+
+    for interrupt in METADATA.interrupts.iter() {
+        match interrupt.name {
+            "GPIOA" => cfgs.enable("gpioa_interrupt"),
+            "GPIOB" => cfgs.enable("gpiob_interrupt"),
+            _ => (),
+        }
+    }
+
+    for group in METADATA.interrupt_groups.iter() {
+        for interrupt in group.interrupts {
+            match interrupt.name {
+                "GPIOA" => cfgs.enable("gpioa_group"),
+                "GPIOB" => cfgs.enable("gpiob_group"),
+                "GPIOC" => cfgs.enable("gpioc_group"),
+                _ => (),
+            }
+        }
+    }
+}
+
 /// rustfmt a given path.
 /// Failures are logged to stderr and ignored.
 fn rustfmt(path: impl AsRef<Path>) {
diff --git a/embassy-mspm0/src/gpio.rs b/embassy-mspm0/src/gpio.rs
index a4d41aa71..d8eb42dc2 100644
--- a/embassy-mspm0/src/gpio.rs
+++ b/embassy-mspm0/src/gpio.rs
@@ -10,7 +10,7 @@ use embassy_sync::waitqueue::AtomicWaker;
 
 use crate::pac::gpio::vals::*;
 use crate::pac::gpio::{self};
-#[cfg(all(feature = "rt", any(mspm0c110x, mspm0c1105_c1106, mspm0l110x)))]
+#[cfg(all(feature = "rt", any(gpioa_interrupt, gpiob_interrupt)))]
 use crate::pac::interrupt;
 use crate::pac::{self};
 
@@ -156,7 +156,12 @@ impl<'d> Flex<'d> {
             w.set_pf(GPIO_PF);
             w.set_hiz1(true);
             w.set_pc(true);
-            w.set_inena(false);
+            w.set_inena(true);
+        });
+
+        // Enable output driver (DOE) - required for open-drain to drive low
+        self.pin.block().doeset31_0().write(|w| {
+            w.set_dio(self.pin.bit_index(), true);
         });
 
         self.set_pull(Pull::None);
@@ -1105,16 +1110,21 @@ fn irq_handler(gpio: gpio::Gpio, wakers: &[AtomicWaker; 32]) {
     }
 }
 
+#[cfg(all(gpioa_interrupt, gpioa_group))]
+compile_error!("gpioa_interrupt and gpioa_group are mutually exclusive cfgs");
+#[cfg(all(gpiob_interrupt, gpiob_group))]
+compile_error!("gpiob_interrupt and gpiob_group are mutually exclusive cfgs");
+
 // C110x and L110x have a dedicated interrupts just for GPIOA.
 //
 // These chips do not have a GROUP1 interrupt.
-#[cfg(all(feature = "rt", any(mspm0c110x, mspm0c1105_c1106, mspm0l110x)))]
+#[cfg(all(feature = "rt", gpioa_interrupt))]
 #[interrupt]
 fn GPIOA() {
     irq_handler(pac::GPIOA, &PORTA_WAKERS);
 }
 
-#[cfg(all(feature = "rt", mspm0c1105_c1106))]
+#[cfg(all(feature = "rt", gpiob_interrupt))]
 #[interrupt]
 fn GPIOB() {
     irq_handler(pac::GPIOB, &PORTB_WAKERS);
@@ -1124,21 +1134,21 @@ fn GPIOB() {
 //
 // Defining these as no_mangle is required so that the linker will pick these over the default handler.
 
-#[cfg(all(feature = "rt", not(any(mspm0c110x, mspm0c1105_c1106, mspm0l110x))))]
+#[cfg(all(feature = "rt", gpioa_group))]
 #[unsafe(no_mangle)]
 #[allow(non_snake_case)]
 fn GPIOA() {
     irq_handler(pac::GPIOA, &PORTA_WAKERS);
 }
 
-#[cfg(all(feature = "rt", gpio_pb, not(mspm0c1105_c1106)))]
+#[cfg(all(feature = "rt", gpiob_group))]
 #[unsafe(no_mangle)]
 #[allow(non_snake_case)]
 fn GPIOB() {
     irq_handler(pac::GPIOB, &PORTB_WAKERS);
 }
 
-#[cfg(all(feature = "rt", gpio_pc))]
+#[cfg(all(feature = "rt", gpioc_group))]
 #[allow(non_snake_case)]
 #[unsafe(no_mangle)]
 fn GPIOC() {
diff --git a/embassy-mspm0/src/i2c.rs b/embassy-mspm0/src/i2c.rs
index a12b4b4a2..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 {
@@ -206,10 +211,10 @@ impl Config {
     }
 
     #[cfg(any(
-        mspm0g110x, mspm0g150x, mspm0g151x, mspm0g310x, mspm0g350x, mspm0g351x, mspm0l110x, mspm0l122x, mspm0l130x,
-        mspm0l134x, mspm0l222x
+        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..7135dd9f0 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;
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-nrf/CHANGELOG.md b/embassy-nrf/CHANGELOG.md
index 0244dedab..a0668c495 100644
--- a/embassy-nrf/CHANGELOG.md
+++ b/embassy-nrf/CHANGELOG.md
@@ -7,7 +7,21 @@ 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
+- 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..f5c9a8156 100644
--- a/embassy-nrf/src/chips/nrf54l15_app.rs
+++ b/embassy-nrf/src/chips/nrf54l15_app.rs
@@ -200,13 +200,152 @@ 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,
+
+    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,
+
+    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 +388,53 @@ 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
+    CRACEN,
+
     #[cfg(feature = "_s")]
     // RRAMC
     RRAMC,
@@ -303,12 +489,170 @@ 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);
 
 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/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..4c3b92a83 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",
@@ -155,28 +151,20 @@ pub mod reset;
 #[cfg(not(feature = "_nrf54l"))] // TODO
 #[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
@@ -934,7 +922,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 +1142,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..57ec13658 100644
--- a/embassy-rp/CHANGELOG.md
+++ b/embassy-rp/CHANGELOG.md
@@ -8,6 +8,7 @@ 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
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/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/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 6e069b22d..2f27aa8b4 100644
--- a/embassy-stm32/CHANGELOG.md
+++ b/embassy-stm32/CHANGELOG.md
@@ -6,8 +6,12 @@ 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]
+
+* **Fix(stm32h5):** Prevent a HardFault crash on STM32H5 devices by changing `uid()` to return `[u8; 12]` by value instead of a reference. (Fixes #2696)
 ## Unreleased - ReleaseDate
 
+- 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,6 +35,9 @@ 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
+- change: timer: added output compare values
+- feat: timer: add ability to set master mode
+- fix: usart: fix race condition in ringbuffered usart
 
 ## 0.4.0 - 2025-08-26
 
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/timer/low_level.rs b/embassy-stm32/src/timer/low_level.rs
index ac039bb0d..82645887e 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));
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/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..14a80efe7 100644
--- a/examples/nrf54l15/Cargo.toml
+++ b/examples/nrf54l15/Cargo.toml
@@ -6,9 +6,13 @@ 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"] }
 
 defmt = "1.0.1"
 defmt-rtt = "1.0.0"
@@ -18,6 +22,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/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/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)));