Struct embassy_stm32::dma::ReadableRingBuffer

pub struct ReadableRingBuffer<'a, W: Word> { /* private fields */ }

Ringbuffer for receiving data using DMA circular mode.

Implementations

impl<'a, W: Word> ReadableRingBuffer<'a, W>

pub unsafe fn new( channel: impl Peripheral<P = impl Channel> + 'a, _request: Request, peri_addr: *mut W, buffer: &'a mut [W], options: TransferOptions ) -> Self

Create a new ring buffer.

pub fn start(&mut self)

Start the ring buffer operation.

You must call this after creating it for it to work.

pub fn clear(&mut self)

Clear all data in the ring buffer.

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

Read elements from the ring buffer Return a tuple of the length read and the length remaining in the buffer If not all of the elements were read, then there will be some elements in the buffer remaining The length remaining is the capacity, ring_buf.len(), less the elements remaining after the read OverrunError is returned if the portion to be read was overwritten by the DMA controller.

pub async fn read_exact( &mut self, buffer: &mut [W] ) -> Result<usize, OverrunError>

Read an exact number of elements from the ringbuffer.

Returns the remaining number of elements available for immediate reading. OverrunError is returned if the portion to be read was overwritten by the DMA controller.

Async/Wake Behavior: The underlying DMA peripheral only can wake us when its buffer pointer has reached the halfway point, and when it wraps around. This means that when called with a buffer of length ‘M’, when this ring buffer was created with a buffer of size ‘N’:

• If M equals N/2 or N/2 divides evenly into M, this function will return every N/2 elements read on the DMA source.
• Otherwise, this function may need up to N/2 extra elements to arrive before returning.

pub const fn capacity(&self) -> usize

The capacity of the ringbuffer

pub fn set_waker(&mut self, waker: &Waker)

Set a waker to be woken when at least one byte is received.

pub fn request_stop(&mut self)

Request DMA to stop.

This doesn’t immediately stop the transfer, you have to wait until is_running returns false.

pub fn is_running(&mut self) -> bool

Return whether DMA is still running.

If this returns false, it can be because either the transfer finished, or it was requested to stop early with request_stop.

pub async fn stop(&mut self)

Stop the DMA transfer and await until the buffer is full.

This disables the DMA transfer’s circular mode so that the transfer stops when the buffer is full.

This is designed to be used with streaming input data such as the I2S/SAI or ADC.

When using the UART, you probably want request_stop().

Trait Implementations

impl<'a, W: Word> Drop for ReadableRingBuffer<'a, W>

fn drop(&mut self)

Executes the destructor for this type.