Struct Inner

pub struct Inner<SPI: Instance> { /* private fields */ }

Implementations

impl<SPI: Instance> Inner<SPI>

pub fn enable(&mut self, enable: bool)

Enable/disable spi

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

Select which frame format is used for data transfers

pub fn is_tx_empty(&self) -> bool

Return true if the TXE flag is set, i.e. new data to transmit can be written to the SPI.

pub fn is_rx_not_empty(&self) -> bool

Return true if the RXNE flag is set, i.e. new data has been received and can be read from the SPI.

pub fn is_modf(&self) -> bool

Return true if the MODF flag is set, i.e. the SPI has experienced a Master Mode Fault. (see chapter 28.3.10 of the STM32F4 Reference Manual)

pub fn is_busy(&self) -> bool

Returns true if the transfer is in progress

pub fn is_overrun(&self) -> bool

Return true if the OVR flag is set, i.e. new data has been received while the receive data register was already filled.

Trait Implementations

impl<SPI: Instance> ClearFlags for Inner<SPI>

type Flag = CFlag

Enum of manually clearable flags

fn clear_flags(&mut self, flags: impl Into<BitFlags<Self::Flag>>)

Clear interrupts flags with Self::Flagss

fn clear_all_flags(&mut self)

Clears all interrupts flags

impl<SPI: Debug + Instance> Debug for Inner<SPI>

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

Formats the value using the given formatter.

impl<SPI: Instance> Listen for Inner<SPI>

type Event = Event

Enum of bit flags associated with events

fn listen(&mut self, event: impl Into<BitFlags<Self::Event>>)

Start listening for Events

fn listen_only(&mut self, event: impl Into<BitFlags<Self::Event>>)

Start listening for Events, stop all other

fn unlisten(&mut self, event: impl Into<BitFlags<Self::Event>>)

Stop listening for Events

fn listen_all(&mut self)

Start listening all Events

fn unlisten_all(&mut self)

Stop listening all Events

impl<SPI: Instance> ReadFlags for Inner<SPI>

type Flag = Flag

Enum of bit flags

fn flags(&self) -> BitFlags<Self::Flag>

Get all interrupts flags a once.