pub struct ReadableRingBuffer<'a, W: Word> { /* private fields */ }Expand description
Ringbuffer for receiving data using DMA circular mode.
Implementations§
source§impl<'a, W: Word> ReadableRingBuffer<'a, W>
impl<'a, W: Word> ReadableRingBuffer<'a, W>
sourcepub unsafe fn new(
channel: impl Peripheral<P = impl Channel> + 'a,
_request: Request,
peri_addr: *mut W,
buffer: &'a mut [W],
options: TransferOptions,
) -> Self
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.
sourcepub fn start(&mut self)
pub fn start(&mut self)
Start the ring buffer operation.
You must call this after creating it for it to work.
sourcepub fn read(&mut self, buf: &mut [W]) -> Result<(usize, usize), Error>
pub fn read(&mut self, buf: &mut [W]) -> Result<(usize, usize), Error>
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 Error is returned if the portion to be read was overwritten by the DMA controller.
sourcepub async fn read_exact(&mut self, buffer: &mut [W]) -> Result<usize, Error>
pub async fn read_exact(&mut self, buffer: &mut [W]) -> Result<usize, Error>
Read an exact number of elements from the ringbuffer.
Returns the remaining number of elements available for immediate reading. Error 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.
sourcepub fn set_waker(&mut self, waker: &Waker)
pub fn set_waker(&mut self, waker: &Waker)
Set a waker to be woken when at least one byte is received.
sourcepub fn request_stop(&mut self)
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.
sourcepub fn request_pause(&mut self)
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.
sourcepub fn is_running(&mut self) -> bool
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.
sourcepub async fn stop(&mut self)
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().