Struct Spi

pub struct Spi<C, A, RxDma = NoneT, TxDma = NoneT>
where
    C: ValidConfig,
    A: Capability,
{ /* private fields */ }

An enabled SPI peripheral that can perform transactions

See the impl_ehal documentation for details on the implementations of the embedded HAL traits, which vary based on Size and Capability.

Implementations

impl<C, A, S> Spi<C, A>

where C: ValidConfig<Sercom = S>, A: Capability, S: Sercom,

pub fn into_future<I>(self, _interrupts: I) -> SpiFuture<C, A>

where C::Word: Copy, u8: AsPrimitive<C::Word>, I: Binding<S::Interrupt, InterruptHandler<S>>,

Turn an Spi into a SpiFuture.

In cases where the underlying Spi is Duplex, reading words need to be accompanied with sending a no-op word. By default it is set to 0x00, but you can configure it by using the nop_word method.

impl<C, A, RxDma, TxDma> Spi<C, A, RxDma, TxDma>

where C: ValidConfig, A: Capability,

pub fn length<L: Length>( self, ) -> Spi<Config<C::Pads, C::OpMode, L>, A, RxDma, TxDma>

where Config<C::Pads, C::OpMode, L>: ValidConfig,

Change the transaction Length

Changing the transaction Length while is enabled is permissible but dangerous. If you have sent or received any bytes at the current Length, you must wait for a TXC flag before changing to a new Length.

pub fn reconfigure(&mut self, update: impl FnOnce(&mut SpecificConfig<C>))

Update the SPI configuration.

Calling this method will temporarily disable the SERCOM peripheral, as some registers are enable-protected. This may interrupt any ongoing transactions.

pub fn enable_interrupts(&mut self, flags: Flags)

Enable interrupts for the specified flags

pub fn disable_interrupts(&mut self, flags: Flags)

Disable interrupts for the specified flags

pub fn read_flags(&self) -> Flags

Read the interrupt flags

pub fn clear_flags(&mut self, flags: Flags)

Clear the corresponding interrupt flags

Only the ERROR, SSL and TXC flags can be cleared.

Note: The implementation of of serial::Write::flush waits on and clears the TXC flag. Manually clearing this flag could cause it to hang indefinitely.

pub fn read_status(&self) -> Status

Read the error status flags

pub fn clear_status(&mut self, status: Status)

Clear the corresponding error status flags

pub fn read_flags_errors(&self) -> Result<Flags, Error>

Try to read the interrupt flags, but first check the error status flags.

pub unsafe fn read_data(&mut self) -> DataWidth

Read from the DATA register

Safety

Reading from the data register directly is unsafe, because it will clear the RXC flag, which could break assumptions made elsewhere in this module.

pub unsafe fn write_data(&mut self, data: DataWidth)

Write to the DATA register

Safety

Writing to the data register directly is unsafe, because it will clear the DRE flag, which could break assumptions made elsewhere in this module.

pub fn disable(self) -> C

Disable the SPI peripheral and return the Config struct

impl<C, D> Spi<C, D>

where C: ValidConfig, D: Receive, C::OpMode: MasterMode,

pub fn with_dma_channels<R, T>(self, rx: R, tx: T) -> Spi<C, D, R, T>

where R: AnyChannel<Status = Ready>, T: AnyChannel<Status = Ready>,

Attach RX and TX DMA channels to this Spi. Its SpiBus implementation will use DMA to carry out its transactions. In Master mode, since even read SPI transaction necessarily involve a write, Rx-only must take two DMA channels, just the same as if it were Duplex.

impl<C, D, RxDma, TxDma, S> Spi<C, D, RxDma, TxDma>

where C: ValidConfig, D: Capability, RxDma: AnyChannel<Status = S>, TxDma: AnyChannel<Status = S>, S: ReadyChannel,

pub fn take_dma_channels(self) -> (Spi<C, D, NoneT, NoneT>, RxDma, TxDma)

Reclaim the DMA channels. Any subsequent SPI transaction will not use DMA.

impl<C> Spi<C, Duplex>

where C: ValidConfig<OpMode = Slave>,

pub fn with_dma_channels_slave<R, T>(self, rx: R, tx: T) -> Spi<C, Duplex, R, T>

where R: AnyChannel<Status = Ready>, T: AnyChannel<Status = Ready>,

Attach a DMA channel to this Spi. Its SpiBus implementation will use DMA to carry out its transactions. In Slave mode, a Duplex Spi needs two DMA channels.

impl<C> Spi<C, Rx>

where C: ValidConfig<OpMode = Slave>,

pub fn with_rx_channel<R>(self, rx: R) -> Spi<C, Rx, R, NoneT>

where R: AnyChannel<Status = Ready>,

Attach a DMA channel to this Spi. Its SpiBus implementation will use DMA to carry out its transactions. In Slave mode, a Rx Spi only needs a single DMA channel.

impl<C, D, R, T, S> Spi<C, D, R, T>

where C: ValidConfig, D: Receive, R: AnyChannel<Status = S>, S: ReadyChannel,

pub fn take_rx_channel(self) -> (Spi<C, D, NoneT, T>, R)

Reclaim the Rx DMA channel. Any subsequent SPI transaction will not use DMA.

impl<C> Spi<C, Tx>

where C: ValidConfig,

pub fn with_tx_channel<T>(self, tx: T) -> Spi<C, Tx, NoneT, T>

where T: AnyChannel<Status = Ready>,

Attach a DMA channel to this Spi. Its SpiBus implementation will use DMA to carry out its transactions. For Tx Spis, only a single DMA channel is necessary.

impl<C, D, R, T, S> Spi<C, D, R, T>

where C: ValidConfig, D: Capability, T: AnyChannel<Status = S>, S: ReadyChannel,

pub fn take_tx_channel(self) -> (Spi<C, D, R, NoneT>, T)

Reclaim the DMA channel. Any subsequent SPI transaction will not use DMA.

impl<C: ValidConfig, R, T> Spi<C, Tx, R, T>

pub fn into_panic_on_write(self) -> PanicOnWrite<Self>

Turn a Tx Spi into a PanicOnWrite

impl<C: ValidConfig, R, T> Spi<C, Tx, R, T>

pub fn into_panic_on_read(self) -> PanicOnRead<Self>

Turn a Rx Spi into a PanicOnRead

impl<P, M, A> Spi<Config<P, M, DynLength>, A>

where P: ValidPads, M: OpMode, Config<P, M, DynLength>: ValidConfig, A: Capability,

pub fn get_dyn_length(&self) -> u8

Return the current transaction length

Read the LENGTH register to determine the current transaction length

pub fn set_dyn_length(&mut self, length: u8)

Set the transaction length

Write the LENGTH register to set the transaction length. Panics if the length is zero.

Changing the transaction LENGTH while is enabled is permissible but dangerous. If you have sent or received any bytes at the current LENGTH, you must wait for a TXC flag before changing to a new LENGTH.

impl<C, A> Spi<C, A>

where C: ValidConfig, A: Transmit, Self: Buffer<Beat = C::Word>,

pub fn send_with_dma<Ch, B>( self, buf: B, channel: Ch, ) -> Transfer<Channel<Ch::Id, Busy>, BufferPair<B, Self>>

where Ch: AnyChannel<Status = Ready>, B: Buffer<Beat = C::Word> + 'static,

👎Deprecated since 0.19.0: Use Spi::with_dma_channels instead. You will have access to DMA-enabled embedded-hal implementations.

Transform an Spi into a DMA Transfer) and start a send transaction.

impl<C, A> Spi<C, A>

where C: ValidConfig, A: Receive, Self: Buffer<Beat = C::Word>,

pub fn receive_with_dma<Ch, B>( self, buf: B, channel: Ch, ) -> Transfer<Channel<Ch::Id, Busy>, BufferPair<Self, B>>

where Ch: AnyChannel<Status = Ready>, B: Buffer<Beat = C::Word> + 'static,

👎Deprecated since 0.19.0: Use Spi::with_dma_channels instead. You will have access to DMA-enabled embedded-hal implementations.

Transform an Spi into a DMA Transfer) and start a receive transaction.

Trait Implementations

impl<C, A> AnySpi for Spi<C, A>

where C: ValidConfig, A: Capability,

type Sercom = <C as AnyConfig>::Sercom

type Pads = <C as AnyConfig>::Pads

type Capability = A

type OpMode = <C as AnyConfig>::OpMode

type Size = <C as AnyConfig>::Size

type Word = <C as AnyConfig>::Word

type Config = C

impl<C, A> AsMut<Spi<C, A>> for Spi<C, A>

where C: ValidConfig, A: Capability,

fn as_mut(&mut self) -> &mut Self

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C, A, R, T> AsMut<Spi<C, A, R, T>> for SpiFuture<C, A, R, T>

where C: ValidConfig, A: Capability,

fn as_mut(&mut self) -> &mut Spi<C, A, R, T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C: ValidConfig, R, T> AsMut<Spi<C, Rx, R, T>> for PanicOnWrite<Spi<C, Rx, R, T>>

fn as_mut(&mut self) -> &mut Spi<C, Rx, R, T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C: ValidConfig, R, T> AsMut<Spi<C, Tx, R, T>> for PanicOnRead<Spi<C, Tx, R, T>>

fn as_mut(&mut self) -> &mut Spi<C, Tx, R, T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C, A> AsRef<Config<<C as AnyConfig>::Pads, <C as AnyConfig>::OpMode, <C as AnyConfig>::Size>> for Spi<C, A>

where C: ValidConfig, A: Capability,

Get a shared reference to the underlying Config struct

This can be used to call the various get_* functions on Config

fn as_ref(&self) -> &SpecificConfig<C>

Converts this type into a shared reference of the (usually inferred) input type.

impl<C, A> AsRef<Spi<C, A>> for Spi<C, A>

where C: ValidConfig, A: Capability,

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<C, A, R, T> AsRef<Spi<C, A, R, T>> for SpiFuture<C, A, R, T>

where C: ValidConfig, A: Capability,

fn as_ref(&self) -> &Spi<C, A, R, T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<C: ValidConfig, R, T> AsRef<Spi<C, Rx, R, T>> for PanicOnWrite<Spi<C, Rx, R, T>>

fn as_ref(&self) -> &Spi<C, Rx, R, T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<C: ValidConfig, R, T> AsRef<Spi<C, Tx, R, T>> for PanicOnRead<Spi<C, Tx, R, T>>

fn as_ref(&self) -> &Spi<C, Tx, R, T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<C, A> Buffer for Spi<C, A>

where C: ValidConfig, C::OpMode: MasterMode, C::Size: AtomicSize<Word = C::Word>, C::Word: Beat, A: Capability,

type Beat = <C as AnyConfig>::Word

DMAC beat size

fn dma_ptr(&mut self) -> *mut Self::Beat

Pointer to the buffer. If the buffer is incrementing, the address should point to one past the last beat transfer in the block.

fn incrementing(&self) -> bool

Return whether the buffer pointer should be incrementing or not

fn buffer_len(&self) -> usize

Buffer length in beats

impl<P, M, L, A> CheckBufLen for Spi<Config<P, M, L>, A>

where Config<P, M, L>: ValidConfig, P: ValidPads, M: OpMode, L: StaticLength, A: Capability,

const LEN: usize = <Self::Size as Unsigned>::USIZE

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Spi transaction length

fn len(&self) -> usize

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Return the Spi transaction length

const STEP: usize = _

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Step size through the SpiFuture buffer

fn step(&self) -> usize

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Return the step size through the SpiFuture buffer

fn check_buf_len(&self, buf: &impl AsRef<[u8]>)

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Check that the buffer has a valid length

impl<P, M, A> CheckBufLen for Spi<Config<P, M, DynLength>, A>

where Config<P, M, DynLength>: ValidConfig, P: ValidPads, M: OpMode, A: Capability,

fn len(&self) -> usize

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Return the Spi transaction length

fn step(&self) -> usize

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Return the step size through the SpiFuture buffer

const LEN: usize = <Self::Size as Unsigned>::USIZE

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Spi transaction length

const STEP: usize = _

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Step size through the SpiFuture buffer

fn check_buf_len(&self, buf: &impl AsRef<[u8]>)

👎Deprecated since 0.19.0: spi_future is deprecated and will be removed in a later version of atsamd_hal. Consider using the async APIs available in the spi module as a replacement.

Check that the buffer has a valid length

impl<C, D, R, T> ErrorType for Spi<C, D, R, T>

where C: ValidConfig, D: Capability,

type Error = Error

Error type.

impl<C, D, R, T> ErrorType for Spi<C, D, R, T>

where C: ValidConfig, D: Capability,

type Error = Error

Error type of all the IO operations on this type.

impl<C, D, R, T> ErrorType for Spi<C, D, R, T>

where C: ValidConfig, D: Capability,

type Error = Error

Error type

impl<C: ValidConfig, R, T> From<PanicOnRead<Spi<C, Tx, R, T>>> for Spi<C, Tx, R, T>

fn from(value: PanicOnRead<Spi<C, Tx, R, T>>) -> Self

Converts to this type from the input type.

impl<C: ValidConfig, R, T> From<PanicOnWrite<Spi<C, Rx, R, T>>> for Spi<C, Rx, R, T>

fn from(value: PanicOnWrite<Spi<C, Rx, R, T>>) -> Self

Converts to this type from the input type.

impl<C> FullDuplex<<C as AnyConfig>::Word> for Spi<C, Duplex>

where C: ValidConfig, C::Size: AtomicSize, C::Word: PrimInt + AsPrimitive<DataWidth>, DataWidth: AsPrimitive<C::Word>,

spi::FullDuplex is only implemented when the Spi struct has Duplex [Capability] and the transaction Length is <= 4 bytes. When the Length is <= 4, the Word is a primitive integer, with a size that depends on the Length (u8, u16 or u32).

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

Reads the word stored in the shift register

fn write(&mut self, word: C::Word) -> Result<(), Error>

Writes a word to the slave

impl<P, M, L> Read<<L as Length>::Word> for Spi<Config<P, M, L>, Rx>

where Config<P, M, L>: ValidConfig, P: ValidPads, M: MasterMode, L: Length, L::Word: PrimInt, DataWidth: AsPrimitive<L::Word>,

Implement ehal_nb::serial::Read for Rx Spi structs in a MasterMode

serial::Read is only implemented for Spi structs with Rx [Capability]. In a MasterMode, Read has to initiate transactions, so it keeps track of the transaction state. If a transaction is in progress, it will wait on RXC. If not, it will wait on DRE, and then send 0.

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

Reads a single word from the serial interface

impl<P, L> Read<<L as Length>::Word> for Spi<Config<P, Slave, L>, Rx>

where Config<P, Slave, L>: ValidConfig, P: ValidPads, L: Length, L::Word: PrimInt, DataWidth: AsPrimitive<L::Word>,

Implement [serial::Read] for Rx Spi structs in Slave OpMode

serial::Read is only implemented for Spi structs with Rx [Capability]. In Slave OpMode, Read does not have to initiate transactions, so it does not have to store any internal state. It only has to wait on RXC.

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

Reads a single word from the serial interface

impl<P, M, Z, D, R, T, S> Read for Spi<Config<P, M, Z>, D, R, T>

where P: ValidPads, M: MasterMode, Z: Size<Word = u8> + 'static, Config<P, M, Z>: ValidConfig<Sercom = S>, D: Receive, S: Sercom, R: AnyChannel<Status = Ready>, T: AnyChannel<Status = Ready>,

embedded_io::Read implementation for Receive Spis in MasterMode, using DMA transfers.

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<P, Z, D, R, T, S> Read for Spi<Config<P, Slave, Z>, D, R, T>

where P: ValidPads, Z: Size<Word = u8> + 'static, Config<P, Slave, Z>: ValidConfig<Sercom = S>, D: Receive, S: Sercom, R: AnyChannel<Status = Ready>,

embedded_io::Read implementation for Receive Spis in Slave mode, using DMA transfers.

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<P, M, C> SpiBus<<C as Length>::Word> for Spi<Config<P, M, C>, Duplex>

where Config<P, M, C>: ValidConfig, P: ValidPads, M: MasterMode, C: Size + 'static, C::Word: PrimInt + AsPrimitive<DataWidth> + Copy, DataWidth: AsPrimitive<C::Word>,

SpiBus implementation for Spi, using word-by-word transfers.

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

Read words from the slave.

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

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

fn transfer( &mut self, read: &mut [Word<C>], write: &[Word<C>], ) -> 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 transfer_in_place( &mut self, words: &mut [Word<C>], ) -> 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 flush(&mut self) -> Result<(), Error>

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

impl<P, M, S, C, R, T> SpiBus<<C as Length>::Word> for Spi<Config<P, M, C>, Duplex, R, T>

where Config<P, M, C>: ValidConfig<Sercom = S>, S: Sercom, P: ValidPads, M: MasterMode, C: Size + 'static, C::Word: PrimInt + AsPrimitive<DataWidth> + Beat, DataWidth: AsPrimitive<C::Word>, R: AnyChannel<Status = Ready>, T: AnyChannel<Status = Ready>,

SpiBus implementation for Spi, using DMA transfers.

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

Read words from the slave.

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

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

fn transfer( &mut self, read: &mut [C::Word], write: &[C::Word], ) -> 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 transfer_in_place( &mut self, words: &mut [C::Word], ) -> 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 flush(&mut self) -> Result<(), Error>

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

impl<C> Write<<C as AnyConfig>::Word> for Spi<C, Tx>

where C: ValidConfig, C::Size: AtomicSize, C::Word: PrimInt + AsPrimitive<DataWidth>,

Implement ehal_nb::serial::Write for Tx Spi structs

serial::Write is only implemented for Spi structs with Tx [Capability]. Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

fn write(&mut self, word: C::Word) -> Result<(), Error>

Writes a single word to the serial interface.

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

Ensures that none of the previously written words are still buffered.

impl<P, M, Z, D, R, T, S> Write for Spi<Config<P, M, Z>, D, R, T>

where P: ValidPads, M: OpMode, Z: Size<Word = u8> + 'static, Config<P, M, Z>: ValidConfig<Sercom = S>, D: Transmit, S: Sercom, T: AnyChannel<Status = Ready>,

embedded_io::Write implementation for Transmit Spis in either Slave or MasterMode, using DMA transfers.

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

Write a buffer into this writer, returning how many bytes were written.

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

Flush this output stream, blocking until all intermediately buffered contents reach their destination.

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

Write an entire buffer into this writer.

fn write_fmt( &mut self, fmt: Arguments<'_>, ) -> Result<(), WriteFmtError<Self::Error>>

Write a formatted string into this writer, returning any error encountered.

impl<P, M> WriteIter<<UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Length>::Word> for Spi<Config<P, M, U4>, Duplex>

where Config<P, M, U4>: ValidConfig, P: ValidPads, M: OpMode,

Implement WriteIter for Spi structs with Duplex [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

where WI: IntoIterator<Item = Word<U4>>,

Sends words to the slave, ignoring all the incoming words

impl<P, M> WriteIter<<UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Length>::Word> for Spi<Config<P, M, U4>, Tx>

where Config<P, M, U4>: ValidConfig, P: ValidPads, M: OpMode,

Implement WriteIter for Spi structs with Tx [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

where WI: IntoIterator<Item = Word<U4>>,

Sends words to the slave, ignoring all the incoming words

impl<P, M> WriteIter<<UInt<UInt<UTerm, B1>, B0> as Length>::Word> for Spi<Config<P, M, U2>, Duplex>

where Config<P, M, U2>: ValidConfig, P: ValidPads, M: OpMode,

Implement WriteIter for Spi structs with Duplex [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

where WI: IntoIterator<Item = Word<U2>>,

Sends words to the slave, ignoring all the incoming words

impl<P, M> WriteIter<<UInt<UInt<UTerm, B1>, B0> as Length>::Word> for Spi<Config<P, M, U2>, Tx>

where Config<P, M, U2>: ValidConfig, P: ValidPads, M: OpMode,

Implement WriteIter for Spi structs with Tx [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

where WI: IntoIterator<Item = Word<U2>>,

Sends words to the slave, ignoring all the incoming words

impl<P, M> WriteIter<<UInt<UInt<UTerm, B1>, B1> as Length>::Word> for Spi<Config<P, M, U3>, Duplex>

where Config<P, M, U3>: ValidConfig, P: ValidPads, M: OpMode,

Implement WriteIter for Spi structs with Duplex [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

where WI: IntoIterator<Item = Word<U3>>,

Sends words to the slave, ignoring all the incoming words

impl<P, M> WriteIter<<UInt<UInt<UTerm, B1>, B1> as Length>::Word> for Spi<Config<P, M, U3>, Tx>

where Config<P, M, U3>: ValidConfig, P: ValidPads, M: OpMode,

Implement WriteIter for Spi structs with Tx [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

where WI: IntoIterator<Item = Word<U3>>,

Sends words to the slave, ignoring all the incoming words

impl<P, M> WriteIter<<UInt<UTerm, B1> as Length>::Word> for Spi<Config<P, M, U1>, Duplex>

where Config<P, M, U1>: ValidConfig, P: ValidPads, M: OpMode,

Implement WriteIter for Spi structs with Duplex [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

where WI: IntoIterator<Item = Word<U1>>,

Sends words to the slave, ignoring all the incoming words

impl<P, M> WriteIter<<UInt<UTerm, B1> as Length>::Word> for Spi<Config<P, M, U1>, Tx>

where Config<P, M, U1>: ValidConfig, P: ValidPads, M: OpMode,

Implement WriteIter for Spi structs with Tx [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

where WI: IntoIterator<Item = Word<U1>>,

Sends words to the slave, ignoring all the incoming words

impl<P, M, A> Transfer<<UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Length>::Word> for Spi<Config<P, M, U4>, A>

where Config<P, M, U4>: ValidConfig, P: ValidPads, M: OpMode, A: Receive,

Implement Transfer for Spi structs that can Receive and have an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

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

impl<P, M, A> Transfer<<UInt<UInt<UTerm, B1>, B0> as Length>::Word> for Spi<Config<P, M, U2>, A>

where Config<P, M, U2>: ValidConfig, P: ValidPads, M: OpMode, A: Receive,

Implement Transfer for Spi structs that can Receive and have an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

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

impl<P, M, A> Transfer<<UInt<UInt<UTerm, B1>, B1> as Length>::Word> for Spi<Config<P, M, U3>, A>

where Config<P, M, U3>: ValidConfig, P: ValidPads, M: OpMode, A: Receive,

Implement Transfer for Spi structs that can Receive and have an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

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

impl<P, M, A> Transfer<<UInt<UTerm, B1> as Length>::Word> for Spi<Config<P, M, U1>, A>

where Config<P, M, U1>: ValidConfig, P: ValidPads, M: OpMode, A: Receive,

Implement Transfer for Spi structs that can Receive and have an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

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

impl<P, M, L, A> Transfer<u8> for Spi<Config<P, M, L>, A>

where Config<P, M, L>: ValidConfig, P: ValidPads, M: OpMode, L: GreaterThan4, A: Receive,

Implement Transfer for Spi structs that can Receive and have long transaction Lengths

The transaction Length must be > 4. The transfer accepts a slice of u8 with a length equal to the transaction Length. If the slice length is incorrect, it will panic.

type Error = Error

Error type

fn transfer<'w>(&mut self, buf: &'w mut [u8]) -> Result<&'w [u8], Error>

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

impl<P, M, A> Transfer<u8> for Spi<Config<P, M, DynLength>, A>

where Config<P, M, DynLength>: ValidConfig, P: ValidPads, M: OpMode, A: Receive,

Implement Transfer for Spi structs that can Receive and have DynLength

The transfer accepts a slice of u8 with a length equal to the run-time dynamic transaction length. If the slice length does not match the result of Spi::get_dyn_length, it will panic.

type Error = Error

Error type

fn transfer<'w>(&mut self, buf: &'w mut [u8]) -> Result<&'w [u8], Error>

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

impl<P, M> Write<<UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Length>::Word> for Spi<Config<P, M, U4>, Duplex>

where Config<P, M, U4>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Duplex [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<<UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Length>::Word> for Spi<Config<P, M, U4>, Tx>

where Config<P, M, U4>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Tx [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<<UInt<UInt<UTerm, B1>, B0> as Length>::Word> for Spi<Config<P, M, U2>, Duplex>

where Config<P, M, U2>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Duplex [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<<UInt<UInt<UTerm, B1>, B0> as Length>::Word> for Spi<Config<P, M, U2>, Tx>

where Config<P, M, U2>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Tx [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<<UInt<UInt<UTerm, B1>, B1> as Length>::Word> for Spi<Config<P, M, U3>, Duplex>

where Config<P, M, U3>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Duplex [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<<UInt<UInt<UTerm, B1>, B1> as Length>::Word> for Spi<Config<P, M, U3>, Tx>

where Config<P, M, U3>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Tx [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<<UInt<UTerm, B1> as Length>::Word> for Spi<Config<P, M, U1>, Duplex>

where Config<P, M, U1>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Duplex [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<<UInt<UTerm, B1> as Length>::Word> for Spi<Config<P, M, U1>, Tx>

where Config<P, M, U1>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Tx [Capability] and an AtomicSize

The transaction Length must be <= 4. The transfer accepts a slice of primitive integers, depending on the Length (u8, u16 or u32).

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M, L> Write<u8> for Spi<Config<P, M, L>, Duplex>

where Config<P, M, L>: ValidConfig, P: ValidPads, M: OpMode, L: GreaterThan4,

Implement Write for Spi structs with Duplex [Capability] and long transaction Lengths

The transaction Length must be > 4. The transfer accepts a [u8] with a length equal to the transfer Length. If the slice length is incorrect, it will panic.

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M, L> Write<u8> for Spi<Config<P, M, L>, Tx>

where Config<P, M, L>: ValidConfig, P: ValidPads, M: OpMode, L: GreaterThan4,

Implement Write for Spi structs with Tx [Capability] and long transaction Lengths

The transaction Length must be > 4. The transfer accepts a [u8] with a length equal to the transfer Length. If the slice length is incorrect, it will panic.

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<u8> for Spi<Config<P, M, DynLength>, Duplex>

where Config<P, M, DynLength>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Duplex [Capability] and DynLength

The transfer accepts a [u8] with a length equal to the run-time dynamic transaction length. If the slice length does not match the result of Spi::get_dyn_length, it will panic.

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M> Write<u8> for Spi<Config<P, M, DynLength>, Tx>

where Config<P, M, DynLength>: ValidConfig, P: ValidPads, M: OpMode,

Implement Write for Spi structs with Tx [Capability] and DynLength

The transfer accepts a [u8] with a length equal to the run-time dynamic transaction length. If the slice length does not match the result of Spi::get_dyn_length], it will panic.

Because the Capability is Tx, this implementation never reads the DATA register and ignores all buffer overflow errors.

type Error = Error

Error type

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

Sends words to the slave, ignoring all the incoming words

impl<P, M, L> Read<<L as Length>::Word> for Spi<Config<P, M, L>, Rx>

where Config<P, M, L>: ValidConfig, P: ValidPads, M: MasterMode, L: Length, L::Word: PrimInt, DataWidth: AsPrimitive<L::Word>,

Implement [serial::Read] for Rx Spi structs in a MasterMode

Refer to the ehal_nb::serial::Read implementation of Spi for more details.

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<P, L> Read<<L as Length>::Word> for Spi<Config<P, Slave, L>, Rx>

where Config<P, Slave, L>: ValidConfig, P: ValidPads, L: Length, L::Word: PrimInt, DataWidth: AsPrimitive<L::Word>,

Implement [serial::Read] for Rx Spi structs in Slave OpMode

Refer to the ehal_nb::serial::Read implementation of Spi for more details.

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<C> Write<<C as AnyConfig>::Word> for Spi<C, Tx>

where C: ValidConfig, C::Size: AtomicSize, C::Word: PrimInt + AsPrimitive<DataWidth>,

Implement [serial::Write] for Tx Spi structs

type Error = Error

Write error

fn write(&mut self, word: C::Word) -> Result<(), Error>

Writes a single word to the serial interface

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

Ensures that none of the previously written words are still buffered

impl<C> FullDuplex<<C as AnyConfig>::Word> for Spi<C, Duplex>

where C: ValidConfig, C::Size: AtomicSize, C::Word: PrimInt + AsPrimitive<DataWidth>, DataWidth: AsPrimitive<C::Word>,

Implement [spi::FullDuplex] for Spi structs with AtomicSize

spi::FullDuplex is only implemented when the Spi struct has Duplex [Capability] and the transaction Length is <= 4 bytes. When the Length is <= 4, the Word is a primitive integer, with a size that depends on the Length (u8, u16 or u32).

type Error = Error

An enumeration of SPI errors

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

Reads the word stored in the shift register

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

Sends a word to the slave

impl<C> Default<<C as AnyConfig>::Word> for Spi<C, Tx>

where C: ValidConfig, Spi<C, Tx>: Write<C::Word>,