Struct WritableRingBuffer

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

Ringbuffer for writing data using DMA circular mode.

Implementations

impl<'a, W: Word> WritableRingBuffer<'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 write_immediate(&mut self, buf: &[W]) -> Result<(usize, usize), Error>

Write elements directly to the raw buffer. This can be used to fill the buffer before starting the DMA transfer.

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

Write elements from the ring buffer Return a tuple of the length written and the length remaining in the buffer

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

Write an exact number of elements to the ringbuffer.

pub async fn wait_write_error(&mut self) -> Result<usize, Error>

Wait for any ring buffer write error.

pub fn len(&mut self) -> Result<usize, Error>

The current length of the ringbuffer

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 the DMA to stop. The configuration for this channel will not be preserved. If you need to restart the transfer at a later point with the same configuration, see request_pause instead.

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

pub fn request_pause(&mut self)

Request the transfer to pause, keeping the existing configuration for this channel. To restart the transfer, call start again.

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 empty.

This disables the DMA transfer’s circular mode so that the transfer stops when all available data has been written.

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

Trait Implementations

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

fn drop(&mut self)

Executes the destructor for this type.