SPI transfer performance using rp-hal and embassy-rp (sync/async)

embassy-rp-async.rs

#![no_std]
#![no_main]

use defmt::*;
use embassy_executor::Spawner;
use embassy_rp::{
    gpio::{Level, Output},
    spi::{self, Spi},
};
use {defmt_rtt as _, panic_probe as _};

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_rp::init(Default::default());

    let miso = p.PIN_16;
    let mosi = p.PIN_19;
    let clk = p.PIN_18;
    let cs = p.PIN_17;

    let mut config = spi::Config::default();
    config.frequency = 16_000_000;

    let mut spi_cs = Output::new(cs, Level::High);

    let mut spi = Spi::new(
        p.SPI0,
        clk,
        mosi,
        miso,
        p.DMA_CH0,
        p.DMA_CH1,
        spi::Config::default(),
    );

    let mut i = 0_u32;

    loop {
        if i == 0 {
            println!("Start");
        }
        spi_cs.set_low();
        let tx = [0; 16];
        let mut rx = [0; 16];
        spi.transfer(&mut rx, &tx).await.unwrap();
        spi_cs.set_high();
        i += 1;
        if i == 1_000_000 {
            println!("Got 1_000_000 values");
            i = 0;
        }
    }
}

embassy-rp-sync.rs

#![no_std]
#![no_main]

use defmt::*;
use embassy_executor::Spawner;
use embassy_rp::spi::Spi;
use embassy_rp::{gpio, spi};
use gpio::{Level, Output};
use {defmt_rtt as _, panic_probe as _};

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_rp::init(Default::default());

    let miso = p.PIN_12;
    let mosi = p.PIN_11;
    let clk = p.PIN_10;
    let cs = p.PIN_16;

    let mut config = spi::Config::default();
    config.frequency = 16_000_000;
    let mut spi = Spi::new_blocking(p.SPI1, clk, mosi, miso, config);

    let mut spi_cs = Output::new(cs, Level::High);

    let mut i = 0_u32;

    loop {
        if i == 0 {
            println!("Start");
        }
        spi_cs.set_low();
        let mut buf = [0; 16];
        spi.blocking_transfer_in_place(&mut buf).unwrap();
        spi_cs.set_high();
        i += 1;
        if i == 1_000_000 {
            println!("Got 1_000_000 values");
            i = 0;
        }
    }
}

rp-hal.rs

#![no_std]
#![no_main]

use cortex_m_rt::entry;
use defmt::*;
use defmt_rtt as _;
use embedded_hal::blocking::spi::Transfer;
use embedded_hal::digital::v2::OutputPin;
use embedded_time::rate::*;
use panic_probe as _;

use rp_pico as bsp;

use bsp::hal::{
    clocks::{init_clocks_and_plls, Clock},
    gpio, pac,
    sio::Sio,
    spi,
    watchdog::Watchdog,
};

#[cfg_attr(not(test), entry)]
fn main() -> ! {
    let mut pac = pac::Peripherals::take().unwrap();
    let mut watchdog = Watchdog::new(pac.WATCHDOG);
    let sio = Sio::new(pac.SIO);

    let external_xtal_freq_hz = 12_000_000u32;
    let clocks = init_clocks_and_plls(
        external_xtal_freq_hz,
        pac.XOSC,
        pac.CLOCKS,
        pac.PLL_SYS,
        pac.PLL_USB,
        &mut pac.RESETS,
        &mut watchdog,
    )
    .ok()
    .unwrap();

    let pins = bsp::Pins::new(
        pac.IO_BANK0,
        pac.PADS_BANK0,
        sio.gpio_bank0,
        &mut pac.RESETS,
    );

    let _spi_sclk = pins.gpio18.into_mode::<gpio::FunctionSpi>();
    let _spi_mosi = pins.gpio19.into_mode::<gpio::FunctionSpi>();
    let _spi_miso = pins.gpio16.into_mode::<gpio::FunctionSpi>();
    let mut spi_cs = pins.gpio17.into_push_pull_output();

    let spi = spi::Spi::<_, _, 8>::new(pac.SPI0);

    let mut spi = spi.init(
        &mut pac.RESETS,
        clocks.peripheral_clock.freq(),
        16_000_000u32.Hz(),
        &embedded_hal::spi::MODE_0,
    );
    spi_cs.set_high().unwrap();

    let mut c = 0_u32;

    loop {
        if c == 0 {
            println!("Start");
        }
        spi_cs.set_low().unwrap();
        let mut buf = [0; 16];
        spi.transfer(&mut buf).unwrap();
        spi_cs.set_high().unwrap();
        c += 1;
        if c == 1_000_000 {
            println!("Got 1_000_000 values");
            c = 0;
        }
    }
}

Testing results for 1,000,000 buffer transfers:

• rp-hal: 11.5s
• embassy-rp-sync: 115.0s
• embassy-rp-async: 550s