Does async Spi must use DMA?

[yanshay]

Hi,
I'm trying to do some async Spi, and I'm a bit confused.
I created spi and did into_async() to get the async.
But then when I try to use it as embedded_hal_async::spi::SpiBus I get the following error:

^^^^^^^^^^ the trait `embedded_hal_async::spi::SpiBus` is not implemented for `esp_hal::spi::master::Spi<'_, Async>`, which is required by `ExclusiveDevice<esp_hal::spi::master::Spi<'_, Async>, Output<'_>, NoDelay>: embedded_hal_async::spi::SpiDevice`
   |
   = help: the following other types implement trait `embedded_hal_async::spi::SpiBus<Word>`:
             `&mut T` implements `embedded_hal_async::spi::SpiBus<Word>`
             `SpiDmaBus<'_, Async, T>` implements `embedded_hal_async::spi::SpiBus`
             `embassy_embedded_hal::adapter::blocking_async::BlockingAsync<T>` implements `embedded_hal_async::spi::SpiBus`
             `embassy_embedded_hal::adapter::yielding_async::YieldingAsync<T>` implements `embedded_hal_async::spi::SpiBus<Word>`
   = note: required for `ExclusiveDevice<esp_hal::spi::master::Spi<'_, Async>, Output<'_>, NoDelay>` to implement `embedded_hal_async::spi::SpiDevice`

So seems like the SpiDmaBus implements the relevant trait. But then, why is there into_async() on the regular spi?

Also, with I2c to use async I didn't need to use DMA, so does is I2c different in that respect?

[Dominaezzz]

See #2691

[yanshay]

I can share the code if it helps, both the crate and the project, but w/o the pn532 module I'm not sure how helpful that would be.

[Dominaezzz]

Not sure, I don't see anything obvious. This kinda smells like a timing issue to me.

Seeing as your transactions are pretty small, can you try using hardware CS instead of software CS?
I'm curious to see if that makes a difference on either the sync or async side.

With regards to sharing code, I'm mostly interested in seeing how you've constructed the Spi driver and the DMA buffers you give it.
What cpu clock speed are you running at?

[yanshay]

Seeing as your transactions are pretty small, can you try using hardware CS instead of software CS?
How do I do that?

I'm using 100khz. The device supports much higher frequencies.

I based it on the example of async spi, here is the code:

    let dma = Dma::new(peripherals.DMA);

    // cfg_if::cfg_if! {
    //     if #[cfg(any(feature = "esp32", feature = "esp32s2"))] {
    // let dma_channel = dma.spi2channel;
    //     } else {
    let dma_channel = dma.channel0;
    //     }
    // }

    let (rx_buffer, rx_descriptors, tx_buffer, tx_descriptors) = dma_buffers!(32000);
    let dma_rx_buf = DmaRxBuf::new(rx_descriptors, rx_buffer).unwrap();
    let dma_tx_buf = DmaTxBuf::new(tx_descriptors, tx_buffer).unwrap();

    // with esp32s3
    let sck = peripherals.GPIO13;
    let mosi = peripherals.GPIO11;
    let miso = peripherals.GPIO12;
    let cs = Output::new(peripherals.GPIO10, Level::High);

    let spi = Spi::new_with_config(
        peripherals.SPI2,
        esp_hal::spi::master::Config {
            frequency: 100.kHz(),
            mode: SpiMode::Mode0,
            read_bit_order: SpiBitOrder::LSBFirst,
            write_bit_order: SpiBitOrder::LSBFirst,
            ..esp_hal::spi::master::Config::default()
        },
    )
    .with_sck(sck)
    .with_mosi(mosi)
    .with_miso(miso)
    .with_dma(dma_channel.configure(false, DmaPriority::Priority0))
    .with_buffers(dma_rx_buf, dma_tx_buf);

    let spi_device =
        embedded_hal_bus::spi::ExclusiveDevice::new_no_delay(spi, cs).unwrap();

[Dominaezzz]

To use hardware CS, do .with_cs(cs) before .with_dma. Then pass a no-op pin to ExclusiveDevice

[yanshay]

After more testing I found that the PN532 was causing this strange behavior due to wrong initialization.
So now everything seems to work fine and consistent.

Thanks for the assistance.