Struct RingBuffer 

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

A ring buffer for continuous DMA reception.

This structure manages a circular DMA transfer, allowing continuous reception of data without losing bytes between reads. It uses both half-transfer and complete-transfer interrupts to track available data.

Example

use embassy_mcxa::dma::{DmaChannel, RingBuffer, TransferOptions};

static mut RX_BUF: [u8; 64] = [0; 64];

let dma_ch = DmaChannel::new(p.DMA_CH0);
let ring_buf = unsafe {
    dma_ch.setup_circular_read(
        uart_rx_addr,
        &mut RX_BUF,
    )
};

// Read data as it arrives
let mut buf = [0u8; 16];
let n = ring_buf.read(&mut buf).await?;

Implementations

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

pub fn available(&self) -> usize

Returns the number of bytes available to read.

pub fn is_overrun(&self) -> bool

Check if the buffer has overrun (data was lost).

This happens when DMA writes faster than the application reads.

pub fn read_immediate(&self, dst: &mut [W]) -> usize

Read data from the ring buffer into the provided slice.

Returns the number of elements read, which may be less than dst.len() if not enough data is available.

This method does not block; use read_async() for async waiting.

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

Read data from the ring buffer asynchronously.

This waits until at least one byte is available, then reads as much as possible into the destination buffer.

Returns the number of elements read.

pub fn clear(&self)

Clear the ring buffer, discarding all unread data.

pub fn stop(self) -> usize

Stop the DMA transfer and consume the ring buffer.

Returns any remaining unread data count.

Trait Implementations

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

fn drop(&mut self)

Executes the destructor for this type.