Rename examples/nrf to examples/nrf52840

51 files changed, 3355 insertions, 0 deletions

diff --git a/examples/nrf52840/src/bin/awaitable_timer.rs b/examples/nrf52840/src/bin/awaitable_timer.rs
new file mode 100644
index 000000000..b32af236c
--- /dev/null
+++ b/examples/nrf52840/src/bin/awaitable_timer.rs
@@ -0,0 +1,26 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::timer::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut t = Timer::new_awaitable(p.TIMER0, interrupt::take!(TIMER0));
+    // default frequency is 1MHz, so this triggers every second
+    t.cc(0).write(1_000_000);
+    // clear the timer value on cc[0] compare match
+    t.cc(0).short_compare_clear();
+    t.start();
+
+    loop {
+        // wait for compare match
+        t.cc(0).wait().await;
+        info!("hardware timer tick");
+    }
+}
diff --git a/examples/nrf52840/src/bin/blinky.rs b/examples/nrf52840/src/bin/blinky.rs
new file mode 100644
index 000000000..513f6cd82
--- /dev/null
+++ b/examples/nrf52840/src/bin/blinky.rs
@@ -0,0 +1,21 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Level, Output, OutputDrive};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);
+
+    loop {
+        led.set_high();
+        Timer::after(Duration::from_millis(300)).await;
+        led.set_low();
+        Timer::after(Duration::from_millis(300)).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/buffered_uart.rs b/examples/nrf52840/src/bin/buffered_uart.rs
new file mode 100644
index 000000000..ea566f4b2
--- /dev/null
+++ b/examples/nrf52840/src/bin/buffered_uart.rs
@@ -0,0 +1,57 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::buffered_uarte::{BufferedUarte, State};
+use embassy_nrf::{interrupt, uarte};
+use embedded_io::asynch::{BufRead, Write};
+use futures::pin_mut;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD115200;
+
+    let mut tx_buffer = [0u8; 4096];
+    let mut rx_buffer = [0u8; 4096];
+
+    let irq = interrupt::take!(UARTE0_UART0);
+    let mut state = State::new();
+    // Please note - important to have hardware flow control (https://github.com/embassy-rs/embassy/issues/536)
+    let u = BufferedUarte::new(
+        &mut state,
+        p.UARTE0,
+        p.TIMER0,
+        p.PPI_CH0,
+        p.PPI_CH1,
+        irq,
+        p.P0_08,
+        p.P0_06,
+        p.P0_07,
+        p.P0_05,
+        config,
+        &mut rx_buffer,
+        &mut tx_buffer,
+    );
+    pin_mut!(u);
+
+    info!("uarte initialized!");
+
+    unwrap!(u.write_all(b"Hello!\r\n").await);
+    info!("wrote hello in uart!");
+
+    loop {
+        info!("reading...");
+        let buf = unwrap!(u.fill_buf().await);
+        info!("read done, got {}", buf);
+
+        // Read bytes have to be explicitly consumed, otherwise fill_buf() will return them again
+        let n = buf.len();
+        u.consume(n);
+    }
+}
diff --git a/examples/nrf52840/src/bin/channel.rs b/examples/nrf52840/src/bin/channel.rs
new file mode 100644
index 000000000..d782a79e7
--- /dev/null
+++ b/examples/nrf52840/src/bin/channel.rs
@@ -0,0 +1,43 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::unwrap;
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Level, Output, OutputDrive};
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::channel::Channel;
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+enum LedState {
+    On,
+    Off,
+}
+
+static CHANNEL: Channel<ThreadModeRawMutex, LedState, 1> = Channel::new();
+
+#[embassy_executor::task]
+async fn my_task() {
+    loop {
+        CHANNEL.send(LedState::On).await;
+        Timer::after(Duration::from_secs(1)).await;
+        CHANNEL.send(LedState::Off).await;
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut led = Output::new(p.P0_13, Level::Low, OutputDrive::Standard);
+
+    unwrap!(spawner.spawn(my_task()));
+
+    loop {
+        match CHANNEL.recv().await {
+            LedState::On => led.set_high(),
+            LedState::Off => led.set_low(),
+        }
+    }
+}
diff --git a/examples/nrf52840/src/bin/channel_sender_receiver.rs b/examples/nrf52840/src/bin/channel_sender_receiver.rs
new file mode 100644
index 000000000..fcccdaed5
--- /dev/null
+++ b/examples/nrf52840/src/bin/channel_sender_receiver.rs
@@ -0,0 +1,50 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::unwrap;
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{AnyPin, Level, Output, OutputDrive, Pin};
+use embassy_sync::blocking_mutex::raw::NoopRawMutex;
+use embassy_sync::channel::{Channel, Receiver, Sender};
+use embassy_time::{Duration, Timer};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+enum LedState {
+    On,
+    Off,
+}
+
+static CHANNEL: StaticCell<Channel<NoopRawMutex, LedState, 1>> = StaticCell::new();
+
+#[embassy_executor::task]
+async fn send_task(sender: Sender<'static, NoopRawMutex, LedState, 1>) {
+    loop {
+        sender.send(LedState::On).await;
+        Timer::after(Duration::from_secs(1)).await;
+        sender.send(LedState::Off).await;
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn recv_task(led: AnyPin, receiver: Receiver<'static, NoopRawMutex, LedState, 1>) {
+    let mut led = Output::new(led, Level::Low, OutputDrive::Standard);
+
+    loop {
+        match receiver.recv().await {
+            LedState::On => led.set_high(),
+            LedState::Off => led.set_low(),
+        }
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let channel = CHANNEL.init(Channel::new());
+
+    unwrap!(spawner.spawn(send_task(channel.sender())));
+    unwrap!(spawner.spawn(recv_task(p.P0_13.degrade(), channel.receiver())));
+}
diff --git a/examples/nrf52840/src/bin/executor_fairness_test.rs b/examples/nrf52840/src/bin/executor_fairness_test.rs
new file mode 100644
index 000000000..2a28f2763
--- /dev/null
+++ b/examples/nrf52840/src/bin/executor_fairness_test.rs
@@ -0,0 +1,43 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::future::poll_fn;
+use core::task::Poll;
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_time::{Duration, Instant, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task]
+async fn run1() {
+    loop {
+        info!("DING DONG");
+        Timer::after(Duration::from_ticks(16000)).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn run2() {
+    loop {
+        Timer::at(Instant::from_ticks(0)).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn run3() {
+    poll_fn(|cx| {
+        cx.waker().wake_by_ref();
+        Poll::<()>::Pending
+    })
+    .await;
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let _p = embassy_nrf::init(Default::default());
+    unwrap!(spawner.spawn(run1()));
+    unwrap!(spawner.spawn(run2()));
+    unwrap!(spawner.spawn(run3()));
+}
diff --git a/examples/nrf52840/src/bin/gpiote_channel.rs b/examples/nrf52840/src/bin/gpiote_channel.rs
new file mode 100644
index 000000000..5bfd02465
--- /dev/null
+++ b/examples/nrf52840/src/bin/gpiote_channel.rs
@@ -0,0 +1,66 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Input, Pull};
+use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Starting!");
+
+    let ch1 = InputChannel::new(
+        p.GPIOTE_CH0,
+        Input::new(p.P0_11, Pull::Up),
+        InputChannelPolarity::HiToLo,
+    );
+    let ch2 = InputChannel::new(
+        p.GPIOTE_CH1,
+        Input::new(p.P0_12, Pull::Up),
+        InputChannelPolarity::LoToHi,
+    );
+    let ch3 = InputChannel::new(
+        p.GPIOTE_CH2,
+        Input::new(p.P0_24, Pull::Up),
+        InputChannelPolarity::Toggle,
+    );
+    let ch4 = InputChannel::new(
+        p.GPIOTE_CH3,
+        Input::new(p.P0_25, Pull::Up),
+        InputChannelPolarity::Toggle,
+    );
+
+    let button1 = async {
+        loop {
+            ch1.wait().await;
+            info!("Button 1 pressed")
+        }
+    };
+
+    let button2 = async {
+        loop {
+            ch2.wait().await;
+            info!("Button 2 released")
+        }
+    };
+
+    let button3 = async {
+        loop {
+            ch3.wait().await;
+            info!("Button 3 toggled")
+        }
+    };
+
+    let button4 = async {
+        loop {
+            ch4.wait().await;
+            info!("Button 4 toggled")
+        }
+    };
+
+    futures::join!(button1, button2, button3, button4);
+}
diff --git a/examples/nrf52840/src/bin/gpiote_port.rs b/examples/nrf52840/src/bin/gpiote_port.rs
new file mode 100644
index 000000000..0155d539e
--- /dev/null
+++ b/examples/nrf52840/src/bin/gpiote_port.rs
@@ -0,0 +1,34 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{AnyPin, Input, Pin as _, Pull};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task(pool_size = 4)]
+async fn button_task(n: usize, mut pin: Input<'static, AnyPin>) {
+    loop {
+        pin.wait_for_low().await;
+        info!("Button {:?} pressed!", n);
+        pin.wait_for_high().await;
+        info!("Button {:?} released!", n);
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Starting!");
+
+    let btn1 = Input::new(p.P0_11.degrade(), Pull::Up);
+    let btn2 = Input::new(p.P0_12.degrade(), Pull::Up);
+    let btn3 = Input::new(p.P0_24.degrade(), Pull::Up);
+    let btn4 = Input::new(p.P0_25.degrade(), Pull::Up);
+
+    unwrap!(spawner.spawn(button_task(1, btn1)));
+    unwrap!(spawner.spawn(button_task(2, btn2)));
+    unwrap!(spawner.spawn(button_task(3, btn3)));
+    unwrap!(spawner.spawn(button_task(4, btn4)));
+}
diff --git a/examples/nrf52840/src/bin/i2s_effect.rs b/examples/nrf52840/src/bin/i2s_effect.rs
new file mode 100644
index 000000000..3cca005b1
--- /dev/null
+++ b/examples/nrf52840/src/bin/i2s_effect.rs
@@ -0,0 +1,117 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::f32::consts::PI;
+
+use defmt::{error, info};
+use embassy_executor::Spawner;
+use embassy_nrf::i2s::{self, Channels, Config, MasterClock, MultiBuffering, Sample as _, SampleWidth, I2S};
+use embassy_nrf::interrupt;
+use {defmt_rtt as _, panic_probe as _};
+
+type Sample = i16;
+
+const NUM_BUFFERS: usize = 2;
+const NUM_SAMPLES: usize = 4;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+
+    let master_clock: MasterClock = i2s::ExactSampleRate::_50000.into();
+
+    let sample_rate = master_clock.sample_rate();
+    info!("Sample rate: {}", sample_rate);
+
+    let config = Config::default()
+        .sample_width(SampleWidth::_16bit)
+        .channels(Channels::MonoLeft);
+
+    let irq = interrupt::take!(I2S);
+    let buffers_out = MultiBuffering::<Sample, NUM_BUFFERS, NUM_SAMPLES>::new();
+    let buffers_in = MultiBuffering::<Sample, NUM_BUFFERS, NUM_SAMPLES>::new();
+    let mut full_duplex_stream = I2S::master(p.I2S, irq, p.P0_25, p.P0_26, p.P0_27, master_clock, config).full_duplex(
+        p.P0_29,
+        p.P0_28,
+        buffers_out,
+        buffers_in,
+    );
+
+    let mut modulator = SineOsc::new();
+    modulator.set_frequency(8.0, 1.0 / sample_rate as f32);
+    modulator.set_amplitude(1.0);
+
+    full_duplex_stream.start().await.expect("I2S Start");
+
+    loop {
+        let (buff_out, buff_in) = full_duplex_stream.buffers();
+        for i in 0..NUM_SAMPLES {
+            let modulation = (Sample::SCALE as f32 * bipolar_to_unipolar(modulator.generate())) as Sample;
+            buff_out[i] = buff_in[i] * modulation;
+        }
+
+        if let Err(err) = full_duplex_stream.send_and_receive().await {
+            error!("{}", err);
+        }
+    }
+}
+
+struct SineOsc {
+    amplitude: f32,
+    modulo: f32,
+    phase_inc: f32,
+}
+
+impl SineOsc {
+    const B: f32 = 4.0 / PI;
+    const C: f32 = -4.0 / (PI * PI);
+    const P: f32 = 0.225;
+
+    pub fn new() -> Self {
+        Self {
+            amplitude: 1.0,
+            modulo: 0.0,
+            phase_inc: 0.0,
+        }
+    }
+
+    pub fn set_frequency(&mut self, freq: f32, inv_sample_rate: f32) {
+        self.phase_inc = freq * inv_sample_rate;
+    }
+
+    pub fn set_amplitude(&mut self, amplitude: f32) {
+        self.amplitude = amplitude;
+    }
+
+    pub fn generate(&mut self) -> f32 {
+        let signal = self.parabolic_sin(self.modulo);
+        self.modulo += self.phase_inc;
+        if self.modulo < 0.0 {
+            self.modulo += 1.0;
+        } else if self.modulo > 1.0 {
+            self.modulo -= 1.0;
+        }
+        signal * self.amplitude
+    }
+
+    fn parabolic_sin(&mut self, modulo: f32) -> f32 {
+        let angle = PI - modulo * 2.0 * PI;
+        let y = Self::B * angle + Self::C * angle * abs(angle);
+        Self::P * (y * abs(y) - y) + y
+    }
+}
+
+#[inline]
+fn abs(value: f32) -> f32 {
+    if value < 0.0 {
+        -value
+    } else {
+        value
+    }
+}
+
+#[inline]
+fn bipolar_to_unipolar(value: f32) -> f32 {
+    (value + 1.0) / 2.0
+}
diff --git a/examples/nrf52840/src/bin/i2s_monitor.rs b/examples/nrf52840/src/bin/i2s_monitor.rs
new file mode 100644
index 000000000..48eb7d581
--- /dev/null
+++ b/examples/nrf52840/src/bin/i2s_monitor.rs
@@ -0,0 +1,115 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{debug, error, info};
+use embassy_executor::Spawner;
+use embassy_nrf::i2s::{self, Channels, Config, DoubleBuffering, MasterClock, Sample as _, SampleWidth, I2S};
+use embassy_nrf::interrupt;
+use embassy_nrf::pwm::{Prescaler, SimplePwm};
+use {defmt_rtt as _, panic_probe as _};
+
+type Sample = i16;
+
+const NUM_SAMPLES: usize = 500;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+
+    let master_clock: MasterClock = i2s::ExactSampleRate::_50000.into();
+
+    let sample_rate = master_clock.sample_rate();
+    info!("Sample rate: {}", sample_rate);
+
+    let config = Config::default()
+        .sample_width(SampleWidth::_16bit)
+        .channels(Channels::MonoLeft);
+
+    let irq = interrupt::take!(I2S);
+    let buffers = DoubleBuffering::<Sample, NUM_SAMPLES>::new();
+    let mut input_stream =
+        I2S::master(p.I2S, irq, p.P0_25, p.P0_26, p.P0_27, master_clock, config).input(p.P0_29, buffers);
+
+    // Configure the PWM to use the pins corresponding to the RGB leds
+    let mut pwm = SimplePwm::new_3ch(p.PWM0, p.P0_23, p.P0_22, p.P0_24);
+    pwm.set_prescaler(Prescaler::Div1);
+    pwm.set_max_duty(255);
+
+    let mut rms_online = RmsOnline::<NUM_SAMPLES>::default();
+
+    input_stream.start().await.expect("I2S Start");
+
+    loop {
+        let rms = rms_online.process(input_stream.buffer());
+        let rgb = rgb_from_rms(rms);
+
+        debug!("RMS: {}, RGB: {:?}", rms, rgb);
+        for i in 0..3 {
+            pwm.set_duty(i, rgb[i].into());
+        }
+
+        if let Err(err) = input_stream.receive().await {
+            error!("{}", err);
+        }
+    }
+}
+
+/// RMS from 0.0 until 0.75 will give green with a proportional intensity
+/// RMS from 0.75 until 0.9 will give a blend between orange and red proportionally to the intensity
+/// RMS above 0.9 will give a red with a proportional intensity
+fn rgb_from_rms(rms: f32) -> [u8; 3] {
+    if rms < 0.75 {
+        let intensity = rms / 0.75;
+        [0, (intensity * 165.0) as u8, 0]
+    } else if rms < 0.9 {
+        let intensity = (rms - 0.75) / 0.15;
+        [200, 165 - (165.0 * intensity) as u8, 0]
+    } else {
+        let intensity = (rms - 0.9) / 0.1;
+        [200 + (55.0 * intensity) as u8, 0, 0]
+    }
+}
+
+pub struct RmsOnline<const N: usize> {
+    pub squares: [f32; N],
+    pub head: usize,
+}
+
+impl<const N: usize> Default for RmsOnline<N> {
+    fn default() -> Self {
+        RmsOnline {
+            squares: [0.0; N],
+            head: 0,
+        }
+    }
+}
+
+impl<const N: usize> RmsOnline<N> {
+    pub fn reset(&mut self) {
+        self.squares = [0.0; N];
+        self.head = 0;
+    }
+
+    pub fn process(&mut self, buf: &[Sample]) -> f32 {
+        buf.iter()
+            .for_each(|sample| self.push(*sample as f32 / Sample::SCALE as f32));
+
+        let sum_of_squares = self.squares.iter().fold(0.0, |acc, v| acc + *v);
+        Self::approx_sqrt(sum_of_squares / N as f32)
+    }
+
+    pub fn push(&mut self, signal: f32) {
+        let square = signal * signal;
+        self.squares[self.head] = square;
+        self.head = (self.head + 1) % N;
+    }
+
+    /// Approximated sqrt taken from [micromath]
+    ///
+    /// [micromath]: https://docs.rs/micromath/latest/src/micromath/float/sqrt.rs.html#11-17
+    ///
+    fn approx_sqrt(value: f32) -> f32 {
+        f32::from_bits((value.to_bits() + 0x3f80_0000) >> 1)
+    }
+}
diff --git a/examples/nrf52840/src/bin/i2s_waveform.rs b/examples/nrf52840/src/bin/i2s_waveform.rs
new file mode 100644
index 000000000..1b0e8ebc8
--- /dev/null
+++ b/examples/nrf52840/src/bin/i2s_waveform.rs
@@ -0,0 +1,151 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::f32::consts::PI;
+
+use defmt::{error, info};
+use embassy_executor::Spawner;
+use embassy_nrf::i2s::{self, Channels, Config, DoubleBuffering, MasterClock, Sample as _, SampleWidth, I2S};
+use embassy_nrf::interrupt;
+use {defmt_rtt as _, panic_probe as _};
+
+type Sample = i16;
+
+const NUM_SAMPLES: usize = 50;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+
+    let master_clock: MasterClock = i2s::ExactSampleRate::_50000.into();
+
+    let sample_rate = master_clock.sample_rate();
+    info!("Sample rate: {}", sample_rate);
+
+    let config = Config::default()
+        .sample_width(SampleWidth::_16bit)
+        .channels(Channels::MonoLeft);
+
+    let irq = interrupt::take!(I2S);
+    let buffers = DoubleBuffering::<Sample, NUM_SAMPLES>::new();
+    let mut output_stream =
+        I2S::master(p.I2S, irq, p.P0_25, p.P0_26, p.P0_27, master_clock, config).output(p.P0_28, buffers);
+
+    let mut waveform = Waveform::new(1.0 / sample_rate as f32);
+
+    waveform.process(output_stream.buffer());
+
+    output_stream.start().await.expect("I2S Start");
+
+    loop {
+        waveform.process(output_stream.buffer());
+
+        if let Err(err) = output_stream.send().await {
+            error!("{}", err);
+        }
+    }
+}
+
+struct Waveform {
+    inv_sample_rate: f32,
+    carrier: SineOsc,
+    freq_mod: SineOsc,
+    amp_mod: SineOsc,
+}
+
+impl Waveform {
+    fn new(inv_sample_rate: f32) -> Self {
+        let mut carrier = SineOsc::new();
+        carrier.set_frequency(110.0, inv_sample_rate);
+
+        let mut freq_mod = SineOsc::new();
+        freq_mod.set_frequency(1.0, inv_sample_rate);
+        freq_mod.set_amplitude(1.0);
+
+        let mut amp_mod = SineOsc::new();
+        amp_mod.set_frequency(16.0, inv_sample_rate);
+        amp_mod.set_amplitude(0.5);
+
+        Self {
+            inv_sample_rate,
+            carrier,
+            freq_mod,
+            amp_mod,
+        }
+    }
+
+    fn process(&mut self, buf: &mut [Sample]) {
+        for sample in buf.chunks_mut(1) {
+            let freq_modulation = bipolar_to_unipolar(self.freq_mod.generate());
+            self.carrier
+                .set_frequency(110.0 + 440.0 * freq_modulation, self.inv_sample_rate);
+
+            let amp_modulation = bipolar_to_unipolar(self.amp_mod.generate());
+            self.carrier.set_amplitude(amp_modulation);
+
+            let signal = self.carrier.generate();
+
+            sample[0] = (Sample::SCALE as f32 * signal) as Sample;
+        }
+    }
+}
+
+struct SineOsc {
+    amplitude: f32,
+    modulo: f32,
+    phase_inc: f32,
+}
+
+impl SineOsc {
+    const B: f32 = 4.0 / PI;
+    const C: f32 = -4.0 / (PI * PI);
+    const P: f32 = 0.225;
+
+    pub fn new() -> Self {
+        Self {
+            amplitude: 1.0,
+            modulo: 0.0,
+            phase_inc: 0.0,
+        }
+    }
+
+    pub fn set_frequency(&mut self, freq: f32, inv_sample_rate: f32) {
+        self.phase_inc = freq * inv_sample_rate;
+    }
+
+    pub fn set_amplitude(&mut self, amplitude: f32) {
+        self.amplitude = amplitude;
+    }
+
+    pub fn generate(&mut self) -> f32 {
+        let signal = self.parabolic_sin(self.modulo);
+        self.modulo += self.phase_inc;
+        if self.modulo < 0.0 {
+            self.modulo += 1.0;
+        } else if self.modulo > 1.0 {
+            self.modulo -= 1.0;
+        }
+        signal * self.amplitude
+    }
+
+    fn parabolic_sin(&mut self, modulo: f32) -> f32 {
+        let angle = PI - modulo * 2.0 * PI;
+        let y = Self::B * angle + Self::C * angle * abs(angle);
+        Self::P * (y * abs(y) - y) + y
+    }
+}
+
+#[inline]
+fn abs(value: f32) -> f32 {
+    if value < 0.0 {
+        -value
+    } else {
+        value
+    }
+}
+
+#[inline]
+fn bipolar_to_unipolar(value: f32) -> f32 {
+    (value + 1.0) / 2.0
+}
diff --git a/examples/nrf52840/src/bin/lora_p2p_report.rs b/examples/nrf52840/src/bin/lora_p2p_report.rs
new file mode 100644
index 000000000..d512b83f6
--- /dev/null
+++ b/examples/nrf52840/src/bin/lora_p2p_report.rs
@@ -0,0 +1,78 @@
+//! This example runs on the RAK4631 WisBlock, which has an nRF52840 MCU and Semtech Sx126x radio.
+//! Other nrf/sx126x combinations may work with appropriate pin modifications.
+//! It demonstates LORA P2P functionality in conjunction with example lora_p2p_sense.rs.
+#![no_std]
+#![no_main]
+#![macro_use]
+#![allow(dead_code)]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_lora::sx126x::*;
+use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pin as _, Pull};
+use embassy_nrf::{interrupt, spim};
+use embassy_time::{Duration, Timer};
+use lorawan_device::async_device::radio::{Bandwidth, CodingRate, PhyRxTx, RfConfig, SpreadingFactor};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut spi_config = spim::Config::default();
+    spi_config.frequency = spim::Frequency::M16;
+
+    let mut radio = {
+        let irq = interrupt::take!(SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1);
+        let spim = spim::Spim::new(p.TWISPI1, irq, p.P1_11, p.P1_13, p.P1_12, spi_config);
+
+        let cs = Output::new(p.P1_10.degrade(), Level::High, OutputDrive::Standard);
+        let reset = Output::new(p.P1_06.degrade(), Level::High, OutputDrive::Standard);
+        let dio1 = Input::new(p.P1_15.degrade(), Pull::Down);
+        let busy = Input::new(p.P1_14.degrade(), Pull::Down);
+        let antenna_rx = Output::new(p.P1_05.degrade(), Level::Low, OutputDrive::Standard);
+        let antenna_tx = Output::new(p.P1_07.degrade(), Level::Low, OutputDrive::Standard);
+
+        match Sx126xRadio::new(spim, cs, reset, antenna_rx, antenna_tx, dio1, busy, false).await {
+            Ok(r) => r,
+            Err(err) => {
+                info!("Sx126xRadio error = {}", err);
+                return;
+            }
+        }
+    };
+
+    let mut debug_indicator = Output::new(p.P1_03, Level::Low, OutputDrive::Standard);
+    let mut start_indicator = Output::new(p.P1_04, Level::Low, OutputDrive::Standard);
+
+    start_indicator.set_high();
+    Timer::after(Duration::from_secs(5)).await;
+    start_indicator.set_low();
+
+    loop {
+        let rf_config = RfConfig {
+            frequency: 903900000, // channel in Hz
+            bandwidth: Bandwidth::_250KHz,
+            spreading_factor: SpreadingFactor::_10,
+            coding_rate: CodingRate::_4_8,
+        };
+
+        let mut buffer = [00u8; 100];
+
+        // P2P receive
+        match radio.rx(rf_config, &mut buffer).await {
+            Ok((buffer_len, rx_quality)) => info!(
+                "RX received = {:?} with length = {} rssi = {} snr = {}",
+                &buffer[0..buffer_len],
+                buffer_len,
+                rx_quality.rssi(),
+                rx_quality.snr()
+            ),
+            Err(err) => info!("RX error = {}", err),
+        }
+
+        debug_indicator.set_high();
+        Timer::after(Duration::from_secs(2)).await;
+        debug_indicator.set_low();
+    }
+}
diff --git a/examples/nrf52840/src/bin/lora_p2p_sense.rs b/examples/nrf52840/src/bin/lora_p2p_sense.rs
new file mode 100644
index 000000000..b9768874b
--- /dev/null
+++ b/examples/nrf52840/src/bin/lora_p2p_sense.rs
@@ -0,0 +1,125 @@
+//! This example runs on the RAK4631 WisBlock, which has an nRF52840 MCU and Semtech Sx126x radio.
+//! Other nrf/sx126x combinations may work with appropriate pin modifications.
+//! It demonstates LORA P2P functionality in conjunction with example lora_p2p_report.rs.
+#![no_std]
+#![no_main]
+#![macro_use]
+#![feature(type_alias_impl_trait)]
+#![feature(alloc_error_handler)]
+#![allow(incomplete_features)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_lora::sx126x::*;
+use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pin as _, Pull};
+use embassy_nrf::{interrupt, spim};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::pubsub::{PubSubChannel, Publisher};
+use embassy_time::{Duration, Timer};
+use lorawan_device::async_device::radio::{Bandwidth, CodingRate, PhyRxTx, RfConfig, SpreadingFactor, TxConfig};
+use {defmt_rtt as _, panic_probe as _, panic_probe as _};
+
+// Message bus: queue of 2, 1 subscriber (Lora P2P), 2 publishers (temperature, motion detection)
+static MESSAGE_BUS: PubSubChannel<CriticalSectionRawMutex, Message, 2, 1, 2> = PubSubChannel::new();
+
+#[derive(Clone, defmt::Format)]
+enum Message {
+    Temperature(i32),
+    MotionDetected,
+}
+
+#[embassy_executor::task]
+async fn temperature_task(publisher: Publisher<'static, CriticalSectionRawMutex, Message, 2, 1, 2>) {
+    // Publish a fake temperature every 43 seconds, minimizing LORA traffic.
+    loop {
+        Timer::after(Duration::from_secs(43)).await;
+        publisher.publish(Message::Temperature(9)).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn motion_detection_task(publisher: Publisher<'static, CriticalSectionRawMutex, Message, 2, 1, 2>) {
+    // Publish a fake motion detection every 79 seconds, minimizing LORA traffic.
+    loop {
+        Timer::after(Duration::from_secs(79)).await;
+        publisher.publish(Message::MotionDetected).await;
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    // set up to funnel temperature and motion detection events to the Lora Tx task
+    let mut lora_tx_subscriber = unwrap!(MESSAGE_BUS.subscriber());
+    let temperature_publisher = unwrap!(MESSAGE_BUS.publisher());
+    let motion_detection_publisher = unwrap!(MESSAGE_BUS.publisher());
+
+    let mut spi_config = spim::Config::default();
+    spi_config.frequency = spim::Frequency::M16;
+
+    let mut radio = {
+        let irq = interrupt::take!(SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1);
+        let spim = spim::Spim::new(p.TWISPI1, irq, p.P1_11, p.P1_13, p.P1_12, spi_config);
+
+        let cs = Output::new(p.P1_10.degrade(), Level::High, OutputDrive::Standard);
+        let reset = Output::new(p.P1_06.degrade(), Level::High, OutputDrive::Standard);
+        let dio1 = Input::new(p.P1_15.degrade(), Pull::Down);
+        let busy = Input::new(p.P1_14.degrade(), Pull::Down);
+        let antenna_rx = Output::new(p.P1_05.degrade(), Level::Low, OutputDrive::Standard);
+        let antenna_tx = Output::new(p.P1_07.degrade(), Level::Low, OutputDrive::Standard);
+
+        match Sx126xRadio::new(spim, cs, reset, antenna_rx, antenna_tx, dio1, busy, false).await {
+            Ok(r) => r,
+            Err(err) => {
+                info!("Sx126xRadio error = {}", err);
+                return;
+            }
+        }
+    };
+
+    let mut start_indicator = Output::new(p.P1_04, Level::Low, OutputDrive::Standard);
+
+    start_indicator.set_high();
+    Timer::after(Duration::from_secs(5)).await;
+    start_indicator.set_low();
+
+    match radio.lora.sleep().await {
+        Ok(()) => info!("Sleep successful"),
+        Err(err) => info!("Sleep unsuccessful = {}", err),
+    }
+
+    unwrap!(spawner.spawn(temperature_task(temperature_publisher)));
+    unwrap!(spawner.spawn(motion_detection_task(motion_detection_publisher)));
+
+    loop {
+        let message = lora_tx_subscriber.next_message_pure().await;
+
+        let tx_config = TxConfig {
+            // 11 byte maximum payload for Bandwidth 125 and SF 10
+            pw: 10, // up to 20
+            rf: RfConfig {
+                frequency: 903900000, // channel in Hz, not MHz
+                bandwidth: Bandwidth::_250KHz,
+                spreading_factor: SpreadingFactor::_10,
+                coding_rate: CodingRate::_4_8,
+            },
+        };
+
+        let mut buffer = [0x00u8];
+        match message {
+            Message::Temperature(temperature) => buffer[0] = temperature as u8,
+            Message::MotionDetected => buffer[0] = 0x01u8,
+        };
+
+        // unencrypted
+        match radio.tx(tx_config, &buffer).await {
+            Ok(ret_val) => info!("TX ret_val = {}", ret_val),
+            Err(err) => info!("TX error = {}", err),
+        }
+
+        match radio.lora.sleep().await {
+            Ok(()) => info!("Sleep successful"),
+            Err(err) => info!("Sleep unsuccessful = {}", err),
+        }
+    }
+}
diff --git a/examples/nrf52840/src/bin/manually_create_executor.rs b/examples/nrf52840/src/bin/manually_create_executor.rs
new file mode 100644
index 000000000..12ce660f9
--- /dev/null
+++ b/examples/nrf52840/src/bin/manually_create_executor.rs
@@ -0,0 +1,49 @@
+// This example showcases how to manually create an executor.
+// This is what the #[embassy::main] macro does behind the scenes.
+
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use cortex_m_rt::entry;
+use defmt::{info, unwrap};
+use embassy_executor::Executor;
+use embassy_time::{Duration, Timer};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task]
+async fn run1() {
+    loop {
+        info!("BIG INFREQUENT TICK");
+        Timer::after(Duration::from_ticks(64000)).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn run2() {
+    loop {
+        info!("tick");
+        Timer::after(Duration::from_ticks(13000)).await;
+    }
+}
+
+static EXECUTOR: StaticCell<Executor> = StaticCell::new();
+
+#[entry]
+fn main() -> ! {
+    info!("Hello World!");
+
+    let _p = embassy_nrf::init(Default::default());
+
+    // Create the executor and put it in a StaticCell, because `run` needs `&'static mut Executor`.
+    let executor = EXECUTOR.init(Executor::new());
+
+    // Run it.
+    // `run` calls the closure then runs the executor forever. It never returns.
+    executor.run(|spawner| {
+        // Here we get access to a spawner to spawn the initial tasks.
+        unwrap!(spawner.spawn(run1()));
+        unwrap!(spawner.spawn(run2()));
+    });
+}
diff --git a/examples/nrf52840/src/bin/multiprio.rs b/examples/nrf52840/src/bin/multiprio.rs
new file mode 100644
index 000000000..25806ae48
--- /dev/null
+++ b/examples/nrf52840/src/bin/multiprio.rs
@@ -0,0 +1,140 @@
+//! 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]
+#![feature(type_alias_impl_trait)]
+
+use cortex_m_rt::entry;
+use defmt::{info, unwrap};
+use embassy_nrf::executor::{Executor, InterruptExecutor};
+use embassy_nrf::interrupt;
+use embassy_nrf::interrupt::InterruptExt;
+use embassy_time::{Duration, Instant, Timer};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task]
+async fn run_high() {
+    loop {
+        info!("        [high] tick!");
+        Timer::after(Duration::from_ticks(27374)).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
+        cortex_m::asm::delay(32_000_000); // ~1 second
+
+        let end = Instant::now();
+        let ms = end.duration_since(start).as_ticks() / 33;
+        info!("    [med] done in {} ms", ms);
+
+        Timer::after(Duration::from_ticks(23421)).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
+        cortex_m::asm::delay(64_000_000); // ~2 seconds
+
+        let end = Instant::now();
+        let ms = end.duration_since(start).as_ticks() / 33;
+        info!("[low] done in {} ms", ms);
+
+        Timer::after(Duration::from_ticks(32983)).await;
+    }
+}
+
+static EXECUTOR_HIGH: StaticCell<InterruptExecutor<interrupt::SWI1_EGU1>> = StaticCell::new();
+static EXECUTOR_MED: StaticCell<InterruptExecutor<interrupt::SWI0_EGU0>> = StaticCell::new();
+static EXECUTOR_LOW: StaticCell<Executor> = StaticCell::new();
+
+#[entry]
+fn main() -> ! {
+    info!("Hello World!");
+
+    let _p = embassy_nrf::init(Default::default());
+
+    // High-priority executor: SWI1_EGU1, priority level 6
+    let irq = interrupt::take!(SWI1_EGU1);
+    irq.set_priority(interrupt::Priority::P6);
+    let executor = EXECUTOR_HIGH.init(InterruptExecutor::new(irq));
+    let spawner = executor.start();
+    unwrap!(spawner.spawn(run_high()));
+
+    // Medium-priority executor: SWI0_EGU0, priority level 7
+    let irq = interrupt::take!(SWI0_EGU0);
+    irq.set_priority(interrupt::Priority::P7);
+    let executor = EXECUTOR_MED.init(InterruptExecutor::new(irq));
+    let spawner = executor.start();
+    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/nrf52840/src/bin/mutex.rs b/examples/nrf52840/src/bin/mutex.rs
new file mode 100644
index 000000000..c402c6ba1
--- /dev/null
+++ b/examples/nrf52840/src/bin/mutex.rs
@@ -0,0 +1,42 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+static MUTEX: Mutex<ThreadModeRawMutex, u32> = Mutex::new(0);
+
+#[embassy_executor::task]
+async fn my_task() {
+    loop {
+        {
+            let mut m = MUTEX.lock().await;
+            info!("start long operation");
+            *m += 1000;
+
+            // Hold the mutex for a long time.
+            Timer::after(Duration::from_secs(1)).await;
+            info!("end long operation: count = {}", *m);
+        }
+
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let _p = embassy_nrf::init(Default::default());
+    unwrap!(spawner.spawn(my_task()));
+
+    loop {
+        Timer::after(Duration::from_millis(300)).await;
+        let mut m = MUTEX.lock().await;
+        *m += 1;
+        info!("short operation: count = {}", *m);
+    }
+}
diff --git a/examples/nrf52840/src/bin/nvmc.rs b/examples/nrf52840/src/bin/nvmc.rs
new file mode 100644
index 000000000..75d090fbb
--- /dev/null
+++ b/examples/nrf52840/src/bin/nvmc.rs
@@ -0,0 +1,43 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_nrf::nvmc::Nvmc;
+use embassy_time::{Duration, Timer};
+use embedded_storage::nor_flash::{NorFlash, ReadNorFlash};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Hello NVMC!");
+
+    // probe-run breaks without this, I'm not sure why.
+    Timer::after(Duration::from_secs(1)).await;
+
+    let mut f = Nvmc::new(p.NVMC);
+    const ADDR: u32 = 0x80000;
+
+    info!("Reading...");
+    let mut buf = [0u8; 4];
+    unwrap!(f.read(ADDR, &mut buf));
+    info!("Read: {=[u8]:x}", buf);
+
+    info!("Erasing...");
+    unwrap!(f.erase(ADDR, ADDR + 4096));
+
+    info!("Reading...");
+    let mut buf = [0u8; 4];
+    unwrap!(f.read(ADDR, &mut buf));
+    info!("Read: {=[u8]:x}", buf);
+
+    info!("Writing...");
+    unwrap!(f.write(ADDR, &[1, 2, 3, 4]));
+
+    info!("Reading...");
+    let mut buf = [0u8; 4];
+    unwrap!(f.read(ADDR, &mut buf));
+    info!("Read: {=[u8]:x}", buf);
+}
diff --git a/examples/nrf52840/src/bin/pdm.rs b/examples/nrf52840/src/bin/pdm.rs
new file mode 100644
index 000000000..7388580fb
--- /dev/null
+++ b/examples/nrf52840/src/bin/pdm.rs
@@ -0,0 +1,33 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::pdm::{Config, Pdm};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_p: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let config = Config::default();
+    let mut pdm = Pdm::new(p.PDM, interrupt::take!(PDM), p.P0_01, p.P0_00, config);
+
+    loop {
+        pdm.start().await;
+
+        // wait some time till the microphon settled
+        Timer::after(Duration::from_millis(1000)).await;
+
+        const SAMPLES: usize = 2048;
+        let mut buf = [0i16; SAMPLES];
+        pdm.sample(&mut buf).await.unwrap();
+
+        info!("samples: {:?}", &buf);
+
+        pdm.stop().await;
+        Timer::after(Duration::from_millis(100)).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/ppi.rs b/examples/nrf52840/src/bin/ppi.rs
new file mode 100644
index 000000000..d74ce4064
--- /dev/null
+++ b/examples/nrf52840/src/bin/ppi.rs
@@ -0,0 +1,73 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::future::pending;
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
+use embassy_nrf::gpiote::{self, InputChannel, InputChannelPolarity};
+use embassy_nrf::ppi::Ppi;
+use gpiote::{OutputChannel, OutputChannelPolarity};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Starting!");
+
+    let button1 = InputChannel::new(
+        p.GPIOTE_CH0,
+        Input::new(p.P0_11, Pull::Up),
+        InputChannelPolarity::HiToLo,
+    );
+    let button2 = InputChannel::new(
+        p.GPIOTE_CH1,
+        Input::new(p.P0_12, Pull::Up),
+        InputChannelPolarity::HiToLo,
+    );
+    let button3 = InputChannel::new(
+        p.GPIOTE_CH2,
+        Input::new(p.P0_24, Pull::Up),
+        InputChannelPolarity::HiToLo,
+    );
+    let button4 = InputChannel::new(
+        p.GPIOTE_CH3,
+        Input::new(p.P0_25, Pull::Up),
+        InputChannelPolarity::HiToLo,
+    );
+
+    let led1 = OutputChannel::new(
+        p.GPIOTE_CH4,
+        Output::new(p.P0_13, Level::Low, OutputDrive::Standard),
+        OutputChannelPolarity::Toggle,
+    );
+
+    let led2 = OutputChannel::new(
+        p.GPIOTE_CH5,
+        Output::new(p.P0_14, Level::Low, OutputDrive::Standard),
+        OutputChannelPolarity::Toggle,
+    );
+
+    let mut ppi = Ppi::new_one_to_one(p.PPI_CH0, button1.event_in(), led1.task_out());
+    ppi.enable();
+
+    let mut ppi = Ppi::new_one_to_one(p.PPI_CH1, button2.event_in(), led1.task_clr());
+    ppi.enable();
+
+    let mut ppi = Ppi::new_one_to_one(p.PPI_CH2, button3.event_in(), led1.task_set());
+    ppi.enable();
+
+    let mut ppi = Ppi::new_one_to_two(p.PPI_CH3, button4.event_in(), led1.task_out(), led2.task_out());
+    ppi.enable();
+
+    info!("PPI setup!");
+    info!("Press button 1 to toggle LED 1");
+    info!("Press button 2 to turn on LED 1");
+    info!("Press button 3 to turn off LED 1");
+    info!("Press button 4 to toggle LEDs 1 and 2");
+
+    // Block forever so the above drivers don't get dropped
+    pending::<()>().await;
+}
diff --git a/examples/nrf52840/src/bin/pubsub.rs b/examples/nrf52840/src/bin/pubsub.rs
new file mode 100644
index 000000000..688e6d075
--- /dev/null
+++ b/examples/nrf52840/src/bin/pubsub.rs
@@ -0,0 +1,107 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::unwrap;
+use embassy_executor::Spawner;
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::pubsub::{DynSubscriber, PubSubChannel, Subscriber};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+/// Create the message bus. It has a queue of 4, supports 3 subscribers and 1 publisher
+static MESSAGE_BUS: PubSubChannel<ThreadModeRawMutex, Message, 4, 3, 1> = PubSubChannel::new();
+
+#[derive(Clone, defmt::Format)]
+enum Message {
+    A,
+    B,
+    C,
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let _p = embassy_nrf::init(Default::default());
+    defmt::info!("Hello World!");
+
+    // It's good to set up the subscribers before publishing anything.
+    // A subscriber will only yield messages that have been published after its creation.
+
+    spawner.must_spawn(fast_logger(unwrap!(MESSAGE_BUS.subscriber())));
+    spawner.must_spawn(slow_logger(unwrap!(MESSAGE_BUS.dyn_subscriber())));
+    spawner.must_spawn(slow_logger_pure(unwrap!(MESSAGE_BUS.dyn_subscriber())));
+
+    // Get a publisher
+    let message_publisher = unwrap!(MESSAGE_BUS.publisher());
+    // We can't get more (normal) publishers
+    // We can have an infinite amount of immediate publishers. They can't await a publish, only do an immediate publish
+    defmt::assert!(MESSAGE_BUS.publisher().is_err());
+
+    let mut index = 0;
+    loop {
+        Timer::after(Duration::from_millis(500)).await;
+
+        let message = match index % 3 {
+            0 => Message::A,
+            1 => Message::B,
+            2..=u32::MAX => Message::C,
+        };
+
+        // We publish immediately and don't await anything.
+        // If the queue is full, it will cause the oldest message to not be received by some/all subscribers
+        message_publisher.publish_immediate(message);
+
+        // Try to comment out the last one and uncomment this line below.
+        // The behaviour will change:
+        // - The subscribers won't miss any messages any more
+        // - Trying to publish now has some wait time when the queue is full
+
+        // message_publisher.publish(message).await;
+
+        index += 1;
+    }
+}
+
+/// A logger task that just awaits the messages it receives
+///
+/// This takes the generic `Subscriber`. This is most performant, but requires you to write down all of the generics
+#[embassy_executor::task]
+async fn fast_logger(mut messages: Subscriber<'static, ThreadModeRawMutex, Message, 4, 3, 1>) {
+    loop {
+        let message = messages.next_message().await;
+        defmt::info!("Received message at fast logger: {:?}", message);
+    }
+}
+
+/// A logger task that awaits the messages, but also does some other work.
+/// Because of this, depeding on how the messages were published, the subscriber might miss some messages
+///
+/// This takes the dynamic `DynSubscriber`. This is not as performant as the generic version, but let's you ignore some of the generics
+#[embassy_executor::task]
+async fn slow_logger(mut messages: DynSubscriber<'static, Message>) {
+    loop {
+        // Do some work
+        Timer::after(Duration::from_millis(2000)).await;
+
+        // If the publisher has used the `publish_immediate` function, then we may receive a lag message here
+        let message = messages.next_message().await;
+        defmt::info!("Received message at slow logger: {:?}", message);
+
+        // If the previous one was a lag message, then we should receive the next message here immediately
+        let message = messages.next_message().await;
+        defmt::info!("Received message at slow logger: {:?}", message);
+    }
+}
+
+/// Same as `slow_logger` but it ignores lag results
+#[embassy_executor::task]
+async fn slow_logger_pure(mut messages: DynSubscriber<'static, Message>) {
+    loop {
+        // Do some work
+        Timer::after(Duration::from_millis(2000)).await;
+
+        // Instead of receiving lags here, we just ignore that and read the next message
+        let message = messages.next_message_pure().await;
+        defmt::info!("Received message at slow logger pure: {:?}", message);
+    }
+}
diff --git a/examples/nrf52840/src/bin/pwm.rs b/examples/nrf52840/src/bin/pwm.rs
new file mode 100644
index 000000000..1698c0bc8
--- /dev/null
+++ b/examples/nrf52840/src/bin/pwm.rs
@@ -0,0 +1,89 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::pwm::{Prescaler, SimplePwm};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+// for i in range(1024): print(int((math.sin(i/512*math.pi)*0.4+0.5)**2*32767), ', ', end='')
+static DUTY: [u16; 1024] = [
+    8191, 8272, 8353, 8434, 8516, 8598, 8681, 8764, 8847, 8931, 9015, 9099, 9184, 9269, 9354, 9440, 9526, 9613, 9700,
+    9787, 9874, 9962, 10050, 10139, 10227, 10316, 10406, 10495, 10585, 10675, 10766, 10857, 10948, 11039, 11131, 11223,
+    11315, 11407, 11500, 11592, 11685, 11779, 11872, 11966, 12060, 12154, 12248, 12343, 12438, 12533, 12628, 12723,
+    12818, 12914, 13010, 13106, 13202, 13298, 13394, 13491, 13587, 13684, 13781, 13878, 13975, 14072, 14169, 14266,
+    14364, 14461, 14558, 14656, 14754, 14851, 14949, 15046, 15144, 15242, 15339, 15437, 15535, 15632, 15730, 15828,
+    15925, 16023, 16120, 16218, 16315, 16412, 16510, 16607, 16704, 16801, 16898, 16995, 17091, 17188, 17284, 17380,
+    17477, 17572, 17668, 17764, 17859, 17955, 18050, 18145, 18239, 18334, 18428, 18522, 18616, 18710, 18803, 18896,
+    18989, 19082, 19174, 19266, 19358, 19449, 19540, 19631, 19722, 19812, 19902, 19991, 20081, 20169, 20258, 20346,
+    20434, 20521, 20608, 20695, 20781, 20867, 20952, 21037, 21122, 21206, 21290, 21373, 21456, 21538, 21620, 21701,
+    21782, 21863, 21943, 22022, 22101, 22179, 22257, 22335, 22412, 22488, 22564, 22639, 22714, 22788, 22861, 22934,
+    23007, 23079, 23150, 23220, 23290, 23360, 23429, 23497, 23564, 23631, 23698, 23763, 23828, 23892, 23956, 24019,
+    24081, 24143, 24204, 24264, 24324, 24383, 24441, 24499, 24555, 24611, 24667, 24721, 24775, 24828, 24881, 24933,
+    24983, 25034, 25083, 25132, 25180, 25227, 25273, 25319, 25363, 25407, 25451, 25493, 25535, 25575, 25615, 25655,
+    25693, 25731, 25767, 25803, 25838, 25873, 25906, 25939, 25971, 26002, 26032, 26061, 26089, 26117, 26144, 26170,
+    26195, 26219, 26242, 26264, 26286, 26307, 26327, 26346, 26364, 26381, 26397, 26413, 26427, 26441, 26454, 26466,
+    26477, 26487, 26496, 26505, 26512, 26519, 26525, 26530, 26534, 26537, 26539, 26540, 26541, 26540, 26539, 26537,
+    26534, 26530, 26525, 26519, 26512, 26505, 26496, 26487, 26477, 26466, 26454, 26441, 26427, 26413, 26397, 26381,
+    26364, 26346, 26327, 26307, 26286, 26264, 26242, 26219, 26195, 26170, 26144, 26117, 26089, 26061, 26032, 26002,
+    25971, 25939, 25906, 25873, 25838, 25803, 25767, 25731, 25693, 25655, 25615, 25575, 25535, 25493, 25451, 25407,
+    25363, 25319, 25273, 25227, 25180, 25132, 25083, 25034, 24983, 24933, 24881, 24828, 24775, 24721, 24667, 24611,
+    24555, 24499, 24441, 24383, 24324, 24264, 24204, 24143, 24081, 24019, 23956, 23892, 23828, 23763, 23698, 23631,
+    23564, 23497, 23429, 23360, 23290, 23220, 23150, 23079, 23007, 22934, 22861, 22788, 22714, 22639, 22564, 22488,
+    22412, 22335, 22257, 22179, 22101, 22022, 21943, 21863, 21782, 21701, 21620, 21538, 21456, 21373, 21290, 21206,
+    21122, 21037, 20952, 20867, 20781, 20695, 20608, 20521, 20434, 20346, 20258, 20169, 20081, 19991, 19902, 19812,
+    19722, 19631, 19540, 19449, 19358, 19266, 19174, 19082, 18989, 18896, 18803, 18710, 18616, 18522, 18428, 18334,
+    18239, 18145, 18050, 17955, 17859, 17764, 17668, 17572, 17477, 17380, 17284, 17188, 17091, 16995, 16898, 16801,
+    16704, 16607, 16510, 16412, 16315, 16218, 16120, 16023, 15925, 15828, 15730, 15632, 15535, 15437, 15339, 15242,
+    15144, 15046, 14949, 14851, 14754, 14656, 14558, 14461, 14364, 14266, 14169, 14072, 13975, 13878, 13781, 13684,
+    13587, 13491, 13394, 13298, 13202, 13106, 13010, 12914, 12818, 12723, 12628, 12533, 12438, 12343, 12248, 12154,
+    12060, 11966, 11872, 11779, 11685, 11592, 11500, 11407, 11315, 11223, 11131, 11039, 10948, 10857, 10766, 10675,
+    10585, 10495, 10406, 10316, 10227, 10139, 10050, 9962, 9874, 9787, 9700, 9613, 9526, 9440, 9354, 9269, 9184, 9099,
+    9015, 8931, 8847, 8764, 8681, 8598, 8516, 8434, 8353, 8272, 8191, 8111, 8031, 7952, 7873, 7794, 7716, 7638, 7561,
+    7484, 7407, 7331, 7255, 7180, 7105, 7031, 6957, 6883, 6810, 6738, 6665, 6594, 6522, 6451, 6381, 6311, 6241, 6172,
+    6104, 6036, 5968, 5901, 5834, 5767, 5702, 5636, 5571, 5507, 5443, 5379, 5316, 5253, 5191, 5130, 5068, 5008, 4947,
+    4888, 4828, 4769, 4711, 4653, 4596, 4539, 4482, 4426, 4371, 4316, 4261, 4207, 4153, 4100, 4047, 3995, 3943, 3892,
+    3841, 3791, 3741, 3691, 3642, 3594, 3546, 3498, 3451, 3404, 3358, 3312, 3267, 3222, 3178, 3134, 3090, 3047, 3005,
+    2962, 2921, 2879, 2839, 2798, 2758, 2719, 2680, 2641, 2603, 2565, 2528, 2491, 2454, 2418, 2382, 2347, 2312, 2278,
+    2244, 2210, 2177, 2144, 2112, 2080, 2048, 2017, 1986, 1956, 1926, 1896, 1867, 1838, 1810, 1781, 1754, 1726, 1699,
+    1673, 1646, 1620, 1595, 1570, 1545, 1520, 1496, 1472, 1449, 1426, 1403, 1380, 1358, 1336, 1315, 1294, 1273, 1252,
+    1232, 1212, 1192, 1173, 1154, 1135, 1117, 1099, 1081, 1063, 1046, 1029, 1012, 996, 980, 964, 948, 933, 918, 903,
+    888, 874, 860, 846, 833, 819, 806, 793, 781, 768, 756, 744, 733, 721, 710, 699, 688, 677, 667, 657, 647, 637, 627,
+    618, 609, 599, 591, 582, 574, 565, 557, 549, 541, 534, 526, 519, 512, 505, 498, 492, 485, 479, 473, 467, 461, 455,
+    450, 444, 439, 434, 429, 424, 419, 415, 410, 406, 402, 398, 394, 390, 386, 383, 379, 376, 373, 370, 367, 364, 361,
+    359, 356, 354, 351, 349, 347, 345, 343, 342, 340, 338, 337, 336, 334, 333, 332, 331, 330, 330, 329, 328, 328, 328,
+    327, 327, 327, 327, 327, 328, 328, 328, 329, 330, 330, 331, 332, 333, 334, 336, 337, 338, 340, 342, 343, 345, 347,
+    349, 351, 354, 356, 359, 361, 364, 367, 370, 373, 376, 379, 383, 386, 390, 394, 398, 402, 406, 410, 415, 419, 424,
+    429, 434, 439, 444, 450, 455, 461, 467, 473, 479, 485, 492, 498, 505, 512, 519, 526, 534, 541, 549, 557, 565, 574,
+    582, 591, 599, 609, 618, 627, 637, 647, 657, 667, 677, 688, 699, 710, 721, 733, 744, 756, 768, 781, 793, 806, 819,
+    833, 846, 860, 874, 888, 903, 918, 933, 948, 964, 980, 996, 1012, 1029, 1046, 1063, 1081, 1099, 1117, 1135, 1154,
+    1173, 1192, 1212, 1232, 1252, 1273, 1294, 1315, 1336, 1358, 1380, 1403, 1426, 1449, 1472, 1496, 1520, 1545, 1570,
+    1595, 1620, 1646, 1673, 1699, 1726, 1754, 1781, 1810, 1838, 1867, 1896, 1926, 1956, 1986, 2017, 2048, 2080, 2112,
+    2144, 2177, 2210, 2244, 2278, 2312, 2347, 2382, 2418, 2454, 2491, 2528, 2565, 2603, 2641, 2680, 2719, 2758, 2798,
+    2839, 2879, 2921, 2962, 3005, 3047, 3090, 3134, 3178, 3222, 3267, 3312, 3358, 3404, 3451, 3498, 3546, 3594, 3642,
+    3691, 3741, 3791, 3841, 3892, 3943, 3995, 4047, 4100, 4153, 4207, 4261, 4316, 4371, 4426, 4482, 4539, 4596, 4653,
+    4711, 4769, 4828, 4888, 4947, 5008, 5068, 5130, 5191, 5253, 5316, 5379, 5443, 5507, 5571, 5636, 5702, 5767, 5834,
+    5901, 5968, 6036, 6104, 6172, 6241, 6311, 6381, 6451, 6522, 6594, 6665, 6738, 6810, 6883, 6957, 7031, 7105, 7180,
+    7255, 7331, 7407, 7484, 7561, 7638, 7716, 7794, 7873, 7952, 8031, 8111,
+];
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut pwm = SimplePwm::new_4ch(p.PWM0, p.P0_13, p.P0_14, p.P0_16, p.P0_15);
+    pwm.set_prescaler(Prescaler::Div1);
+    pwm.set_max_duty(32767);
+    info!("pwm initialized!");
+
+    let mut i = 0;
+    loop {
+        i += 1;
+        pwm.set_duty(0, DUTY[i % 1024]);
+        pwm.set_duty(1, DUTY[(i + 256) % 1024]);
+        pwm.set_duty(2, DUTY[(i + 512) % 1024]);
+        pwm.set_duty(3, DUTY[(i + 768) % 1024]);
+        Timer::after(Duration::from_millis(3)).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/pwm_double_sequence.rs b/examples/nrf52840/src/bin/pwm_double_sequence.rs
new file mode 100644
index 000000000..16e50e909
--- /dev/null
+++ b/examples/nrf52840/src/bin/pwm_double_sequence.rs
@@ -0,0 +1,41 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::pwm::{
+    Config, Prescaler, Sequence, SequenceConfig, SequenceMode, SequencePwm, Sequencer, StartSequence,
+};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let seq_words_0: [u16; 5] = [1000, 250, 100, 50, 0];
+    let seq_words_1: [u16; 4] = [50, 100, 250, 1000];
+
+    let mut config = Config::default();
+    config.prescaler = Prescaler::Div128;
+    // 1 period is 1000 * (128/16mhz = 0.000008s = 0.008ms) = 8us
+    // but say we want to hold the value for 5000ms
+    // so we want to repeat our value as many times as necessary until 5000ms passes
+    // want 5000/8 = 625 periods total to occur, so 624 (we get the one period for free remember)
+    let mut seq_config = SequenceConfig::default();
+    seq_config.refresh = 624;
+    // thus our sequence takes 5 * 5000ms or 25 seconds
+
+    let mut pwm = unwrap!(SequencePwm::new_1ch(p.PWM0, p.P0_13, config));
+
+    let sequence_0 = Sequence::new(&seq_words_0, seq_config.clone());
+    let sequence_1 = Sequence::new(&seq_words_1, seq_config);
+    let sequencer = Sequencer::new(&mut pwm, sequence_0, Some(sequence_1));
+    unwrap!(sequencer.start(StartSequence::Zero, SequenceMode::Loop(1)));
+
+    // we can abort a sequence if we need to before its complete with pwm.stop()
+    // or stop is also implicitly called when the pwm peripheral is dropped
+    // when it goes out of scope
+    Timer::after(Duration::from_millis(40000)).await;
+    info!("pwm stopped early!");
+}
diff --git a/examples/nrf52840/src/bin/pwm_sequence.rs b/examples/nrf52840/src/bin/pwm_sequence.rs
new file mode 100644
index 000000000..b9aca9aaa
--- /dev/null
+++ b/examples/nrf52840/src/bin/pwm_sequence.rs
@@ -0,0 +1,36 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::pwm::{Config, Prescaler, SequenceConfig, SequencePwm, SingleSequenceMode, SingleSequencer};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let seq_words: [u16; 5] = [1000, 250, 100, 50, 0];
+
+    let mut config = Config::default();
+    config.prescaler = Prescaler::Div128;
+    // 1 period is 1000 * (128/16mhz = 0.000008s = 0.008ms) = 8us
+    // but say we want to hold the value for 5000ms
+    // so we want to repeat our value as many times as necessary until 5000ms passes
+    // want 5000/8 = 625 periods total to occur, so 624 (we get the one period for free remember)
+    let mut seq_config = SequenceConfig::default();
+    seq_config.refresh = 624;
+    // thus our sequence takes 5 * 5000ms or 25 seconds
+
+    let mut pwm = unwrap!(SequencePwm::new_1ch(p.PWM0, p.P0_13, config,));
+
+    let sequencer = SingleSequencer::new(&mut pwm, &seq_words, seq_config);
+    unwrap!(sequencer.start(SingleSequenceMode::Times(1)));
+
+    // we can abort a sequence if we need to before its complete with pwm.stop()
+    // or stop is also implicitly called when the pwm peripheral is dropped
+    // when it goes out of scope
+    Timer::after(Duration::from_millis(20000)).await;
+    info!("pwm stopped early!");
+}
diff --git a/examples/nrf52840/src/bin/pwm_sequence_ppi.rs b/examples/nrf52840/src/bin/pwm_sequence_ppi.rs
new file mode 100644
index 000000000..6594fa348
--- /dev/null
+++ b/examples/nrf52840/src/bin/pwm_sequence_ppi.rs
@@ -0,0 +1,67 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::future::pending;
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Input, Pull};
+use embassy_nrf::gpiote::{InputChannel, InputChannelPolarity};
+use embassy_nrf::ppi::Ppi;
+use embassy_nrf::pwm::{Config, Prescaler, SequenceConfig, SequencePwm, SingleSequenceMode, SingleSequencer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let seq_words: [u16; 5] = [1000, 250, 100, 50, 0];
+
+    let mut config = Config::default();
+    config.prescaler = Prescaler::Div128;
+    // 1 period is 1000 * (128/16mhz = 0.000008s = 0.008ms) = 8us
+    // but say we want to hold the value for 250ms 250ms/8 = 31.25 periods
+    // so round to 31 - 1 (we get the one period for free remember)
+    // thus our sequence takes 5 * 250ms or 1.25 seconds
+    let mut seq_config = SequenceConfig::default();
+    seq_config.refresh = 30;
+
+    let mut pwm = unwrap!(SequencePwm::new_1ch(p.PWM0, p.P0_13, config));
+
+    // pwm.stop() deconfigures pins, and then the task_start_seq0 task cant work
+    // so its going to have to start running in order load the configuration
+
+    let button1 = InputChannel::new(
+        p.GPIOTE_CH0,
+        Input::new(p.P0_11, Pull::Up),
+        InputChannelPolarity::HiToLo,
+    );
+
+    let button2 = InputChannel::new(
+        p.GPIOTE_CH1,
+        Input::new(p.P0_12, Pull::Up),
+        InputChannelPolarity::HiToLo,
+    );
+
+    // messing with the pwm tasks is ill advised
+    // Times::Ininite and Times even are seq0, Times odd is seq1
+    let start = unsafe { pwm.task_start_seq0() };
+    let stop = unsafe { pwm.task_stop() };
+
+    let sequencer = SingleSequencer::new(&mut pwm, &seq_words, seq_config);
+    unwrap!(sequencer.start(SingleSequenceMode::Infinite));
+
+    let mut ppi = Ppi::new_one_to_one(p.PPI_CH1, button1.event_in(), start);
+    ppi.enable();
+
+    let mut ppi2 = Ppi::new_one_to_one(p.PPI_CH0, button2.event_in(), stop);
+    ppi2.enable();
+
+    info!("PPI setup!");
+    info!("Press button 1 to start LED 1");
+    info!("Press button 2 to stop LED 1");
+    info!("Note! task_stop stops the sequence, but not the pin output");
+
+    // Block forever so the above drivers don't get dropped
+    pending::<()>().await;
+}
diff --git a/examples/nrf52840/src/bin/pwm_sequence_ws2812b.rs b/examples/nrf52840/src/bin/pwm_sequence_ws2812b.rs
new file mode 100644
index 000000000..711c8a17b
--- /dev/null
+++ b/examples/nrf52840/src/bin/pwm_sequence_ws2812b.rs
@@ -0,0 +1,75 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::pwm::{
+    Config, Prescaler, SequenceConfig, SequenceLoad, SequencePwm, SingleSequenceMode, SingleSequencer,
+};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+// WS2812B LED light demonstration. Drives just one light.
+// The following reference on WS2812B may be of use:
+// https://cdn-shop.adafruit.com/datasheets/WS2812B.pdf.
+// This demo lights up a single LED in blue. It then proceeds
+// to pulsate the LED rapidly.
+
+// In the following declarations, setting the high bit tells the PWM
+// to reverse polarity, which is what the WS2812B expects.
+
+const T1H: u16 = 0x8000 | 13; // Duty = 13/20 ticks (0.8us/1.25us) for a 1
+const T0H: u16 = 0x8000 | 7; // Duty 7/20 ticks (0.4us/1.25us) for a 0
+const RES: u16 = 0x8000;
+
+// Provides data to a WS2812b (Neopixel) LED and makes it go blue. The data
+// line is assumed to be P1_05.
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut config = Config::default();
+    config.sequence_load = SequenceLoad::Common;
+    config.prescaler = Prescaler::Div1;
+    config.max_duty = 20; // 1.25us (1s / 16Mhz * 20)
+    let mut pwm = unwrap!(SequencePwm::new_1ch(p.PWM0, p.P1_05, config));
+
+    // Declare the bits of 24 bits in a buffer we'll be
+    // mutating later.
+    let mut seq_words = [
+        T0H, T0H, T0H, T0H, T0H, T0H, T0H, T0H, // G
+        T0H, T0H, T0H, T0H, T0H, T0H, T0H, T0H, // R
+        T1H, T1H, T1H, T1H, T1H, T1H, T1H, T1H, // B
+        RES,
+    ];
+    let mut seq_config = SequenceConfig::default();
+    seq_config.end_delay = 799; // 50us (20 ticks * 40) - 1 tick because we've already got one RES;
+
+    let mut color_bit = 16;
+    let mut bit_value = T0H;
+
+    loop {
+        let sequences = SingleSequencer::new(&mut pwm, &seq_words, seq_config.clone());
+        unwrap!(sequences.start(SingleSequenceMode::Times(1)));
+
+        Timer::after(Duration::from_millis(50)).await;
+
+        if bit_value == T0H {
+            if color_bit == 20 {
+                bit_value = T1H;
+            } else {
+                color_bit += 1;
+            }
+        } else {
+            if color_bit == 16 {
+                bit_value = T0H;
+            } else {
+                color_bit -= 1;
+            }
+        }
+
+        drop(sequences);
+
+        seq_words[color_bit] = bit_value;
+    }
+}
diff --git a/examples/nrf52840/src/bin/pwm_servo.rs b/examples/nrf52840/src/bin/pwm_servo.rs
new file mode 100644
index 000000000..19228f433
--- /dev/null
+++ b/examples/nrf52840/src/bin/pwm_servo.rs
@@ -0,0 +1,47 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::pwm::{Prescaler, SimplePwm};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut pwm = SimplePwm::new_1ch(p.PWM0, p.P0_05);
+    // sg90 microervo requires 50hz or 20ms period
+    // set_period can only set down to 125khz so we cant use it directly
+    // Div128 is 125khz or 0.000008s or 0.008ms, 20/0.008 is 2500 is top
+    pwm.set_prescaler(Prescaler::Div128);
+    pwm.set_max_duty(2500);
+    info!("pwm initialized!");
+
+    Timer::after(Duration::from_millis(5000)).await;
+
+    // 1ms 0deg (1/.008=125), 1.5ms 90deg (1.5/.008=187.5), 2ms 180deg (2/.008=250),
+    loop {
+        info!("45 deg");
+        // poor mans inverting, subtract our value from max_duty
+        pwm.set_duty(0, 2500 - 156);
+        Timer::after(Duration::from_millis(5000)).await;
+
+        info!("90 deg");
+        pwm.set_duty(0, 2500 - 187);
+        Timer::after(Duration::from_millis(5000)).await;
+
+        info!("135 deg");
+        pwm.set_duty(0, 2500 - 218);
+        Timer::after(Duration::from_millis(5000)).await;
+
+        info!("180 deg");
+        pwm.set_duty(0, 2500 - 250);
+        Timer::after(Duration::from_millis(5000)).await;
+
+        info!("0 deg");
+        pwm.set_duty(0, 2500 - 125);
+        Timer::after(Duration::from_millis(5000)).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/qdec.rs b/examples/nrf52840/src/bin/qdec.rs
new file mode 100644
index 000000000..600bba07a
--- /dev/null
+++ b/examples/nrf52840/src/bin/qdec.rs
@@ -0,0 +1,24 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::qdec::{self, Qdec};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let irq = interrupt::take!(QDEC);
+    let config = qdec::Config::default();
+    let mut rotary_enc = Qdec::new(p.QDEC, irq, p.P0_31, p.P0_30, config);
+
+    info!("Turn rotary encoder!");
+    let mut value = 0;
+    loop {
+        value += rotary_enc.read().await;
+        info!("Value: {}", value);
+    }
+}
diff --git a/examples/nrf52840/src/bin/qspi.rs b/examples/nrf52840/src/bin/qspi.rs
new file mode 100644
index 000000000..bdcf710b8
--- /dev/null
+++ b/examples/nrf52840/src/bin/qspi.rs
@@ -0,0 +1,76 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{assert_eq, info, unwrap};
+use embassy_executor::Spawner;
+use embassy_nrf::{interrupt, qspi};
+use {defmt_rtt as _, panic_probe as _};
+
+const PAGE_SIZE: usize = 4096;
+
+// Workaround for alignment requirements.
+// Nicer API will probably come in the future.
+#[repr(C, align(4))]
+struct AlignedBuf([u8; 4096]);
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    // Config for the MX25R64 present in the nRF52840 DK
+    let mut config = qspi::Config::default();
+    config.read_opcode = qspi::ReadOpcode::READ4IO;
+    config.write_opcode = qspi::WriteOpcode::PP4IO;
+    config.write_page_size = qspi::WritePageSize::_256BYTES;
+
+    let irq = interrupt::take!(QSPI);
+    let mut q: qspi::Qspi<_, 67108864> = qspi::Qspi::new(
+        p.QSPI, irq, p.P0_19, p.P0_17, p.P0_20, p.P0_21, p.P0_22, p.P0_23, config,
+    );
+
+    let mut id = [1; 3];
+    unwrap!(q.custom_instruction(0x9F, &[], &mut id).await);
+    info!("id: {}", id);
+
+    // Read status register
+    let mut status = [4; 1];
+    unwrap!(q.custom_instruction(0x05, &[], &mut status).await);
+
+    info!("status: {:?}", status[0]);
+
+    if status[0] & 0x40 == 0 {
+        status[0] |= 0x40;
+
+        unwrap!(q.custom_instruction(0x01, &status, &mut []).await);
+
+        info!("enabled quad in status");
+    }
+
+    let mut buf = AlignedBuf([0u8; PAGE_SIZE]);
+
+    let pattern = |a: u32| (a ^ (a >> 8) ^ (a >> 16) ^ (a >> 24)) as u8;
+
+    for i in 0..8 {
+        info!("page {:?}: erasing... ", i);
+        unwrap!(q.erase(i * PAGE_SIZE).await);
+
+        for j in 0..PAGE_SIZE {
+            buf.0[j] = pattern((j + i * PAGE_SIZE) as u32);
+        }
+
+        info!("programming...");
+        unwrap!(q.write(i * PAGE_SIZE, &buf.0).await);
+    }
+
+    for i in 0..8 {
+        info!("page {:?}: reading... ", i);
+        unwrap!(q.read(i * PAGE_SIZE, &mut buf.0).await);
+
+        info!("verifying...");
+        for j in 0..PAGE_SIZE {
+            assert_eq!(buf.0[j], pattern((j + i * PAGE_SIZE) as u32));
+        }
+    }
+
+    info!("done!")
+}
diff --git a/examples/nrf52840/src/bin/qspi_lowpower.rs b/examples/nrf52840/src/bin/qspi_lowpower.rs
new file mode 100644
index 000000000..9341a2376
--- /dev/null
+++ b/examples/nrf52840/src/bin/qspi_lowpower.rs
@@ -0,0 +1,78 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::mem;
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_nrf::{interrupt, qspi};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+// Workaround for alignment requirements.
+// Nicer API will probably come in the future.
+#[repr(C, align(4))]
+struct AlignedBuf([u8; 64]);
+
+#[embassy_executor::main]
+async fn main(_p: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut irq = interrupt::take!(QSPI);
+
+    loop {
+        // Config for the MX25R64 present in the nRF52840 DK
+        let mut config = qspi::Config::default();
+        config.read_opcode = qspi::ReadOpcode::READ4IO;
+        config.write_opcode = qspi::WriteOpcode::PP4IO;
+        config.write_page_size = qspi::WritePageSize::_256BYTES;
+        config.deep_power_down = Some(qspi::DeepPowerDownConfig {
+            enter_time: 3, // tDP = 30uS
+            exit_time: 3,  // tRDP = 35uS
+        });
+
+        let mut q: qspi::Qspi<_, 67108864> = qspi::Qspi::new(
+            &mut p.QSPI,
+            &mut irq,
+            &mut p.P0_19,
+            &mut p.P0_17,
+            &mut p.P0_20,
+            &mut p.P0_21,
+            &mut p.P0_22,
+            &mut p.P0_23,
+            config,
+        );
+
+        let mut id = [1; 3];
+        unwrap!(q.custom_instruction(0x9F, &[], &mut id).await);
+        info!("id: {}", id);
+
+        // Read status register
+        let mut status = [4; 1];
+        unwrap!(q.custom_instruction(0x05, &[], &mut status).await);
+
+        info!("status: {:?}", status[0]);
+
+        if status[0] & 0x40 == 0 {
+            status[0] |= 0x40;
+
+            unwrap!(q.custom_instruction(0x01, &status, &mut []).await);
+
+            info!("enabled quad in status");
+        }
+
+        let mut buf = AlignedBuf([0u8; 64]);
+
+        info!("reading...");
+        unwrap!(q.read(0, &mut buf.0).await);
+        info!("read: {=[u8]:x}", buf.0);
+
+        // Drop the QSPI instance. This disables the peripehral and deconfigures the pins.
+        // This clears the borrow on the singletons, so they can now be used again.
+        mem::drop(q);
+
+        // Sleep for 1 second. The executor ensures the core sleeps with a WFE when it has nothing to do.
+        // During this sleep, the nRF chip should only use ~3uA
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/raw_spawn.rs b/examples/nrf52840/src/bin/raw_spawn.rs
new file mode 100644
index 000000000..1b067f5e4
--- /dev/null
+++ b/examples/nrf52840/src/bin/raw_spawn.rs
@@ -0,0 +1,52 @@
+#![no_std]
+#![no_main]
+
+use core::mem;
+
+use cortex_m_rt::entry;
+use defmt::{info, unwrap};
+use embassy_executor::raw::TaskStorage;
+use embassy_executor::Executor;
+use embassy_time::{Duration, Timer};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+async fn run1() {
+    loop {
+        info!("BIG INFREQUENT TICK");
+        Timer::after(Duration::from_ticks(64000)).await;
+    }
+}
+
+async fn run2() {
+    loop {
+        info!("tick");
+        Timer::after(Duration::from_ticks(13000)).await;
+    }
+}
+
+static EXECUTOR: StaticCell<Executor> = StaticCell::new();
+
+#[entry]
+fn main() -> ! {
+    info!("Hello World!");
+
+    let _p = embassy_nrf::init(Default::default());
+    let executor = EXECUTOR.init(Executor::new());
+
+    let run1_task = TaskStorage::new();
+    let run2_task = TaskStorage::new();
+
+    // Safety: these variables do live forever if main never returns.
+    let run1_task = unsafe { make_static(&run1_task) };
+    let run2_task = unsafe { make_static(&run2_task) };
+
+    executor.run(|spawner| {
+        unwrap!(spawner.spawn(run1_task.spawn(|| run1())));
+        unwrap!(spawner.spawn(run2_task.spawn(|| run2())));
+    });
+}
+
+unsafe fn make_static<T>(t: &T) -> &'static T {
+    mem::transmute(t)
+}
diff --git a/examples/nrf52840/src/bin/rng.rs b/examples/nrf52840/src/bin/rng.rs
new file mode 100644
index 000000000..647073949
--- /dev/null
+++ b/examples/nrf52840/src/bin/rng.rs
@@ -0,0 +1,30 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::rng::Rng;
+use rand::Rng as _;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut rng = Rng::new(p.RNG, interrupt::take!(RNG));
+
+    // Async API
+    let mut bytes = [0; 4];
+    rng.fill_bytes(&mut bytes).await;
+    defmt::info!("Some random bytes: {:?}", bytes);
+
+    // Sync API with `rand`
+    defmt::info!("A random number from 1 to 10: {:?}", rng.gen_range(1..=10));
+
+    let mut bytes = [0; 1024];
+    rng.fill_bytes(&mut bytes).await;
+    let zero_count: u32 = bytes.iter().fold(0, |acc, val| acc + val.count_zeros());
+    let one_count: u32 = bytes.iter().fold(0, |acc, val| acc + val.count_ones());
+    defmt::info!("Chance of zero: {}%", zero_count * 100 / (bytes.len() as u32 * 8));
+    defmt::info!("Chance of one: {}%", one_count * 100 / (bytes.len() as u32 * 8));
+}
diff --git a/examples/nrf52840/src/bin/saadc.rs b/examples/nrf52840/src/bin/saadc.rs
new file mode 100644
index 000000000..7cf588090
--- /dev/null
+++ b/examples/nrf52840/src/bin/saadc.rs
@@ -0,0 +1,25 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::saadc::{ChannelConfig, Config, Saadc};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_p: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let config = Config::default();
+    let channel_config = ChannelConfig::single_ended(&mut p.P0_02);
+    let mut saadc = Saadc::new(p.SAADC, interrupt::take!(SAADC), config, [channel_config]);
+
+    loop {
+        let mut buf = [0; 1];
+        saadc.sample(&mut buf).await;
+        info!("sample: {=i16}", &buf[0]);
+        Timer::after(Duration::from_millis(100)).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/saadc_continuous.rs b/examples/nrf52840/src/bin/saadc_continuous.rs
new file mode 100644
index 000000000..bb50ac65e
--- /dev/null
+++ b/examples/nrf52840/src/bin/saadc_continuous.rs
@@ -0,0 +1,68 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::saadc::{ChannelConfig, Config, Saadc, SamplerState};
+use embassy_nrf::timer::Frequency;
+use embassy_time::Duration;
+use {defmt_rtt as _, panic_probe as _};
+
+// Demonstrates both continuous sampling and scanning multiple channels driven by a PPI linked timer
+
+#[embassy_executor::main]
+async fn main(_p: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let config = Config::default();
+    let channel_1_config = ChannelConfig::single_ended(&mut p.P0_02);
+    let channel_2_config = ChannelConfig::single_ended(&mut p.P0_03);
+    let channel_3_config = ChannelConfig::single_ended(&mut p.P0_04);
+    let mut saadc = Saadc::new(
+        p.SAADC,
+        interrupt::take!(SAADC),
+        config,
+        [channel_1_config, channel_2_config, channel_3_config],
+    );
+
+    // This delay demonstrates that starting the timer prior to running
+    // the task sampler is benign given the calibration that follows.
+    embassy_time::Timer::after(Duration::from_millis(500)).await;
+    saadc.calibrate().await;
+
+    let mut bufs = [[[0; 3]; 500]; 2];
+
+    let mut c = 0;
+    let mut a: i32 = 0;
+
+    saadc
+        .run_task_sampler(
+            &mut p.TIMER0,
+            &mut p.PPI_CH0,
+            &mut p.PPI_CH1,
+            Frequency::F1MHz,
+            1000, // We want to sample at 1KHz
+            &mut bufs,
+            move |buf| {
+                // NOTE: It is important that the time spent within this callback
+                // does not exceed the time taken to acquire the 1500 samples we
+                // have in this example, which would be 10us + 2us per
+                // sample * 1500 = 18ms. You need to measure the time taken here
+                // and set the sample buffer size accordingly. Exceeding this
+                // time can lead to the peripheral re-writing the other buffer.
+                for b in buf {
+                    a += b[0] as i32;
+                }
+                c += buf.len();
+                if c > 1000 {
+                    a = a / c as i32;
+                    info!("channel 1: {=i32}", a);
+                    c = 0;
+                    a = 0;
+                }
+                SamplerState::Sampled
+            },
+        )
+        .await;
+}
diff --git a/examples/nrf52840/src/bin/self_spawn.rs b/examples/nrf52840/src/bin/self_spawn.rs
new file mode 100644
index 000000000..196255a52
--- /dev/null
+++ b/examples/nrf52840/src/bin/self_spawn.rs
@@ -0,0 +1,22 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task(pool_size = 2)]
+async fn my_task(spawner: Spawner, n: u32) {
+    Timer::after(Duration::from_secs(1)).await;
+    info!("Spawning self! {}", n);
+    unwrap!(spawner.spawn(my_task(spawner, n + 1)));
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let _p = embassy_nrf::init(Default::default());
+    info!("Hello World!");
+    unwrap!(spawner.spawn(my_task(spawner, 0)));
+}
diff --git a/examples/nrf52840/src/bin/self_spawn_current_executor.rs b/examples/nrf52840/src/bin/self_spawn_current_executor.rs
new file mode 100644
index 000000000..8a179886c
--- /dev/null
+++ b/examples/nrf52840/src/bin/self_spawn_current_executor.rs
@@ -0,0 +1,22 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task(pool_size = 2)]
+async fn my_task(n: u32) {
+    Timer::after(Duration::from_secs(1)).await;
+    info!("Spawning self! {}", n);
+    unwrap!(Spawner::for_current_executor().await.spawn(my_task(n + 1)));
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let _p = embassy_nrf::init(Default::default());
+    info!("Hello World!");
+    unwrap!(spawner.spawn(my_task(0)));
+}
diff --git a/examples/nrf52840/src/bin/spim.rs b/examples/nrf52840/src/bin/spim.rs
new file mode 100644
index 000000000..132e01660
--- /dev/null
+++ b/examples/nrf52840/src/bin/spim.rs
@@ -0,0 +1,68 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Level, Output, OutputDrive};
+use embassy_nrf::{interrupt, spim};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("running!");
+
+    let mut config = spim::Config::default();
+    config.frequency = spim::Frequency::M16;
+
+    let irq = interrupt::take!(SPIM3);
+    let mut spim = spim::Spim::new(p.SPI3, irq, p.P0_29, p.P0_28, p.P0_30, config);
+
+    let mut ncs = Output::new(p.P0_31, Level::High, OutputDrive::Standard);
+
+    // Example on how to talk to an ENC28J60 chip
+
+    // softreset
+    cortex_m::asm::delay(10);
+    ncs.set_low();
+    cortex_m::asm::delay(5);
+    let tx = [0xFF];
+    unwrap!(spim.transfer(&mut [], &tx).await);
+    cortex_m::asm::delay(10);
+    ncs.set_high();
+
+    cortex_m::asm::delay(100000);
+
+    let mut rx = [0; 2];
+
+    // read ESTAT
+    cortex_m::asm::delay(5000);
+    ncs.set_low();
+    cortex_m::asm::delay(5000);
+    let tx = [0b000_11101, 0];
+    unwrap!(spim.transfer(&mut rx, &tx).await);
+    cortex_m::asm::delay(5000);
+    ncs.set_high();
+    info!("estat: {=[?]}", rx);
+
+    // Switch to bank 3
+    cortex_m::asm::delay(10);
+    ncs.set_low();
+    cortex_m::asm::delay(5);
+    let tx = [0b100_11111, 0b11];
+    unwrap!(spim.transfer(&mut rx, &tx).await);
+    cortex_m::asm::delay(10);
+    ncs.set_high();
+
+    // read EREVID
+    cortex_m::asm::delay(10);
+    ncs.set_low();
+    cortex_m::asm::delay(5);
+    let tx = [0b000_10010, 0];
+    unwrap!(spim.transfer(&mut rx, &tx).await);
+    cortex_m::asm::delay(10);
+    ncs.set_high();
+
+    info!("erevid: {=[?]}", rx);
+}
diff --git a/examples/nrf52840/src/bin/spis.rs b/examples/nrf52840/src/bin/spis.rs
new file mode 100644
index 000000000..fe3b0c53d
--- /dev/null
+++ b/examples/nrf52840/src/bin/spis.rs
@@ -0,0 +1,27 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::spis::{Config, Spis};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Running!");
+
+    let irq = interrupt::take!(SPIM2_SPIS2_SPI2);
+    let mut spis = Spis::new(p.SPI2, irq, p.P0_31, p.P0_29, p.P0_28, p.P0_30, Config::default());
+
+    loop {
+        let mut rx_buf = [0_u8; 64];
+        let tx_buf = [1_u8, 2, 3, 4, 5, 6, 7, 8];
+        if let Ok((n_rx, n_tx)) = spis.transfer(&mut rx_buf, &tx_buf).await {
+            info!("RX: {:?}", rx_buf[..n_rx]);
+            info!("TX: {:?}", tx_buf[..n_tx]);
+        }
+    }
+}
diff --git a/examples/nrf52840/src/bin/temp.rs b/examples/nrf52840/src/bin/temp.rs
new file mode 100644
index 000000000..b06ac709e
--- /dev/null
+++ b/examples/nrf52840/src/bin/temp.rs
@@ -0,0 +1,23 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::info;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::temp::Temp;
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let irq = interrupt::take!(TEMP);
+    let mut temp = Temp::new(p.TEMP, irq);
+
+    loop {
+        let value = temp.read().await;
+        info!("temperature: {}℃", value.to_num::<u16>());
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/timer.rs b/examples/nrf52840/src/bin/timer.rs
new file mode 100644
index 000000000..c22b5acd5
--- /dev/null
+++ b/examples/nrf52840/src/bin/timer.rs
@@ -0,0 +1,31 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::task]
+async fn run1() {
+    loop {
+        info!("BIG INFREQUENT TICK");
+        Timer::after(Duration::from_ticks(64000)).await;
+    }
+}
+
+#[embassy_executor::task]
+async fn run2() {
+    loop {
+        info!("tick");
+        Timer::after(Duration::from_ticks(13000)).await;
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let _p = embassy_nrf::init(Default::default());
+    unwrap!(spawner.spawn(run1()));
+    unwrap!(spawner.spawn(run2()));
+}
diff --git a/examples/nrf52840/src/bin/twim.rs b/examples/nrf52840/src/bin/twim.rs
new file mode 100644
index 000000000..a027cc1e7
--- /dev/null
+++ b/examples/nrf52840/src/bin/twim.rs
@@ -0,0 +1,31 @@
+//! Example on how to read a 24C/24LC i2c eeprom.
+//!
+//! Connect SDA to P0.03, SCL to P0.04
+
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::twim::{self, Twim};
+use {defmt_rtt as _, panic_probe as _};
+
+const ADDRESS: u8 = 0x50;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Initializing TWI...");
+    let config = twim::Config::default();
+    let irq = interrupt::take!(SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0);
+    let mut twi = Twim::new(p.TWISPI0, irq, p.P0_03, p.P0_04, config);
+
+    info!("Reading...");
+
+    let mut buf = [0u8; 16];
+    unwrap!(twi.blocking_write_read(ADDRESS, &mut [0x00], &mut buf));
+
+    info!("Read: {=[u8]:x}", buf);
+}
diff --git a/examples/nrf52840/src/bin/twim_lowpower.rs b/examples/nrf52840/src/bin/twim_lowpower.rs
new file mode 100644
index 000000000..e30cc9688
--- /dev/null
+++ b/examples/nrf52840/src/bin/twim_lowpower.rs
@@ -0,0 +1,50 @@
+//! Example on how to read a 24C/24LC i2c eeprom with low power consumption.
+//! The eeprom is read every 1 second, while ensuring lowest possible power while
+//! sleeping between reads.
+//!
+//! Connect SDA to P0.03, SCL to P0.04
+
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::mem;
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::twim::{self, Twim};
+use embassy_time::{Duration, Timer};
+use {defmt_rtt as _, panic_probe as _};
+
+const ADDRESS: u8 = 0x50;
+
+#[embassy_executor::main]
+async fn main(_p: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    info!("Started!");
+    let mut irq = interrupt::take!(SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0);
+
+    loop {
+        info!("Initializing TWI...");
+        let config = twim::Config::default();
+
+        // Create the TWIM instance with borrowed singletons, so they're not consumed.
+        let mut twi = Twim::new(&mut p.TWISPI0, &mut irq, &mut p.P0_03, &mut p.P0_04, config);
+
+        info!("Reading...");
+
+        let mut buf = [0u8; 16];
+        unwrap!(twi.blocking_write_read(ADDRESS, &mut [0x00], &mut buf));
+
+        info!("Read: {=[u8]:x}", buf);
+
+        // Drop the TWIM instance. This disables the peripehral and deconfigures the pins.
+        // This clears the borrow on the singletons, so they can now be used again.
+        mem::drop(twi);
+
+        // Sleep for 1 second. The executor ensures the core sleeps with a WFE when it has nothing to do.
+        // During this sleep, the nRF chip should only use ~3uA
+        Timer::after(Duration::from_secs(1)).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/twis.rs b/examples/nrf52840/src/bin/twis.rs
new file mode 100644
index 000000000..54cba9494
--- /dev/null
+++ b/examples/nrf52840/src/bin/twis.rs
@@ -0,0 +1,46 @@
+//! TWIS example
+
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::interrupt;
+use embassy_nrf::twis::{self, Command, Twis};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+
+    let irq = interrupt::take!(SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0);
+    let mut config = twis::Config::default();
+    // Set i2c address
+    config.address0 = 0x55;
+    let mut i2c = Twis::new(p.TWISPI0, irq, p.P0_03, p.P0_04, config);
+
+    info!("Listening...");
+    loop {
+        let response = [1, 2, 3, 4, 5, 6, 7, 8];
+        // This buffer is used if the i2c master performs a Write or WriteRead
+        let mut buf = [0u8; 16];
+        match i2c.listen(&mut buf).await {
+            Ok(Command::Read) => {
+                info!("Got READ command. Respond with data:\n{:?}\n", response);
+                if let Err(e) = i2c.respond_to_read(&response).await {
+                    error!("{:?}", e);
+                }
+            }
+            Ok(Command::Write(n)) => info!("Got WRITE command with data:\n{:?}\n", buf[..n]),
+            Ok(Command::WriteRead(n)) => {
+                info!("Got WRITE/READ command with data:\n{:?}", buf[..n]);
+                info!("Respond with data:\n{:?}\n", response);
+                if let Err(e) = i2c.respond_to_read(&response).await {
+                    error!("{:?}", e);
+                }
+            }
+            Err(e) => error!("{:?}", e),
+        }
+    }
+}
diff --git a/examples/nrf52840/src/bin/uart.rs b/examples/nrf52840/src/bin/uart.rs
new file mode 100644
index 000000000..600f7a6ef
--- /dev/null
+++ b/examples/nrf52840/src/bin/uart.rs
@@ -0,0 +1,35 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::{interrupt, uarte};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD115200;
+
+    let irq = interrupt::take!(UARTE0_UART0);
+    let mut uart = uarte::Uarte::new(p.UARTE0, irq, p.P0_08, p.P0_06, config);
+
+    info!("uarte initialized!");
+
+    // Message must be in SRAM
+    let mut buf = [0; 8];
+    buf.copy_from_slice(b"Hello!\r\n");
+
+    unwrap!(uart.write(&buf).await);
+    info!("wrote hello in uart!");
+
+    loop {
+        info!("reading...");
+        unwrap!(uart.read(&mut buf).await);
+        info!("writing...");
+        unwrap!(uart.write(&buf).await);
+    }
+}
diff --git a/examples/nrf52840/src/bin/uart_idle.rs b/examples/nrf52840/src/bin/uart_idle.rs
new file mode 100644
index 000000000..6af4f7097
--- /dev/null
+++ b/examples/nrf52840/src/bin/uart_idle.rs
@@ -0,0 +1,35 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::{interrupt, uarte};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD115200;
+
+    let irq = interrupt::take!(UARTE0_UART0);
+    let uart = uarte::Uarte::new(p.UARTE0, irq, p.P0_08, p.P0_06, config);
+    let (mut tx, mut rx) = uart.split_with_idle(p.TIMER0, p.PPI_CH0, p.PPI_CH1);
+
+    info!("uarte initialized!");
+
+    // Message must be in SRAM
+    let mut buf = [0; 8];
+    buf.copy_from_slice(b"Hello!\r\n");
+
+    unwrap!(tx.write(&buf).await);
+    info!("wrote hello in uart!");
+
+    loop {
+        info!("reading...");
+        let n = unwrap!(rx.read_until_idle(&mut buf).await);
+        info!("got {} bytes", n);
+    }
+}
diff --git a/examples/nrf52840/src/bin/uart_split.rs b/examples/nrf52840/src/bin/uart_split.rs
new file mode 100644
index 000000000..1adaf53fd
--- /dev/null
+++ b/examples/nrf52840/src/bin/uart_split.rs
@@ -0,0 +1,60 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::peripherals::UARTE0;
+use embassy_nrf::uarte::UarteRx;
+use embassy_nrf::{interrupt, uarte};
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::channel::Channel;
+use {defmt_rtt as _, panic_probe as _};
+
+static CHANNEL: Channel<ThreadModeRawMutex, [u8; 8], 1> = Channel::new();
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD115200;
+
+    let irq = interrupt::take!(UARTE0_UART0);
+    let uart = uarte::Uarte::new(p.UARTE0, irq, p.P0_08, p.P0_06, config);
+    let (mut tx, rx) = uart.split();
+
+    info!("uarte initialized!");
+
+    // Spawn a task responsible purely for reading
+
+    unwrap!(spawner.spawn(reader(rx)));
+
+    // Message must be in SRAM
+    {
+        let mut buf = [0; 23];
+        buf.copy_from_slice(b"Type 8 chars to echo!\r\n");
+
+        unwrap!(tx.write(&buf).await);
+        info!("wrote hello in uart!");
+    }
+
+    // Continue reading in this main task and write
+    // back out the buffer we receive from the read
+    // task.
+    loop {
+        let buf = CHANNEL.recv().await;
+        info!("writing...");
+        unwrap!(tx.write(&buf).await);
+    }
+}
+
+#[embassy_executor::task]
+async fn reader(mut rx: UarteRx<'static, UARTE0>) {
+    let mut buf = [0; 8];
+    loop {
+        info!("reading...");
+        unwrap!(rx.read(&mut buf).await);
+        CHANNEL.send(buf).await;
+    }
+}
diff --git a/examples/nrf52840/src/bin/usb_ethernet.rs b/examples/nrf52840/src/bin/usb_ethernet.rs
new file mode 100644
index 000000000..e5f704524
--- /dev/null
+++ b/examples/nrf52840/src/bin/usb_ethernet.rs
@@ -0,0 +1,169 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::mem;
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_net::tcp::TcpSocket;
+use embassy_net::{Stack, StackResources};
+use embassy_nrf::rng::Rng;
+use embassy_nrf::usb::{Driver, PowerUsb};
+use embassy_nrf::{interrupt, pac, peripherals};
+use embassy_usb::class::cdc_ncm::embassy_net::{Device, Runner, State as NetState};
+use embassy_usb::class::cdc_ncm::{CdcNcmClass, State};
+use embassy_usb::{Builder, Config, UsbDevice};
+use embedded_io::asynch::Write;
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+type MyDriver = Driver<'static, peripherals::USBD, PowerUsb>;
+
+macro_rules! singleton {
+    ($val:expr) => {{
+        type T = impl Sized;
+        static STATIC_CELL: StaticCell<T> = StaticCell::new();
+        let (x,) = STATIC_CELL.init(($val,));
+        x
+    }};
+}
+
+const MTU: usize = 1514;
+
+#[embassy_executor::task]
+async fn usb_task(mut device: UsbDevice<'static, MyDriver>) -> ! {
+    device.run().await
+}
+
+#[embassy_executor::task]
+async fn usb_ncm_task(class: Runner<'static, MyDriver, MTU>) -> ! {
+    class.run().await
+}
+
+#[embassy_executor::task]
+async fn net_task(stack: &'static Stack<Device<'static, MTU>>) -> ! {
+    stack.run().await
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let clock: pac::CLOCK = unsafe { mem::transmute(()) };
+
+    info!("Enabling ext hfosc...");
+    clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
+    while clock.events_hfclkstarted.read().bits() != 1 {}
+
+    // Create the driver, from the HAL.
+    let irq = interrupt::take!(USBD);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
+
+    // Create embassy-usb Config
+    let mut config = Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("USB-Ethernet example");
+    config.serial_number = Some("12345678");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    // Required for Windows support.
+    config.composite_with_iads = true;
+    config.device_class = 0xEF;
+    config.device_sub_class = 0x02;
+    config.device_protocol = 0x01;
+
+    // Create embassy-usb DeviceBuilder using the driver and config.
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut singleton!([0; 256])[..],
+        &mut singleton!([0; 256])[..],
+        &mut singleton!([0; 256])[..],
+        &mut singleton!([0; 128])[..],
+        None,
+    );
+
+    // Our MAC addr.
+    let our_mac_addr = [0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC];
+    // Host's MAC addr. This is the MAC the host "thinks" its USB-to-ethernet adapter has.
+    let host_mac_addr = [0x88, 0x88, 0x88, 0x88, 0x88, 0x88];
+
+    // Create classes on the builder.
+    let class = CdcNcmClass::new(&mut builder, singleton!(State::new()), host_mac_addr, 64);
+
+    // Build the builder.
+    let usb = builder.build();
+
+    unwrap!(spawner.spawn(usb_task(usb)));
+
+    let (runner, device) = class.into_embassy_net_device::<MTU, 4, 4>(singleton!(NetState::new()), our_mac_addr);
+    unwrap!(spawner.spawn(usb_ncm_task(runner)));
+
+    let config = embassy_net::ConfigStrategy::Dhcp;
+    //let config = embassy_net::ConfigStrategy::Static(embassy_net::Config {
+    //    address: Ipv4Cidr::new(Ipv4Address::new(10, 42, 0, 61), 24),
+    //    dns_servers: Vec::new(),
+    //    gateway: Some(Ipv4Address::new(10, 42, 0, 1)),
+    //});
+
+    // Generate random seed
+    let mut rng = Rng::new(p.RNG, interrupt::take!(RNG));
+    let mut seed = [0; 8];
+    rng.blocking_fill_bytes(&mut seed);
+    let seed = u64::from_le_bytes(seed);
+
+    // Init network stack
+    let stack = &*singleton!(Stack::new(
+        device,
+        config,
+        singleton!(StackResources::<1, 2, 8>::new()),
+        seed
+    ));
+
+    unwrap!(spawner.spawn(net_task(stack)));
+
+    // And now we can use it!
+
+    let mut rx_buffer = [0; 4096];
+    let mut tx_buffer = [0; 4096];
+    let mut buf = [0; 4096];
+
+    loop {
+        let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
+        socket.set_timeout(Some(embassy_net::SmolDuration::from_secs(10)));
+
+        info!("Listening on TCP:1234...");
+        if let Err(e) = socket.accept(1234).await {
+            warn!("accept error: {:?}", e);
+            continue;
+        }
+
+        info!("Received connection from {:?}", socket.remote_endpoint());
+
+        loop {
+            let n = match socket.read(&mut buf).await {
+                Ok(0) => {
+                    warn!("read EOF");
+                    break;
+                }
+                Ok(n) => n,
+                Err(e) => {
+                    warn!("read error: {:?}", e);
+                    break;
+                }
+            };
+
+            info!("rxd {:02x}", &buf[..n]);
+
+            match socket.write_all(&buf[..n]).await {
+                Ok(()) => {}
+                Err(e) => {
+                    warn!("write error: {:?}", e);
+                    break;
+                }
+            };
+        }
+    }
+}
diff --git a/examples/nrf52840/src/bin/usb_hid_keyboard.rs b/examples/nrf52840/src/bin/usb_hid_keyboard.rs
new file mode 100644
index 000000000..76e198719
--- /dev/null
+++ b/examples/nrf52840/src/bin/usb_hid_keyboard.rs
@@ -0,0 +1,222 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::mem;
+use core::sync::atomic::{AtomicBool, Ordering};
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_futures::select::{select, Either};
+use embassy_nrf::gpio::{Input, Pin, Pull};
+use embassy_nrf::usb::{Driver, PowerUsb};
+use embassy_nrf::{interrupt, pac};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::signal::Signal;
+use embassy_usb::class::hid::{HidReaderWriter, ReportId, RequestHandler, State};
+use embassy_usb::control::OutResponse;
+use embassy_usb::{Builder, Config, DeviceStateHandler};
+use usbd_hid::descriptor::{KeyboardReport, SerializedDescriptor};
+use {defmt_rtt as _, panic_probe as _};
+
+static SUSPENDED: AtomicBool = AtomicBool::new(false);
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let clock: pac::CLOCK = unsafe { mem::transmute(()) };
+
+    info!("Enabling ext hfosc...");
+    clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
+    while clock.events_hfclkstarted.read().bits() != 1 {}
+
+    // Create the driver, from the HAL.
+    let irq = interrupt::take!(USBD);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
+
+    // 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;
+    config.supports_remote_wakeup = true;
+
+    // Create embassy-usb DeviceBuilder using the driver and config.
+    // It needs some buffers for building the descriptors.
+    let mut device_descriptor = [0; 256];
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 256];
+    let mut control_buf = [0; 64];
+    let request_handler = MyRequestHandler {};
+    let device_state_handler = MyDeviceStateHandler::new();
+
+    let mut state = State::new();
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut device_descriptor,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut control_buf,
+        Some(&device_state_handler),
+    );
+
+    // Create classes on the builder.
+    let config = embassy_usb::class::hid::Config {
+        report_descriptor: KeyboardReport::desc(),
+        request_handler: Some(&request_handler),
+        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();
+
+    let remote_wakeup: Signal<CriticalSectionRawMutex, _> = Signal::new();
+
+    // Run the USB device.
+    let usb_fut = async {
+        loop {
+            usb.run_until_suspend().await;
+            match select(usb.wait_resume(), remote_wakeup.wait()).await {
+                Either::First(_) => (),
+                Either::Second(_) => unwrap!(usb.remote_wakeup().await),
+            }
+        }
+    };
+
+    let mut button = Input::new(p.P0_11.degrade(), Pull::Up);
+
+    let (reader, mut writer) = hid.split();
+
+    // Do stuff with the class!
+    let in_fut = async {
+        loop {
+            button.wait_for_low().await;
+            info!("PRESSED");
+
+            if SUSPENDED.load(Ordering::Acquire) {
+                info!("Triggering remote wakeup");
+                remote_wakeup.signal(());
+            } else {
+                let report = KeyboardReport {
+                    keycodes: [4, 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),
+                };
+            }
+
+            button.wait_for_high().await;
+            info!("RELEASED");
+            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, &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(&self, id: ReportId, _buf: &mut [u8]) -> Option<usize> {
+        info!("Get report for {:?}", id);
+        None
+    }
+
+    fn set_report(&self, id: ReportId, data: &[u8]) -> OutResponse {
+        info!("Set report for {:?}: {=[u8]}", id, data);
+        OutResponse::Accepted
+    }
+
+    fn set_idle_ms(&self, id: Option<ReportId>, dur: u32) {
+        info!("Set idle rate for {:?} to {:?}", id, dur);
+    }
+
+    fn get_idle_ms(&self, id: Option<ReportId>) -> Option<u32> {
+        info!("Get idle rate for {:?}", id);
+        None
+    }
+}
+
+struct MyDeviceStateHandler {
+    configured: AtomicBool,
+}
+
+impl MyDeviceStateHandler {
+    fn new() -> Self {
+        MyDeviceStateHandler {
+            configured: AtomicBool::new(false),
+        }
+    }
+}
+
+impl DeviceStateHandler for MyDeviceStateHandler {
+    fn enabled(&self, enabled: bool) {
+        self.configured.store(false, Ordering::Relaxed);
+        SUSPENDED.store(false, Ordering::Release);
+        if enabled {
+            info!("Device enabled");
+        } else {
+            info!("Device disabled");
+        }
+    }
+
+    fn reset(&self) {
+        self.configured.store(false, Ordering::Relaxed);
+        info!("Bus reset, the Vbus current limit is 100mA");
+    }
+
+    fn addressed(&self, addr: u8) {
+        self.configured.store(false, Ordering::Relaxed);
+        info!("USB address set to: {}", addr);
+    }
+
+    fn configured(&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.");
+        }
+    }
+
+    fn suspended(&self, suspended: bool) {
+        if suspended {
+            info!("Device suspended, the Vbus current limit is 500µA (or 2.5mA for high-power devices with remote wakeup enabled).");
+            SUSPENDED.store(true, Ordering::Release);
+        } else {
+            SUSPENDED.store(false, Ordering::Release);
+            if self.configured.load(Ordering::Relaxed) {
+                info!("Device resumed, it may now draw up to the configured current limit from Vbus");
+            } else {
+                info!("Device resumed, the Vbus current limit is 100mA");
+            }
+        }
+    }
+}
diff --git a/examples/nrf52840/src/bin/usb_hid_mouse.rs b/examples/nrf52840/src/bin/usb_hid_mouse.rs
new file mode 100644
index 000000000..4916a38d4
--- /dev/null
+++ b/examples/nrf52840/src/bin/usb_hid_mouse.rs
@@ -0,0 +1,124 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::mem;
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::usb::{Driver, PowerUsb};
+use embassy_nrf::{interrupt, pac};
+use embassy_time::{Duration, Timer};
+use embassy_usb::class::hid::{HidWriter, ReportId, RequestHandler, State};
+use embassy_usb::control::OutResponse;
+use embassy_usb::{Builder, Config};
+use usbd_hid::descriptor::{MouseReport, SerializedDescriptor};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let clock: pac::CLOCK = unsafe { mem::transmute(()) };
+
+    info!("Enabling ext hfosc...");
+    clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
+    while clock.events_hfclkstarted.read().bits() != 1 {}
+
+    // Create the driver, from the HAL.
+    let irq = interrupt::take!(USBD);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
+
+    // Create embassy-usb Config
+    let mut config = Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("HID mouse 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 device_descriptor = [0; 256];
+    let mut config_descriptor = [0; 256];
+    let mut bos_descriptor = [0; 256];
+    let mut control_buf = [0; 64];
+    let request_handler = MyRequestHandler {};
+
+    let mut state = State::new();
+
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut device_descriptor,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut control_buf,
+        None,
+    );
+
+    // Create classes on the builder.
+    let config = embassy_usb::class::hid::Config {
+        report_descriptor: MouseReport::desc(),
+        request_handler: Some(&request_handler),
+        poll_ms: 60,
+        max_packet_size: 8,
+    };
+
+    let mut writer = HidWriter::<_, 5>::new(&mut builder, &mut state, config);
+
+    // Build the builder.
+    let mut usb = builder.build();
+
+    // Run the USB device.
+    let usb_fut = usb.run();
+
+    // Do stuff with the class!
+    let hid_fut = async {
+        let mut y: i8 = 5;
+        loop {
+            Timer::after(Duration::from_millis(500)).await;
+
+            y = -y;
+            let report = MouseReport {
+                buttons: 0,
+                x: 0,
+                y,
+                wheel: 0,
+                pan: 0,
+            };
+            match writer.write_serialize(&report).await {
+                Ok(()) => {}
+                Err(e) => warn!("Failed to send report: {:?}", e),
+            }
+        }
+    };
+
+    // Run everything concurrently.
+    // If we had made everything `'static` above instead, we could do this using separate tasks instead.
+    join(usb_fut, hid_fut).await;
+}
+
+struct MyRequestHandler {}
+
+impl RequestHandler for MyRequestHandler {
+    fn get_report(&self, id: ReportId, _buf: &mut [u8]) -> Option<usize> {
+        info!("Get report for {:?}", id);
+        None
+    }
+
+    fn set_report(&self, id: ReportId, data: &[u8]) -> OutResponse {
+        info!("Set report for {:?}: {=[u8]}", id, data);
+        OutResponse::Accepted
+    }
+
+    fn set_idle_ms(&self, id: Option<ReportId>, dur: u32) {
+        info!("Set idle rate for {:?} to {:?}", id, dur);
+    }
+
+    fn get_idle_ms(&self, id: Option<ReportId>) -> Option<u32> {
+        info!("Get idle rate for {:?}", id);
+        None
+    }
+}
diff --git a/examples/nrf52840/src/bin/usb_serial.rs b/examples/nrf52840/src/bin/usb_serial.rs
new file mode 100644
index 000000000..7c9c4184b
--- /dev/null
+++ b/examples/nrf52840/src/bin/usb_serial.rs
@@ -0,0 +1,110 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::mem;
+
+use defmt::{info, panic};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::usb::{Driver, Instance, PowerUsb, UsbSupply};
+use embassy_nrf::{interrupt, pac};
+use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
+use embassy_usb::driver::EndpointError;
+use embassy_usb::{Builder, Config};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let clock: pac::CLOCK = unsafe { mem::transmute(()) };
+
+    info!("Enabling ext hfosc...");
+    clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
+    while clock.events_hfclkstarted.read().bits() != 1 {}
+
+    // Create the driver, from the HAL.
+    let irq = interrupt::take!(USBD);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
+
+    // Create embassy-usb Config
+    let mut config = Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("USB-serial example");
+    config.serial_number = Some("12345678");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    // Required for windows compatiblity.
+    // https://developer.nordicsemi.com/nRF_Connect_SDK/doc/1.9.1/kconfig/CONFIG_CDC_ACM_IAD.html#help
+    config.device_class = 0xEF;
+    config.device_sub_class = 0x02;
+    config.device_protocol = 0x01;
+    config.composite_with_iads = true;
+
+    // Create embassy-usb DeviceBuilder using the driver and config.
+    // It needs some buffers for building the descriptors.
+    let mut device_descriptor = [0; 256];
+    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 device_descriptor,
+        &mut config_descriptor,
+        &mut bos_descriptor,
+        &mut control_buf,
+        None,
+    );
+
+    // Create classes on the builder.
+    let mut 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();
+
+    // Do stuff with the class!
+    let echo_fut = async {
+        loop {
+            class.wait_connection().await;
+            info!("Connected");
+            let _ = echo(&mut class).await;
+            info!("Disconnected");
+        }
+    };
+
+    // Run everything concurrently.
+    // If we had made everything `'static` above instead, we could do this using separate tasks instead.
+    join(usb_fut, echo_fut).await;
+}
+
+struct Disconnected {}
+
+impl From<EndpointError> for Disconnected {
+    fn from(val: EndpointError) -> Self {
+        match val {
+            EndpointError::BufferOverflow => panic!("Buffer overflow"),
+            EndpointError::Disabled => Disconnected {},
+        }
+    }
+}
+
+async fn echo<'d, T: Instance + 'd, P: UsbSupply + 'd>(
+    class: &mut CdcAcmClass<'d, Driver<'d, T, P>>,
+) -> Result<(), Disconnected> {
+    let mut buf = [0; 64];
+    loop {
+        let n = class.read_packet(&mut buf).await?;
+        let data = &buf[..n];
+        info!("data: {:x}", data);
+        class.write_packet(data).await?;
+    }
+}
diff --git a/examples/nrf52840/src/bin/usb_serial_multitask.rs b/examples/nrf52840/src/bin/usb_serial_multitask.rs
new file mode 100644
index 000000000..93efc2fe6
--- /dev/null
+++ b/examples/nrf52840/src/bin/usb_serial_multitask.rs
@@ -0,0 +1,118 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use core::mem;
+
+use defmt::{info, panic, unwrap};
+use embassy_executor::Spawner;
+use embassy_nrf::usb::{Driver, PowerUsb};
+use embassy_nrf::{interrupt, pac, peripherals};
+use embassy_usb::class::cdc_acm::{CdcAcmClass, State};
+use embassy_usb::driver::EndpointError;
+use embassy_usb::{Builder, Config, UsbDevice};
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+type MyDriver = Driver<'static, peripherals::USBD, PowerUsb>;
+
+#[embassy_executor::task]
+async fn usb_task(mut device: UsbDevice<'static, MyDriver>) {
+    device.run().await;
+}
+
+#[embassy_executor::task]
+async fn echo_task(mut class: CdcAcmClass<'static, MyDriver>) {
+    loop {
+        class.wait_connection().await;
+        info!("Connected");
+        let _ = echo(&mut class).await;
+        info!("Disconnected");
+    }
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    let clock: pac::CLOCK = unsafe { mem::transmute(()) };
+
+    info!("Enabling ext hfosc...");
+    clock.tasks_hfclkstart.write(|w| unsafe { w.bits(1) });
+    while clock.events_hfclkstarted.read().bits() != 1 {}
+    // Create the driver, from the HAL.
+    let irq = interrupt::take!(USBD);
+    let power_irq = interrupt::take!(POWER_CLOCK);
+    let driver = Driver::new(p.USBD, irq, PowerUsb::new(power_irq));
+
+    // Create embassy-usb Config
+    let mut config = Config::new(0xc0de, 0xcafe);
+    config.manufacturer = Some("Embassy");
+    config.product = Some("USB-serial example");
+    config.serial_number = Some("12345678");
+    config.max_power = 100;
+    config.max_packet_size_0 = 64;
+
+    // Required for windows compatiblity.
+    // https://developer.nordicsemi.com/nRF_Connect_SDK/doc/1.9.1/kconfig/CONFIG_CDC_ACM_IAD.html#help
+    config.device_class = 0xEF;
+    config.device_sub_class = 0x02;
+    config.device_protocol = 0x01;
+    config.composite_with_iads = true;
+
+    struct Resources {
+        device_descriptor: [u8; 256],
+        config_descriptor: [u8; 256],
+        bos_descriptor: [u8; 256],
+        control_buf: [u8; 64],
+        serial_state: State<'static>,
+    }
+    static RESOURCES: StaticCell<Resources> = StaticCell::new();
+    let res = RESOURCES.init(Resources {
+        device_descriptor: [0; 256],
+        config_descriptor: [0; 256],
+        bos_descriptor: [0; 256],
+        control_buf: [0; 64],
+        serial_state: State::new(),
+    });
+
+    // Create embassy-usb DeviceBuilder using the driver and config.
+    let mut builder = Builder::new(
+        driver,
+        config,
+        &mut res.device_descriptor,
+        &mut res.config_descriptor,
+        &mut res.bos_descriptor,
+        &mut res.control_buf,
+        None,
+    );
+
+    // Create classes on the builder.
+    let class = CdcAcmClass::new(&mut builder, &mut res.serial_state, 64);
+
+    // Build the builder.
+    let usb = builder.build();
+
+    unwrap!(spawner.spawn(usb_task(usb)));
+    unwrap!(spawner.spawn(echo_task(class)));
+}
+
+struct Disconnected {}
+
+impl From<EndpointError> for Disconnected {
+    fn from(val: EndpointError) -> Self {
+        match val {
+            EndpointError::BufferOverflow => panic!("Buffer overflow"),
+            EndpointError::Disabled => Disconnected {},
+        }
+    }
+}
+
+async fn echo(class: &mut CdcAcmClass<'static, MyDriver>) -> Result<(), Disconnected> {
+    let mut buf = [0; 64];
+    loop {
+        let n = class.read_packet(&mut buf).await?;
+        let data = &buf[..n];
+        info!("data: {:x}", data);
+        class.write_packet(data).await?;
+    }
+}
diff --git a/examples/nrf52840/src/bin/wdt.rs b/examples/nrf52840/src/bin/wdt.rs
new file mode 100644
index 000000000..b0b9c3b81
--- /dev/null
+++ b/examples/nrf52840/src/bin/wdt.rs
@@ -0,0 +1,41 @@
+#![no_std]
+#![no_main]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Input, Pull};
+use embassy_nrf::wdt::{Config, Watchdog};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("Hello World!");
+
+    let mut config = Config::default();
+    config.timeout_ticks = 32768 * 3; // 3 seconds
+
+    // This is needed for `probe-run` to be able to catch the panic message
+    // in the WDT interrupt. The core resets 2 ticks after firing the interrupt.
+    config.run_during_debug_halt = false;
+
+    let (_wdt, [mut handle]) = match Watchdog::try_new(p.WDT, config) {
+        Ok(x) => x,
+        Err(_) => {
+            info!("Watchdog already active with wrong config, waiting for it to timeout...");
+            loop {}
+        }
+    };
+
+    let mut button = Input::new(p.P0_11, Pull::Up);
+
+    info!("Watchdog started, press button 1 to pet it or I'll reset in 3 seconds!");
+
+    loop {
+        button.wait_for_high().await;
+        button.wait_for_low().await;
+        info!("Button pressed, petting watchdog!");
+        handle.pet();
+    }
+}