Struct SpiSlave 

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

Spi in Slave mode

Implementations

impl<SPI: Instance, Otype, PULL: UpMode> SpiSlave<SPI, u8, Otype, PULL>

pub fn new<const R: u8>( spi: impl Into<Rmp<SPI, R>>, pins: (Option<impl RInto<SPI::SSck, R>>, Option<impl RInto<SPI::So<Otype>, R>>, Option<impl RInto<SPI::Si<PULL>, R>>), mode: Mode, 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 (Input<Floating>, Alternate<...>, Input<...>).

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

impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL>

pub fn release( self, ) -> (SPI, (Option<SPI::SSck>, Option<SPI::So<Otype>>, Option<SPI::Si<PULL>>))

impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u8, Otype, PULL>

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

Converts from 8bit dataframe to 16bit.

impl<SPI: Instance, Otype, PULL> SpiSlave<SPI, u16, Otype, PULL>

pub fn frame_size_8bit(self) -> SpiSlave<SPI, u8, Otype, PULL>

Converts from 16bit dataframe to 8bit.

impl<Otype, PULL> SpiSlave<SPI1, u8, Otype, PULL>

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

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

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

impl<Otype, PULL> SpiSlave<SPI2, u8, Otype, PULL>

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

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

pub fn with_rx_tx_dma( self, rxchannel: C4, txchannel: C5, ) -> SpiSlaveRxTxDma<SPI2, C4, C5, Otype, 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, Otype, PULL> Deref for SpiSlave<SPI, W, Otype, PULL>

type Target = SpiInner<SPI, W>

The resulting type after dereferencing.

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

Dereferences the value.

impl<SPI: Instance, W, Otype, PULL> DerefMut for SpiSlave<SPI, W, Otype, PULL>

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

Mutably dereferences the value.