Struct Transfer

pub struct Transfer<Chan, Buf>
where
    Buf: AnyBufferPair,
    Chan: AnyChannel,
{ /* private fields */ }

DMA transfer, owning the resources until the transfer is done and Transfer::wait is called.

Implementations

impl<C, S, D, R> Transfer<C, BufferPair<S, D>>

where S: Buffer + 'static, D: Buffer<Beat = S::Beat> + 'static, C: AnyChannel<Status = R>, R: ReadyChannel,

pub fn new( chan: C, source: S, destination: D, circular: bool, ) -> Result<Transfer<C, BufferPair<S, D>>>

Safely construct a new Transfer. To guarantee memory safety, both buffers are required to be 'static. Refer here or here for more information.

If two array references can be used as source and destination buffers (as opposed to slices), then it is recommended to use the Transfer::new_from_arrays method instead.

Errors

Returns Error::LengthMismatch if both buffers have a length > 1 and are not of equal length.

impl<C, S, D, R> Transfer<C, BufferPair<S, D>>

where S: Buffer, D: Buffer<Beat = S::Beat>, C: AnyChannel<Status = R>, R: ReadyChannel,

pub unsafe fn new_unchecked( chan: C, source: S, destination: D, circular: bool, ) -> Transfer<C, BufferPair<S, D>>

Construct a new Transfer without checking for memory safety.

Safety

To guarantee the safety of creating a Transfer using this method, you must uphold some invariants:

• A Transfer holding a Channel<Id, Running> must never be dropped. It should always be explicitly be waited upon or stopped.

• The size in bytes or the source and destination buffers should be exacly the same, unless one or both buffers are of length 1. The transfer length will be set to the longest of both buffers if they are not of equal size.

impl<C, S, D> Transfer<C, BufferPair<S, D>>

where S: Buffer, D: Buffer<Beat = S::Beat>, C: AnyChannel<Status = Ready>,

pub fn begin( self, trig_src: TriggerSource, trig_act: TriggerAction, ) -> Transfer<Channel<ChannelId<C>, Busy>, BufferPair<S, D>>

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

pub fn free(self) -> (Channel<ChannelId<C>, Ready>, S, D)

Free the Transfer and return the resources it holds.

Similar to stop, but it acts on a Transfer holding a Ready channel, so there is no need to explicitly stop the transfer.

impl<B, C, R, const N: usize> Transfer<C, BufferPair<&'static mut [B; N]>>

where B: 'static + Beat, C: AnyChannel<Status = R>, R: ReadyChannel,

pub fn new_from_arrays( chan: C, source: &'static mut [B; N], destination: &'static mut [B; N], circular: bool, ) -> Self

Create a new Transfer from static array references of the same type and length. When two array references are available (instead of slice references), it is recommended to use this function over Transfer::new, because it provides compile-time checking that the array lengths match. It therefore does not panic, and saves some runtime checking of the array lengths.

impl<S, D, C> Transfer<C, BufferPair<S, D>>

where S: Buffer, D: Buffer<Beat = S::Beat>, C: AnyChannel<Status = Busy>,

pub fn software_trigger(&mut self)

Issue a software trigger request to the corresponding channel. Note that is not guaranteed that the trigger request will register, if a trigger request is already pending for the channel.

pub fn wait(self) -> (Channel<ChannelId<C>, Ready>, S, D)

Wait for the DMA transfer to complete and release all owned resources

Blocking: This method may block

pub fn complete(&mut self) -> bool

Check if the transfer has completed

pub fn block_transfer_interrupt(&mut self) -> bool

Checks and clears the block transfer complete interrupt flag

pub fn recycle(&mut self, source: S, destination: D) -> Result<(S, D)>

Modify a completed transfer with new source and destination, then restart.

Returns a Result containing the source and destination from the completed transfer. Returns Err(_) if the buffer lengths are mismatched or if the previous transfer has not yet completed.

pub fn recycle_source(&mut self, destination: D) -> Result<D>

Modify a completed transfer with a new destination, then restart.

Returns a Result containing the destination from the completed transfer. Returns Err(_) if the buffer lengths are mismatched or if the previous transfer has not yet completed.

pub fn recycle_destination(&mut self, source: S) -> Result<S>

Modify a completed transfer with a new source, then restart.

Returns a Result containing the source from the completed transfer. Returns Err(_) if the buffer lengths are mismatched or if the previous transfer has not yet completed.

pub fn stop(self) -> (Channel<ChannelId<C>, Ready>, S, D)

Non-blocking; Immediately stop the DMA transfer and release all owned resources