Struct Spi

pub struct Spi<SPI: Instance, const BIDI: bool = false, W = u8> { /* private fields */ }

Spi in Master mode

Implementations

impl<SPI: Instance, const BIDI: bool, W: FrameSize> Spi<SPI, BIDI, W>

pub fn init(self) -> Self

impl<SPI: Instance, W: FrameSize> Spi<SPI, false, W>

pub fn to_bidi_transfer_mode(self) -> Spi<SPI, true, W>

impl<SPI: Instance, W: FrameSize> Spi<SPI, true, W>

pub fn to_normal_transfer_mode(self) -> Spi<SPI, false, W>

impl<SPI, const BIDI: bool> Spi<SPI, BIDI, u8>

where SPI: Instance,

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

Converts from 8bit dataframe to 16bit.

impl<SPI, const BIDI: bool> Spi<SPI, BIDI, u16>

where SPI: Instance,

pub fn frame_size_8bit(self) -> Spi<SPI, BIDI, u8>

Converts from 16bit dataframe to 8bit.

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

pub fn new( spi: SPI, pins: (impl Into<SPI::Sck>, impl Into<SPI::Miso>, impl Into<SPI::Mosi>), mode: impl Into<Mode>, freq: Hertz, clocks: &Clocks, ) -> Self

Enables the SPI clock, resets the peripheral, sets Alternate mode for pins and initialize the peripheral as SPI Master Normal mode.

Note

Depending on freq you may need to set GPIO speed for pins (the Speed::Low is default for GPIO) before create Spi instance. Otherwise it may lead to the ‘wrong last bit in every received byte’ problem.

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

pub fn new_bidi( spi: SPI, pins: (impl Into<SPI::Sck>, impl Into<SPI::Mosi>), mode: impl Into<Mode>, freq: Hertz, clocks: &Clocks, ) -> Self

where NoPin: Into<SPI::Miso>,

Enables the SPI clock, resets the peripheral, sets Alternate mode for pins and initialize the peripheral as SPI Master BIDI mode.

Note

Depending on freq you may need to set GPIO speed for pins (the Speed::Low is default for GPIO) before create Spi instance. Otherwise it may lead to the ‘wrong last bit in every received byte’ problem.

impl<SPI: Instance, const BIDI: bool, W> Spi<SPI, BIDI, W>

pub fn release(self) -> (SPI, (SPI::Sck, SPI::Miso, SPI::Mosi))

impl<SPI: Instance, const BIDI: bool> Spi<SPI, BIDI, u8>

pub fn use_dma(self) -> DmaBuilder<SPI>

impl<SPI: Instance, const BIDI: bool, W: FrameSize> Spi<SPI, BIDI, W>

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

pub fn write_nonblocking(&mut self, byte: 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 write(&mut self, words: &[W]) -> Result<(), Error>

pub fn write_iter( &mut self, words: impl IntoIterator<Item = W>, ) -> Result<(), Error>

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

Methods from Deref<Target = 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: Debug + Instance, const BIDI: bool, W: Debug> Debug for Spi<SPI, BIDI, W>

where SPI::Sck: Debug, SPI::Miso: Debug, SPI::Mosi: Debug,

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

Formats the value using the given formatter.

impl<SPI: Instance, const BIDI: bool, W> Deref for Spi<SPI, BIDI, W>

type Target = Inner<SPI>

The resulting type after dereferencing.

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

Dereferences the value.

impl<SPI: Instance, const BIDI: bool, W> DerefMut for Spi<SPI, BIDI, W>

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

Mutably dereferences the value.

impl<SPI: Instance, const BIDI: bool, W> ErrorType for Spi<SPI, BIDI, W>

type Error = Error

Error type.

impl<SPI, const BIDI: bool, W: FrameSize> FullDuplex<W> for Spi<SPI, BIDI, W>

where SPI: Instance,

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

Reads the word stored in the shift register

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

Writes a word to the slave

impl<SPI, const BIDI: bool, W: FrameSize + 'static> SpiBus<W> for Spi<SPI, BIDI, W>

where SPI: Instance,

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, const BIDI: bool, W: Copy + 'static> Transactional<W> for Spi<SPI, BIDI, W>

where Self: Transfer<W, Error = Error> + Write<W, Error = Error>, SPI: Instance,

type Error = Error

Associated error type

fn exec(&mut self, operations: &mut [Operation<'_, W>]) -> Result<(), Error>

Execute the provided transactions

impl<SPI, const BIDI: bool> WriteIter<u16> for Spi<SPI, BIDI, u16>

where SPI: Instance,

type Error = Error

Error type

fn write_iter<WI>(&mut self, words: WI) -> Result<(), Self::Error>

where WI: IntoIterator<Item = u16>,

Sends words to the slave, ignoring all the incoming words

impl<SPI, const BIDI: bool> WriteIter<u8> for Spi<SPI, BIDI, u8>

where SPI: Instance,

type Error = Error

Error type

fn write_iter<WI>(&mut self, words: WI) -> Result<(), Self::Error>

where WI: IntoIterator<Item = u8>,

Sends words to the slave, ignoring all the incoming words

impl<SPI> Transfer<u16> for Spi<SPI, false, u16>

where SPI: Instance,

type Error = Error

Error type

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

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

impl<SPI> Transfer<u8> for Spi<SPI, false, u8>

where SPI: Instance,

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<SPI, const BIDI: bool> Write<u16> for Spi<SPI, BIDI, u16>

where SPI: Instance,

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<SPI, const BIDI: bool> Write<u8> for Spi<SPI, BIDI, u8>

where SPI: Instance,

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<SPI, const BIDI: bool, W: FrameSize> FullDuplex<W> for Spi<SPI, BIDI, W>

where SPI: Instance,

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, byte: W) -> Result<(), Error>

Sends a word to the slave