Struct UartFuture

pub struct UartFuture<C, D, R = NoneT, T = NoneT>
where
    C: ValidConfig,
    D: Capability,
{ /* private fields */ }

async version of a Uart.

Create this struct by calling Uart::into_future.

Implementations

impl<C, D, R, T> UartFuture<C, D, R, T>

where C: ValidConfig, D: Capability, R: AnyChannel<Status = ReadyFuture>,

pub fn take_rx_channel(self) -> (UartFuture<C, D, NoneT, T>, R)

Reclaim the RX DMA channel. Subsequent RX operations will no longer use DMA.

impl<C, D, R, T> UartFuture<C, D, R, T>

where C: ValidConfig, D: Capability, T: AnyChannel<Status = ReadyFuture>,

pub fn take_tx_channel(self) -> (UartFuture<C, D, R, NoneT>, T)

Reclaim the TX DMA channel. Subsequent TX operations will no longer use DMA.

impl<C, D, S, R, T> UartFuture<C, D, R, T>

where C: ValidConfig<Sercom = S>, C::Word: Beat, D: Receive, S: Sercom + 'static, DataReg: AsPrimitive<C::Word>, R: AnyChannel<Status = ReadyFuture>,

pub async fn read(&mut self, words: &mut [C::Word]) -> Result<(), Error>

Read the specified number of Words into a buffer using DMA.

impl<C, D, S, R, T> UartFuture<C, D, R, T>

where C: ValidConfig<Sercom = S>, C::Word: Beat, D: Transmit, S: Sercom + 'static, T: AnyChannel<Status = ReadyFuture>,

pub async fn write(&mut self, words: &[C::Word]) -> Result<(), Error>

Write words from a buffer asynchronously, using DMA.

impl<C, R, T> UartFuture<C, Duplex, R, T>

where C: ValidConfig,

pub fn split( self, ) -> (UartFuture<C, RxDuplex, R, NoneT>, UartFuture<C, TxDuplex, NoneT, T>)

Split the UartFuture into RxDuplexand TxDuplex halves.

pub fn join( rx: UartFuture<C, RxDuplex, R, NoneT>, tx: UartFuture<C, TxDuplex, NoneT, T>, ) -> Self

Join RxDuplex and TxDuplex halves back into a full UartFuture<C, Duplex>

impl<C, D> UartFuture<C, D, NoneT, NoneT>

where C: ValidConfig, D: SingleOwner,

pub fn free(self) -> Uart<C, D>

Return the underlying Uart.

impl<C, D, S, R, T> UartFuture<C, D, R, T>

where C: ValidConfig<Sercom = S>, D: Receive, S: Sercom, DataReg: AsPrimitive<C::Word>,

pub fn with_rx_dma_channel<Chan: AnyChannel<Status = ReadyFuture>>( self, rx_channel: Chan, ) -> UartFuture<C, D, Chan, T>

Use a DMA channel for receiving words on the RX line

pub async fn read_word(&mut self) -> Result<C::Word, Error>

Read a single Word from the UART.

impl<C, D, S, T> UartFuture<C, D, NoneT, T>

where C: ValidConfig<Sercom = S>, D: Receive, S: Sercom, DataReg: AsPrimitive<C::Word>,

pub async fn read( &mut self, buffer: &mut [C::Word], ) -> Result<(), (Error, usize)>

Read the specified number of Words into a buffer, word by word.

In case of an error, returns Err(Error, usize) where the usize represents the number of valid words read before the error occured.

impl<C, D, S, R, T> UartFuture<C, D, R, T>

where C: ValidConfig<Sercom = S>, D: Transmit, S: Sercom,

pub fn with_tx_dma_channel<Chan: AnyChannel<Status = ReadyFuture>>( self, tx_channel: Chan, ) -> UartFuture<C, D, R, Chan>

Use a DMA channel for sending words on the TX line

pub async fn write_word(&mut self, word: C::Word)

Write a single Word to the UART.

impl<C, D, S, R> UartFuture<C, D, R, NoneT>

where C: ValidConfig<Sercom = S>, D: Transmit, S: Sercom,

pub async fn write(&mut self, buffer: &[C::Word])

Write the specified number of Words from a buffer to the UART, word by word.

Trait Implementations

impl<C, D, R, T, S> AsMut<Uart<C, D, R, T>> for UartFuture<C, D, R, T>

where C: ValidConfig<Sercom = S>, D: Capability, S: Sercom,

fn as_mut(&mut self) -> &mut Uart<C, D, R, T>

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

impl<C, D, R, T, S> AsRef<Uart<C, D, R, T>> for UartFuture<C, D, R, T>

where C: ValidConfig<Sercom = S>, D: Capability, S: Sercom,

fn as_ref(&self) -> &Uart<C, D, R, T>

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

impl<C, D, R, T> ErrorType for UartFuture<C, D, R, T>

where C: ValidConfig, D: Capability,

type Error = Error

Error type of all the IO operations on this type.

impl<C, D, S, R> Read for UartFuture<C, D, NoneT, R>

where C: ValidConfig<Sercom = S, Word = u8>, D: Receive, S: Sercom,

async fn read(&mut self, buffer: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<C, D, S, R, T> Read for UartFuture<C, D, R, T>

where C: ValidConfig<Sercom = S, Word = u8>, D: Receive, S: Sercom + 'static, DataReg: AsPrimitive<C::Word>, R: AnyChannel<Status = ReadyFuture>,

async fn read(&mut self, words: &mut [u8]) -> Result<usize, Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<C, D, S, R> Write for UartFuture<C, D, R, NoneT>

where C: ValidConfig<Sercom = S, Word = u8>, D: Transmit, S: Sercom,

async fn write(&mut self, buffer: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.

impl<C, D, S, R, T> Write for UartFuture<C, D, R, T>

where C: ValidConfig<Sercom = S, Word = u8>, D: Transmit, S: Sercom + 'static, T: AnyChannel<Status = ReadyFuture>,

async fn write(&mut self, words: &[u8]) -> Result<usize, Error>

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.