Struct SpiDma

pub struct SpiDma<'d, Dm>
where
    Dm: DriverMode,
{ /* private fields */ }

Available on crate feature unstable only.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time. A DMA capable SPI instance.

Using SpiDma is not recommended unless you wish to manage buffers yourself. It’s recommended to use SpiDmaBus via with_buffers to get access to a DMA capable SPI bus that implements the embedded-hal traits.

let dma_channel = peripherals.DMA_CH0;
let (rx_buffer, rx_descriptors, tx_buffer, tx_descriptors) =
    dma_buffers!(32000);

let dma_rx_buf = DmaRxBuf::new(
    rx_descriptors,
    rx_buffer
)?;

let dma_tx_buf = DmaTxBuf::new(
    tx_descriptors,
    tx_buffer
)?;

let mut spi = Spi::new(
    peripherals.SPI2,
    Config::default().with_frequency(Rate::from_khz(100)).
with_mode(Mode::_0) )?
.with_dma(dma_channel)
.with_buffers(dma_rx_buf, dma_tx_buf);

Implementations

impl<'d> SpiDma<'d, Blocking>

pub fn into_async(self) -> SpiDma<'d, Async>

Converts the SPI instance into async mode.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

impl<'d> SpiDma<'d, Async>

pub fn into_blocking(self) -> SpiDma<'d, Blocking>

Converts the SPI instance into async mode.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

impl SpiDma<'_, Blocking>

pub fn listen(&mut self, interrupts: impl Into<EnumSet<SpiInterrupt>>)

Listen for the given interrupts

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn unlisten(&mut self, interrupts: impl Into<EnumSet<SpiInterrupt>>)

Unlisten the given interrupts

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn interrupts(&mut self) -> EnumSet<SpiInterrupt>

Gets asserted interrupts

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn clear_interrupts(&mut self, interrupts: impl Into<EnumSet<SpiInterrupt>>)

Resets asserted interrupts

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

impl<'d, Dm> SpiDma<'d, Dm>

where Dm: DriverMode,

pub fn apply_config(&mut self, config: &Config) -> Result<(), ConfigError>

Change the bus configuration.

Errors

If frequency passed in config exceeds 80MHz or is below 70kHz, ConfigError::UnsupportedFrequency error will be returned.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn with_buffers( self, dma_rx_buf: DmaRxBuf, dma_tx_buf: DmaTxBuf, ) -> SpiDmaBus<'d, Dm>

Configures the DMA buffers for the SPI instance.

This method sets up both RX and TX buffers for DMA transfers. It returns an instance of SpiDmaBus that can be used for SPI communication.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

impl<'d, Dm> SpiDma<'d, Dm>

where Dm: DriverMode,

pub fn write<TX: DmaTxBuffer>( self, bytes_to_write: usize, buffer: TX, ) -> Result<SpiDmaTransfer<'d, Dm, TX>, (Error, Self, TX)>

Perform a DMA write.

This will return a SpiDmaTransfer owning the buffer and the SPI instance. The maximum amount of data to be sent is 32736 bytes.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn read<RX: DmaRxBuffer>( self, bytes_to_read: usize, buffer: RX, ) -> Result<SpiDmaTransfer<'d, Dm, RX>, (Error, Self, RX)>

Perform a DMA read.

This will return a SpiDmaTransfer owning the buffer and the SPI instance. The maximum amount of data to be received is 32736 bytes.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn transfer<RX: DmaRxBuffer, TX: DmaTxBuffer>( self, bytes_to_read: usize, rx_buffer: RX, bytes_to_write: usize, tx_buffer: TX, ) -> Result<SpiDmaTransfer<'d, Dm, (RX, TX)>, (Error, Self, RX, TX)>

Perform a DMA transfer

This will return a SpiDmaTransfer owning the buffers and the SPI instance. The maximum amount of data to be sent/received is 32736 bytes.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn half_duplex_read<RX: DmaRxBuffer>( self, data_mode: DataMode, cmd: Command, address: Address, dummy: u8, bytes_to_read: usize, buffer: RX, ) -> Result<SpiDmaTransfer<'d, Dm, RX>, (Error, Self, RX)>

Perform a half-duplex read operation using DMA.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn half_duplex_write<TX: DmaTxBuffer>( self, data_mode: DataMode, cmd: Command, address: Address, dummy: u8, bytes_to_write: usize, buffer: TX, ) -> Result<SpiDmaTransfer<'d, Dm, TX>, (Error, Self, TX)>

Perform a half-duplex write operation using DMA.

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

Trait Implementations

impl<Dm> Debug for SpiDma<'_, Dm>

where Dm: DriverMode,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the SpiDma instance for debugging purposes.

This method returns a debug struct with the name “SpiDma” without exposing internal details.

impl<'d, Dm> Format for SpiDma<'d, Dm>

where Dm: DriverMode, PeripheralRef<'d, AnySpi>: Format, Channel<'d, Dm, PeripheralDmaChannel<AnySpi>>: Format, PeripheralGuard: Format, SpiPinGuard: Format,

fn format(&self, f: Formatter<'_>)

Writes the defmt representation of self to fmt.

impl InterruptConfigurable for SpiDma<'_, Blocking>

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

fn set_interrupt_handler(&mut self, handler: InterruptHandler)

Sets the interrupt handler

Interrupts are not enabled at the peripheral level here.

impl<Dm> SetConfig for SpiDma<'_, Dm>

where Dm: DriverMode,

Stability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

type Config = Config

The configuration type used by this driver.

type ConfigError = ConfigError

The error type that can occur if set_config fails.

fn set_config(&mut self, config: &Self::Config) -> Result<(), Self::ConfigError>

Set the configuration of the driver.