Struct Spi

pub struct Spi<'d, PIO: Instance, const SM: usize, M: Mode> { /* private fields */ }

PIO based Spi driver. Unlike other PIO programs, the PIO SPI driver owns and holds a reference to the PIO memory it uses. This is so that it can be reconfigured at runtime if desired.

Implementations

impl<'d, PIO: Instance, const SM: usize, M: Mode> Spi<'d, PIO, SM, M>

pub fn blocking_read(&mut self, data: &mut [u8]) -> Result<(), Error>

Read data from SPI blocking execution until done.

pub fn blocking_write(&mut self, data: &[u8]) -> Result<(), Error>

Write data to SPI blocking execution until done.

pub fn blocking_transfer( &mut self, read: &mut [u8], write: &[u8], ) -> Result<(), Error>

Transfer data to SPI blocking execution until done.

pub fn blocking_transfer_in_place( &mut self, data: &mut [u8], ) -> Result<(), Error>

Transfer data in place to SPI blocking execution until done.

pub fn flush(&mut self) -> Result<(), Error>

Block execution until SPI is done.

pub fn set_frequency(&mut self, freq: u32)

Set SPI frequency.

pub fn set_config(&mut self, pio: &mut Common<'d, PIO>, config: &Config)

Set SPI config.

This operation will panic if the PIO program needs to be reloaded and there is insufficient room. This is unlikely since the programs for each phase only differ in size by a single instruction.

impl<'d, PIO: Instance, const SM: usize> Spi<'d, PIO, SM, Blocking>

pub fn new_blocking( pio: &mut Common<'d, PIO>, sm: StateMachine<'d, PIO, SM>, clk: Peri<'d, impl PioPin>, mosi: Peri<'d, impl PioPin>, miso: Peri<'d, impl PioPin>, config: Config, ) -> Self

Create an SPI driver in blocking mode.

impl<'d, PIO: Instance, const SM: usize> Spi<'d, PIO, SM, Async>

pub fn new( pio: &mut Common<'d, PIO>, sm: StateMachine<'d, PIO, SM>, clk: Peri<'d, impl PioPin>, mosi: Peri<'d, impl PioPin>, miso: Peri<'d, impl PioPin>, tx_dma: Peri<'d, impl Channel>, rx_dma: Peri<'d, impl Channel>, config: Config, ) -> Self

Create an SPI driver in async mode supporting DMA operations.

pub async fn read(&mut self, buffer: &mut [u8]) -> Result<(), Error>

Read data from SPI using DMA.

pub async fn write(&mut self, buffer: &[u8]) -> Result<(), Error>

Write data to SPI using DMA.

pub async fn transfer( &mut self, rx_buffer: &mut [u8], tx_buffer: &[u8], ) -> Result<(), Error>

Transfer data to SPI using DMA.

pub async fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Error>

Transfer data in place to SPI using DMA.

Trait Implementations

impl<'d, PIO: Instance, const SM: usize, M: Mode> ErrorType for Spi<'d, PIO, SM, M>

type Error = Error

Error type.

impl<'d, PIO: Instance, const SM: usize> SpiBus for Spi<'d, PIO, SM, Async>

async fn flush(&mut self) -> Result<(), Self::Error>

Wait until all operations have completed and the bus is idle.

async fn write(&mut self, words: &[u8]) -> Result<(), Self::Error>

Write words to the slave, ignoring all the incoming words.

async fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error>

Read words from the slave.

async fn transfer( &mut self, read: &mut [u8], write: &[u8], ) -> Result<(), Self::Error>

Write and read simultaneously. write is written to the slave on MOSI and words received on MISO are stored in read.

async fn transfer_in_place( &mut self, words: &mut [u8], ) -> Result<(), Self::Error>

Write and read simultaneously. The contents of words are written to the slave, and the received words are stored into the same words buffer, overwriting it.

impl<'d, PIO: Instance, const SM: usize, M: Mode> SpiBus for Spi<'d, PIO, SM, M>

fn flush(&mut self) -> Result<(), Self::Error>

Wait until all operations have completed and the bus is idle.

fn read(&mut self, words: &mut [u8]) -> Result<(), Self::Error>

Read words from the slave.

fn write(&mut self, words: &[u8]) -> Result<(), Self::Error>

Write words to the slave, ignoring all the incoming words.

fn transfer(&mut self, read: &mut [u8], write: &[u8]) -> Result<(), Self::Error>

Write and read simultaneously. write is written to the slave on MOSI and words received on MISO are stored in read.

fn transfer_in_place(&mut self, words: &mut [u8]) -> Result<(), Self::Error>

Write and read simultaneously. The contents of words are written to the slave, and the received words are stored into the same words buffer, overwriting it.

impl<'d, PIO: Instance, const SM: usize, M: Mode> Transfer<u8> for Spi<'d, PIO, SM, M>

type Error = Error

Error type

fn transfer<'w>(&mut self, words: &'w mut [u8]) -> Result<&'w [u8], Self::Error>

Sends words to the slave. Returns the words received from the slave

impl<'d, PIO: Instance, const SM: usize, M: Mode> Write<u8> for Spi<'d, PIO, SM, M>

type Error = Error

Error type

fn write(&mut self, words: &[u8]) -> Result<(), Self::Error>

Sends words to the slave, ignoring all the incoming words