Struct RingBufferedSpiRx

Source

pub struct RingBufferedSpiRx<'d, W: Word> { /* private fields */ }

Expand description

Rx-only Ring-buffered SPI Driver

Created with Spi::into_ring_buffered

§Notes on ‘waiting for bytes’

The read(buf) (but not read()) function may need to wait for bytes to arrive, if the ring buffer does not contain enough bytes to fill the buffer passed by the caller of the function, or is empty.

Waiting for bytes operates in one of two modes, depending on the behavior of the sender, the size of the buffer passed to the function:

If the slave is deselected (either rising or falling edge on NSS pin depending on SPI configuration), then any bytes in the ring buffer will be returned. If there are no bytes in the buffer, the check will be repeated each time the NSS deselect edge is detected, so if the sender sends just a single byte, it will be returned once the NSS deselect edge is detected.
If the sender sends continuously, the call will wait until the DMA controller indicates that it has written to either the middle byte or last byte of the ring buffer (‘half transfer’ or ‘transfer complete’, respectively). This does not indicate the buffer is half-full or full, though, because the DMA controller does not detect those conditions; it sends an interrupt when those specific buffer addresses have been written.

Implementations§

Source §

impl<'d, W: Word> RingBufferedSpiRx<'d, W>

Source

pub fn set_config(&mut self, config: &Config) -> Result<(), ()>

Reconfigure the driver

Source

pub fn start(&mut self)

Configure and start the DMA backed SPI receiver

Note: This is also done automatically by the read functions if required.

Source

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

Read bytes that are available in the ring buffer.

Background reception is started if necessary (if start() had not previously been called, or if an error was detected which caused background reception to be stopped).

Background reception is terminated when an error is returned. It must be started again by calling start() or by calling a read function again.

Source

pub fn blocking_read(&mut self, buf: &mut [W]) -> Result<usize, Error>

Read bytes that are readily available in the ring buffer. If no bytes are currently available in the buffer the call waits until the some bytes are available (at least one byte and at most half the buffer size)

Background receive is started if start() has not been previously called.

Receive in the background is terminated if an error is returned. It must then manually be started again by calling start() or by re-calling blocking_read().