Merge branch 'main' into u0-lcd

12 files changed, 768 insertions, 0 deletions

diff --git a/tests/nrf/src/bin/buffered_uart.rs b/tests/nrf/src/bin/buffered_uart.rs
new file mode 100644
index 000000000..8c4827464
--- /dev/null
+++ b/tests/nrf/src/bin/buffered_uart.rs
@@ -0,0 +1,82 @@
+// required-features: easydma
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{panic, *};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::buffered_uarte::{self, BufferedUarte};
+use embassy_nrf::{peripherals, uarte};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD1M;
+
+    let mut tx_buffer = [0u8; 1024];
+    let mut rx_buffer = [0u8; 1024];
+
+    // test teardown + recreate of the buffereduarte works fine.
+    for _ in 0..2 {
+        let u = BufferedUarte::new(
+            peri!(p, UART0).reborrow(),
+            p.TIMER0.reborrow(),
+            p.PPI_CH0.reborrow(),
+            p.PPI_CH1.reborrow(),
+            p.PPI_GROUP0.reborrow(),
+            peri!(p, PIN_A).reborrow(),
+            peri!(p, PIN_B).reborrow(),
+            irqs!(UART0_BUFFERED),
+            config.clone(),
+            &mut rx_buffer,
+            &mut tx_buffer,
+        );
+
+        info!("uarte initialized!");
+
+        let (mut rx, mut tx) = u.split();
+
+        const COUNT: usize = 40_000;
+
+        let tx_fut = async {
+            let mut tx_buf = [0; 215];
+            let mut i = 0;
+            while i < COUNT {
+                let n = tx_buf.len().min(COUNT - i);
+                let tx_buf = &mut tx_buf[..n];
+                for (j, b) in tx_buf.iter_mut().enumerate() {
+                    *b = (i + j) as u8;
+                }
+                let n = unwrap!(tx.write(tx_buf).await);
+                i += n;
+            }
+        };
+        let rx_fut = async {
+            let mut i = 0;
+            while i < COUNT {
+                let buf = unwrap!(rx.fill_buf().await);
+
+                for &b in buf {
+                    if b != i as u8 {
+                        panic!("mismatch {} vs {}, index {}", b, i as u8, i);
+                    }
+                    i = i + 1;
+                }
+
+                let n = buf.len();
+                rx.consume(n);
+            }
+        };
+
+        join(rx_fut, tx_fut).await;
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/buffered_uart_full.rs b/tests/nrf/src/bin/buffered_uart_full.rs
new file mode 100644
index 000000000..e0f41b891
--- /dev/null
+++ b/tests/nrf/src/bin/buffered_uart_full.rs
@@ -0,0 +1,70 @@
+// required-features: easydma
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_nrf::buffered_uarte::{self, BufferedUarte};
+use embassy_nrf::{peripherals, uarte};
+use embedded_io_async::{Read, Write};
+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::BAUD1M;
+
+    let mut tx_buffer = [0u8; 500];
+    let mut rx_buffer = [0u8; 500];
+
+    let u = BufferedUarte::new(
+        peri!(p, UART0),
+        p.TIMER0,
+        p.PPI_CH0,
+        p.PPI_CH1,
+        p.PPI_GROUP0,
+        peri!(p, PIN_A),
+        peri!(p, PIN_B),
+        irqs!(UART0_BUFFERED),
+        config.clone(),
+        &mut rx_buffer,
+        &mut tx_buffer,
+    );
+
+    info!("uarte initialized!");
+
+    let (mut rx, mut tx) = u.split();
+
+    let mut buf = [0; 500];
+    for (j, b) in buf.iter_mut().enumerate() {
+        *b = j as u8;
+    }
+
+    // Write 500b. This causes the rx buffer to get exactly full.
+    unwrap!(tx.write_all(&buf).await);
+    unwrap!(tx.flush().await);
+
+    // Read those 500b.
+    unwrap!(rx.read_exact(&mut buf).await);
+    for (j, b) in buf.iter().enumerate() {
+        assert_eq!(*b, j as u8);
+    }
+
+    // The buffer should now be unclogged. Write 500b again.
+    unwrap!(tx.write_all(&buf).await);
+    unwrap!(tx.flush().await);
+
+    // Read should work again.
+    unwrap!(rx.read_exact(&mut buf).await);
+    for (j, b) in buf.iter().enumerate() {
+        assert_eq!(*b, j as u8);
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/buffered_uart_halves.rs b/tests/nrf/src/bin/buffered_uart_halves.rs
new file mode 100644
index 000000000..e6debd76e
--- /dev/null
+++ b/tests/nrf/src/bin/buffered_uart_halves.rs
@@ -0,0 +1,86 @@
+// required-features: two-uarts
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::buffered_uarte::{self, BufferedUarteRx, BufferedUarteTx};
+use embassy_nrf::{peripherals, uarte};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD1M;
+
+    let mut tx_buffer = [0u8; 1024];
+    let mut rx_buffer = [0u8; 1024];
+
+    // test teardown + recreate of the buffereduarte works fine.
+    for _ in 0..2 {
+        const COUNT: usize = 40_000;
+
+        let mut tx = BufferedUarteTx::new(
+            peri!(p, UART1).reborrow(),
+            peri!(p, PIN_A).reborrow(),
+            irqs!(UART1_BUFFERED),
+            config.clone(),
+            &mut tx_buffer,
+        );
+
+        let mut rx = BufferedUarteRx::new(
+            peri!(p, UART0).reborrow(),
+            p.TIMER0.reborrow(),
+            p.PPI_CH0.reborrow(),
+            p.PPI_CH1.reborrow(),
+            p.PPI_GROUP0.reborrow(),
+            irqs!(UART0_BUFFERED),
+            peri!(p, PIN_B).reborrow(),
+            config.clone(),
+            &mut rx_buffer,
+        );
+
+        let tx_fut = async {
+            info!("tx initialized!");
+
+            let mut tx_buf = [0; 215];
+            let mut i = 0;
+            while i < COUNT {
+                let n = tx_buf.len().min(COUNT - i);
+                let tx_buf = &mut tx_buf[..n];
+                for (j, b) in tx_buf.iter_mut().enumerate() {
+                    *b = (i + j) as u8;
+                }
+                let n = unwrap!(tx.write(tx_buf).await);
+                i += n;
+            }
+        };
+        let rx_fut = async {
+            info!("rx initialized!");
+
+            let mut i = 0;
+            while i < COUNT {
+                let buf = unwrap!(rx.fill_buf().await);
+
+                for &b in buf {
+                    assert_eq!(b, i as u8);
+                    i = i + 1;
+                }
+
+                let n = buf.len();
+                rx.consume(n);
+            }
+        };
+
+        join(rx_fut, tx_fut).await;
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/buffered_uart_spam.rs b/tests/nrf/src/bin/buffered_uart_spam.rs
new file mode 100644
index 000000000..6d862e19d
--- /dev/null
+++ b/tests/nrf/src/bin/buffered_uart_spam.rs
@@ -0,0 +1,90 @@
+// required-features: two-uarts
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use core::mem;
+use core::ptr::NonNull;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_nrf::buffered_uarte::{self, BufferedUarteRx};
+use embassy_nrf::gpio::{Level, Output, OutputDrive};
+use embassy_nrf::ppi::{Event, Ppi, Task};
+use embassy_nrf::uarte::UarteTx;
+use embassy_nrf::{pac, peripherals, uarte};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD1M;
+
+    let mut rx_buffer = [0u8; 1024];
+
+    mem::forget(Output::new(
+        peri!(p, PIN_A).reborrow(),
+        Level::High,
+        OutputDrive::Standard,
+    ));
+
+    let mut u = BufferedUarteRx::new(
+        peri!(p, UART0),
+        p.TIMER0,
+        p.PPI_CH0,
+        p.PPI_CH1,
+        p.PPI_GROUP0,
+        irqs!(UART0_BUFFERED),
+        peri!(p, PIN_B),
+        config.clone(),
+        &mut rx_buffer,
+    );
+
+    info!("uarte initialized!");
+
+    // uarte needs some quiet time to start rxing properly.
+    Timer::after_millis(10).await;
+
+    // Tx spam in a loop.
+    const NSPAM: usize = 17;
+    static mut TX_BUF: [u8; NSPAM] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+    let _spam = UarteTx::new(peri!(p, UART1), irqs!(UART1), peri!(p, PIN_A), config.clone());
+    let spam_peri = pac::UARTE1;
+    let event = unsafe { Event::new_unchecked(NonNull::new_unchecked(spam_peri.events_dma().tx().end().as_ptr())) };
+    let task = unsafe { Task::new_unchecked(NonNull::new_unchecked(spam_peri.tasks_dma().tx().start().as_ptr())) };
+    let mut spam_ppi = Ppi::new_one_to_one(p.PPI_CH2, event, task);
+    spam_ppi.enable();
+    let p = (&raw mut TX_BUF) as *mut u8;
+    spam_peri.dma().tx().ptr().write_value(p as u32);
+    spam_peri.dma().tx().maxcnt().write(|w| w.set_maxcnt(NSPAM as _));
+    spam_peri.tasks_dma().tx().start().write_value(1);
+
+    let mut i = 0;
+    let mut total = 0;
+    while total < 256 * 1024 {
+        let buf = unwrap!(u.fill_buf().await);
+        //info!("rx {}", buf);
+
+        for &b in buf {
+            assert_eq!(b, unsafe { TX_BUF[i] });
+
+            i = i + 1;
+            if i == NSPAM {
+                i = 0;
+            }
+        }
+
+        // Read bytes have to be explicitly consumed, otherwise fill_buf() will return them again
+        let n = buf.len();
+        u.consume(n);
+        total += n;
+    }
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/ethernet_enc28j60_perf.rs b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
new file mode 100644
index 000000000..bd6a2effd
--- /dev/null
+++ b/tests/nrf/src/bin/ethernet_enc28j60_perf.rs
@@ -0,0 +1,85 @@
+// required-features: nrf52840
+#![no_std]
+#![no_main]
+teleprobe_meta::target!(b"ak-gwe-r7");
+teleprobe_meta::timeout!(120);
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_net::StackResources;
+use embassy_net_enc28j60::Enc28j60;
+use embassy_nrf::gpio::{Level, Output, OutputDrive};
+use embassy_nrf::rng::Rng;
+use embassy_nrf::spim::{self, Spim};
+use embassy_nrf::{bind_interrupts, peripherals};
+use embassy_time::Delay;
+use embedded_hal_bus::spi::ExclusiveDevice;
+use static_cell::StaticCell;
+use {defmt_rtt as _, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    SPIM3 => spim::InterruptHandler<peripherals::SPI3>;
+    RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>;
+});
+
+type MyDriver = Enc28j60<ExclusiveDevice<Spim<'static>, Output<'static>, Delay>, Output<'static>>;
+
+#[embassy_executor::task]
+async fn net_task(mut runner: embassy_net::Runner<'static, MyDriver>) -> ! {
+    runner.run().await
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+    info!("running!");
+
+    let eth_sck = p.P0_20;
+    let eth_mosi = p.P0_22;
+    let eth_miso = p.P0_24;
+    let eth_cs = p.P0_15;
+    let eth_rst = p.P0_13;
+    let _eth_irq = p.P0_12;
+
+    let mut config = spim::Config::default();
+    config.frequency = spim::Frequency::M16;
+    let spi = spim::Spim::new(p.SPI3, Irqs, eth_sck, eth_miso, eth_mosi, config);
+    let cs = Output::new(eth_cs, Level::High, OutputDrive::Standard);
+    let spi = ExclusiveDevice::new(spi, cs, Delay);
+
+    let rst = Output::new(eth_rst, Level::High, OutputDrive::Standard);
+    let mac_addr = [2, 3, 4, 5, 6, 7];
+    let device = Enc28j60::new(spi, Some(rst), mac_addr);
+
+    let config = embassy_net::Config::dhcpv4(Default::default());
+    // let config = embassy_net::Config::ipv4_static(embassy_net::StaticConfigV4 {
+    //    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, Irqs);
+    let mut seed = [0; 8];
+    rng.blocking_fill_bytes(&mut seed);
+    let seed = u64::from_le_bytes(seed);
+
+    // Init network stack
+    static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
+    let (stack, runner) = embassy_net::new(device, config, RESOURCES.init(StackResources::new()), seed);
+
+    spawner.spawn(unwrap!(net_task(runner)));
+
+    perf_client::run(
+        stack,
+        perf_client::Expected {
+            down_kbps: 200,
+            up_kbps: 200,
+            updown_kbps: 150,
+        },
+    )
+    .await;
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/gpio.rs b/tests/nrf/src/bin/gpio.rs
new file mode 100644
index 000000000..4995d244c
--- /dev/null
+++ b/tests/nrf/src/bin/gpio.rs
@@ -0,0 +1,31 @@
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert, info};
+use embassy_executor::Spawner;
+use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
+use embassy_time::Timer;
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+
+    let input = Input::new(peri!(p, PIN_A), Pull::Up);
+    let mut output = Output::new(peri!(p, PIN_B), Level::Low, OutputDrive::Standard);
+
+    output.set_low();
+    assert!(output.is_set_low());
+    Timer::after_millis(10).await;
+    assert!(input.is_low());
+
+    output.set_high();
+    assert!(output.is_set_high());
+    Timer::after_millis(10).await;
+    assert!(input.is_high());
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/gpiote.rs b/tests/nrf/src/bin/gpiote.rs
new file mode 100644
index 000000000..0700016d1
--- /dev/null
+++ b/tests/nrf/src/bin/gpiote.rs
@@ -0,0 +1,50 @@
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert, info};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
+use embassy_time::{Duration, Instant, Timer};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_nrf::init(Default::default());
+
+    let mut input = Input::new(peri!(p, PIN_A), Pull::Up);
+    let mut output = Output::new(peri!(p, PIN_B), Level::Low, OutputDrive::Standard);
+
+    let fut1 = async {
+        Timer::after_millis(100).await;
+        output.set_high();
+    };
+    let fut2 = async {
+        let start = Instant::now();
+        input.wait_for_high().await;
+        let dur = Instant::now() - start;
+        info!("took {} ms", dur.as_millis());
+        assert!((Duration::from_millis(90)..Duration::from_millis(110)).contains(&dur));
+    };
+
+    join(fut1, fut2).await;
+
+    let fut1 = async {
+        Timer::after_millis(100).await;
+        output.set_low();
+    };
+    let fut2 = async {
+        let start = Instant::now();
+        input.wait_for_low().await;
+        let dur = Instant::now() - start;
+        info!("took {} ms", dur.as_millis());
+        assert!((Duration::from_millis(90)..Duration::from_millis(110)).contains(&dur));
+    };
+
+    join(fut1, fut2).await;
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/spim.rs b/tests/nrf/src/bin/spim.rs
new file mode 100644
index 000000000..2b38f0409
--- /dev/null
+++ b/tests/nrf/src/bin/spim.rs
@@ -0,0 +1,42 @@
+// required-features: easydma
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_nrf::spim::Spim;
+use embassy_nrf::{peripherals, spim};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = spim::Config::default();
+    config.frequency = spim::Frequency::M1;
+    let mut spim = Spim::new(
+        peri!(p, SPIM0).reborrow(),
+        irqs!(SPIM0),
+        peri!(p, PIN_X).reborrow(),
+        peri!(p, PIN_A).reborrow(), // MISO
+        peri!(p, PIN_B).reborrow(), // MOSI
+        config.clone(),
+    );
+    let data = [
+        0x42, 0x43, 0x44, 0x45, 0x66, 0x12, 0x23, 0x34, 0x45, 0x19, 0x91, 0xaa, 0xff, 0xa5, 0x5a, 0x77,
+    ];
+    let mut buf = [0u8; 16];
+
+    buf.fill(0);
+    spim.blocking_transfer(&mut buf, &data).unwrap();
+    assert_eq!(data, buf);
+
+    buf.fill(0);
+    spim.transfer(&mut buf, &data).await.unwrap();
+    assert_eq!(data, buf);
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/timer.rs b/tests/nrf/src/bin/timer.rs
new file mode 100644
index 000000000..1ae9dd647
--- /dev/null
+++ b/tests/nrf/src/bin/timer.rs
@@ -0,0 +1,26 @@
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert, info};
+use embassy_executor::Spawner;
+use embassy_time::{Instant, Timer};
+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 start = Instant::now();
+    Timer::after_millis(100).await;
+    let end = Instant::now();
+    let ms = (end - start).as_millis();
+    info!("slept for {} ms", ms);
+    assert!(ms >= 99);
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/uart_halves.rs b/tests/nrf/src/bin/uart_halves.rs
new file mode 100644
index 000000000..a462f80ce
--- /dev/null
+++ b/tests/nrf/src/bin/uart_halves.rs
@@ -0,0 +1,51 @@
+// required-features: two-uarts
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::uarte::{UarteRx, UarteTx};
+use embassy_nrf::{peripherals, uarte};
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD1M;
+
+    let mut tx = UarteTx::new(
+        peri!(p, UART0).reborrow(),
+        irqs!(UART0),
+        peri!(p, PIN_A).reborrow(),
+        config.clone(),
+    );
+    let mut rx = UarteRx::new(
+        peri!(p, UART1).reborrow(),
+        irqs!(UART1),
+        peri!(p, PIN_B).reborrow(),
+        config.clone(),
+    );
+
+    let data = [
+        0x42, 0x43, 0x44, 0x45, 0x66, 0x12, 0x23, 0x34, 0x45, 0x19, 0x91, 0xaa, 0xff, 0xa5, 0x5a, 0x77,
+    ];
+
+    let tx_fut = async {
+        tx.write(&data).await.unwrap();
+    };
+    let rx_fut = async {
+        let mut buf = [0u8; 16];
+        rx.read(&mut buf).await.unwrap();
+        assert_eq!(data, buf);
+    };
+    join(rx_fut, tx_fut).await;
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/uart_split.rs b/tests/nrf/src/bin/uart_split.rs
new file mode 100644
index 000000000..8fe710068
--- /dev/null
+++ b/tests/nrf/src/bin/uart_split.rs
@@ -0,0 +1,49 @@
+// required-features: easydma
+#![no_std]
+#![no_main]
+
+#[path = "../common.rs"]
+mod common;
+
+use defmt::{assert_eq, *};
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_nrf::uarte::Uarte;
+use embassy_nrf::{peripherals, uarte};
+use embassy_time::Timer;
+use {defmt_rtt as _, panic_probe as _};
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut p = embassy_nrf::init(Default::default());
+    let mut config = uarte::Config::default();
+    config.parity = uarte::Parity::EXCLUDED;
+    config.baudrate = uarte::Baudrate::BAUD9600;
+
+    let uarte = Uarte::new(
+        peri!(p, UART0).reborrow(),
+        peri!(p, PIN_A).reborrow(),
+        peri!(p, PIN_B).reborrow(),
+        irqs!(UART0),
+        config.clone(),
+    );
+    let (mut tx, mut rx) = uarte.split();
+
+    let data = [
+        0x42, 0x43, 0x44, 0x45, 0x66, 0x12, 0x23, 0x34, 0x45, 0x19, 0x91, 0xaa, 0xff, 0xa5, 0x5a, 0x77,
+    ];
+
+    let tx_fut = async {
+        Timer::after_millis(10).await;
+        tx.write(&data).await.unwrap();
+    };
+    let rx_fut = async {
+        let mut buf = [0u8; 16];
+        rx.read(&mut buf).await.unwrap();
+        assert_eq!(data, buf);
+    };
+    join(rx_fut, tx_fut).await;
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}
diff --git a/tests/nrf/src/bin/wifi_esp_hosted_perf.rs b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
new file mode 100644
index 000000000..ac082dbb8
--- /dev/null
+++ b/tests/nrf/src/bin/wifi_esp_hosted_perf.rs
@@ -0,0 +1,106 @@
+// required-features: nrf52840
+#![no_std]
+#![no_main]
+teleprobe_meta::target!(b"nrf52840-dk");
+teleprobe_meta::timeout!(120);
+
+use defmt::{info, unwrap};
+use embassy_executor::Spawner;
+use embassy_net::{Config, StackResources};
+use embassy_nrf::gpio::{Input, Level, Output, OutputDrive, Pull};
+use embassy_nrf::rng::Rng;
+use embassy_nrf::spim::{self, Spim};
+use embassy_nrf::{bind_interrupts, peripherals};
+use embassy_time::Delay;
+use embedded_hal_bus::spi::ExclusiveDevice;
+use static_cell::StaticCell;
+use {defmt_rtt as _, embassy_net_esp_hosted as hosted, panic_probe as _};
+
+bind_interrupts!(struct Irqs {
+    SPIM3 => spim::InterruptHandler<peripherals::SPI3>;
+    RNG => embassy_nrf::rng::InterruptHandler<peripherals::RNG>;
+});
+
+// Test-only wifi network, no internet access!
+const WIFI_NETWORK: &str = "EmbassyTest";
+const WIFI_PASSWORD: &str = "V8YxhKt5CdIAJFud";
+
+#[embassy_executor::task]
+async fn wifi_task(
+    runner: hosted::Runner<
+        'static,
+        hosted::SpiInterface<ExclusiveDevice<Spim<'static>, Output<'static>, Delay>, Input<'static>>,
+        Output<'static>,
+    >,
+) -> ! {
+    runner.run().await
+}
+
+type MyDriver = hosted::NetDriver<'static>;
+
+#[embassy_executor::task]
+async fn net_task(mut runner: embassy_net::Runner<'static, MyDriver>) -> ! {
+    runner.run().await
+}
+
+#[embassy_executor::main]
+async fn main(spawner: Spawner) {
+    info!("Hello World!");
+
+    let p = embassy_nrf::init(Default::default());
+
+    let miso = p.P0_28;
+    let sck = p.P0_29;
+    let mosi = p.P0_30;
+    let cs = Output::new(p.P0_31, Level::High, OutputDrive::HighDrive);
+    let handshake = Input::new(p.P1_01, Pull::Up);
+    let ready = Input::new(p.P1_04, Pull::None);
+    let reset = Output::new(p.P1_05, Level::Low, OutputDrive::Standard);
+
+    let mut config = spim::Config::default();
+    config.frequency = spim::Frequency::M32;
+    config.mode = spim::MODE_2; // !!!
+    let spi = spim::Spim::new(p.SPI3, Irqs, sck, miso, mosi, config);
+    let spi = ExclusiveDevice::new(spi, cs, Delay);
+
+    let iface = hosted::SpiInterface::new(spi, handshake, ready);
+
+    static STATE: StaticCell<embassy_net_esp_hosted::State> = StaticCell::new();
+    let (device, mut control, runner) =
+        embassy_net_esp_hosted::new(STATE.init(embassy_net_esp_hosted::State::new()), iface, reset).await;
+
+    spawner.spawn(unwrap!(wifi_task(runner)));
+
+    unwrap!(control.init().await);
+    unwrap!(control.connect(WIFI_NETWORK, WIFI_PASSWORD).await);
+
+    // Generate random seed
+    let mut rng = Rng::new(p.RNG, Irqs);
+    let mut seed = [0; 8];
+    rng.blocking_fill_bytes(&mut seed);
+    let seed = u64::from_le_bytes(seed);
+
+    // Init network stack
+    static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
+    let (stack, runner) = embassy_net::new(
+        device,
+        Config::dhcpv4(Default::default()),
+        RESOURCES.init(StackResources::new()),
+        seed,
+    );
+
+    spawner.spawn(unwrap!(net_task(runner)));
+
+    perf_client::run(
+        stack,
+        perf_client::Expected {
+            down_kbps: 50,
+            up_kbps: 50,
+            updown_kbps: 50,
+        },
+    )
+    .await;
+
+    info!("Test OK");
+    cortex_m::asm::bkpt();
+}