Struct Channel

pub struct Channel<Id: ChId, S: Status> { /* private fields */ }

DMA channel, capable of executing Transfers. Ongoing DMA transfers are automatically stopped when a Channel is dropped.

Implementations

impl<Id: ChId, S: Status> Channel<Id, S>

These methods may be used on any DMA channel in any configuration

pub fn init(self, lvl: PriorityLevel) -> Channel<Id, S::Ready>

Configure the DMA channel so that it is ready to be used by a Transfer.

Return

A Channel with a Ready status

pub fn enable_interrupts(&mut self, flags: InterruptFlags)

Selectively enable interrupts

pub fn disable_interrupts(&mut self, flags: InterruptFlags)

Selectively disable interrupts

pub fn check_and_clear_interrupts( &mut self, flags: InterruptFlags, ) -> InterruptFlags

Check the specified flags, clear then return any that were set

impl<Id, R> Channel<Id, R>

where Id: ChId, R: ReadyChannel,

pub fn reset(self) -> Channel<Id, R::Uninitialized>

Issue a software reset to the channel. This will return the channel to its startup state

pub fn fifo_threshold(&mut self, threshold: FifoThreshold)

Set the FIFO threshold length. The channel will wait until it has received the selected number of Beats before triggering the Burst transfer, reducing the DMA transfer latency.

pub fn burst_length(&mut self, burst_length: BurstLength)

Set burst length for the channel, in number of beats. A burst transfer is an atomic, uninterruptible operation.

impl<Id: ChId> Channel<Id, ReadyFuture>

pub async fn transfer_future<S, D>( &mut self, source: S, dest: D, trig_src: TriggerSource, trig_act: TriggerAction, ) -> Result<(), Error>

where S: Buffer, D: Buffer<Beat = S::Beat>,

Begin DMA transfer using async operation.

If TriggerSource::Disable is used, a software trigger will be issued to the DMA channel to launch the transfer. It is therefore not necessary, in most cases, to manually issue a software trigger to the channel.

Safety

In async mode, a transfer does NOT require 'static source and destination buffers. This, in theory, makes transfer_future an unsafe function, although it is marked as safe for better ergonomics.

This means that, as an user, you must ensure that the Future returned by this function may never be forgotten through forget or by wrapping it with a ManuallyDrop.

The returned future implements Drop and will automatically stop any ongoing transfers to guarantee that the memory occupied by the now-dropped buffers may not be corrupted by running transfers. This also means that should you forget this Future after its first poll call, the transfer will keep running, ruining the now-reclaimed memory, as well as the rest of your day.

• awaiting is fine: the Future will run to completion.
• Dropping an incomplete transfer is also fine. Dropping can happen, for example, if the transfer doesn’t complete before a timeout expires.

Trait Implementations

impl<Id, S> AnyChannel for Channel<Id, S>

where Id: ChId, S: Status,

type Id = Id

type Status = S

impl<Id, S> AsMut<Channel<Id, S>> for Channel<Id, S>

where Id: ChId, S: Status,

fn as_mut(&mut self) -> &mut Self

Converts this type into a mutable reference of the (usually inferred) input type.

impl<Id, S> AsRef<Channel<Id, S>> for Channel<Id, S>

where Id: ChId, S: Status,

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<Id: ChId> From<Channel<Id, Ready>> for Channel<Id, Uninitialized>

fn from(item: Channel<Id, Ready>) -> Self

Converts to this type from the input type.