Struct Spi 

pub struct Spi<SPI: Instance, W, PULL = Floating> { /* private fields */ }

Spi in Master mode

Implementations

impl<SPI: Instance, PULL: UpMode> Spi<SPI, u8, PULL>

pub fn new<const R: u8>( spi: impl Into<Rmp<SPI, R>>, pins: (Option<impl RInto<SPI::MSck, R>>, Option<impl RInto<SPI::Mi<PULL>, R>>, Option<impl RInto<SPI::Mo, R>>), mode: Mode, freq: Hertz, rcc: &mut Rcc, ) -> Self

Constructs an SPI instance using SPI1 in 8bit dataframe mode.

The pin parameter tuple (sck, miso, mosi) should be (PA5, PA6, PA7) or (PB3, PB4, PB5) configured as (Alternate<PushPull>, Input<...>, Alternate<PushPull>).

You can also use NoSck, NoMiso or NoMosi if you don’t want to use the pins

impl<SPI: Instance, PULL> Spi<SPI, u8, PULL>

pub fn release( self, ) -> (SPI, (Option<SPI::MSck>, Option<SPI::Mi<PULL>>, Option<SPI::Mo>))

impl<SPI: Instance, PULL> Spi<SPI, u8, PULL>

pub fn frame_size_16bit(self) -> Spi<SPI, u16, PULL>

Converts from 8bit dataframe to 16bit.

impl<SPI: Instance, PULL> Spi<SPI, u16, PULL>

pub fn frame_size_8bit(self) -> Spi<SPI, u16, PULL>

Converts from 16bit dataframe to 8bit.

impl<PULL> Spi<SPI1, u8, PULL>

pub fn with_tx_dma(self, channel: C3) -> SpiTxDma<SPI1, C3, PULL>

pub fn with_rx_dma(self, channel: C2) -> SpiRxDma<SPI1, C2, PULL>

pub fn with_rx_tx_dma( self, rxchannel: C2, txchannel: C3, ) -> SpiRxTxDma<SPI1, C2, C3, PULL>

impl<PULL> Spi<SPI2, u8, PULL>

pub fn with_tx_dma(self, channel: C5) -> SpiTxDma<SPI2, C5, PULL>

pub fn with_rx_dma(self, channel: C4) -> SpiRxDma<SPI2, C4, PULL>

pub fn with_rx_tx_dma( self, rxchannel: C4, txchannel: C5, ) -> SpiRxTxDma<SPI2, C4, C5, PULL>

Methods from Deref<Target = SpiInner<SPI, W>>

pub fn bit_format(&mut self, format: SpiBitFormat)

Select which frame format is used for data transfers

pub fn listen(&mut self, event: Event)

Starts listening to the SPI by enabling the Received data ready to be read (RXNE) interrupt and Transmit data register empty (TXE) interrupt

pub fn unlisten(&mut self, event: Event)

Stops listening to the SPI by disabling the Received data ready to be read (RXNE) interrupt and Transmit data register empty (TXE) interrupt

pub fn is_tx_empty(&self) -> bool

Returns true if the tx register is empty (and can accept data)

pub fn is_rx_not_empty(&self) -> bool

Returns true if the rx register is not empty (and can be read)

pub fn is_busy(&self) -> bool

Returns true if the transfer is in progress

pub fn is_overrun(&self) -> bool

Returns true if data are received and the previous data have not yet been read from SPI_DR.

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

pub fn write_nonblocking(&mut self, data: W) -> Result<(), Error>

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

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

pub fn transfer(&mut self, buff: &mut [W], data: &[W]) -> Result<(), Error>

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

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

Trait Implementations

impl<SPI: Instance, W, PULL> Deref for Spi<SPI, W, PULL>

type Target = SpiInner<SPI, W>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<SPI: Instance, W, PULL> DerefMut for Spi<SPI, W, PULL>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<SPI: Instance, W, PULL> ErrorType for Spi<SPI, W, PULL>

type Error = Error

Error type.

impl<SPI, W, PULL> FullDuplex<W> for Spi<SPI, W, PULL>

where SPI: Instance, W: FrameSize,

fn read(&mut self) -> Result<W, Error>

Reads the word stored in the shift register

fn write(&mut self, data: W) -> Result<(), Error>

Writes a word to the slave

impl<SPI, W, PULL> SpiBus<W> for Spi<SPI, W, PULL>

where SPI: Instance, W: FrameSize + 'static,

fn transfer_in_place(&mut self, words: &mut [W]) -> 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.

fn transfer(&mut self, buff: &mut [W], data: &[W]) -> 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 read(&mut self, words: &mut [W]) -> Result<(), Self::Error>

Read words from the slave.

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

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

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

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

impl<SPI: Instance, PULL> Write<u16> for Spi<SPI, u16, PULL>

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<SPI: Instance, PULL> Write<u8> for Spi<SPI, u8, PULL>

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<SPI, W, PULL> FullDuplex<W> for Spi<SPI, W, PULL>

where SPI: Instance, W: FrameSize,

type Error = Error

An enumeration of SPI errors

fn read(&mut self) -> Result<W, Error>

Reads the word stored in the shift register

fn send(&mut self, data: W) -> Result<(), Error>

Sends a word to the slave

impl<SPI, W, PULL> Default<W> for Spi<SPI, W, PULL>

where SPI: Instance, W: FrameSize,