Struct stm32f7xx_hal::spi::Spi

pub struct Spi<I, P, State> { /* fields omitted */ }

Entry point to the SPI API

Implementations

impl<I, P> Spi<I, P, Disabled> where
    I: Instance + Enable,
    P: Pins<I>, 

pub fn new(instance: I, pins: P) -> Self

Create a new instance of the SPI API

pub fn enable<Word>(
    self,
    apb: &mut <I as RccBus>::Bus,
    clock_divider: ClockDivider,
    mode: Mode
) -> Spi<I, P, Enabled<Word>> where
    Word: SupportedWordSize, 

Initialize the SPI peripheral

impl<I, P, Word> Spi<I, P, Enabled<Word>> where
    I: Instance,
    P: Pins<I>,
    Word: SupportedWordSize, 

pub fn transfer_all<B>(
    self,
    buffer: Pin<B>,
    dma_rx: &Handle<<Rx<I> as Target>::Instance, Enabled>,
    dma_tx: &Handle<<Tx<I> as Target>::Instance, Enabled>,
    rx: <Rx<I> as Target>::Stream,
    tx: <Tx<I> as Target>::Stream
) -> Transfer<Word, I, P, B, Rx<I>, Tx<I>, Ready> where
    Rx<I>: Target,
    Tx<I>: Target,
    B: DerefMut + 'static,
    B::Target: AsMutSlice<Element = Word>, 

Start an SPI transfer using DMA

Sends the data in buffer and writes the received data into buffer right after. Returns a Transfer, to represent the ongoing SPI transfer.

Please note that the word “transfer” is used with two different meanings here:

• An SPI transfer, as in an SPI transaction that involves both sending and receiving data. The method name refers to this kind of transfer.
• A DMA transfer, as in an ongoing DMA operation. The name of the return type refers to this kind of transfer.

This method, as well as all other DMA-related methods in this module, requires references to two DMA handles, one each for the RX and TX streams. This will actually always be the same handle, as each SPI instance uses the same DMA instance for both sending and receiving. It would be nice to simplify that, but I believe that requires an equality constraint in the where clause, which is not supported yet by the compiler.

impl<I, P, State> Spi<I, P, State> where
    I: Instance,
    P: Pins<I>, 

pub fn free(self) -> (I, P)

Destroy the peripheral API and return a raw SPI peripheral instance

Trait Implementations

impl<I, P, Word> FullDuplex<Word> for Spi<I, P, Enabled<Word>> where
    I: Instance,
    P: Pins<I>,
    Word: SupportedWordSize, 

type Error = Error

An enumeration of SPI errors

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

Reads the word stored in the shift register

fn send(&mut self, word: Word) -> Result<(), Self::Error>

Sends a word to the slave

impl<I, P, Word> Default<Word> for Spi<I, P, Enabled<Word>> where
    I: Instance,
    P: Pins<I>,
    Word: SupportedWordSize, 

impl<I, P, Word> Default<Word> for Spi<I, P, Enabled<Word>> where
    I: Instance,
    P: Pins<I>,
    Word: SupportedWordSize, 

impl<I, P, Word> Default<Word> for Spi<I, P, Enabled<Word>> where
    I: Instance,
    P: Pins<I>,
    Word: SupportedWordSize,