rename `rp23` (?) folder to `rp235x`; fix `ci.sh` to use `rp235x` folder

51 files changed, 4231 insertions, 0 deletions

diff --git a/examples/rp235x/src/bin/adc.rs b/examples/rp235x/src/bin/adc.rs
new file mode 100644
index 000000000..b7324f755
--- /dev/null
+++ b/examples/rp235x/src/bin/adc.rs
@@ -0,0 +1,48 @@
+//! This example test the ADC (Analog to Digital Conversion) of the RP2350A pins 26, 27 and 28.
+//! It also reads the temperature sensor in the chip.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::adc::{Adc, Channel, Config, InterruptHandler};
+use embassy_rp::bind_interrupts;
+use embassy_rp::gpio::Pull;
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    ADC_IRQ_FIFO => InterruptHandler;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let mut adc = Adc::new(p.ADC, Irqs, Config::default());
+
+    let mut p26 = Channel::new_pin(p.PIN_26, Pull::None);
+    let mut p27 = Channel::new_pin(p.PIN_27, Pull::None);
+    let mut p28 = Channel::new_pin(p.PIN_28, Pull::None);
+    let mut ts = Channel::new_temp_sensor(p.ADC_TEMP_SENSOR);
+
+    loop {
+        let level = adc.read(&mut p26).await.unwrap();
+        info!("Pin 26 ADC: {}", level);
+        let level = adc.read(&mut p27).await.unwrap();
+        info!("Pin 27 ADC: {}", level);
+        let level = adc.read(&mut p28).await.unwrap();
+        info!("Pin 28 ADC: {}", level);
+        let temp = adc.read(&mut ts).await.unwrap();
+        info!("Temp: {} degrees", convert_to_celsius(temp));
+        Timer::after_secs(1).await;
+    }
+}
+
+fn convert_to_celsius(raw_temp: u16) -> f32 {
+    // According to chapter 4.9.5. Temperature Sensor in RP2040 datasheet
+    let temp = 27.0 - (raw_temp as f32 * 3.3 / 4096.0 - 0.706) / 0.001721;
+    let sign = if temp < 0.0 { -1.0 } else { 1.0 };
+    let rounded_temp_x10: i16 = ((temp * 10.0) + 0.5 * sign) as i16;
+    (rounded_temp_x10 as f32) / 10.0
+}
diff --git a/examples/rp235x/src/bin/adc_dma.rs b/examples/rp235x/src/bin/adc_dma.rs
new file mode 100644
index 000000000..f755cf5bf
--- /dev/null
+++ b/examples/rp235x/src/bin/adc_dma.rs
@@ -0,0 +1,54 @@
+//! This example shows how to use the RP2040 ADC with DMA, both single- and multichannel reads.
+//! For multichannel, the samples are interleaved in the buffer:
+//! `[ch1, ch2, ch3, ch4, ch1, ch2, ch3, ch4, ...]`
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::adc::{Adc, Channel, Config, InterruptHandler};
+use embassy_rp::bind_interrupts;
+use embassy_rp::gpio::Pull;
+use embassy_time::{Duration, Ticker};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    ADC_IRQ_FIFO => InterruptHandler;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Here we go!");
+
+    let mut adc = Adc::new(p.ADC, Irqs, Config::default());
+    let mut dma = p.DMA_CH0;
+    let mut pin = Channel::new_pin(p.PIN_26, Pull::Up);
+    let mut pins = [
+        Channel::new_pin(p.PIN_27, Pull::Down),
+        Channel::new_pin(p.PIN_28, Pull::None),
+        Channel::new_pin(p.PIN_29, Pull::Up),
+        Channel::new_temp_sensor(p.ADC_TEMP_SENSOR),
+    ];
+
+    const BLOCK_SIZE: usize = 100;
+    const NUM_CHANNELS: usize = 4;
+    let mut ticker = Ticker::every(Duration::from_secs(1));
+    loop {
+        // Read 100 samples from a single channel
+        let mut buf = [0_u16; BLOCK_SIZE];
+        let div = 479; // 100kHz sample rate (48Mhz / 100kHz - 1)
+        adc.read_many(&mut pin, &mut buf, div, &mut dma).await.unwrap();
+        info!("single: {:?} ...etc", buf[..8]);
+
+        // Read 100 samples from 4 channels interleaved
+        let mut buf = [0_u16; { BLOCK_SIZE * NUM_CHANNELS }];
+        let div = 119; // 100kHz sample rate (48Mhz / 100kHz * 4ch - 1)
+        adc.read_many_multichannel(&mut pins, &mut buf, div, &mut dma)
+            .await
+            .unwrap();
+        info!("multi:  {:?} ...etc", buf[..NUM_CHANNELS * 2]);
+
+        ticker.next().await;
+    }
+}
diff --git a/examples/rp235x/src/bin/assign_resources.rs b/examples/rp235x/src/bin/assign_resources.rs
new file mode 100644
index 000000000..ff6eff4a2
--- /dev/null
+++ b/examples/rp235x/src/bin/assign_resources.rs
@@ -0,0 +1,79 @@
+//! This example demonstrates how to assign resources to multiple tasks by splitting up the peripherals.
+//! It is not about sharing the same resources between tasks, see sharing.rs for that or head to https://embassy.dev/book/#_sharing_peripherals_between_tasks)
+//! Of course splitting up resources and sharing resources can be combined, yet this example is only about splitting up resources.
+//!
+//! There are basically two ways we demonstrate here:
+//! 1) Assigning resources to a task by passing parts of the peripherals
+//! 2) Assigning resources to a task by passing a struct with the split up peripherals, using the assign-resources macro
+//!
+//! using four LEDs on Pins 10, 11, 20 and 21
+
+#![no_std]
+#![no_main]
+
+use assign_resources::assign_resources;
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::gpio::{Level, Output};
+use embassy_rp::peripherals::{self, PIN_20, PIN_21};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    // initialize the peripherals
+    let p = embassy_rp::init(Default::default());
+
+    // 1) Assigning a resource to a task by passing parts of the peripherals.
+    spawner
+        .spawn(double_blinky_manually_assigned(spawner, p.PIN_20, p.PIN_21))
+        .unwrap();
+
+    // 2) Using the assign-resources macro to assign resources to a task.
+    // we perform the split, see further below for the definition of the resources struct
+    let r = split_resources!(p);
+    // and then we can use them
+    spawner.spawn(double_blinky_macro_assigned(spawner, r.leds)).unwrap();
+}
+
+// 1) Assigning a resource to a task by passing parts of the peripherals.
+#[embassy_executor::task]
+async fn double_blinky_manually_assigned(_spawner: Spawner, pin_20: PIN_20, pin_21: PIN_21) {
+    let mut led_20 = Output::new(pin_20, Level::Low);
+    let mut led_21 = Output::new(pin_21, Level::High);
+
+    loop {
+        info!("toggling leds");
+        led_20.toggle();
+        led_21.toggle();
+        Timer::after_secs(1).await;
+    }
+}
+
+// 2) Using the assign-resources macro to assign resources to a task.
+// first we define the resources we want to assign to the task using the assign_resources! macro
+// basically this will split up the peripherals struct into smaller structs, that we define here
+// naming is up to you, make sure your future self understands what you did here
+assign_resources! {
+    leds: Leds{
+        led_10: PIN_10,
+        led_11: PIN_11,
+    }
+    // add more resources to more structs if needed, for example defining one struct for each task
+}
+// this could be done in another file and imported here, but for the sake of simplicity we do it here
+// see https://github.com/adamgreig/assign-resources for more information
+
+// 2) Using the split resources in a task
+#[embassy_executor::task]
+async fn double_blinky_macro_assigned(_spawner: Spawner, r: Leds) {
+    let mut led_10 = Output::new(r.led_10, Level::Low);
+    let mut led_11 = Output::new(r.led_11, Level::High);
+
+    loop {
+        info!("toggling leds");
+        led_10.toggle();
+        led_11.toggle();
+        Timer::after_secs(1).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/blinky.rs b/examples/rp235x/src/bin/blinky.rs
new file mode 100644
index 000000000..2d962baca
--- /dev/null
+++ b/examples/rp235x/src/bin/blinky.rs
@@ -0,0 +1,42 @@
+//! This example test the RP Pico on board LED.
+//!
+//! It does not work with the RP Pico W board. See wifi_blinky.rs.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::gpio;
+use embassy_time::Timer;
+use gpio::{Level, Output};
+use {defmt_rtt as _, panic_probe as _};
+
+// Program metadata for `picotool info`.
+// This isn't needed, but it's recomended to have these minimal entries.
+#[link_section = ".bi_entries"]
+#[used]
+pub static PICOTOOL_ENTRIES: [embassy_rp::binary_info::EntryAddr; 4] = [
+    embassy_rp::binary_info::rp_program_name!(c"Blinky Example"),
+    embassy_rp::binary_info::rp_program_description!(
+        c"This example tests the RP Pico on board LED, connected to gpio 25"
+    ),
+    embassy_rp::binary_info::rp_cargo_version!(),
+    embassy_rp::binary_info::rp_program_build_attribute!(),
+];
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let mut led = Output::new(p.PIN_25, Level::Low);
+
+    loop {
+        info!("led on!");
+        led.set_high();
+        Timer::after_millis(250).await;
+
+        info!("led off!");
+        led.set_low();
+        Timer::after_millis(250).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/blinky_two_channels.rs b/examples/rp235x/src/bin/blinky_two_channels.rs
new file mode 100644
index 000000000..b2eec2a21
--- /dev/null
+++ b/examples/rp235x/src/bin/blinky_two_channels.rs
@@ -0,0 +1,50 @@
+#![no_std]
+#![no_main]
+/// This example demonstrates how to access a given pin from more than one embassy task
+/// The on-board LED is toggled by two tasks with slightly different periods, leading to the
+/// apparent duty cycle of the LED increasing, then decreasing, linearly. The phenomenon is similar
+/// to interference and the 'beats' you can hear if you play two frequencies close to one another
+/// [Link explaining it](https://www.physicsclassroom.com/class/sound/Lesson-3/Interference-and-Beats)
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::gpio;
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::channel::{Channel, Sender};
+use embassy_time::{Duration, Ticker};
+use gpio::{AnyPin, Level, Output};
+use {defmt_rtt as _, panic_probe as _};
+
+enum LedState {
+    Toggle,
+}
+static CHANNEL: Channel<ThreadModeRawMutex, LedState, 64> = Channel::new();
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let mut led = Output::new(AnyPin::from(p.PIN_25), Level::High);
+
+    let dt = 100 * 1_000_000;
+    let k = 1.003;
+
+    unwrap!(spawner.spawn(toggle_led(CHANNEL.sender(), Duration::from_nanos(dt))));
+    unwrap!(spawner.spawn(toggle_led(
+        CHANNEL.sender(),
+        Duration::from_nanos((dt as f64 * k) as u64)
+    )));
+
+    loop {
+        match CHANNEL.receive().await {
+            LedState::Toggle => led.toggle(),
+        }
+    }
+}
+
+#[embassy_executor::task(pool_size = 2)]
+async fn toggle_led(control: Sender<'static, ThreadModeRawMutex, LedState, 64>, delay: Duration) {
+    let mut ticker = Ticker::every(delay);
+    loop {
+        control.send(LedState::Toggle).await;
+        ticker.next().await;
+    }
+}
diff --git a/examples/rp235x/src/bin/blinky_two_tasks.rs b/examples/rp235x/src/bin/blinky_two_tasks.rs
new file mode 100644
index 000000000..a57b513d6
--- /dev/null
+++ b/examples/rp235x/src/bin/blinky_two_tasks.rs
@@ -0,0 +1,49 @@
+#![no_std]
+#![no_main]
+/// This example demonstrates how to access a given pin from more than one embassy task
+/// The on-board LED is toggled by two tasks with slightly different periods, leading to the
+/// apparent duty cycle of the LED increasing, then decreasing, linearly. The phenomenon is similar
+/// to interference and the 'beats' you can hear if you play two frequencies close to one another
+/// [Link explaining it](https://www.physicsclassroom.com/class/sound/Lesson-3/Interference-and-Beats)
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::gpio;
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_time::{Duration, Ticker};
+use gpio::{AnyPin, Level, Output};
+use {defmt_rtt as _, panic_probe as _};
+
+type LedType = Mutex<ThreadModeRawMutex, Option<Output<'static>>>;
+static LED: LedType = Mutex::new(None);
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    // set the content of the global LED reference to the real LED pin
+    let led = Output::new(AnyPin::from(p.PIN_25), Level::High);
+    // inner scope is so that once the mutex is written to, the MutexGuard is dropped, thus the
+    // Mutex is released
+    {
+        *(LED.lock().await) = Some(led);
+    }
+    let dt = 100 * 1_000_000;
+    let k = 1.003;
+
+    unwrap!(spawner.spawn(toggle_led(&LED, Duration::from_nanos(dt))));
+    unwrap!(spawner.spawn(toggle_led(&LED, Duration::from_nanos((dt as f64 * k) as u64))));
+}
+
+#[embassy_executor::task(pool_size = 2)]
+async fn toggle_led(led: &'static LedType, delay: Duration) {
+    let mut ticker = Ticker::every(delay);
+    loop {
+        {
+            let mut led_unlocked = led.lock().await;
+            if let Some(pin_ref) = led_unlocked.as_mut() {
+                pin_ref.toggle();
+            }
+        }
+        ticker.next().await;
+    }
+}
diff --git a/examples/rp235x/src/bin/button.rs b/examples/rp235x/src/bin/button.rs
new file mode 100644
index 000000000..4ad2ca3b7
--- /dev/null
+++ b/examples/rp235x/src/bin/button.rs
@@ -0,0 +1,28 @@
+//! This example uses the RP Pico on board LED to test input pin 28. This is not the button on the board.
+//!
+//! It does not work with the RP Pico W board. Use wifi_blinky.rs and add input pin.
+
+#![no_std]
+#![no_main]
+
+use embassy_executor::Spawner;
+use embassy_rp::gpio::{Input, Level, Output, Pull};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let mut led = Output::new(p.PIN_25, Level::Low);
+
+    // Use PIN_28, Pin34 on J0 for RP Pico, as a input.
+    // You need to add your own button.
+    let button = Input::new(p.PIN_28, Pull::Up);
+
+    loop {
+        if button.is_high() {
+            led.set_high();
+        } else {
+            led.set_low();
+        }
+    }
+}
diff --git a/examples/rp235x/src/bin/debounce.rs b/examples/rp235x/src/bin/debounce.rs
new file mode 100644
index 000000000..0077f19fc
--- /dev/null
+++ b/examples/rp235x/src/bin/debounce.rs
@@ -0,0 +1,80 @@
+//! This example shows the ease of debouncing a button with async rust.
+//! Hook up a button or switch between pin 9 and ground.
+
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::gpio::{Input, Level, Pull};
+use embassy_time::{with_deadline, Duration, Instant, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+pub struct Debouncer<'a> {
+    input: Input<'a>,
+    debounce: Duration,
+}
+
+impl<'a> Debouncer<'a> {
+    pub fn new(input: Input<'a>, debounce: Duration) -> Self {
+        Self { input, debounce }
+    }
+
+    pub async fn debounce(&mut self) -> Level {
+        loop {
+            let l1 = self.input.get_level();
+
+            self.input.wait_for_any_edge().await;
+
+            Timer::after(self.debounce).await;
+
+            let l2 = self.input.get_level();
+            if l1 != l2 {
+                break l2;
+            }
+        }
+    }
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let mut btn = Debouncer::new(Input::new(p.PIN_9, Pull::Up), Duration::from_millis(20));
+
+    info!("Debounce Demo");
+
+    loop {
+        // button pressed
+        btn.debounce().await;
+        let start = Instant::now();
+        info!("Button Press");
+
+        match with_deadline(start + Duration::from_secs(1), btn.debounce()).await {
+            // Button Released < 1s
+            Ok(_) => {
+                info!("Button pressed for: {}ms", start.elapsed().as_millis());
+                continue;
+            }
+            // button held for > 1s
+            Err(_) => {
+                info!("Button Held");
+            }
+        }
+
+        match with_deadline(start + Duration::from_secs(5), btn.debounce()).await {
+            // Button released <5s
+            Ok(_) => {
+                info!("Button pressed for: {}ms", start.elapsed().as_millis());
+                continue;
+            }
+            // button held for > >5s
+            Err(_) => {
+                info!("Button Long Held");
+            }
+        }
+
+        // wait for button release before handling another press
+        btn.debounce().await;
+        info!("Button pressed for: {}ms", start.elapsed().as_millis());
+    }
+}
diff --git a/examples/rp235x/src/bin/flash.rs b/examples/rp235x/src/bin/flash.rs
new file mode 100644
index 000000000..31ad4aafc
--- /dev/null
+++ b/examples/rp235x/src/bin/flash.rs
@@ -0,0 +1,125 @@
+//! This example test the flash connected to the RP2350 chip.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::flash::{Async, ERASE_SIZE, FLASH_BASE};
+use embassy_rp::peripherals::FLASH;
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+const ADDR_OFFSET: u32 = 0x100000;
+const FLASH_SIZE: usize = 2 * 1024 * 1024;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Hello World!");
+
+    // add some delay to give an attached debug probe time to parse the
+    // defmt RTT header. Reading that header might touch flash memory, which
+    // interferes with flash write operations.
+    // https://github.com/knurling-rs/defmt/pull/683
+    Timer::after_millis(10).await;
+
+    let mut flash = embassy_rp::flash::Flash::<_, Async, FLASH_SIZE>::new(p.FLASH, p.DMA_CH0);
+
+    erase_write_sector(&mut flash, 0x00);
+
+    multiwrite_bytes(&mut flash, ERASE_SIZE as u32);
+
+    background_read(&mut flash, (ERASE_SIZE * 2) as u32).await;
+
+    info!("Flash Works!");
+}
+
+fn multiwrite_bytes(flash: &mut embassy_rp::flash::Flash<'_, FLASH, Async, FLASH_SIZE>, offset: u32) {
+    info!(">>>> [multiwrite_bytes]");
+    let mut read_buf = [0u8; ERASE_SIZE];
+    defmt::unwrap!(flash.blocking_read(ADDR_OFFSET + offset, &mut read_buf));
+
+    info!("Addr of flash block is {:x}", ADDR_OFFSET + offset + FLASH_BASE as u32);
+    info!("Contents start with {=[u8]}", read_buf[0..4]);
+
+    defmt::unwrap!(flash.blocking_erase(ADDR_OFFSET + offset, ADDR_OFFSET + offset + ERASE_SIZE as u32));
+
+    defmt::unwrap!(flash.blocking_read(ADDR_OFFSET + offset, &mut read_buf));
+    info!("Contents after erase starts with {=[u8]}", read_buf[0..4]);
+    if read_buf.iter().any(|x| *x != 0xFF) {
+        defmt::panic!("unexpected");
+    }
+
+    defmt::unwrap!(flash.blocking_write(ADDR_OFFSET + offset, &[0x01]));
+    defmt::unwrap!(flash.blocking_write(ADDR_OFFSET + offset + 1, &[0x02]));
+    defmt::unwrap!(flash.blocking_write(ADDR_OFFSET + offset + 2, &[0x03]));
+    defmt::unwrap!(flash.blocking_write(ADDR_OFFSET + offset + 3, &[0x04]));
+
+    defmt::unwrap!(flash.blocking_read(ADDR_OFFSET + offset, &mut read_buf));
+    info!("Contents after write starts with {=[u8]}", read_buf[0..4]);
+    if read_buf[0..4] != [0x01, 0x02, 0x03, 0x04] {
+        defmt::panic!("unexpected");
+    }
+}
+
+fn erase_write_sector(flash: &mut embassy_rp::flash::Flash<'_, FLASH, Async, FLASH_SIZE>, offset: u32) {
+    info!(">>>> [erase_write_sector]");
+    let mut buf = [0u8; ERASE_SIZE];
+    defmt::unwrap!(flash.blocking_read(ADDR_OFFSET + offset, &mut buf));
+
+    info!("Addr of flash block is {:x}", ADDR_OFFSET + offset + FLASH_BASE as u32);
+    info!("Contents start with {=[u8]}", buf[0..4]);
+
+    defmt::unwrap!(flash.blocking_erase(ADDR_OFFSET + offset, ADDR_OFFSET + offset + ERASE_SIZE as u32));
+
+    defmt::unwrap!(flash.blocking_read(ADDR_OFFSET + offset, &mut buf));
+    info!("Contents after erase starts with {=[u8]}", buf[0..4]);
+    if buf.iter().any(|x| *x != 0xFF) {
+        defmt::panic!("unexpected");
+    }
+
+    for b in buf.iter_mut() {
+        *b = 0xDA;
+    }
+
+    defmt::unwrap!(flash.blocking_write(ADDR_OFFSET + offset, &buf));
+
+    defmt::unwrap!(flash.blocking_read(ADDR_OFFSET + offset, &mut buf));
+    info!("Contents after write starts with {=[u8]}", buf[0..4]);
+    if buf.iter().any(|x| *x != 0xDA) {
+        defmt::panic!("unexpected");
+    }
+}
+
+async fn background_read(flash: &mut embassy_rp::flash::Flash<'_, FLASH, Async, FLASH_SIZE>, offset: u32) {
+    info!(">>>> [background_read]");
+
+    let mut buf = [0u32; 8];
+    defmt::unwrap!(flash.background_read(ADDR_OFFSET + offset, &mut buf)).await;
+
+    info!("Addr of flash block is {:x}", ADDR_OFFSET + offset + FLASH_BASE as u32);
+    info!("Contents start with {=u32:x}", buf[0]);
+
+    defmt::unwrap!(flash.blocking_erase(ADDR_OFFSET + offset, ADDR_OFFSET + offset + ERASE_SIZE as u32));
+
+    defmt::unwrap!(flash.background_read(ADDR_OFFSET + offset, &mut buf)).await;
+    info!("Contents after erase starts with {=u32:x}", buf[0]);
+    if buf.iter().any(|x| *x != 0xFFFFFFFF) {
+        defmt::panic!("unexpected");
+    }
+
+    for b in buf.iter_mut() {
+        *b = 0xDABA1234;
+    }
+
+    defmt::unwrap!(flash.blocking_write(ADDR_OFFSET + offset, unsafe {
+        core::slice::from_raw_parts(buf.as_ptr() as *const u8, buf.len() * 4)
+    }));
+
+    defmt::unwrap!(flash.background_read(ADDR_OFFSET + offset, &mut buf)).await;
+    info!("Contents after write starts with {=u32:x}", buf[0]);
+    if buf.iter().any(|x| *x != 0xDABA1234) {
+        defmt::panic!("unexpected");
+    }
+}
diff --git a/examples/rp235x/src/bin/gpio_async.rs b/examples/rp235x/src/bin/gpio_async.rs
new file mode 100644
index 000000000..b79fb2a15
--- /dev/null
+++ b/examples/rp235x/src/bin/gpio_async.rs
@@ -0,0 +1,40 @@
+//! This example shows how async gpio can be used with a RP2040.
+//!
+//! The LED on the RP Pico W board is connected differently. See wifi_blinky.rs.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::gpio;
+use embassy_time::Timer;
+use gpio::{Input, Level, Output, Pull};
+use {defmt_rtt as _, panic_probe as _};
+
+/// It requires an external signal to be manually triggered on PIN 16. For
+/// example, this could be accomplished using an external power source with a
+/// button so that it is possible to toggle the signal from low to high.
+///
+/// This example will begin with turning on the LED on the board and wait for a
+/// high signal on PIN 16. Once the high event/signal occurs the program will
+/// continue and turn off the LED, and then wait for 2 seconds before completing
+/// the loop and starting over again.
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let mut led = Output::new(p.PIN_25, Level::Low);
+    let mut async_input = Input::new(p.PIN_16, Pull::None);
+
+    loop {
+        info!("wait_for_high. Turn on LED");
+        led.set_high();
+
+        async_input.wait_for_high().await;
+
+        info!("done wait_for_high. Turn off LED");
+        led.set_low();
+
+        Timer::after_secs(2).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/gpout.rs b/examples/rp235x/src/bin/gpout.rs
new file mode 100644
index 000000000..011359253
--- /dev/null
+++ b/examples/rp235x/src/bin/gpout.rs
@@ -0,0 +1,37 @@
+//! This example shows how GPOUT (General purpose clock outputs) can toggle a output pin.
+//!
+//! The LED on the RP Pico W board is connected differently. Add a LED and resistor to another pin.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::clocks;
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    let gpout3 = clocks::Gpout::new(p.PIN_25);
+    gpout3.set_div(1000, 0);
+    gpout3.enable();
+
+    loop {
+        gpout3.set_src(clocks::GpoutSrc::Sys);
+        info!(
+            "Pin 25 is now outputing CLK_SYS/1000, should be toggling at {}",
+            gpout3.get_freq()
+        );
+        Timer::after_secs(2).await;
+
+        gpout3.set_src(clocks::GpoutSrc::Ref);
+        info!(
+            "Pin 25 is now outputing CLK_REF/1000, should be toggling at {}",
+            gpout3.get_freq()
+        );
+        Timer::after_secs(2).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/i2c_async.rs b/examples/rp235x/src/bin/i2c_async.rs
new file mode 100644
index 000000000..e31cc894c
--- /dev/null
+++ b/examples/rp235x/src/bin/i2c_async.rs
@@ -0,0 +1,110 @@
+//! This example shows how to communicate asynchronous using i2c with external chips.
+//!
+//! Example written for the [`MCP23017 16-Bit I2C I/O Expander with Serial Interface`] chip.
+//! (https://www.microchip.com/en-us/product/mcp23017)
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::i2c::{self, Config, InterruptHandler};
+use embassy_rp::peripherals::I2C1;
+use embassy_time::Timer;
+use embedded_hal_async::i2c::I2c;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    I2C1_IRQ => InterruptHandler<I2C1>;
+});
+
+#[allow(dead_code)]
+mod mcp23017 {
+    pub const ADDR: u8 = 0x20; // default addr
+
+    macro_rules! mcpregs {
+        ($($name:ident : $val:expr),* $(,)?) => {
+            $(
+                pub const $name: u8 = $val;
+            )*
+
+            pub fn regname(reg: u8) -> &'static str {
+                match reg {
+                    $(
+                        $val => stringify!($name),
+                    )*
+                    _ => panic!("bad reg"),
+                }
+            }
+        }
+    }
+
+    // These are correct for IOCON.BANK=0
+    mcpregs! {
+        IODIRA: 0x00,
+        IPOLA: 0x02,
+        GPINTENA: 0x04,
+        DEFVALA: 0x06,
+        INTCONA: 0x08,
+        IOCONA: 0x0A,
+        GPPUA: 0x0C,
+        INTFA: 0x0E,
+        INTCAPA: 0x10,
+        GPIOA: 0x12,
+        OLATA: 0x14,
+        IODIRB: 0x01,
+        IPOLB: 0x03,
+        GPINTENB: 0x05,
+        DEFVALB: 0x07,
+        INTCONB: 0x09,
+        IOCONB: 0x0B,
+        GPPUB: 0x0D,
+        INTFB: 0x0F,
+        INTCAPB: 0x11,
+        GPIOB: 0x13,
+        OLATB: 0x15,
+    }
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    let sda = p.PIN_14;
+    let scl = p.PIN_15;
+
+    info!("set up i2c ");
+    let mut i2c = i2c::I2c::new_async(p.I2C1, scl, sda, Irqs, Config::default());
+
+    use mcp23017::*;
+
+    info!("init mcp23017 config for IxpandO");
+    // init - a outputs, b inputs
+    i2c.write(ADDR, &[IODIRA, 0x00]).await.unwrap();
+    i2c.write(ADDR, &[IODIRB, 0xff]).await.unwrap();
+    i2c.write(ADDR, &[GPPUB, 0xff]).await.unwrap(); // pullups
+
+    let mut val = 1;
+    loop {
+        let mut portb = [0];
+
+        i2c.write_read(mcp23017::ADDR, &[GPIOB], &mut portb).await.unwrap();
+        info!("portb = {:02x}", portb[0]);
+        i2c.write(mcp23017::ADDR, &[GPIOA, val | portb[0]]).await.unwrap();
+        val = val.rotate_left(1);
+
+        // get a register dump
+        info!("getting register dump");
+        let mut regs = [0; 22];
+        i2c.write_read(ADDR, &[0], &mut regs).await.unwrap();
+        // always get the regdump but only display it if portb'0 is set
+        if portb[0] & 1 != 0 {
+            for (idx, reg) in regs.into_iter().enumerate() {
+                info!("{} => {:02x}", regname(idx as u8), reg);
+            }
+        }
+
+        Timer::after_millis(100).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/i2c_async_embassy.rs b/examples/rp235x/src/bin/i2c_async_embassy.rs
new file mode 100644
index 000000000..a65b71b9f
--- /dev/null
+++ b/examples/rp235x/src/bin/i2c_async_embassy.rs
@@ -0,0 +1,85 @@
+//! This example shows how to communicate asynchronous using i2c with external chip.
+//!
+//! It's using embassy's functions directly instead of traits from embedded_hal_async::i2c::I2c.
+//! While most of i2c devices are addressed using 7 bits, an extension allows 10 bits too.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_rp::i2c::InterruptHandler;
+use {defmt_rtt as _, panic_probe as _};
+
+// Our anonymous hypotetical temperature sensor could be:
+// a 12-bit sensor, with 100ms startup time, range of -40*C - 125*C, and precision 0.25*C
+// It requires no configuration or calibration, works with all i2c bus speeds,
+// never stretches clock or does anything complicated. Replies with one u16.
+// It requires only one write to take it out of suspend mode, and stays on.
+// Often result would be just on 12 bits, but here we'll simplify it to 16.
+
+enum UncomplicatedSensorId {
+    A(UncomplicatedSensorU8),
+    B(UncomplicatedSensorU16),
+}
+enum UncomplicatedSensorU8 {
+    First = 0x48,
+}
+enum UncomplicatedSensorU16 {
+    Other = 0x0049,
+}
+
+impl Into<u16> for UncomplicatedSensorU16 {
+    fn into(self) -> u16 {
+        self as u16
+    }
+}
+impl Into<u16> for UncomplicatedSensorU8 {
+    fn into(self) -> u16 {
+        0x48
+    }
+}
+impl From<UncomplicatedSensorId> for u16 {
+    fn from(t: UncomplicatedSensorId) -> Self {
+        match t {
+            UncomplicatedSensorId::A(x) => x.into(),
+            UncomplicatedSensorId::B(x) => x.into(),
+        }
+    }
+}
+
+embassy_rp::bind_interrupts!(struct Irqs {
+    I2C1_IRQ => InterruptHandler<embassy_rp::peripherals::I2C1>;
+});
+
+#[embassy_executor::main]
+async fn main(_task_spawner: embassy_executor::Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let sda = p.PIN_14;
+    let scl = p.PIN_15;
+    let config = embassy_rp::i2c::Config::default();
+    let mut bus = embassy_rp::i2c::I2c::new_async(p.I2C1, scl, sda, Irqs, config);
+
+    const WAKEYWAKEY: u16 = 0xBABE;
+    let mut result: [u8; 2] = [0, 0];
+    // wait for sensors to initialize
+    embassy_time::Timer::after(embassy_time::Duration::from_millis(100)).await;
+
+    let _res_1 = bus
+        .write_async(UncomplicatedSensorU8::First, WAKEYWAKEY.to_be_bytes())
+        .await;
+    let _res_2 = bus
+        .write_async(UncomplicatedSensorU16::Other, WAKEYWAKEY.to_be_bytes())
+        .await;
+
+    loop {
+        let s1 = UncomplicatedSensorId::A(UncomplicatedSensorU8::First);
+        let s2 = UncomplicatedSensorId::B(UncomplicatedSensorU16::Other);
+        let sensors = [s1, s2];
+        for sensor in sensors {
+            if bus.read_async(sensor, &mut result).await.is_ok() {
+                info!("Result {}", u16::from_be_bytes(result.into()));
+            }
+        }
+        embassy_time::Timer::after(embassy_time::Duration::from_millis(200)).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/i2c_blocking.rs b/examples/rp235x/src/bin/i2c_blocking.rs
new file mode 100644
index 000000000..c9c8a2760
--- /dev/null
+++ b/examples/rp235x/src/bin/i2c_blocking.rs
@@ -0,0 +1,74 @@
+//! This example shows how to communicate using i2c with external chips.
+//!
+//! Example written for the [`MCP23017 16-Bit I2C I/O Expander with Serial Interface`] chip.
+//! (https://www.microchip.com/en-us/product/mcp23017)
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::i2c::{self, Config};
+use embassy_time::Timer;
+use embedded_hal_1::i2c::I2c;
+use {defmt_rtt as _, panic_probe as _};
+
+#[allow(dead_code)]
+mod mcp23017 {
+    pub const ADDR: u8 = 0x20; // default addr
+
+    pub const IODIRA: u8 = 0x00;
+    pub const IPOLA: u8 = 0x02;
+    pub const GPINTENA: u8 = 0x04;
+    pub const DEFVALA: u8 = 0x06;
+    pub const INTCONA: u8 = 0x08;
+    pub const IOCONA: u8 = 0x0A;
+    pub const GPPUA: u8 = 0x0C;
+    pub const INTFA: u8 = 0x0E;
+    pub const INTCAPA: u8 = 0x10;
+    pub const GPIOA: u8 = 0x12;
+    pub const OLATA: u8 = 0x14;
+    pub const IODIRB: u8 = 0x01;
+    pub const IPOLB: u8 = 0x03;
+    pub const GPINTENB: u8 = 0x05;
+    pub const DEFVALB: u8 = 0x07;
+    pub const INTCONB: u8 = 0x09;
+    pub const IOCONB: u8 = 0x0B;
+    pub const GPPUB: u8 = 0x0D;
+    pub const INTFB: u8 = 0x0F;
+    pub const INTCAPB: u8 = 0x11;
+    pub const GPIOB: u8 = 0x13;
+    pub const OLATB: u8 = 0x15;
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    let sda = p.PIN_14;
+    let scl = p.PIN_15;
+
+    info!("set up i2c ");
+    let mut i2c = i2c::I2c::new_blocking(p.I2C1, scl, sda, Config::default());
+
+    use mcp23017::*;
+
+    info!("init mcp23017 config for IxpandO");
+    // init - a outputs, b inputs
+    i2c.write(ADDR, &[IODIRA, 0x00]).unwrap();
+    i2c.write(ADDR, &[IODIRB, 0xff]).unwrap();
+    i2c.write(ADDR, &[GPPUB, 0xff]).unwrap(); // pullups
+
+    let mut val = 0xaa;
+    loop {
+        let mut portb = [0];
+
+        i2c.write(mcp23017::ADDR, &[GPIOA, val]).unwrap();
+        i2c.write_read(mcp23017::ADDR, &[GPIOB], &mut portb).unwrap();
+
+        info!("portb = {:02x}", portb[0]);
+        val = !val;
+
+        Timer::after_secs(1).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/i2c_slave.rs b/examples/rp235x/src/bin/i2c_slave.rs
new file mode 100644
index 000000000..9fffb4646
--- /dev/null
+++ b/examples/rp235x/src/bin/i2c_slave.rs
@@ -0,0 +1,117 @@
+//! This example shows how to use the 2040 as an i2c slave.
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::peripherals::{I2C0, I2C1};
+use embassy_rp::{bind_interrupts, i2c, i2c_slave};
+use embassy_time::Timer;
+use embedded_hal_async::i2c::I2c;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    I2C0_IRQ => i2c::InterruptHandler<I2C0>;
+    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
+});
+
+const DEV_ADDR: u8 = 0x42;
+
+#[embassy_executor::task]
+async fn device_task(mut dev: i2c_slave::I2cSlave<'static, I2C1>) -> ! {
+    info!("Device start");
+
+    let mut state = 0;
+
+    loop {
+        let mut buf = [0u8; 128];
+        match dev.listen(&mut buf).await {
+            Ok(i2c_slave::Command::GeneralCall(len)) => info!("Device received general call write: {}", buf[..len]),
+            Ok(i2c_slave::Command::Read) => loop {
+                match dev.respond_to_read(&[state]).await {
+                    Ok(x) => match x {
+                        i2c_slave::ReadStatus::Done => break,
+                        i2c_slave::ReadStatus::NeedMoreBytes => (),
+                        i2c_slave::ReadStatus::LeftoverBytes(x) => {
+                            info!("tried to write {} extra bytes", x);
+                            break;
+                        }
+                    },
+                    Err(e) => error!("error while responding {}", e),
+                }
+            },
+            Ok(i2c_slave::Command::Write(len)) => info!("Device received write: {}", buf[..len]),
+            Ok(i2c_slave::Command::WriteRead(len)) => {
+                info!("device received write read: {:x}", buf[..len]);
+                match buf[0] {
+                    // Set the state
+                    0xC2 => {
+                        state = buf[1];
+                        match dev.respond_and_fill(&[state], 0x00).await {
+                            Ok(read_status) => info!("response read status {}", read_status),
+                            Err(e) => error!("error while responding {}", e),
+                        }
+                    }
+                    // Reset State
+                    0xC8 => {
+                        state = 0;
+                        match dev.respond_and_fill(&[state], 0x00).await {
+                            Ok(read_status) => info!("response read status {}", read_status),
+                            Err(e) => error!("error while responding {}", e),
+                        }
+                    }
+                    x => error!("Invalid Write Read {:x}", x),
+                }
+            }
+            Err(e) => error!("{}", e),
+        }
+    }
+}
+
+#[embassy_executor::task]
+async fn controller_task(mut con: i2c::I2c<'static, I2C0, i2c::Async>) {
+    info!("Controller start");
+
+    loop {
+        let mut resp_buff = [0u8; 2];
+        for i in 0..10 {
+            match con.write_read(DEV_ADDR, &[0xC2, i], &mut resp_buff).await {
+                Ok(_) => info!("write_read response: {}", resp_buff),
+                Err(e) => error!("Error writing {}", e),
+            }
+
+            Timer::after_millis(100).await;
+        }
+        match con.read(DEV_ADDR, &mut resp_buff).await {
+            Ok(_) => info!("read response: {}", resp_buff),
+            Err(e) => error!("Error writing {}", e),
+        }
+        match con.write_read(DEV_ADDR, &[0xC8], &mut resp_buff).await {
+            Ok(_) => info!("write_read response: {}", resp_buff),
+            Err(e) => error!("Error writing {}", e),
+        }
+        Timer::after_millis(100).await;
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Hello World!");
+
+    let d_sda = p.PIN_3;
+    let d_scl = p.PIN_2;
+    let mut config = i2c_slave::Config::default();
+    config.addr = DEV_ADDR as u16;
+    let device = i2c_slave::I2cSlave::new(p.I2C1, d_sda, d_scl, Irqs, config);
+
+    unwrap!(spawner.spawn(device_task(device)));
+
+    let c_sda = p.PIN_1;
+    let c_scl = p.PIN_0;
+    let mut config = i2c::Config::default();
+    config.frequency = 1_000_000;
+    let controller = i2c::I2c::new_async(p.I2C0, c_sda, c_scl, Irqs, config);
+
+    unwrap!(spawner.spawn(controller_task(controller)));
+}
diff --git a/examples/rp235x/src/bin/interrupt.rs b/examples/rp235x/src/bin/interrupt.rs
new file mode 100644
index 000000000..e9ac76486
--- /dev/null
+++ b/examples/rp235x/src/bin/interrupt.rs
@@ -0,0 +1,93 @@
+//! This example shows how you can use raw interrupt handlers alongside embassy.
+//! The example also showcases some of the options available for sharing resources/data.
+//!
+//! In the example, an ADC reading is triggered every time the PWM wraps around.
+//! The sample data is sent down a channel, to be processed inside a low priority task.
+//! The processed data is then used to adjust the PWM duty cycle, once every second.
+
+#![no_std]
+#![no_main]
+
+use core::cell::{Cell, RefCell};
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::adc::{self, Adc, Blocking};
+use embassy_rp::gpio::Pull;
+use embassy_rp::interrupt;
+use embassy_rp::pwm::{Config, Pwm};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::blocking_mutex::Mutex;
+use embassy_sync::channel::Channel;
+use embassy_time::{Duration, Ticker};
+use portable_atomic::{AtomicU32, Ordering};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+static COUNTER: AtomicU32 = AtomicU32::new(0);
+static PWM: Mutex<CriticalSectionRawMutex, RefCell<Option<Pwm>>> = Mutex::new(RefCell::new(None));
+static ADC: Mutex<CriticalSectionRawMutex, RefCell<Option<(Adc<Blocking>, adc::Channel)>>> =
+    Mutex::new(RefCell::new(None));
+static ADC_VALUES: Channel<CriticalSectionRawMutex, u16, 2048> = Channel::new();
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    let adc = Adc::new_blocking(p.ADC, Default::default());
+    let p26 = adc::Channel::new_pin(p.PIN_26, Pull::None);
+    ADC.lock(|a| a.borrow_mut().replace((adc, p26)));
+
+    let pwm = Pwm::new_output_b(p.PWM_SLICE4, p.PIN_25, Default::default());
+    PWM.lock(|p| p.borrow_mut().replace(pwm));
+
+    // Enable the interrupt for pwm slice 4
+    embassy_rp::pac::PWM.irq0_inte().modify(|w| w.set_ch4(true));
+    unsafe {
+        cortex_m::peripheral::NVIC::unmask(interrupt::PWM_IRQ_WRAP_0);
+    }
+
+    // Tasks require their resources to have 'static lifetime
+    // No Mutex needed when sharing within the same executor/prio level
+    static AVG: StaticCell<Cell<u32>> = StaticCell::new();
+    let avg = AVG.init(Default::default());
+    spawner.must_spawn(processing(avg));
+
+    let mut ticker = Ticker::every(Duration::from_secs(1));
+    loop {
+        ticker.next().await;
+        let freq = COUNTER.swap(0, Ordering::Relaxed);
+        info!("pwm freq: {:?} Hz", freq);
+        info!("adc average: {:?}", avg.get());
+
+        // Update the pwm duty cycle, based on the averaged adc reading
+        let mut config = Config::default();
+        config.compare_b = ((avg.get() as f32 / 4095.0) * config.top as f32) as _;
+        PWM.lock(|p| p.borrow_mut().as_mut().unwrap().set_config(&config));
+    }
+}
+
+#[embassy_executor::task]
+async fn processing(avg: &'static Cell<u32>) {
+    let mut buffer: heapless::HistoryBuffer<u16, 100> = Default::default();
+    loop {
+        let val = ADC_VALUES.receive().await;
+        buffer.write(val);
+        let sum: u32 = buffer.iter().map(|x| *x as u32).sum();
+        avg.set(sum / buffer.len() as u32);
+    }
+}
+
+#[interrupt]
+fn PWM_IRQ_WRAP_0() {
+    critical_section::with(|cs| {
+        let mut adc = ADC.borrow(cs).borrow_mut();
+        let (adc, p26) = adc.as_mut().unwrap();
+        let val = adc.blocking_read(p26).unwrap();
+        ADC_VALUES.try_send(val).ok();
+
+        // Clear the interrupt, so we don't immediately re-enter this irq handler
+        PWM.borrow(cs).borrow_mut().as_mut().unwrap().clear_wrapped();
+    });
+    COUNTER.fetch_add(1, Ordering::Relaxed);
+}
diff --git a/examples/rp235x/src/bin/multicore.rs b/examples/rp235x/src/bin/multicore.rs
new file mode 100644
index 000000000..7cb546c91
--- /dev/null
+++ b/examples/rp235x/src/bin/multicore.rs
@@ -0,0 +1,66 @@
+//! This example shows how to send messages between the two cores in the RP2040 chip.
+//!
+//! The LED on the RP Pico W board is connected differently. See wifi_blinky.rs.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Executor;
+use embassy_rp::gpio::{Level, Output};
+use embassy_rp::multicore::{spawn_core1, Stack};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::channel::Channel;
+use embassy_time::Timer;
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+static mut CORE1_STACK: Stack<4096> = Stack::new();
+static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
+static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
+static CHANNEL: Channel<CriticalSectionRawMutex, LedState, 1> = Channel::new();
+
+enum LedState {
+    On,
+    Off,
+}
+
+#[cortex_m_rt::entry]
+fn main() -> ! {
+    let p = embassy_rp::init(Default::default());
+    let led = Output::new(p.PIN_25, Level::Low);
+
+    spawn_core1(
+        p.CORE1,
+        unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
+        move || {
+            let executor1 = EXECUTOR1.init(Executor::new());
+            executor1.run(|spawner| unwrap!(spawner.spawn(core1_task(led))));
+        },
+    );
+
+    let executor0 = EXECUTOR0.init(Executor::new());
+    executor0.run(|spawner| unwrap!(spawner.spawn(core0_task())));
+}
+
+#[embassy_executor::task]
+async fn core0_task() {
+    info!("Hello from core 0");
+    loop {
+        CHANNEL.send(LedState::On).await;
+        Timer::after_millis(100).await;
+        CHANNEL.send(LedState::Off).await;
+        Timer::after_millis(400).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn core1_task(mut led: Output<'static>) {
+    info!("Hello from core 1");
+    loop {
+        match CHANNEL.receive().await {
+            LedState::On => led.set_high(),
+            LedState::Off => led.set_low(),
+        }
+    }
+}
diff --git a/examples/rp235x/src/bin/multiprio.rs b/examples/rp235x/src/bin/multiprio.rs
new file mode 100644
index 000000000..2b397f97d
--- /dev/null
+++ b/examples/rp235x/src/bin/multiprio.rs
@@ -0,0 +1,145 @@
+//! This example showcases how to create multiple Executor instances to run tasks at
+//! different priority levels.
+//!
+//! Low priority executor runs in thread mode (not interrupt), and uses `sev` for signaling
+//! there's work in the queue, and `wfe` for waiting for work.
+//!
+//! Medium and high priority executors run in two interrupts with different priorities.
+//! Signaling work is done by pending the interrupt. No "waiting" needs to be done explicitly, since
+//! when there's work the interrupt will trigger and run the executor.
+//!
+//! Sample output below. Note that high priority ticks can interrupt everything else, and
+//! medium priority computations can interrupt low priority computations, making them to appear
+//! to take significantly longer time.
+//!
+//! ```not_rust
+//!     [med] Starting long computation
+//!     [med] done in 992 ms
+//!         [high] tick!
+//! [low] Starting long computation
+//!     [med] Starting long computation
+//!         [high] tick!
+//!         [high] tick!
+//!     [med] done in 993 ms
+//!     [med] Starting long computation
+//!         [high] tick!
+//!         [high] tick!
+//!     [med] done in 993 ms
+//! [low] done in 3972 ms
+//!     [med] Starting long computation
+//!         [high] tick!
+//!         [high] tick!
+//!     [med] done in 993 ms
+//! ```
+//!
+//! For comparison, try changing the code so all 3 tasks get spawned on the low priority executor.
+//! You will get an output like the following. Note that no computation is ever interrupted.
+//!
+//! ```not_rust
+//!         [high] tick!
+//!     [med] Starting long computation
+//!     [med] done in 496 ms
+//! [low] Starting long computation
+//! [low] done in 992 ms
+//!     [med] Starting long computation
+//!     [med] done in 496 ms
+//!         [high] tick!
+//! [low] Starting long computation
+//! [low] done in 992 ms
+//!         [high] tick!
+//!     [med] Starting long computation
+//!     [med] done in 496 ms
+//!         [high] tick!
+//! ```
+//!
+
+#![no_std]
+#![no_main]
+
+use cortex_m_rt::entry;
+use defmt::{info, unwrap};
+use embassy_executor::{Executor, InterruptExecutor};
+use embassy_rp::interrupt;
+use embassy_rp::interrupt::{InterruptExt, Priority};
+use embassy_time::{Instant, Timer, TICK_HZ};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task]
+async fn run_high() {
+    loop {
+        info!("        [high] tick!");
+        Timer::after_ticks(673740).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn run_med() {
+    loop {
+        let start = Instant::now();
+        info!("    [med] Starting long computation");
+
+        // Spin-wait to simulate a long CPU computation
+        embassy_time::block_for(embassy_time::Duration::from_secs(1)); // ~1 second
+
+        let end = Instant::now();
+        let ms = end.duration_since(start).as_ticks() * 1000 / TICK_HZ;
+        info!("    [med] done in {} ms", ms);
+
+        Timer::after_ticks(53421).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn run_low() {
+    loop {
+        let start = Instant::now();
+        info!("[low] Starting long computation");
+
+        // Spin-wait to simulate a long CPU computation
+        embassy_time::block_for(embassy_time::Duration::from_secs(2)); // ~2 seconds
+
+        let end = Instant::now();
+        let ms = end.duration_since(start).as_ticks() * 1000 / TICK_HZ;
+        info!("[low] done in {} ms", ms);
+
+        Timer::after_ticks(82983).await;
+    }
+}
+
+static EXECUTOR_HIGH: InterruptExecutor = InterruptExecutor::new();
+static EXECUTOR_MED: InterruptExecutor = InterruptExecutor::new();
+static EXECUTOR_LOW: StaticCell<Executor> = StaticCell::new();
+
+#[interrupt]
+unsafe fn SWI_IRQ_1() {
+    EXECUTOR_HIGH.on_interrupt()
+}
+
+#[interrupt]
+unsafe fn SWI_IRQ_0() {
+    EXECUTOR_MED.on_interrupt()
+}
+
+#[entry]
+fn main() -> ! {
+    info!("Hello World!");
+
+    let _p = embassy_rp::init(Default::default());
+
+    // High-priority executor: SWI_IRQ_1, priority level 2
+    interrupt::SWI_IRQ_1.set_priority(Priority::P2);
+    let spawner = EXECUTOR_HIGH.start(interrupt::SWI_IRQ_1);
+    unwrap!(spawner.spawn(run_high()));
+
+    // Medium-priority executor: SWI_IRQ_0, priority level 3
+    interrupt::SWI_IRQ_0.set_priority(Priority::P3);
+    let spawner = EXECUTOR_MED.start(interrupt::SWI_IRQ_0);
+    unwrap!(spawner.spawn(run_med()));
+
+    // Low priority executor: runs in thread mode, using WFE/SEV
+    let executor = EXECUTOR_LOW.init(Executor::new());
+    executor.run(|spawner| {
+        unwrap!(spawner.spawn(run_low()));
+    });
+}
diff --git a/examples/rp235x/src/bin/otp.rs b/examples/rp235x/src/bin/otp.rs
new file mode 100644
index 000000000..5ffbb7610
--- /dev/null
+++ b/examples/rp235x/src/bin/otp.rs
@@ -0,0 +1,31 @@
+//! This example shows reading the OTP constants on the RP235x.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::otp;
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let _ = embassy_rp::init(Default::default());
+    //
+    // add some delay to give an attached debug probe time to parse the
+    // defmt RTT header. Reading that header might touch flash memory, which
+    // interferes with flash write operations.
+    // https://github.com/knurling-rs/defmt/pull/683
+    Timer::after_millis(10).await;
+
+    let chip_id = unwrap!(otp::get_chipid());
+    info!("Unique id:{:X}", chip_id);
+
+    let private_rand = unwrap!(otp::get_private_random_number());
+    info!("Private Rand:{:X}", private_rand);
+
+    loop {
+        Timer::after_secs(1).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_async.rs b/examples/rp235x/src/bin/pio_async.rs
new file mode 100644
index 000000000..08c702347
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_async.rs
@@ -0,0 +1,131 @@
+//! This example shows powerful PIO module in the RP2040 chip.
+
+#![no_std]
+#![no_main]
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::program::pio_asm;
+use embassy_rp::pio::{Common, Config, InterruptHandler, Irq, Pio, PioPin, ShiftDirection, StateMachine};
+use fixed::traits::ToFixed;
+use fixed_macro::types::U56F8;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+fn setup_pio_task_sm0<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a, PIO0, 0>, pin: impl PioPin) {
+    // Setup sm0
+
+    // Send data serially to pin
+    let prg = pio_asm!(
+        ".origin 16",
+        "set pindirs, 1",
+        ".wrap_target",
+        "out pins,1 [19]",
+        ".wrap",
+    );
+
+    let mut cfg = Config::default();
+    cfg.use_program(&pio.load_program(&prg.program), &[]);
+    let out_pin = pio.make_pio_pin(pin);
+    cfg.set_out_pins(&[&out_pin]);
+    cfg.set_set_pins(&[&out_pin]);
+    cfg.clock_divider = (U56F8!(125_000_000) / 20 / 200).to_fixed();
+    cfg.shift_out.auto_fill = true;
+    sm.set_config(&cfg);
+}
+
+#[embassy_executor::task]
+async fn pio_task_sm0(mut sm: StateMachine<'static, PIO0, 0>) {
+    sm.set_enable(true);
+
+    let mut v = 0x0f0caffa;
+    loop {
+        sm.tx().wait_push(v).await;
+        v ^= 0xffff;
+        info!("Pushed {:032b} to FIFO", v);
+    }
+}
+
+fn setup_pio_task_sm1<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a, PIO0, 1>) {
+    // Setupm sm1
+
+    // Read 0b10101 repeatedly until ISR is full
+    let prg = pio_asm!(
+        //
+        ".origin 8",
+        "set x, 0x15",
+        ".wrap_target",
+        "in x, 5 [31]",
+        ".wrap",
+    );
+
+    let mut cfg = Config::default();
+    cfg.use_program(&pio.load_program(&prg.program), &[]);
+    cfg.clock_divider = (U56F8!(125_000_000) / 2000).to_fixed();
+    cfg.shift_in.auto_fill = true;
+    cfg.shift_in.direction = ShiftDirection::Right;
+    sm.set_config(&cfg);
+}
+
+#[embassy_executor::task]
+async fn pio_task_sm1(mut sm: StateMachine<'static, PIO0, 1>) {
+    sm.set_enable(true);
+    loop {
+        let rx = sm.rx().wait_pull().await;
+        info!("Pulled {:032b} from FIFO", rx);
+    }
+}
+
+fn setup_pio_task_sm2<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a, PIO0, 2>) {
+    // Setup sm2
+
+    // Repeatedly trigger IRQ 3
+    let prg = pio_asm!(
+        ".origin 0",
+        ".wrap_target",
+        "set x,10",
+        "delay:",
+        "jmp x-- delay [15]",
+        "irq 3 [15]",
+        ".wrap",
+    );
+    let mut cfg = Config::default();
+    cfg.use_program(&pio.load_program(&prg.program), &[]);
+    cfg.clock_divider = (U56F8!(125_000_000) / 2000).to_fixed();
+    sm.set_config(&cfg);
+}
+
+#[embassy_executor::task]
+async fn pio_task_sm2(mut irq: Irq<'static, PIO0, 3>, mut sm: StateMachine<'static, PIO0, 2>) {
+    sm.set_enable(true);
+    loop {
+        irq.wait().await;
+        info!("IRQ trigged");
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let pio = p.PIO0;
+
+    let Pio {
+        mut common,
+        irq3,
+        mut sm0,
+        mut sm1,
+        mut sm2,
+        ..
+    } = Pio::new(pio, Irqs);
+
+    setup_pio_task_sm0(&mut common, &mut sm0, p.PIN_0);
+    setup_pio_task_sm1(&mut common, &mut sm1);
+    setup_pio_task_sm2(&mut common, &mut sm2);
+    spawner.spawn(pio_task_sm0(sm0)).unwrap();
+    spawner.spawn(pio_task_sm1(sm1)).unwrap();
+    spawner.spawn(pio_task_sm2(irq3, sm2)).unwrap();
+}
diff --git a/examples/rp235x/src/bin/pio_dma.rs b/examples/rp235x/src/bin/pio_dma.rs
new file mode 100644
index 000000000..d00ed2142
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_dma.rs
@@ -0,0 +1,84 @@
+//! This example shows powerful PIO module in the RP2040 chip.
+
+#![no_std]
+#![no_main]
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::program::pio_asm;
+use embassy_rp::pio::{Config, InterruptHandler, Pio, ShiftConfig, ShiftDirection};
+use embassy_rp::{bind_interrupts, Peripheral};
+use fixed::traits::ToFixed;
+use fixed_macro::types::U56F8;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+fn swap_nibbles(v: u32) -> u32 {
+    let v = (v & 0x0f0f_0f0f) << 4 | (v & 0xf0f0_f0f0) >> 4;
+    let v = (v & 0x00ff_00ff) << 8 | (v & 0xff00_ff00) >> 8;
+    (v & 0x0000_ffff) << 16 | (v & 0xffff_0000) >> 16
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let pio = p.PIO0;
+    let Pio {
+        mut common,
+        sm0: mut sm,
+        ..
+    } = Pio::new(pio, Irqs);
+
+    let prg = pio_asm!(
+        ".origin 0",
+        "set pindirs,1",
+        ".wrap_target",
+        "set y,7",
+        "loop:",
+        "out x,4",
+        "in x,4",
+        "jmp y--, loop",
+        ".wrap",
+    );
+
+    let mut cfg = Config::default();
+    cfg.use_program(&common.load_program(&prg.program), &[]);
+    cfg.clock_divider = (U56F8!(125_000_000) / U56F8!(10_000)).to_fixed();
+    cfg.shift_in = ShiftConfig {
+        auto_fill: true,
+        threshold: 32,
+        direction: ShiftDirection::Left,
+    };
+    cfg.shift_out = ShiftConfig {
+        auto_fill: true,
+        threshold: 32,
+        direction: ShiftDirection::Right,
+    };
+
+    sm.set_config(&cfg);
+    sm.set_enable(true);
+
+    let mut dma_out_ref = p.DMA_CH0.into_ref();
+    let mut dma_in_ref = p.DMA_CH1.into_ref();
+    let mut dout = [0x12345678u32; 29];
+    for i in 1..dout.len() {
+        dout[i] = (dout[i - 1] & 0x0fff_ffff) * 13 + 7;
+    }
+    let mut din = [0u32; 29];
+    loop {
+        let (rx, tx) = sm.rx_tx();
+        join(
+            tx.dma_push(dma_out_ref.reborrow(), &dout),
+            rx.dma_pull(dma_in_ref.reborrow(), &mut din),
+        )
+        .await;
+        for i in 0..din.len() {
+            assert_eq!(din[i], swap_nibbles(dout[i]));
+        }
+        info!("Swapped {} words", dout.len());
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_hd44780.rs b/examples/rp235x/src/bin/pio_hd44780.rs
new file mode 100644
index 000000000..164e6f8d3
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_hd44780.rs
@@ -0,0 +1,87 @@
+//! This example shows powerful PIO module in the RP2040 chip to communicate with a HD44780 display.
+//! See (https://www.sparkfun.com/datasheets/LCD/HD44780.pdf)
+
+#![no_std]
+#![no_main]
+
+use core::fmt::Write;
+
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{InterruptHandler, Pio};
+use embassy_rp::pio_programs::hd44780::{PioHD44780, PioHD44780CommandSequenceProgram, PioHD44780CommandWordProgram};
+use embassy_rp::pwm::{self, Pwm};
+use embassy_time::{Instant, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(pub struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    // this test assumes a 2x16 HD44780 display attached as follow:
+    //   rs  = PIN0
+    //   rw  = PIN1
+    //   e   = PIN2
+    //   db4 = PIN3
+    //   db5 = PIN4
+    //   db6 = PIN5
+    //   db7 = PIN6
+    // additionally a pwm signal for a bias voltage charge pump is provided on pin 15,
+    // allowing direct connection of the display to the RP2040 without level shifters.
+    let p = embassy_rp::init(Default::default());
+
+    let _pwm = Pwm::new_output_b(p.PWM_SLICE7, p.PIN_15, {
+        let mut c = pwm::Config::default();
+        c.divider = 125.into();
+        c.top = 100;
+        c.compare_b = 50;
+        c
+    });
+
+    let Pio {
+        mut common, sm0, irq0, ..
+    } = Pio::new(p.PIO0, Irqs);
+
+    let word_prg = PioHD44780CommandWordProgram::new(&mut common);
+    let seq_prg = PioHD44780CommandSequenceProgram::new(&mut common);
+
+    let mut hd = PioHD44780::new(
+        &mut common,
+        sm0,
+        irq0,
+        p.DMA_CH3,
+        p.PIN_0,
+        p.PIN_1,
+        p.PIN_2,
+        p.PIN_3,
+        p.PIN_4,
+        p.PIN_5,
+        p.PIN_6,
+        &word_prg,
+        &seq_prg,
+    )
+    .await;
+
+    loop {
+        struct Buf<const N: usize>([u8; N], usize);
+        impl<const N: usize> Write for Buf<N> {
+            fn write_str(&mut self, s: &str) -> Result<(), core::fmt::Error> {
+                for b in s.as_bytes() {
+                    if self.1 >= N {
+                        return Err(core::fmt::Error);
+                    }
+                    self.0[self.1] = *b;
+                    self.1 += 1;
+                }
+                Ok(())
+            }
+        }
+        let mut buf = Buf([0; 16], 0);
+        write!(buf, "up {}s", Instant::now().as_micros() as f32 / 1e6).unwrap();
+        hd.add_line(&buf.0[0..buf.1]).await;
+        Timer::after_secs(1).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_i2s.rs b/examples/rp235x/src/bin/pio_i2s.rs
new file mode 100644
index 000000000..ae937a4ed
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_i2s.rs
@@ -0,0 +1,95 @@
+//! This example shows generating audio and sending it to a connected i2s DAC using the PIO
+//! module of the RP2040.
+//!
+//! Connect the i2s DAC as follows:
+//!   bclk : GPIO 18
+//!   lrc  : GPIO 19
+//!   din  : GPIO 20
+//! Then hold down the boot select button to trigger a rising triangle waveform.
+
+#![no_std]
+#![no_main]
+
+use core::mem;
+
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::gpio::{Input, Pull};
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{InterruptHandler, Pio};
+use embassy_rp::pio_programs::i2s::{PioI2sOut, PioI2sOutProgram};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+const SAMPLE_RATE: u32 = 48_000;
+const BIT_DEPTH: u32 = 16;
+const CHANNELS: u32 = 2;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    // Setup pio state machine for i2s output
+    let Pio { mut common, sm0, .. } = Pio::new(p.PIO0, Irqs);
+
+    let bit_clock_pin = p.PIN_18;
+    let left_right_clock_pin = p.PIN_19;
+    let data_pin = p.PIN_20;
+
+    let program = PioI2sOutProgram::new(&mut common);
+    let mut i2s = PioI2sOut::new(
+        &mut common,
+        sm0,
+        p.DMA_CH0,
+        data_pin,
+        bit_clock_pin,
+        left_right_clock_pin,
+        SAMPLE_RATE,
+        BIT_DEPTH,
+        CHANNELS,
+        &program,
+    );
+
+    let fade_input = Input::new(p.PIN_0, Pull::Up);
+
+    // create two audio buffers (back and front) which will take turns being
+    // filled with new audio data and being sent to the pio fifo using dma
+    const BUFFER_SIZE: usize = 960;
+    static DMA_BUFFER: StaticCell<[u32; BUFFER_SIZE * 2]> = StaticCell::new();
+    let dma_buffer = DMA_BUFFER.init_with(|| [0u32; BUFFER_SIZE * 2]);
+    let (mut back_buffer, mut front_buffer) = dma_buffer.split_at_mut(BUFFER_SIZE);
+
+    // start pio state machine
+    let mut fade_value: i32 = 0;
+    let mut phase: i32 = 0;
+
+    loop {
+        // trigger transfer of front buffer data to the pio fifo
+        // but don't await the returned future, yet
+        let dma_future = i2s.write(front_buffer);
+
+        // fade in audio when bootsel is pressed
+        let fade_target = if fade_input.is_low() { i32::MAX } else { 0 };
+
+        // fill back buffer with fresh audio samples before awaiting the dma future
+        for s in back_buffer.iter_mut() {
+            // exponential approach of fade_value => fade_target
+            fade_value += (fade_target - fade_value) >> 14;
+            // generate triangle wave with amplitude and frequency based on fade value
+            phase = (phase + (fade_value >> 22)) & 0xffff;
+            let triangle_sample = (phase as i16 as i32).abs() - 16384;
+            let sample = (triangle_sample * (fade_value >> 15)) >> 16;
+            // duplicate mono sample into lower and upper half of dma word
+            *s = (sample as u16 as u32) * 0x10001;
+        }
+
+        // now await the dma future. once the dma finishes, the next buffer needs to be queued
+        // within DMA_DEPTH / SAMPLE_RATE = 8 / 48000 seconds = 166us
+        dma_future.await;
+        mem::swap(&mut back_buffer, &mut front_buffer);
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_onewire.rs b/examples/rp235x/src/bin/pio_onewire.rs
new file mode 100644
index 000000000..991510851
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_onewire.rs
@@ -0,0 +1,83 @@
+//! This example shows how you can use PIO to read a `DS18B20` one-wire temperature sensor.
+
+#![no_std]
+#![no_main]
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{self, InterruptHandler, Pio};
+use embassy_rp::pio_programs::onewire::{PioOneWire, PioOneWireProgram};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let mut pio = Pio::new(p.PIO0, Irqs);
+
+    let prg = PioOneWireProgram::new(&mut pio.common);
+    let onewire = PioOneWire::new(&mut pio.common, pio.sm0, p.PIN_2, &prg);
+
+    let mut sensor = Ds18b20::new(onewire);
+
+    loop {
+        sensor.start().await; // Start a new measurement
+        Timer::after_secs(1).await; // Allow 1s for the measurement to finish
+        match sensor.temperature().await {
+            Ok(temp) => info!("temp = {:?} deg C", temp),
+            _ => error!("sensor error"),
+        }
+        Timer::after_secs(1).await;
+    }
+}
+
+/// DS18B20 temperature sensor driver
+pub struct Ds18b20<'d, PIO: pio::Instance, const SM: usize> {
+    wire: PioOneWire<'d, PIO, SM>,
+}
+
+impl<'d, PIO: pio::Instance, const SM: usize> Ds18b20<'d, PIO, SM> {
+    pub fn new(wire: PioOneWire<'d, PIO, SM>) -> Self {
+        Self { wire }
+    }
+
+    /// Calculate CRC8 of the data
+    fn crc8(data: &[u8]) -> u8 {
+        let mut temp;
+        let mut data_byte;
+        let mut crc = 0;
+        for b in data {
+            data_byte = *b;
+            for _ in 0..8 {
+                temp = (crc ^ data_byte) & 0x01;
+                crc >>= 1;
+                if temp != 0 {
+                    crc ^= 0x8C;
+                }
+                data_byte >>= 1;
+            }
+        }
+        crc
+    }
+
+    /// Start a new measurement. Allow at least 1000ms before getting `temperature`.
+    pub async fn start(&mut self) {
+        self.wire.write_bytes(&[0xCC, 0x44]).await;
+    }
+
+    /// Read the temperature. Ensure >1000ms has passed since `start` before calling this.
+    pub async fn temperature(&mut self) -> Result<f32, ()> {
+        self.wire.write_bytes(&[0xCC, 0xBE]).await;
+        let mut data = [0; 9];
+        self.wire.read_bytes(&mut data).await;
+        match Self::crc8(&data) == 0 {
+            true => Ok(((data[1] as u32) << 8 | data[0] as u32) as f32 / 16.),
+            false => Err(()),
+        }
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_pwm.rs b/examples/rp235x/src/bin/pio_pwm.rs
new file mode 100644
index 000000000..7eabb2289
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_pwm.rs
@@ -0,0 +1,38 @@
+//! This example shows how to create a pwm using the PIO module in the RP2040 chip.
+
+#![no_std]
+#![no_main]
+use core::time::Duration;
+
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{InterruptHandler, Pio};
+use embassy_rp::pio_programs::pwm::{PioPwm, PioPwmProgram};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+const REFRESH_INTERVAL: u64 = 20000;
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let Pio { mut common, sm0, .. } = Pio::new(p.PIO0, Irqs);
+
+    // Note that PIN_25 is the led pin on the Pico
+    let prg = PioPwmProgram::new(&mut common);
+    let mut pwm_pio = PioPwm::new(&mut common, sm0, p.PIN_25, &prg);
+    pwm_pio.set_period(Duration::from_micros(REFRESH_INTERVAL));
+    pwm_pio.start();
+
+    let mut duration = 0;
+    loop {
+        duration = (duration + 1) % 1000;
+        pwm_pio.write(Duration::from_micros(duration));
+        Timer::after_millis(1).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_rotary_encoder.rs b/examples/rp235x/src/bin/pio_rotary_encoder.rs
new file mode 100644
index 000000000..2750f61ae
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_rotary_encoder.rs
@@ -0,0 +1,55 @@
+//! This example shows how to use the PIO module in the RP2040 to read a quadrature rotary encoder.
+
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{InterruptHandler, Pio};
+use embassy_rp::pio_programs::rotary_encoder::{Direction, PioEncoder, PioEncoderProgram};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::task]
+async fn encoder_0(mut encoder: PioEncoder<'static, PIO0, 0>) {
+    let mut count = 0;
+    loop {
+        info!("Count: {}", count);
+        count += match encoder.read().await {
+            Direction::Clockwise => 1,
+            Direction::CounterClockwise => -1,
+        };
+    }
+}
+
+#[embassy_executor::task]
+async fn encoder_1(mut encoder: PioEncoder<'static, PIO0, 1>) {
+    let mut count = 0;
+    loop {
+        info!("Count: {}", count);
+        count += match encoder.read().await {
+            Direction::Clockwise => 1,
+            Direction::CounterClockwise => -1,
+        };
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let Pio {
+        mut common, sm0, sm1, ..
+    } = Pio::new(p.PIO0, Irqs);
+
+    let prg = PioEncoderProgram::new(&mut common);
+    let encoder0 = PioEncoder::new(&mut common, sm0, p.PIN_4, p.PIN_5, &prg);
+    let encoder1 = PioEncoder::new(&mut common, sm1, p.PIN_6, p.PIN_7, &prg);
+
+    spawner.must_spawn(encoder_0(encoder0));
+    spawner.must_spawn(encoder_1(encoder1));
+}
diff --git a/examples/rp235x/src/bin/pio_rotary_encoder_rxf.rs b/examples/rp235x/src/bin/pio_rotary_encoder_rxf.rs
new file mode 100644
index 000000000..0216c131b
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_rotary_encoder_rxf.rs
@@ -0,0 +1,112 @@
+//! This example shows how to use the PIO module in the RP235x to read a quadrature rotary encoder.
+//! It differs from the other example in that it uses the RX FIFO as a status register
+
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::gpio::Pull;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::program::pio_asm;
+use embassy_rp::{bind_interrupts, pio};
+use embassy_time::Timer;
+use fixed::traits::ToFixed;
+use pio::{Common, Config, FifoJoin, Instance, InterruptHandler, Pio, PioPin, ShiftDirection, StateMachine};
+use {defmt_rtt as _, panic_probe as _};
+
+// Program metadata for `picotool info`
+#[link_section = ".bi_entries"]
+#[used]
+pub static PICOTOOL_ENTRIES: [embassy_rp::binary_info::EntryAddr; 4] = [
+    embassy_rp::binary_info::rp_program_name!(c"example_pio_rotary_encoder_rxf"),
+    embassy_rp::binary_info::rp_cargo_version!(),
+    embassy_rp::binary_info::rp_program_description!(c"Rotary encoder (RXF)"),
+    embassy_rp::binary_info::rp_program_build_attribute!(),
+];
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+pub struct PioEncoder<'d, T: Instance, const SM: usize> {
+    sm: StateMachine<'d, T, SM>,
+}
+
+impl<'d, T: Instance, const SM: usize> PioEncoder<'d, T, SM> {
+    pub fn new(
+        pio: &mut Common<'d, T>,
+        mut sm: StateMachine<'d, T, SM>,
+        pin_a: impl PioPin,
+        pin_b: impl PioPin,
+    ) -> Self {
+        let mut pin_a = pio.make_pio_pin(pin_a);
+        let mut pin_b = pio.make_pio_pin(pin_b);
+        pin_a.set_pull(Pull::Up);
+        pin_b.set_pull(Pull::Up);
+
+        sm.set_pin_dirs(pio::Direction::In, &[&pin_a, &pin_b]);
+
+        let prg = pio_asm!(
+            "start:"
+            // encoder count is stored in X
+            "mov isr, x"
+            // and then moved to the RX FIFO register
+            "mov rxfifo[0], isr"
+
+            // wait for encoder transition
+            "wait 1 pin 1"
+            "wait 0 pin 1"
+
+            "set y, 0"
+            "mov y, pins[1]"
+
+            // update X depending on pin 1
+            "jmp !y decr"
+
+            // this is just a clever way of doing x++
+            "mov x, ~x"
+            "jmp x--, incr"
+            "incr:"
+            "mov x, ~x"
+            "jmp start"
+
+            // and this is x--
+            "decr:"
+            "jmp x--, start"
+        );
+
+        let mut cfg = Config::default();
+        cfg.set_in_pins(&[&pin_a, &pin_b]);
+        cfg.fifo_join = FifoJoin::RxAsStatus;
+        cfg.shift_in.direction = ShiftDirection::Left;
+        cfg.clock_divider = 10_000.to_fixed();
+        cfg.use_program(&pio.load_program(&prg.program), &[]);
+        sm.set_config(&cfg);
+
+        sm.set_enable(true);
+        Self { sm }
+    }
+
+    pub async fn read(&mut self) -> u32 {
+        self.sm.get_rxf_entry(0)
+    }
+}
+
+pub enum Direction {
+    Clockwise,
+    CounterClockwise,
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let Pio { mut common, sm0, .. } = Pio::new(p.PIO0, Irqs);
+
+    let mut encoder = PioEncoder::new(&mut common, sm0, p.PIN_4, p.PIN_5);
+
+    loop {
+        info!("Count: {}", encoder.read().await);
+        Timer::after_millis(1000).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_servo.rs b/examples/rp235x/src/bin/pio_servo.rs
new file mode 100644
index 000000000..c52ee7492
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_servo.rs
@@ -0,0 +1,128 @@
+//! This example shows how to create a pwm using the PIO module in the RP2040 chip.
+
+#![no_std]
+#![no_main]
+use core::time::Duration;
+
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{Instance, InterruptHandler, Pio};
+use embassy_rp::pio_programs::pwm::{PioPwm, PioPwmProgram};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+const DEFAULT_MIN_PULSE_WIDTH: u64 = 1000; // uncalibrated default, the shortest duty cycle sent to a servo
+const DEFAULT_MAX_PULSE_WIDTH: u64 = 2000; // uncalibrated default, the longest duty cycle sent to a servo
+const DEFAULT_MAX_DEGREE_ROTATION: u64 = 160; // 160 degrees is typical
+const REFRESH_INTERVAL: u64 = 20000; // The period of each cycle
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+pub struct ServoBuilder<'d, T: Instance, const SM: usize> {
+    pwm: PioPwm<'d, T, SM>,
+    period: Duration,
+    min_pulse_width: Duration,
+    max_pulse_width: Duration,
+    max_degree_rotation: u64,
+}
+
+impl<'d, T: Instance, const SM: usize> ServoBuilder<'d, T, SM> {
+    pub fn new(pwm: PioPwm<'d, T, SM>) -> Self {
+        Self {
+            pwm,
+            period: Duration::from_micros(REFRESH_INTERVAL),
+            min_pulse_width: Duration::from_micros(DEFAULT_MIN_PULSE_WIDTH),
+            max_pulse_width: Duration::from_micros(DEFAULT_MAX_PULSE_WIDTH),
+            max_degree_rotation: DEFAULT_MAX_DEGREE_ROTATION,
+        }
+    }
+
+    pub fn set_period(mut self, duration: Duration) -> Self {
+        self.period = duration;
+        self
+    }
+
+    pub fn set_min_pulse_width(mut self, duration: Duration) -> Self {
+        self.min_pulse_width = duration;
+        self
+    }
+
+    pub fn set_max_pulse_width(mut self, duration: Duration) -> Self {
+        self.max_pulse_width = duration;
+        self
+    }
+
+    pub fn set_max_degree_rotation(mut self, degree: u64) -> Self {
+        self.max_degree_rotation = degree;
+        self
+    }
+
+    pub fn build(mut self) -> Servo<'d, T, SM> {
+        self.pwm.set_period(self.period);
+        Servo {
+            pwm: self.pwm,
+            min_pulse_width: self.min_pulse_width,
+            max_pulse_width: self.max_pulse_width,
+            max_degree_rotation: self.max_degree_rotation,
+        }
+    }
+}
+
+pub struct Servo<'d, T: Instance, const SM: usize> {
+    pwm: PioPwm<'d, T, SM>,
+    min_pulse_width: Duration,
+    max_pulse_width: Duration,
+    max_degree_rotation: u64,
+}
+
+impl<'d, T: Instance, const SM: usize> Servo<'d, T, SM> {
+    pub fn start(&mut self) {
+        self.pwm.start();
+    }
+
+    pub fn stop(&mut self) {
+        self.pwm.stop();
+    }
+
+    pub fn write_time(&mut self, duration: Duration) {
+        self.pwm.write(duration);
+    }
+
+    pub fn rotate(&mut self, degree: u64) {
+        let degree_per_nano_second = (self.max_pulse_width.as_nanos() as u64 - self.min_pulse_width.as_nanos() as u64)
+            / self.max_degree_rotation;
+        let mut duration =
+            Duration::from_nanos(degree * degree_per_nano_second + self.min_pulse_width.as_nanos() as u64);
+        if self.max_pulse_width < duration {
+            duration = self.max_pulse_width;
+        }
+
+        self.pwm.write(duration);
+    }
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let Pio { mut common, sm0, .. } = Pio::new(p.PIO0, Irqs);
+
+    let prg = PioPwmProgram::new(&mut common);
+    let pwm_pio = PioPwm::new(&mut common, sm0, p.PIN_1, &prg);
+    let mut servo = ServoBuilder::new(pwm_pio)
+        .set_max_degree_rotation(120) // Example of adjusting values for MG996R servo
+        .set_min_pulse_width(Duration::from_micros(350)) // This value was detemined by a rough experiment.
+        .set_max_pulse_width(Duration::from_micros(2600)) // Along with this value.
+        .build();
+
+    servo.start();
+
+    let mut degree = 0;
+    loop {
+        degree = (degree + 1) % 120;
+        servo.rotate(degree);
+        Timer::after_millis(50).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_stepper.rs b/examples/rp235x/src/bin/pio_stepper.rs
new file mode 100644
index 000000000..3862c248b
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_stepper.rs
@@ -0,0 +1,49 @@
+//! This example shows how to use the PIO module in the RP2040 to implement a stepper motor driver
+//! for a 5-wire stepper such as the 28BYJ-48. You can halt an ongoing rotation by dropping the future.
+
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{InterruptHandler, Pio};
+use embassy_rp::pio_programs::stepper::{PioStepper, PioStepperProgram};
+use embassy_time::{with_timeout, Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let Pio {
+        mut common, irq0, sm0, ..
+    } = Pio::new(p.PIO0, Irqs);
+
+    let prg = PioStepperProgram::new(&mut common);
+    let mut stepper = PioStepper::new(&mut common, sm0, irq0, p.PIN_4, p.PIN_5, p.PIN_6, p.PIN_7, &prg);
+    stepper.set_frequency(120);
+    loop {
+        info!("CW full steps");
+        stepper.step(1000).await;
+
+        info!("CCW full steps, drop after 1 sec");
+        if with_timeout(Duration::from_secs(1), stepper.step(-i32::MAX))
+            .await
+            .is_err()
+        {
+            info!("Time's up!");
+            Timer::after(Duration::from_secs(1)).await;
+        }
+
+        info!("CW half steps");
+        stepper.step_half(1000).await;
+
+        info!("CCW half steps");
+        stepper.step_half(-1000).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_uart.rs b/examples/rp235x/src/bin/pio_uart.rs
new file mode 100644
index 000000000..9712984f9
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_uart.rs
@@ -0,0 +1,190 @@
+//! This example shows how to use the PIO module in the RP2040 chip to implement a duplex UART.
+//! The PIO module is a very powerful peripheral that can be used to implement many different
+//! protocols. It is a very flexible state machine that can be programmed to do almost anything.
+//!
+//! This example opens up a USB device that implements a CDC ACM serial port. It then uses the
+//! PIO module to implement a UART that is connected to the USB serial port. This allows you to
+//! communicate with a device connected to the RP2040 over USB serial.
+
+#![no_std]
+#![no_main]
+#![allow(async_fn_in_trait)]
+
+use defmt::{info, panic, trace};
+use embassy_executor::Spawner;
+use embassy_futures::join::{join, join3};
+use embassy_rp::peripherals::{PIO0, USB};
+use embassy_rp::pio_programs::uart::{PioUartRx, PioUartRxProgram, PioUartTx, PioUartTxProgram};
+use embassy_rp::usb::{Driver, Instance, InterruptHandler};
+use embassy_rp::{bind_interrupts, pio};
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::pipe::Pipe;
+use embassy_usb::class::cdc_acm::{CdcAcmClass, Receiver, Sender, State};
+use embassy_usb::driver::EndpointError;
+use embassy_usb::{Builder, Config};
+use embedded_io_async::{Read, Write};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    USBCTRL_IRQ => InterruptHandler<USB>;
+    PIO0_IRQ_0 => pio::InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    info!("Hello there!");
+
+    let p = embassy_rp::init(Default::default());
+
+    // Create the driver, from the HAL.
+    let driver = Driver::new(p.USB, Irqs);
+
+    // Create embassy-usb Config
+    let mut config = Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("PIO UART example");
+    config.serial_number = Some("12345678");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    // Create embassy-usb DeviceBuilder using the driver and config.
+    // It needs some buffers for building the descriptors.
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 256];
+    let mut control_buf = [0; 64];
+
+    let mut state = State::new();
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut [], // no msos descriptors
+        &mut control_buf,
+    );
+
+    // Create classes on the builder.
+    let class = CdcAcmClass::new(&mut builder, &mut state, 64);
+
+    // Build the builder.
+    let mut usb = builder.build();
+
+    // Run the USB device.
+    let usb_fut = usb.run();
+
+    // PIO UART setup
+    let pio::Pio {
+        mut common, sm0, sm1, ..
+    } = pio::Pio::new(p.PIO0, Irqs);
+
+    let tx_program = PioUartTxProgram::new(&mut common);
+    let mut uart_tx = PioUartTx::new(9600, &mut common, sm0, p.PIN_4, &tx_program);
+
+    let rx_program = PioUartRxProgram::new(&mut common);
+    let mut uart_rx = PioUartRx::new(9600, &mut common, sm1, p.PIN_5, &rx_program);
+
+    // Pipe setup
+    let mut usb_pipe: Pipe<NoopRawMutex, 20> = Pipe::new();
+    let (mut usb_pipe_reader, mut usb_pipe_writer) = usb_pipe.split();
+
+    let mut uart_pipe: Pipe<NoopRawMutex, 20> = Pipe::new();
+    let (mut uart_pipe_reader, mut uart_pipe_writer) = uart_pipe.split();
+
+    let (mut usb_tx, mut usb_rx) = class.split();
+
+    // Read + write from USB
+    let usb_future = async {
+        loop {
+            info!("Wait for USB connection");
+            usb_rx.wait_connection().await;
+            info!("Connected");
+            let _ = join(
+                usb_read(&mut usb_rx, &mut uart_pipe_writer),
+                usb_write(&mut usb_tx, &mut usb_pipe_reader),
+            )
+            .await;
+            info!("Disconnected");
+        }
+    };
+
+    // Read + write from UART
+    let uart_future = join(
+        uart_read(&mut uart_rx, &mut usb_pipe_writer),
+        uart_write(&mut uart_tx, &mut uart_pipe_reader),
+    );
+
+    // Run everything concurrently.
+    // If we had made everything `'static` above instead, we could do this using separate tasks instead.
+    join3(usb_fut, usb_future, uart_future).await;
+}
+
+struct Disconnected {}
+
+impl From<EndpointError> for Disconnected {
+    fn from(val: EndpointError) -> Self {
+        match val {
+            EndpointError::BufferOverflow => panic!("Buffer overflow"),
+            EndpointError::Disabled => Disconnected {},
+        }
+    }
+}
+
+/// Read from the USB and write it to the UART TX pipe
+async fn usb_read<'d, T: Instance + 'd>(
+    usb_rx: &mut Receiver<'d, Driver<'d, T>>,
+    uart_pipe_writer: &mut embassy_sync::pipe::Writer<'_, NoopRawMutex, 20>,
+) -> Result<(), Disconnected> {
+    let mut buf = [0; 64];
+    loop {
+        let n = usb_rx.read_packet(&mut buf).await?;
+        let data = &buf[..n];
+        trace!("USB IN: {:x}", data);
+        (*uart_pipe_writer).write(data).await;
+    }
+}
+
+/// Read from the USB TX pipe and write it to the USB
+async fn usb_write<'d, T: Instance + 'd>(
+    usb_tx: &mut Sender<'d, Driver<'d, T>>,
+    usb_pipe_reader: &mut embassy_sync::pipe::Reader<'_, NoopRawMutex, 20>,
+) -> Result<(), Disconnected> {
+    let mut buf = [0; 64];
+    loop {
+        let n = (*usb_pipe_reader).read(&mut buf).await;
+        let data = &buf[..n];
+        trace!("USB OUT: {:x}", data);
+        usb_tx.write_packet(&data).await?;
+    }
+}
+
+/// Read from the UART and write it to the USB TX pipe
+async fn uart_read<PIO: pio::Instance, const SM: usize>(
+    uart_rx: &mut PioUartRx<'_, PIO, SM>,
+    usb_pipe_writer: &mut embassy_sync::pipe::Writer<'_, NoopRawMutex, 20>,
+) -> ! {
+    let mut buf = [0; 64];
+    loop {
+        let n = uart_rx.read(&mut buf).await.expect("UART read error");
+        if n == 0 {
+            continue;
+        }
+        let data = &buf[..n];
+        trace!("UART IN: {:x}", buf);
+        (*usb_pipe_writer).write(data).await;
+    }
+}
+
+/// Read from the UART TX pipe and write it to the UART
+async fn uart_write<PIO: pio::Instance, const SM: usize>(
+    uart_tx: &mut PioUartTx<'_, PIO, SM>,
+    uart_pipe_reader: &mut embassy_sync::pipe::Reader<'_, NoopRawMutex, 20>,
+) -> ! {
+    let mut buf = [0; 64];
+    loop {
+        let n = (*uart_pipe_reader).read(&mut buf).await;
+        let data = &buf[..n];
+        trace!("UART OUT: {:x}", data);
+        let _ = uart_tx.write(&data).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pio_ws2812.rs b/examples/rp235x/src/bin/pio_ws2812.rs
new file mode 100644
index 000000000..d1fcfc471
--- /dev/null
+++ b/examples/rp235x/src/bin/pio_ws2812.rs
@@ -0,0 +1,68 @@
+//! This example shows powerful PIO module in the RP2040 chip to communicate with WS2812 LED modules.
+//! See (https://www.sparkfun.com/categories/tags/ws2812)
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::PIO0;
+use embassy_rp::pio::{InterruptHandler, Pio};
+use embassy_rp::pio_programs::ws2812::{PioWs2812, PioWs2812Program};
+use embassy_time::{Duration, Ticker};
+use smart_leds::RGB8;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+/// Input a value 0 to 255 to get a color value
+/// The colours are a transition r - g - b - back to r.
+fn wheel(mut wheel_pos: u8) -> RGB8 {
+    wheel_pos = 255 - wheel_pos;
+    if wheel_pos < 85 {
+        return (255 - wheel_pos * 3, 0, wheel_pos * 3).into();
+    }
+    if wheel_pos < 170 {
+        wheel_pos -= 85;
+        return (0, wheel_pos * 3, 255 - wheel_pos * 3).into();
+    }
+    wheel_pos -= 170;
+    (wheel_pos * 3, 255 - wheel_pos * 3, 0).into()
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    info!("Start");
+    let p = embassy_rp::init(Default::default());
+
+    let Pio { mut common, sm0, .. } = Pio::new(p.PIO0, Irqs);
+
+    // This is the number of leds in the string. Helpfully, the sparkfun thing plus and adafruit
+    // feather boards for the 2040 both have one built in.
+    const NUM_LEDS: usize = 1;
+    let mut data = [RGB8::default(); NUM_LEDS];
+
+    // Common neopixel pins:
+    // Thing plus: 8
+    // Adafruit Feather: 16;  Adafruit Feather+RFM95: 4
+    let program = PioWs2812Program::new(&mut common);
+    let mut ws2812 = PioWs2812::new(&mut common, sm0, p.DMA_CH0, p.PIN_16, &program);
+
+    // Loop forever making RGB values and pushing them out to the WS2812.
+    let mut ticker = Ticker::every(Duration::from_millis(10));
+    loop {
+        for j in 0..(256 * 5) {
+            debug!("New Colors:");
+            for i in 0..NUM_LEDS {
+                data[i] = wheel((((i * 256) as u16 / NUM_LEDS as u16 + j as u16) & 255) as u8);
+                debug!("R: {} G: {} B: {}", data[i].r, data[i].g, data[i].b);
+            }
+            ws2812.write(&data).await;
+
+            ticker.next().await;
+        }
+    }
+}
diff --git a/examples/rp235x/src/bin/pwm.rs b/examples/rp235x/src/bin/pwm.rs
new file mode 100644
index 000000000..a3c0f7e49
--- /dev/null
+++ b/examples/rp235x/src/bin/pwm.rs
@@ -0,0 +1,79 @@
+//! This example shows how to use PWM (Pulse Width Modulation) in the RP235x chip.
+//!
+//! We demonstrate two ways of using PWM:
+//! 1. Via config
+//! 2. Via setting a duty cycle
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::peripherals::{PIN_25, PIN_4, PWM_SLICE2, PWM_SLICE4};
+use embassy_rp::pwm::{Config, Pwm, SetDutyCycle};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    spawner.spawn(pwm_set_config(p.PWM_SLICE4, p.PIN_25)).unwrap();
+    spawner.spawn(pwm_set_dutycycle(p.PWM_SLICE2, p.PIN_4)).unwrap();
+}
+
+/// Demonstrate PWM by modifying & applying the config
+///
+/// Using the onboard led, if You are using a different Board than plain Pico2 (i.e. W variant)
+/// you must use another slice & pin and an appropriate resistor.
+#[embassy_executor::task]
+async fn pwm_set_config(slice4: PWM_SLICE4, pin25: PIN_25) {
+    let mut c = Config::default();
+    c.top = 32_768;
+    c.compare_b = 8;
+    let mut pwm = Pwm::new_output_b(slice4, pin25, c.clone());
+
+    loop {
+        info!("current LED duty cycle: {}/32768", c.compare_b);
+        Timer::after_secs(1).await;
+        c.compare_b = c.compare_b.rotate_left(4);
+        pwm.set_config(&c);
+    }
+}
+
+/// Demonstrate PWM by setting duty cycle
+///
+/// Using GP4 in Slice2, make sure to use an appropriate resistor.
+#[embassy_executor::task]
+async fn pwm_set_dutycycle(slice2: PWM_SLICE2, pin4: PIN_4) {
+    // If we aim for a specific frequency, here is how we can calculate the top value.
+    // The top value sets the period of the PWM cycle, so a counter goes from 0 to top and then wraps around to 0.
+    // Every such wraparound is one PWM cycle. So here is how we get 25KHz:
+    let desired_freq_hz = 25_000;
+    let clock_freq_hz = embassy_rp::clocks::clk_sys_freq();
+    let divider = 16u8;
+    let period = (clock_freq_hz / (desired_freq_hz * divider as u32)) as u16 - 1;
+
+    let mut c = Config::default();
+    c.top = period;
+    c.divider = divider.into();
+
+    let mut pwm = Pwm::new_output_a(slice2, pin4, c.clone());
+
+    loop {
+        // 100% duty cycle, fully on
+        pwm.set_duty_cycle_fully_on().unwrap();
+        Timer::after_secs(1).await;
+
+        // 66% duty cycle. Expressed as simple percentage.
+        pwm.set_duty_cycle_percent(66).unwrap();
+        Timer::after_secs(1).await;
+
+        // 25% duty cycle. Expressed as 32768/4 = 8192.
+        pwm.set_duty_cycle(c.top / 4).unwrap();
+        Timer::after_secs(1).await;
+
+        // 0% duty cycle, fully off.
+        pwm.set_duty_cycle_fully_off().unwrap();
+        Timer::after_secs(1).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pwm_input.rs b/examples/rp235x/src/bin/pwm_input.rs
new file mode 100644
index 000000000..bf454a936
--- /dev/null
+++ b/examples/rp235x/src/bin/pwm_input.rs
@@ -0,0 +1,26 @@
+//! This example shows how to use the PWM module to measure the frequency of an input signal.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::gpio::Pull;
+use embassy_rp::pwm::{Config, InputMode, Pwm};
+use embassy_time::{Duration, Ticker};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    let cfg: Config = Default::default();
+    let pwm = Pwm::new_input(p.PWM_SLICE2, p.PIN_5, Pull::None, InputMode::RisingEdge, cfg);
+
+    let mut ticker = Ticker::every(Duration::from_secs(1));
+    loop {
+        info!("Input frequency: {} Hz", pwm.counter());
+        pwm.set_counter(0);
+        ticker.next().await;
+    }
+}
diff --git a/examples/rp235x/src/bin/pwm_tb6612fng_motor_driver.rs b/examples/rp235x/src/bin/pwm_tb6612fng_motor_driver.rs
new file mode 100644
index 000000000..3b700884c
--- /dev/null
+++ b/examples/rp235x/src/bin/pwm_tb6612fng_motor_driver.rs
@@ -0,0 +1,105 @@
+//! # PWM TB6612FNG motor driver
+//!
+//! This example shows the use of a TB6612FNG motor driver. The driver is built on top of embedded_hal and the example demonstrates how embassy_rp can be used to interact with ist.
+
+#![no_std]
+#![no_main]
+
+use assign_resources::assign_resources;
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::config::Config;
+use embassy_rp::gpio::Output;
+use embassy_rp::{gpio, peripherals, pwm};
+use embassy_time::{Duration, Timer};
+use tb6612fng::{DriveCommand, Motor, Tb6612fng};
+use {defmt_rtt as _, panic_probe as _};
+
+assign_resources! {
+    motor: MotorResources {
+        standby_pin: PIN_22,
+        left_slice: PWM_SLICE6,
+        left_pwm_pin: PIN_28,
+        left_forward_pin: PIN_21,
+        left_backward_pin: PIN_20,
+        right_slice: PWM_SLICE5,
+        right_pwm_pin: PIN_27,
+        right_forward_pin: PIN_19,
+        right_backward_pin: PIN_18,
+        },
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Config::default());
+    let s = split_resources!(p);
+    let r = s.motor;
+
+    // we want a PWM frequency of 10KHz, especially cheaper motors do not respond well to higher frequencies
+    let desired_freq_hz = 10_000;
+    let clock_freq_hz = embassy_rp::clocks::clk_sys_freq();
+    let divider = 16u8;
+    let period = (clock_freq_hz / (desired_freq_hz * divider as u32)) as u16 - 1;
+
+    // we need a standby output and two motors to construct a full TB6612FNG
+
+    // standby pin
+    let stby = Output::new(r.standby_pin, gpio::Level::Low);
+
+    // motor A, here defined to be the left motor
+    let left_fwd = gpio::Output::new(r.left_forward_pin, gpio::Level::Low);
+    let left_bckw = gpio::Output::new(r.left_backward_pin, gpio::Level::Low);
+    let mut left_speed = pwm::Config::default();
+    left_speed.top = period;
+    left_speed.divider = divider.into();
+    let left_pwm = pwm::Pwm::new_output_a(r.left_slice, r.left_pwm_pin, left_speed);
+    let left_motor = Motor::new(left_fwd, left_bckw, left_pwm).unwrap();
+
+    // motor B, here defined to be the right motor
+    let right_fwd = gpio::Output::new(r.right_forward_pin, gpio::Level::Low);
+    let right_bckw = gpio::Output::new(r.right_backward_pin, gpio::Level::Low);
+    let mut right_speed = pwm::Config::default();
+    right_speed.top = period;
+    right_speed.divider = divider.into();
+    let right_pwm = pwm::Pwm::new_output_b(r.right_slice, r.right_pwm_pin, right_speed);
+    let right_motor = Motor::new(right_fwd, right_bckw, right_pwm).unwrap();
+
+    // construct the motor driver
+    let mut control = Tb6612fng::new(left_motor, right_motor, stby).unwrap();
+
+    loop {
+        // wake up the motor driver
+        info!("end standby");
+        control.disable_standby().unwrap();
+        Timer::after(Duration::from_millis(100)).await;
+
+        // drive a straight line forward at 20% speed for 5s
+        info!("drive straight");
+        control.motor_a.drive(DriveCommand::Forward(80)).unwrap();
+        control.motor_b.drive(DriveCommand::Forward(80)).unwrap();
+        Timer::after(Duration::from_secs(5)).await;
+
+        // coast for 2s
+        info!("coast");
+        control.motor_a.drive(DriveCommand::Stop).unwrap();
+        control.motor_b.drive(DriveCommand::Stop).unwrap();
+        Timer::after(Duration::from_secs(2)).await;
+
+        // actively brake
+        info!("brake");
+        control.motor_a.drive(DriveCommand::Brake).unwrap();
+        control.motor_b.drive(DriveCommand::Brake).unwrap();
+        Timer::after(Duration::from_secs(1)).await;
+
+        // slowly turn for 3s
+        info!("turn");
+        control.motor_a.drive(DriveCommand::Backward(50)).unwrap();
+        control.motor_b.drive(DriveCommand::Forward(50)).unwrap();
+        Timer::after(Duration::from_secs(3)).await;
+
+        // and put the driver in standby mode and wait for 5s
+        info!("standby");
+        control.enable_standby().unwrap();
+        Timer::after(Duration::from_secs(5)).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/rosc.rs b/examples/rp235x/src/bin/rosc.rs
new file mode 100644
index 000000000..942b72319
--- /dev/null
+++ b/examples/rp235x/src/bin/rosc.rs
@@ -0,0 +1,31 @@
+//! This example test the RP Pico on board LED.
+//!
+//! It does not work with the RP Pico W board. See wifi_blinky.rs.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::{clocks, gpio};
+use embassy_time::Timer;
+use gpio::{Level, Output};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut config = embassy_rp::config::Config::default();
+    config.clocks = clocks::ClockConfig::rosc();
+    let p = embassy_rp::init(config);
+    let mut led = Output::new(p.PIN_25, Level::Low);
+
+    loop {
+        info!("led on!");
+        led.set_high();
+        Timer::after_secs(1).await;
+
+        info!("led off!");
+        led.set_low();
+        Timer::after_secs(1).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/shared_bus.rs b/examples/rp235x/src/bin/shared_bus.rs
new file mode 100644
index 000000000..c6cb5d64c
--- /dev/null
+++ b/examples/rp235x/src/bin/shared_bus.rs
@@ -0,0 +1,115 @@
+//! This example shows how to share (async) I2C and SPI buses between multiple devices.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_embedded_hal::shared_bus::asynch::i2c::I2cDevice;
+use embassy_embedded_hal::shared_bus::asynch::spi::SpiDevice;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::gpio::{AnyPin, Level, Output};
+use embassy_rp::i2c::{self, I2c, InterruptHandler};
+use embassy_rp::peripherals::{I2C1, SPI1};
+use embassy_rp::spi::{self, Spi};
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_time::Timer;
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+type Spi1Bus = Mutex<NoopRawMutex, Spi<'static, SPI1, spi::Async>>;
+type I2c1Bus = Mutex<NoopRawMutex, I2c<'static, I2C1, i2c::Async>>;
+
+bind_interrupts!(struct Irqs {
+    I2C1_IRQ => InterruptHandler<I2C1>;
+});
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Here we go!");
+
+    // Shared I2C bus
+    let i2c = I2c::new_async(p.I2C1, p.PIN_15, p.PIN_14, Irqs, i2c::Config::default());
+    static I2C_BUS: StaticCell<I2c1Bus> = StaticCell::new();
+    let i2c_bus = I2C_BUS.init(Mutex::new(i2c));
+
+    spawner.must_spawn(i2c_task_a(i2c_bus));
+    spawner.must_spawn(i2c_task_b(i2c_bus));
+
+    // Shared SPI bus
+    let spi_cfg = spi::Config::default();
+    let spi = Spi::new(p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, p.DMA_CH0, p.DMA_CH1, spi_cfg);
+    static SPI_BUS: StaticCell<Spi1Bus> = StaticCell::new();
+    let spi_bus = SPI_BUS.init(Mutex::new(spi));
+
+    // Chip select pins for the SPI devices
+    let cs_a = Output::new(AnyPin::from(p.PIN_0), Level::High);
+    let cs_b = Output::new(AnyPin::from(p.PIN_1), Level::High);
+
+    spawner.must_spawn(spi_task_a(spi_bus, cs_a));
+    spawner.must_spawn(spi_task_b(spi_bus, cs_b));
+}
+
+#[embassy_executor::task]
+async fn i2c_task_a(i2c_bus: &'static I2c1Bus) {
+    let i2c_dev = I2cDevice::new(i2c_bus);
+    let _sensor = DummyI2cDeviceDriver::new(i2c_dev, 0xC0);
+    loop {
+        info!("i2c task A");
+        Timer::after_secs(1).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn i2c_task_b(i2c_bus: &'static I2c1Bus) {
+    let i2c_dev = I2cDevice::new(i2c_bus);
+    let _sensor = DummyI2cDeviceDriver::new(i2c_dev, 0xDE);
+    loop {
+        info!("i2c task B");
+        Timer::after_secs(1).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn spi_task_a(spi_bus: &'static Spi1Bus, cs: Output<'static>) {
+    let spi_dev = SpiDevice::new(spi_bus, cs);
+    let _sensor = DummySpiDeviceDriver::new(spi_dev);
+    loop {
+        info!("spi task A");
+        Timer::after_secs(1).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn spi_task_b(spi_bus: &'static Spi1Bus, cs: Output<'static>) {
+    let spi_dev = SpiDevice::new(spi_bus, cs);
+    let _sensor = DummySpiDeviceDriver::new(spi_dev);
+    loop {
+        info!("spi task B");
+        Timer::after_secs(1).await;
+    }
+}
+
+// Dummy I2C device driver, using `embedded-hal-async`
+struct DummyI2cDeviceDriver<I2C: embedded_hal_async::i2c::I2c> {
+    _i2c: I2C,
+}
+
+impl<I2C: embedded_hal_async::i2c::I2c> DummyI2cDeviceDriver<I2C> {
+    fn new(i2c_dev: I2C, _address: u8) -> Self {
+        Self { _i2c: i2c_dev }
+    }
+}
+
+// Dummy SPI device driver, using `embedded-hal-async`
+struct DummySpiDeviceDriver<SPI: embedded_hal_async::spi::SpiDevice> {
+    _spi: SPI,
+}
+
+impl<SPI: embedded_hal_async::spi::SpiDevice> DummySpiDeviceDriver<SPI> {
+    fn new(spi_dev: SPI) -> Self {
+        Self { _spi: spi_dev }
+    }
+}
diff --git a/examples/rp235x/src/bin/sharing.rs b/examples/rp235x/src/bin/sharing.rs
new file mode 100644
index 000000000..5416e20ce
--- /dev/null
+++ b/examples/rp235x/src/bin/sharing.rs
@@ -0,0 +1,150 @@
+//! This example shows some common strategies for sharing resources between tasks.
+//!
+//! We demonstrate five different ways of sharing, covering different use cases:
+//! - Atomics: This method is used for simple values, such as bool and u8..u32
+//! - Blocking Mutex: This is used for sharing non-async things, using Cell/RefCell for interior mutability.
+//! - Async Mutex: This is used for sharing async resources, where you need to hold the lock across await points.
+//!   The async Mutex has interior mutability built-in, so no RefCell is needed.
+//! - Cell: For sharing Copy types between tasks running on the same executor.
+//! - RefCell: When you want &mut access to a value shared between tasks running on the same executor.
+//!
+//! More information: https://embassy.dev/book/#_sharing_peripherals_between_tasks
+
+#![no_std]
+#![no_main]
+
+use core::cell::{Cell, RefCell};
+use core::sync::atomic::{AtomicU32, Ordering};
+
+use cortex_m_rt::entry;
+use defmt::info;
+use embassy_executor::{Executor, InterruptExecutor};
+use embassy_rp::clocks::RoscRng;
+use embassy_rp::interrupt::{InterruptExt, Priority};
+use embassy_rp::peripherals::UART0;
+use embassy_rp::uart::{self, InterruptHandler, UartTx};
+use embassy_rp::{bind_interrupts, interrupt};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::{blocking_mutex, mutex};
+use embassy_time::{Duration, Ticker};
+use rand::RngCore;
+use static_cell::{ConstStaticCell, StaticCell};
+use {defmt_rtt as _, panic_probe as _};
+
+type UartAsyncMutex = mutex::Mutex<CriticalSectionRawMutex, UartTx<'static, UART0, uart::Async>>;
+
+struct MyType {
+    inner: u32,
+}
+
+static EXECUTOR_HI: InterruptExecutor = InterruptExecutor::new();
+static EXECUTOR_LOW: StaticCell<Executor> = StaticCell::new();
+
+// Use Atomics for simple values
+static ATOMIC: AtomicU32 = AtomicU32::new(0);
+
+// Use blocking Mutex with Cell/RefCell for sharing non-async things
+static MUTEX_BLOCKING: blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<MyType>> =
+    blocking_mutex::Mutex::new(RefCell::new(MyType { inner: 0 }));
+
+bind_interrupts!(struct Irqs {
+    UART0_IRQ => InterruptHandler<UART0>;
+});
+
+#[interrupt]
+unsafe fn SWI_IRQ_0() {
+    EXECUTOR_HI.on_interrupt()
+}
+
+#[entry]
+fn main() -> ! {
+    let p = embassy_rp::init(Default::default());
+    info!("Here we go!");
+
+    let uart = UartTx::new(p.UART0, p.PIN_0, p.DMA_CH0, uart::Config::default());
+    // Use the async Mutex for sharing async things (built-in interior mutability)
+    static UART: StaticCell<UartAsyncMutex> = StaticCell::new();
+    let uart = UART.init(mutex::Mutex::new(uart));
+
+    // High-priority executor: runs in interrupt mode
+    interrupt::SWI_IRQ_0.set_priority(Priority::P3);
+    let spawner = EXECUTOR_HI.start(interrupt::SWI_IRQ_0);
+    spawner.must_spawn(task_a(uart));
+
+    // Low priority executor: runs in thread mode
+    let executor = EXECUTOR_LOW.init(Executor::new());
+    executor.run(|spawner| {
+        // No Mutex needed when sharing between tasks running on the same executor
+
+        // Use Cell for Copy-types
+        static CELL: ConstStaticCell<Cell<[u8; 4]>> = ConstStaticCell::new(Cell::new([0; 4]));
+        let cell = CELL.take();
+
+        // Use RefCell for &mut access
+        static REF_CELL: ConstStaticCell<RefCell<MyType>> = ConstStaticCell::new(RefCell::new(MyType { inner: 0 }));
+        let ref_cell = REF_CELL.take();
+
+        spawner.must_spawn(task_b(uart, cell, ref_cell));
+        spawner.must_spawn(task_c(cell, ref_cell));
+    });
+}
+
+#[embassy_executor::task]
+async fn task_a(uart: &'static UartAsyncMutex) {
+    let mut ticker = Ticker::every(Duration::from_secs(1));
+    loop {
+        let random = RoscRng.next_u32();
+
+        {
+            let mut uart = uart.lock().await;
+            uart.write(b"task a").await.unwrap();
+            // The uart lock is released when it goes out of scope
+        }
+
+        ATOMIC.store(random, Ordering::Relaxed);
+
+        MUTEX_BLOCKING.lock(|x| x.borrow_mut().inner = random);
+
+        ticker.next().await;
+    }
+}
+
+#[embassy_executor::task]
+async fn task_b(uart: &'static UartAsyncMutex, cell: &'static Cell<[u8; 4]>, ref_cell: &'static RefCell<MyType>) {
+    let mut ticker = Ticker::every(Duration::from_secs(1));
+    loop {
+        let random = RoscRng.next_u32();
+
+        uart.lock().await.write(b"task b").await.unwrap();
+
+        cell.set(random.to_be_bytes());
+
+        ref_cell.borrow_mut().inner = random;
+
+        ticker.next().await;
+    }
+}
+
+#[embassy_executor::task]
+async fn task_c(cell: &'static Cell<[u8; 4]>, ref_cell: &'static RefCell<MyType>) {
+    let mut ticker = Ticker::every(Duration::from_secs(1));
+    loop {
+        info!("=======================");
+
+        let atomic_val = ATOMIC.load(Ordering::Relaxed);
+        info!("atomic: {}", atomic_val);
+
+        MUTEX_BLOCKING.lock(|x| {
+            let val = x.borrow().inner;
+            info!("blocking mutex: {}", val);
+        });
+
+        let cell_val = cell.get();
+        info!("cell: {:?}", cell_val);
+
+        let ref_cell_val = ref_cell.borrow().inner;
+        info!("ref_cell: {:?}", ref_cell_val);
+
+        ticker.next().await;
+    }
+}
diff --git a/examples/rp235x/src/bin/spi.rs b/examples/rp235x/src/bin/spi.rs
new file mode 100644
index 000000000..4cc4f5210
--- /dev/null
+++ b/examples/rp235x/src/bin/spi.rs
@@ -0,0 +1,46 @@
+//! This example shows how to use SPI (Serial Peripheral Interface) in the RP2040 chip.
+//!
+//! Example for resistive touch sensor in Waveshare Pico-ResTouch
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::spi::Spi;
+use embassy_rp::{gpio, spi};
+use gpio::{Level, Output};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Hello World!");
+
+    // Example for resistive touch sensor in Waveshare Pico-ResTouch
+
+    let miso = p.PIN_12;
+    let mosi = p.PIN_11;
+    let clk = p.PIN_10;
+    let touch_cs = p.PIN_16;
+
+    // create SPI
+    let mut config = spi::Config::default();
+    config.frequency = 2_000_000;
+    let mut spi = Spi::new_blocking(p.SPI1, clk, mosi, miso, config);
+
+    // Configure CS
+    let mut cs = Output::new(touch_cs, Level::Low);
+
+    loop {
+        cs.set_low();
+        let mut buf = [0x90, 0x00, 0x00, 0xd0, 0x00, 0x00];
+        spi.blocking_transfer_in_place(&mut buf).unwrap();
+        cs.set_high();
+
+        let x = (buf[1] as u32) << 5 | (buf[2] as u32) >> 3;
+        let y = (buf[4] as u32) << 5 | (buf[5] as u32) >> 3;
+
+        info!("touch: {=u32} {=u32}", x, y);
+    }
+}
diff --git a/examples/rp235x/src/bin/spi_async.rs b/examples/rp235x/src/bin/spi_async.rs
new file mode 100644
index 000000000..266584efc
--- /dev/null
+++ b/examples/rp235x/src/bin/spi_async.rs
@@ -0,0 +1,31 @@
+//! This example shows how to use SPI (Serial Peripheral Interface) in the RP2040 chip.
+//! No specific hardware is specified in this example. If you connect pin 11 and 12 you should get the same data back.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::spi::{Config, Spi};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Hello World!");
+
+    let miso = p.PIN_12;
+    let mosi = p.PIN_11;
+    let clk = p.PIN_10;
+
+    let mut spi = Spi::new(p.SPI1, clk, mosi, miso, p.DMA_CH0, p.DMA_CH1, Config::default());
+
+    loop {
+        let tx_buf = [1_u8, 2, 3, 4, 5, 6];
+        let mut rx_buf = [0_u8; 6];
+        spi.transfer(&mut rx_buf, &tx_buf).await.unwrap();
+        info!("{:?}", rx_buf);
+        Timer::after_secs(1).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/spi_display.rs b/examples/rp235x/src/bin/spi_display.rs
new file mode 100644
index 000000000..9c524ab25
--- /dev/null
+++ b/examples/rp235x/src/bin/spi_display.rs
@@ -0,0 +1,177 @@
+//! This example shows how to use SPI (Serial Peripheral Interface) in the RP2350 chip.
+//!
+//! Example written for a display using the ST7789 chip. Possibly the Waveshare Pico-ResTouch
+//! (https://www.waveshare.com/wiki/Pico-ResTouch-LCD-2.8)
+
+#![no_std]
+#![no_main]
+
+use core::cell::RefCell;
+
+use defmt::*;
+use display_interface_spi::SPIInterface;
+use embassy_embedded_hal::shared_bus::blocking::spi::SpiDeviceWithConfig;
+use embassy_executor::Spawner;
+use embassy_rp::gpio::{Level, Output};
+use embassy_rp::spi;
+use embassy_rp::spi::{Blocking, Spi};
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::blocking_mutex::Mutex;
+use embassy_time::Delay;
+use embedded_graphics::image::{Image, ImageRawLE};
+use embedded_graphics::mono_font::ascii::FONT_10X20;
+use embedded_graphics::mono_font::MonoTextStyle;
+use embedded_graphics::pixelcolor::Rgb565;
+use embedded_graphics::prelude::*;
+use embedded_graphics::primitives::{PrimitiveStyleBuilder, Rectangle};
+use embedded_graphics::text::Text;
+use mipidsi::models::ST7789;
+use mipidsi::options::{Orientation, Rotation};
+use mipidsi::Builder;
+use {defmt_rtt as _, panic_probe as _};
+
+use crate::touch::Touch;
+
+const DISPLAY_FREQ: u32 = 64_000_000;
+const TOUCH_FREQ: u32 = 200_000;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Hello World!");
+
+    let bl = p.PIN_13;
+    let rst = p.PIN_15;
+    let display_cs = p.PIN_9;
+    let dcx = p.PIN_8;
+    let miso = p.PIN_12;
+    let mosi = p.PIN_11;
+    let clk = p.PIN_10;
+    let touch_cs = p.PIN_16;
+    //let touch_irq = p.PIN_17;
+
+    // create SPI
+    let mut display_config = spi::Config::default();
+    display_config.frequency = DISPLAY_FREQ;
+    display_config.phase = spi::Phase::CaptureOnSecondTransition;
+    display_config.polarity = spi::Polarity::IdleHigh;
+    let mut touch_config = spi::Config::default();
+    touch_config.frequency = TOUCH_FREQ;
+    touch_config.phase = spi::Phase::CaptureOnSecondTransition;
+    touch_config.polarity = spi::Polarity::IdleHigh;
+
+    let spi: Spi<'_, _, Blocking> = Spi::new_blocking(p.SPI1, clk, mosi, miso, touch_config.clone());
+    let spi_bus: Mutex<NoopRawMutex, _> = Mutex::new(RefCell::new(spi));
+
+    let display_spi = SpiDeviceWithConfig::new(&spi_bus, Output::new(display_cs, Level::High), display_config);
+    let touch_spi = SpiDeviceWithConfig::new(&spi_bus, Output::new(touch_cs, Level::High), touch_config);
+
+    let mut touch = Touch::new(touch_spi);
+
+    let dcx = Output::new(dcx, Level::Low);
+    let rst = Output::new(rst, Level::Low);
+    // dcx: 0 = command, 1 = data
+
+    // Enable LCD backlight
+    let _bl = Output::new(bl, Level::High);
+
+    // display interface abstraction from SPI and DC
+    let di = SPIInterface::new(display_spi, dcx);
+
+    // Define the display from the display interface and initialize it
+    let mut display = Builder::new(ST7789, di)
+        .display_size(240, 320)
+        .reset_pin(rst)
+        .orientation(Orientation::new().rotate(Rotation::Deg90))
+        .init(&mut Delay)
+        .unwrap();
+    display.clear(Rgb565::BLACK).unwrap();
+
+    let raw_image_data = ImageRawLE::new(include_bytes!("../../assets/ferris.raw"), 86);
+    let ferris = Image::new(&raw_image_data, Point::new(34, 68));
+
+    // Display the image
+    ferris.draw(&mut display).unwrap();
+
+    let style = MonoTextStyle::new(&FONT_10X20, Rgb565::GREEN);
+    Text::new(
+        "Hello embedded_graphics \n + embassy + RP2040!",
+        Point::new(20, 200),
+        style,
+    )
+    .draw(&mut display)
+    .unwrap();
+
+    loop {
+        if let Some((x, y)) = touch.read() {
+            let style = PrimitiveStyleBuilder::new().fill_color(Rgb565::BLUE).build();
+
+            Rectangle::new(Point::new(x - 1, y - 1), Size::new(3, 3))
+                .into_styled(style)
+                .draw(&mut display)
+                .unwrap();
+        }
+    }
+}
+
+/// Driver for the XPT2046 resistive touchscreen sensor
+mod touch {
+    use embedded_hal_1::spi::{Operation, SpiDevice};
+
+    struct Calibration {
+        x1: i32,
+        x2: i32,
+        y1: i32,
+        y2: i32,
+        sx: i32,
+        sy: i32,
+    }
+
+    const CALIBRATION: Calibration = Calibration {
+        x1: 3880,
+        x2: 340,
+        y1: 262,
+        y2: 3850,
+        sx: 320,
+        sy: 240,
+    };
+
+    pub struct Touch<SPI: SpiDevice> {
+        spi: SPI,
+    }
+
+    impl<SPI> Touch<SPI>
+    where
+        SPI: SpiDevice,
+    {
+        pub fn new(spi: SPI) -> Self {
+            Self { spi }
+        }
+
+        pub fn read(&mut self) -> Option<(i32, i32)> {
+            let mut x = [0; 2];
+            let mut y = [0; 2];
+            self.spi
+                .transaction(&mut [
+                    Operation::Write(&[0x90]),
+                    Operation::Read(&mut x),
+                    Operation::Write(&[0xd0]),
+                    Operation::Read(&mut y),
+                ])
+                .unwrap();
+
+            let x = (u16::from_be_bytes(x) >> 3) as i32;
+            let y = (u16::from_be_bytes(y) >> 3) as i32;
+
+            let cal = &CALIBRATION;
+
+            let x = ((x - cal.x1) * cal.sx / (cal.x2 - cal.x1)).clamp(0, cal.sx);
+            let y = ((y - cal.y1) * cal.sy / (cal.y2 - cal.y1)).clamp(0, cal.sy);
+            if x == 0 && y == 0 {
+                None
+            } else {
+                Some((x, y))
+            }
+        }
+    }
+}
diff --git a/examples/rp235x/src/bin/spi_sdmmc.rs b/examples/rp235x/src/bin/spi_sdmmc.rs
new file mode 100644
index 000000000..9808b6a5d
--- /dev/null
+++ b/examples/rp235x/src/bin/spi_sdmmc.rs
@@ -0,0 +1,82 @@
+//! This example shows how to use `embedded-sdmmc` with the RP2040 chip, over SPI.
+//!
+//! The example will attempt to read a file `MY_FILE.TXT` from the root directory
+//! of the SD card and print its contents.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_embedded_hal::SetConfig;
+use embassy_executor::Spawner;
+use embassy_rp::spi::Spi;
+use embassy_rp::{gpio, spi};
+use embedded_hal_bus::spi::ExclusiveDevice;
+use embedded_sdmmc::sdcard::{DummyCsPin, SdCard};
+use gpio::{Level, Output};
+use {defmt_rtt as _, panic_probe as _};
+
+struct DummyTimesource();
+
+impl embedded_sdmmc::TimeSource for DummyTimesource {
+    fn get_timestamp(&self) -> embedded_sdmmc::Timestamp {
+        embedded_sdmmc::Timestamp {
+            year_since_1970: 0,
+            zero_indexed_month: 0,
+            zero_indexed_day: 0,
+            hours: 0,
+            minutes: 0,
+            seconds: 0,
+        }
+    }
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    // SPI clock needs to be running at <= 400kHz during initialization
+    let mut config = spi::Config::default();
+    config.frequency = 400_000;
+    let spi = Spi::new_blocking(p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, config);
+    // Use a dummy cs pin here, for embedded-hal SpiDevice compatibility reasons
+    let spi_dev = ExclusiveDevice::new_no_delay(spi, DummyCsPin);
+    // Real cs pin
+    let cs = Output::new(p.PIN_16, Level::High);
+
+    let sdcard = SdCard::new(spi_dev, cs, embassy_time::Delay);
+    info!("Card size is {} bytes", sdcard.num_bytes().unwrap());
+
+    // Now that the card is initialized, the SPI clock can go faster
+    let mut config = spi::Config::default();
+    config.frequency = 16_000_000;
+    sdcard.spi(|dev| SetConfig::set_config(dev.bus_mut(), &config)).ok();
+
+    // Now let's look for volumes (also known as partitions) on our block device.
+    // To do this we need a Volume Manager. It will take ownership of the block device.
+    let mut volume_mgr = embedded_sdmmc::VolumeManager::new(sdcard, DummyTimesource());
+
+    // Try and access Volume 0 (i.e. the first partition).
+    // The volume object holds information about the filesystem on that volume.
+    let mut volume0 = volume_mgr.open_volume(embedded_sdmmc::VolumeIdx(0)).unwrap();
+    info!("Volume 0: {:?}", defmt::Debug2Format(&volume0));
+
+    // Open the root directory (mutably borrows from the volume).
+    let mut root_dir = volume0.open_root_dir().unwrap();
+
+    // Open a file called "MY_FILE.TXT" in the root directory
+    // This mutably borrows the directory.
+    let mut my_file = root_dir
+        .open_file_in_dir("MY_FILE.TXT", embedded_sdmmc::Mode::ReadOnly)
+        .unwrap();
+
+    // Print the contents of the file
+    while !my_file.is_eof() {
+        let mut buf = [0u8; 32];
+        if let Ok(n) = my_file.read(&mut buf) {
+            info!("{:a}", buf[..n]);
+        }
+    }
+
+    loop {}
+}
diff --git a/examples/rp235x/src/bin/trng.rs b/examples/rp235x/src/bin/trng.rs
new file mode 100644
index 000000000..ad19aef3e
--- /dev/null
+++ b/examples/rp235x/src/bin/trng.rs
@@ -0,0 +1,49 @@
+//! This example shows TRNG usage
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::gpio::{Level, Output};
+use embassy_rp::peripherals::TRNG;
+use embassy_rp::trng::Trng;
+use embassy_time::Timer;
+use rand::RngCore;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    TRNG_IRQ => embassy_rp::trng::InterruptHandler<TRNG>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let peripherals = embassy_rp::init(Default::default());
+
+    // Initialize the TRNG with default configuration
+    let mut trng = Trng::new(peripherals.TRNG, Irqs, embassy_rp::trng::Config::default());
+    // A buffer to collect random bytes in.
+    let mut randomness = [0u8; 58];
+
+    let mut led = Output::new(peripherals.PIN_25, Level::Low);
+
+    loop {
+        trng.fill_bytes(&mut randomness).await;
+        info!("Random bytes async {}", &randomness);
+        trng.blocking_fill_bytes(&mut randomness);
+        info!("Random bytes blocking {}", &randomness);
+        let random_u32 = trng.next_u32();
+        let random_u64 = trng.next_u64();
+        info!("Random u32 {} u64 {}", random_u32, random_u64);
+        // Random number of blinks between 0 and 31
+        let blinks = random_u32 % 32;
+        for _ in 0..blinks {
+            led.set_high();
+            Timer::after_millis(20).await;
+            led.set_low();
+            Timer::after_millis(20).await;
+        }
+        Timer::after_millis(1000).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/uart.rs b/examples/rp235x/src/bin/uart.rs
new file mode 100644
index 000000000..a59f537bf
--- /dev/null
+++ b/examples/rp235x/src/bin/uart.rs
@@ -0,0 +1,25 @@
+//! This example shows how to use UART (Universal asynchronous receiver-transmitter) in the RP2040 chip.
+//!
+//! No specific hardware is specified in this example. Only output on pin 0 is tested.
+//! The Raspberry Pi Debug Probe (https://www.raspberrypi.com/products/debug-probe/) could be used
+//! with its UART port.
+
+#![no_std]
+#![no_main]
+
+use embassy_executor::Spawner;
+use embassy_rp::uart;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let config = uart::Config::default();
+    let mut uart = uart::Uart::new_blocking(p.UART1, p.PIN_4, p.PIN_5, config);
+    uart.blocking_write("Hello World!\r\n".as_bytes()).unwrap();
+
+    loop {
+        uart.blocking_write("hello there!\r\n".as_bytes()).unwrap();
+        cortex_m::asm::delay(1_000_000);
+    }
+}
diff --git a/examples/rp235x/src/bin/uart_buffered_split.rs b/examples/rp235x/src/bin/uart_buffered_split.rs
new file mode 100644
index 000000000..468d2b61a
--- /dev/null
+++ b/examples/rp235x/src/bin/uart_buffered_split.rs
@@ -0,0 +1,58 @@
+//! This example shows how to use UART (Universal asynchronous receiver-transmitter) in the RP2040 chip.
+//!
+//! No specific hardware is specified in this example. If you connect pin 0 and 1 you should get the same data back.
+//! The Raspberry Pi Debug Probe (https://www.raspberrypi.com/products/debug-probe/) could be used
+//! with its UART port.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::UART0;
+use embassy_rp::uart::{BufferedInterruptHandler, BufferedUart, BufferedUartRx, Config};
+use embassy_time::Timer;
+use embedded_io_async::{Read, Write};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    UART0_IRQ => BufferedInterruptHandler<UART0>;
+});
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let (tx_pin, rx_pin, uart) = (p.PIN_0, p.PIN_1, p.UART0);
+
+    static TX_BUF: StaticCell<[u8; 16]> = StaticCell::new();
+    let tx_buf = &mut TX_BUF.init([0; 16])[..];
+    static RX_BUF: StaticCell<[u8; 16]> = StaticCell::new();
+    let rx_buf = &mut RX_BUF.init([0; 16])[..];
+    let uart = BufferedUart::new(uart, Irqs, tx_pin, rx_pin, tx_buf, rx_buf, Config::default());
+    let (mut tx, rx) = uart.split();
+
+    unwrap!(spawner.spawn(reader(rx)));
+
+    info!("Writing...");
+    loop {
+        let data = [
+            1u8, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+            29, 30, 31,
+        ];
+        info!("TX {:?}", data);
+        tx.write_all(&data).await.unwrap();
+        Timer::after_secs(1).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn reader(mut rx: BufferedUartRx<'static, UART0>) {
+    info!("Reading...");
+    loop {
+        let mut buf = [0; 31];
+        rx.read_exact(&mut buf).await.unwrap();
+        info!("RX {:?}", buf);
+    }
+}
diff --git a/examples/rp235x/src/bin/uart_r503.rs b/examples/rp235x/src/bin/uart_r503.rs
new file mode 100644
index 000000000..085be280b
--- /dev/null
+++ b/examples/rp235x/src/bin/uart_r503.rs
@@ -0,0 +1,158 @@
+#![no_std]
+#![no_main]
+
+use defmt::{debug, error, info};
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::UART0;
+use embassy_rp::uart::{Config, DataBits, InterruptHandler as UARTInterruptHandler, Parity, StopBits, Uart};
+use embassy_time::{with_timeout, Duration, Timer};
+use heapless::Vec;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(pub struct Irqs {
+    UART0_IRQ  => UARTInterruptHandler<UART0>;
+});
+
+const START: u16 = 0xEF01;
+const ADDRESS: u32 = 0xFFFFFFFF;
+
+// ================================================================================
+
+// Data package format
+// Name     Length          Description
+// ==========================================================================================================
+// Start    2 bytes         Fixed value of 0xEF01; High byte transferred first.
+// Address  4 bytes         Default value is 0xFFFFFFFF, which can be modified by command.
+//                          High byte transferred first and at wrong adder value, module
+//                          will reject to transfer.
+// PID      1 byte          01H     Command packet;
+//                          02H     Data packet; Data packet shall not appear alone in executing
+//                                  processs, must follow command packet or acknowledge packet.
+//                          07H     Acknowledge packet;
+//                          08H     End of Data packet.
+// LENGTH   2 bytes         Refers to the length of package content (command packets and data packets)
+//                          plus the length of Checksum (2 bytes). Unit is byte. Max length is 256 bytes.
+//                          And high byte is transferred first.
+// DATA     -               It can be commands, data, command’s parameters, acknowledge result, etc.
+//                          (fingerprint character value, template are all deemed as data);
+// SUM      2 bytes         The arithmetic sum of package identifier, package length and all package
+//                          contens. Overflowing bits are omitted. high byte is transferred first.
+
+// ================================================================================
+
+// Checksum is calculated on 'length (2 bytes) + data (??)'.
+fn compute_checksum(buf: Vec<u8, 32>) -> u16 {
+    let mut checksum = 0u16;
+
+    let check_end = buf.len();
+    let checked_bytes = &buf[6..check_end];
+    for byte in checked_bytes {
+        checksum += (*byte) as u16;
+    }
+    return checksum;
+}
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    info!("Start");
+
+    let p = embassy_rp::init(Default::default());
+
+    // Initialize the fingerprint scanner.
+    let mut config = Config::default();
+    config.baudrate = 57600;
+    config.stop_bits = StopBits::STOP1;
+    config.data_bits = DataBits::DataBits8;
+    config.parity = Parity::ParityNone;
+
+    let (uart, tx_pin, tx_dma, rx_pin, rx_dma) = (p.UART0, p.PIN_16, p.DMA_CH0, p.PIN_17, p.DMA_CH1);
+    let uart = Uart::new(uart, tx_pin, rx_pin, Irqs, tx_dma, rx_dma, config);
+    let (mut tx, mut rx) = uart.split();
+
+    let mut vec_buf: Vec<u8, 32> = heapless::Vec::new();
+    let mut data: Vec<u8, 32> = heapless::Vec::new();
+
+    let mut speeds: Vec<u8, 3> = heapless::Vec::new();
+    let _ = speeds.push(0xC8); // Slow
+    let _ = speeds.push(0x20); // Medium
+    let _ = speeds.push(0x02); // Fast
+
+    // Cycle through the three colours Red, Blue and Purple forever.
+    loop {
+        for colour in 1..=3 {
+            for speed in &speeds {
+                // Set the data first, because the length is dependent on that.
+                // However, we write the length bits before we do the data.
+                data.clear();
+                let _ = data.push(0x01); // ctrl=Breathing light
+                let _ = data.push(*speed);
+                let _ = data.push(colour as u8); // colour=Red, Blue, Purple
+                let _ = data.push(0x00); // times=Infinite
+
+                // Clear buffers
+                vec_buf.clear();
+
+                // START
+                let _ = vec_buf.extend_from_slice(&START.to_be_bytes()[..]);
+
+                // ADDRESS
+                let _ = vec_buf.extend_from_slice(&ADDRESS.to_be_bytes()[..]);
+
+                // PID
+                let _ = vec_buf.extend_from_slice(&[0x01]);
+
+                // LENGTH
+                let len: u16 = (1 + data.len() + 2).try_into().unwrap();
+                let _ = vec_buf.extend_from_slice(&len.to_be_bytes()[..]);
+
+                // COMMAND
+                let _ = vec_buf.push(0x35); // Command: AuraLedConfig
+
+                // DATA
+                let _ = vec_buf.extend_from_slice(&data);
+
+                // SUM
+                let chk = compute_checksum(vec_buf.clone());
+                let _ = vec_buf.extend_from_slice(&chk.to_be_bytes()[..]);
+
+                // =====
+
+                // Send command buffer.
+                let data_write: [u8; 16] = vec_buf.clone().into_array().unwrap();
+                debug!("  write='{:?}'", data_write[..]);
+                match tx.write(&data_write).await {
+                    Ok(..) => info!("Write successful."),
+                    Err(e) => error!("Write error: {:?}", e),
+                }
+
+                // =====
+
+                // Read command buffer.
+                let mut read_buf: [u8; 1] = [0; 1]; // Can only read one byte at a time!
+                let mut data_read: Vec<u8, 32> = heapless::Vec::new(); // Save buffer.
+
+                info!("Attempting read.");
+                loop {
+                    // Some commands, like `Img2Tz()` needs longer, but we hard-code this to 200ms
+                    // for this command.
+                    match with_timeout(Duration::from_millis(200), rx.read(&mut read_buf)).await {
+                        Ok(..) => {
+                            // Extract and save read byte.
+                            debug!("  r='{=u8:#04x}H' ({:03}D)", read_buf[0], read_buf[0]);
+                            let _ = data_read.push(read_buf[0]).unwrap();
+                        }
+                        Err(..) => break, // TimeoutError -> Ignore.
+                    }
+                }
+                info!("Read successful");
+                debug!("  read='{:?}'", data_read[..]);
+
+                Timer::after_secs(3).await;
+                info!("Changing speed.");
+            }
+
+            info!("Changing colour.");
+        }
+    }
+}
diff --git a/examples/rp235x/src/bin/uart_unidir.rs b/examples/rp235x/src/bin/uart_unidir.rs
new file mode 100644
index 000000000..a45f40756
--- /dev/null
+++ b/examples/rp235x/src/bin/uart_unidir.rs
@@ -0,0 +1,50 @@
+//! This example shows how to use UART (Universal asynchronous receiver-transmitter) in the RP2040 chip.
+//!
+//! Test TX-only and RX-only on two different UARTs. You need to connect GPIO0 to GPIO5 for
+//! this to work
+//! The Raspberry Pi Debug Probe (https://www.raspberrypi.com/products/debug-probe/) could be used
+//! with its UART port.
+
+#![no_std]
+#![no_main]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::UART1;
+use embassy_rp::uart::{Async, Config, InterruptHandler, UartRx, UartTx};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    UART1_IRQ => InterruptHandler<UART1>;
+});
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    let mut uart_tx = UartTx::new(p.UART0, p.PIN_0, p.DMA_CH0, Config::default());
+    let uart_rx = UartRx::new(p.UART1, p.PIN_5, Irqs, p.DMA_CH1, Config::default());
+
+    unwrap!(spawner.spawn(reader(uart_rx)));
+
+    info!("Writing...");
+    loop {
+        let data = [1u8, 2, 3, 4, 5, 6, 7, 8];
+        info!("TX {:?}", data);
+        uart_tx.write(&data).await.unwrap();
+        Timer::after_secs(1).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn reader(mut rx: UartRx<'static, UART1, Async>) {
+    info!("Reading...");
+    loop {
+        // read a total of 4 transmissions (32 / 8) and then print the result
+        let mut buf = [0; 32];
+        rx.read(&mut buf).await.unwrap();
+        info!("RX {:?}", buf);
+    }
+}
diff --git a/examples/rp235x/src/bin/usb_hid_keyboard.rs b/examples/rp235x/src/bin/usb_hid_keyboard.rs
new file mode 100644
index 000000000..6f496e23a
--- /dev/null
+++ b/examples/rp235x/src/bin/usb_hid_keyboard.rs
@@ -0,0 +1,188 @@
+#![no_std]
+#![no_main]
+
+use core::sync::atomic::{AtomicBool, Ordering};
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_rp::bind_interrupts;
+use embassy_rp::gpio::{Input, Pull};
+use embassy_rp::peripherals::USB;
+use embassy_rp::usb::{Driver as UsbDriver, InterruptHandler};
+use embassy_usb::class::hid::{HidReaderWriter, ReportId, RequestHandler, State as HidState};
+use embassy_usb::control::OutResponse;
+use embassy_usb::{Builder, Config, Handler};
+use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    USBCTRL_IRQ => InterruptHandler<USB>;
+});
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    // Create the driver, from the HAL.
+    let driver = UsbDriver::new(p.USB, Irqs);
+
+    // Create embassy-usb Config
+    let mut config = Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("HID keyboard example");
+    config.serial_number = Some("12345678");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    // Create embassy-usb DeviceBuilder using the driver and config.
+    // It needs some buffers for building the descriptors.
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 256];
+    // You can also add a Microsoft OS descriptor.
+    let mut msos_descriptor = [0; 256];
+    let mut control_buf = [0; 64];
+    let mut request_handler = MyRequestHandler {};
+    let mut device_handler = MyDeviceHandler::new();
+
+    let mut state = HidState::new();
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut msos_descriptor,
+        &mut control_buf,
+    );
+
+    builder.handler(&mut device_handler);
+
+    // Create classes on the builder.
+    let config = embassy_usb::class::hid::Config {
+        report_descriptor: KeyboardReport::desc(),
+        request_handler: None,
+        poll_ms: 60,
+        max_packet_size: 64,
+    };
+    let hid = HidReaderWriter::<_, 1, 8>::new(&mut builder, &mut state, config);
+
+    // Build the builder.
+    let mut usb = builder.build();
+
+    // Run the USB device.
+    let usb_fut = usb.run();
+
+    // Set up the signal pin that will be used to trigger the keyboard.
+    let mut signal_pin = Input::new(p.PIN_16, Pull::None);
+
+    // Enable the schmitt trigger to slightly debounce.
+    signal_pin.set_schmitt(true);
+
+    let (reader, mut writer) = hid.split();
+
+    // Do stuff with the class!
+    let in_fut = async {
+        loop {
+            info!("Waiting for HIGH on pin 16");
+            signal_pin.wait_for_high().await;
+            info!("HIGH DETECTED");
+            // Create a report with the A key pressed. (no shift modifier)
+            let report = KeyboardReport {
+                keycodes: [4, 0, 0, 0, 0, 0],
+                leds: 0,
+                modifier: 0,
+                reserved: 0,
+            };
+            // Send the report.
+            match writer.write_serialize(&report).await {
+                Ok(()) => {}
+                Err(e) => warn!("Failed to send report: {:?}", e),
+            };
+            signal_pin.wait_for_low().await;
+            info!("LOW DETECTED");
+            let report = KeyboardReport {
+                keycodes: [0, 0, 0, 0, 0, 0],
+                leds: 0,
+                modifier: 0,
+                reserved: 0,
+            };
+            match writer.write_serialize(&report).await {
+                Ok(()) => {}
+                Err(e) => warn!("Failed to send report: {:?}", e),
+            };
+        }
+    };
+
+    let out_fut = async {
+        reader.run(false, &mut request_handler).await;
+    };
+
+    // Run everything concurrently.
+    // If we had made everything `'static` above instead, we could do this using separate tasks instead.
+    join(usb_fut, join(in_fut, out_fut)).await;
+}
+
+struct MyRequestHandler {}
+
+impl RequestHandler for MyRequestHandler {
+    fn get_report(&mut self, id: ReportId, _buf: &mut [u8]) -> Option<usize> {
+        info!("Get report for {:?}", id);
+        None
+    }
+
+    fn set_report(&mut self, id: ReportId, data: &[u8]) -> OutResponse {
+        info!("Set report for {:?}: {=[u8]}", id, data);
+        OutResponse::Accepted
+    }
+
+    fn set_idle_ms(&mut self, id: Option<ReportId>, dur: u32) {
+        info!("Set idle rate for {:?} to {:?}", id, dur);
+    }
+
+    fn get_idle_ms(&mut self, id: Option<ReportId>) -> Option<u32> {
+        info!("Get idle rate for {:?}", id);
+        None
+    }
+}
+
+struct MyDeviceHandler {
+    configured: AtomicBool,
+}
+
+impl MyDeviceHandler {
+    fn new() -> Self {
+        MyDeviceHandler {
+            configured: AtomicBool::new(false),
+        }
+    }
+}
+
+impl Handler for MyDeviceHandler {
+    fn enabled(&mut self, enabled: bool) {
+        self.configured.store(false, Ordering::Relaxed);
+        if enabled {
+            info!("Device enabled");
+        } else {
+            info!("Device disabled");
+        }
+    }
+
+    fn reset(&mut self) {
+        self.configured.store(false, Ordering::Relaxed);
+        info!("Bus reset, the Vbus current limit is 100mA");
+    }
+
+    fn addressed(&mut self, addr: u8) {
+        self.configured.store(false, Ordering::Relaxed);
+        info!("USB address set to: {}", addr);
+    }
+
+    fn configured(&mut self, configured: bool) {
+        self.configured.store(configured, Ordering::Relaxed);
+        if configured {
+            info!("Device configured, it may now draw up to the configured current limit from Vbus.")
+        } else {
+            info!("Device is no longer configured, the Vbus current limit is 100mA.");
+        }
+    }
+}
diff --git a/examples/rp235x/src/bin/usb_webusb.rs b/examples/rp235x/src/bin/usb_webusb.rs
new file mode 100644
index 000000000..e73938ac9
--- /dev/null
+++ b/examples/rp235x/src/bin/usb_webusb.rs
@@ -0,0 +1,155 @@
+//! This example shows how to use USB (Universal Serial Bus) in the RP2040 chip.
+//!
+//! This creates a WebUSB capable device that echoes data back to the host.
+//!
+//! To test this in the browser (ideally host this on localhost:8080, to test the landing page
+//! feature):
+//! ```js
+//! (async () => {
+//!     const device = await navigator.usb.requestDevice({ filters: [{ vendorId: 0xf569 }] });
+//!     await device.open();
+//!     await device.claimInterface(1);
+//!     device.transferIn(1, 64).then(data => console.log(data));
+//!     await device.transferOut(1, new Uint8Array([1,2,3]));
+//! })();
+//! ```
+
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_rp::bind_interrupts;
+use embassy_rp::peripherals::USB;
+use embassy_rp::usb::{Driver as UsbDriver, InterruptHandler};
+use embassy_usb::class::web_usb::{Config as WebUsbConfig, State, Url, WebUsb};
+use embassy_usb::driver::{Driver, Endpoint, EndpointIn, EndpointOut};
+use embassy_usb::msos::{self, windows_version};
+use embassy_usb::{Builder, Config};
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    USBCTRL_IRQ => InterruptHandler<USB>;
+});
+
+// This is a randomly generated GUID to allow clients on Windows to find our device
+const DEVICE_INTERFACE_GUIDS: &[&str] = &["{AFB9A6FB-30BA-44BC-9232-806CFC875321}"];
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    // Create the driver, from the HAL.
+    let driver = UsbDriver::new(p.USB, Irqs);
+
+    // Create embassy-usb Config
+    let mut config = Config::new(0xf569, 0x0001);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("WebUSB example");
+    config.serial_number = Some("12345678");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    // Required for windows compatibility.
+    // https://developer.nordicsemi.com/nRF_Connect_SDK/doc/1.9.1/kconfig/CONFIG_CDC_ACM_IAD.html#help
+    config.device_class = 0xff;
+    config.device_sub_class = 0x00;
+    config.device_protocol = 0x00;
+
+    // Create embassy-usb DeviceBuilder using the driver and config.
+    // It needs some buffers for building the descriptors.
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 256];
+    let mut control_buf = [0; 64];
+    let mut msos_descriptor = [0; 256];
+
+    let webusb_config = WebUsbConfig {
+        max_packet_size: 64,
+        vendor_code: 1,
+        // If defined, shows a landing page which the device manufacturer would like the user to visit in order to control their device. Suggest the user to navigate to this URL when the device is connected.
+        landing_url: Some(Url::new("http://localhost:8080")),
+    };
+
+    let mut state = State::new();
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut msos_descriptor,
+        &mut control_buf,
+    );
+
+    // Add the Microsoft OS Descriptor (MSOS/MOD) descriptor.
+    // We tell Windows that this entire device is compatible with the "WINUSB" feature,
+    // which causes it to use the built-in WinUSB driver automatically, which in turn
+    // can be used by libusb/rusb software without needing a custom driver or INF file.
+    // In principle you might want to call msos_feature() just on a specific function,
+    // if your device also has other functions that still use standard class drivers.
+    builder.msos_descriptor(windows_version::WIN8_1, 0);
+    builder.msos_feature(msos::CompatibleIdFeatureDescriptor::new("WINUSB", ""));
+    builder.msos_feature(msos::RegistryPropertyFeatureDescriptor::new(
+        "DeviceInterfaceGUIDs",
+        msos::PropertyData::RegMultiSz(DEVICE_INTERFACE_GUIDS),
+    ));
+
+    // Create classes on the builder (WebUSB just needs some setup, but doesn't return anything)
+    WebUsb::configure(&mut builder, &mut state, &webusb_config);
+    // Create some USB bulk endpoints for testing.
+    let mut endpoints = WebEndpoints::new(&mut builder, &webusb_config);
+
+    // Build the builder.
+    let mut usb = builder.build();
+
+    // Run the USB device.
+    let usb_fut = usb.run();
+
+    // Do some WebUSB transfers.
+    let webusb_fut = async {
+        loop {
+            endpoints.wait_connected().await;
+            info!("Connected");
+            endpoints.echo().await;
+        }
+    };
+
+    // Run everything concurrently.
+    // If we had made everything `'static` above instead, we could do this using separate tasks instead.
+    join(usb_fut, webusb_fut).await;
+}
+
+struct WebEndpoints<'d, D: Driver<'d>> {
+    write_ep: D::EndpointIn,
+    read_ep: D::EndpointOut,
+}
+
+impl<'d, D: Driver<'d>> WebEndpoints<'d, D> {
+    fn new(builder: &mut Builder<'d, D>, config: &'d WebUsbConfig<'d>) -> Self {
+        let mut func = builder.function(0xff, 0x00, 0x00);
+        let mut iface = func.interface();
+        let mut alt = iface.alt_setting(0xff, 0x00, 0x00, None);
+
+        let write_ep = alt.endpoint_bulk_in(config.max_packet_size);
+        let read_ep = alt.endpoint_bulk_out(config.max_packet_size);
+
+        WebEndpoints { write_ep, read_ep }
+    }
+
+    // Wait until the device's endpoints are enabled.
+    async fn wait_connected(&mut self) {
+        self.read_ep.wait_enabled().await
+    }
+
+    // Echo data back to the host.
+    async fn echo(&mut self) {
+        let mut buf = [0; 64];
+        loop {
+            let n = self.read_ep.read(&mut buf).await.unwrap();
+            let data = &buf[..n];
+            info!("Data read: {:x}", data);
+            self.write_ep.write(data).await.unwrap();
+        }
+    }
+}
diff --git a/examples/rp235x/src/bin/watchdog.rs b/examples/rp235x/src/bin/watchdog.rs
new file mode 100644
index 000000000..b9d4ef22f
--- /dev/null
+++ b/examples/rp235x/src/bin/watchdog.rs
@@ -0,0 +1,51 @@
+//! This example shows how to use Watchdog in the RP2040 chip.
+//!
+//! It does not work with the RP Pico W board. See wifi_blinky.rs or connect external LED and resistor.
+
+#![no_std]
+#![no_main]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_rp::gpio;
+use embassy_rp::watchdog::*;
+use embassy_time::{Duration, Timer};
+use gpio::{Level, Output};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Hello world!");
+
+    let mut watchdog = Watchdog::new(p.WATCHDOG);
+    let mut led = Output::new(p.PIN_25, Level::Low);
+
+    // Set the LED high for 2 seconds so we know when we're about to start the watchdog
+    led.set_high();
+    Timer::after_secs(2).await;
+
+    // Set to watchdog to reset if it's not fed within 1.05 seconds, and start it
+    watchdog.start(Duration::from_millis(1_050));
+    info!("Started the watchdog timer");
+
+    // Blink once a second for 5 seconds, feed the watchdog timer once a second to avoid a reset
+    for _ in 1..=5 {
+        led.set_low();
+        Timer::after_millis(500).await;
+        led.set_high();
+        Timer::after_millis(500).await;
+        info!("Feeding watchdog");
+        watchdog.feed();
+    }
+
+    info!("Stopped feeding, device will reset in 1.05 seconds");
+    // Blink 10 times per second, not feeding the watchdog.
+    // The processor should reset in 1.05 seconds.
+    loop {
+        led.set_low();
+        Timer::after_millis(100).await;
+        led.set_high();
+        Timer::after_millis(100).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/wifi_blinky_pico_plus_2.rs b/examples/rp235x/src/bin/wifi_blinky_pico_plus_2.rs
new file mode 100644
index 000000000..ab7d6a93e
--- /dev/null
+++ b/examples/rp235x/src/bin/wifi_blinky_pico_plus_2.rs
@@ -0,0 +1,88 @@
+//! This example test the Pimoroni Pico Plus 2 on board LED.
+//!
+//! It does not work with the RP Pico board. See blinky.rs.
+
+#![no_std]
+#![no_main]
+
+use cyw43_pio::{PioSpi, RM2_CLOCK_DIVIDER};
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::peripherals::{DMA_CH0, PIO0};
+use embassy_rp::pio::{InterruptHandler, Pio};
+use embassy_rp::{bind_interrupts, gpio};
+use embassy_time::{Duration, Timer};
+use gpio::{Level, Output};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+// Program metadata for `picotool info`.
+// This isn't needed, but it's recomended to have these minimal entries.
+#[link_section = ".bi_entries"]
+#[used]
+pub static PICOTOOL_ENTRIES: [embassy_rp::binary_info::EntryAddr; 4] = [
+    embassy_rp::binary_info::rp_program_name!(c"Blinky Example"),
+    embassy_rp::binary_info::rp_program_description!(
+        c"This example tests the RP Pico on board LED, connected to gpio 25"
+    ),
+    embassy_rp::binary_info::rp_cargo_version!(),
+    embassy_rp::binary_info::rp_program_build_attribute!(),
+];
+
+bind_interrupts!(struct Irqs {
+    PIO0_IRQ_0 => InterruptHandler<PIO0>;
+});
+
+#[embassy_executor::task]
+async fn cyw43_task(runner: cyw43::Runner<'static, Output<'static>, PioSpi<'static, PIO0, 0, DMA_CH0>>) -> ! {
+    runner.run().await
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    let fw = include_bytes!("../../../../cyw43-firmware/43439A0.bin");
+    let clm = include_bytes!("../../../../cyw43-firmware/43439A0_clm.bin");
+
+    // To make flashing faster for development, you may want to flash the firmwares independently
+    // at hardcoded addresses, instead of baking them into the program with `include_bytes!`:
+    //     probe-rs download ../../cyw43-firmware/43439A0.bin --binary-format bin --chip RP2040 --base-address 0x10100000
+    //     probe-rs download ../../cyw43-firmware/43439A0_clm.bin --binary-format bin --chip RP2040 --base-address 0x10140000
+    //let fw = unsafe { core::slice::from_raw_parts(0x10100000 as *const u8, 230321) };
+    //let clm = unsafe { core::slice::from_raw_parts(0x10140000 as *const u8, 4752) };
+
+    let pwr = Output::new(p.PIN_23, Level::Low);
+    let cs = Output::new(p.PIN_25, Level::High);
+    let mut pio = Pio::new(p.PIO0, Irqs);
+    let spi = PioSpi::new(
+        &mut pio.common,
+        pio.sm0,
+        RM2_CLOCK_DIVIDER,
+        pio.irq0,
+        cs,
+        p.PIN_24,
+        p.PIN_29,
+        p.DMA_CH0,
+    );
+
+    static STATE: StaticCell<cyw43::State> = StaticCell::new();
+    let state = STATE.init(cyw43::State::new());
+    let (_net_device, mut control, runner) = cyw43::new(state, pwr, spi, fw).await;
+    unwrap!(spawner.spawn(cyw43_task(runner)));
+
+    control.init(clm).await;
+    control
+        .set_power_management(cyw43::PowerManagementMode::PowerSave)
+        .await;
+
+    let delay = Duration::from_secs(1);
+    loop {
+        info!("led on!");
+        control.gpio_set(0, true).await;
+        Timer::after(delay).await;
+
+        info!("led off!");
+        control.gpio_set(0, false).await;
+        Timer::after(delay).await;
+    }
+}
diff --git a/examples/rp235x/src/bin/zerocopy.rs b/examples/rp235x/src/bin/zerocopy.rs
new file mode 100644
index 000000000..39f03c8e4
--- /dev/null
+++ b/examples/rp235x/src/bin/zerocopy.rs
@@ -0,0 +1,94 @@
+//! This example shows how to use `zerocopy_channel` from `embassy_sync` for
+//! sending large values between two tasks without copying.
+//! The example also shows how to use the RP2040 ADC with DMA.
+#![no_std]
+#![no_main]
+
+use core::sync::atomic::{AtomicU16, Ordering};
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_rp::adc::{self, Adc, Async, Config, InterruptHandler};
+use embassy_rp::bind_interrupts;
+use embassy_rp::gpio::Pull;
+use embassy_rp::peripherals::DMA_CH0;
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::zerocopy_channel::{Channel, Receiver, Sender};
+use embassy_time::{Duration, Ticker, Timer};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+type SampleBuffer = [u16; 512];
+
+bind_interrupts!(struct Irqs {
+    ADC_IRQ_FIFO => InterruptHandler;
+});
+
+const BLOCK_SIZE: usize = 512;
+const NUM_BLOCKS: usize = 2;
+static MAX: AtomicU16 = AtomicU16::new(0);
+
+struct AdcParts {
+    adc: Adc<'static, Async>,
+    pin: adc::Channel<'static>,
+    dma: DMA_CH0,
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+    info!("Here we go!");
+
+    let adc_parts = AdcParts {
+        adc: Adc::new(p.ADC, Irqs, Config::default()),
+        pin: adc::Channel::new_pin(p.PIN_29, Pull::None),
+        dma: p.DMA_CH0,
+    };
+
+    static BUF: StaticCell<[SampleBuffer; NUM_BLOCKS]> = StaticCell::new();
+    let buf = BUF.init([[0; BLOCK_SIZE]; NUM_BLOCKS]);
+
+    static CHANNEL: StaticCell<Channel<'_, NoopRawMutex, SampleBuffer>> = StaticCell::new();
+    let channel = CHANNEL.init(Channel::new(buf));
+    let (sender, receiver) = channel.split();
+
+    spawner.must_spawn(consumer(receiver));
+    spawner.must_spawn(producer(sender, adc_parts));
+
+    let mut ticker = Ticker::every(Duration::from_secs(1));
+    loop {
+        ticker.next().await;
+        let max = MAX.load(Ordering::Relaxed);
+        info!("latest block's max value: {:?}", max);
+    }
+}
+
+#[embassy_executor::task]
+async fn producer(mut sender: Sender<'static, NoopRawMutex, SampleBuffer>, mut adc: AdcParts) {
+    loop {
+        // Obtain a free buffer from the channel
+        let buf = sender.send().await;
+
+        // Fill it with data
+        adc.adc.read_many(&mut adc.pin, buf, 1, &mut adc.dma).await.unwrap();
+
+        // Notify the channel that the buffer is now ready to be received
+        sender.send_done();
+    }
+}
+
+#[embassy_executor::task]
+async fn consumer(mut receiver: Receiver<'static, NoopRawMutex, SampleBuffer>) {
+    loop {
+        // Receive a buffer from the channel
+        let buf = receiver.receive().await;
+
+        // Simulate using the data, while the producer is filling up the next buffer
+        Timer::after_micros(1000).await;
+        let max = buf.iter().max().unwrap();
+        MAX.store(*max, Ordering::Relaxed);
+
+        // Notify the channel that the buffer is now ready to be reused
+        receiver.receive_done();
+    }
+}