Struct Uart

pub struct Uart<'d, M, T = AnyUart> { /* private fields */ }

UART (Full-duplex)

Implementations

impl<'d> Uart<'d, Blocking>

pub fn new( uart: impl Peripheral<P = impl Instance> + 'd, rx: impl Peripheral<P = impl PeripheralInput> + 'd, tx: impl Peripheral<P = impl PeripheralOutput> + 'd, ) -> Result<Self, Error>

Create a new UART instance in Blocking mode.

pub fn new_with_config( uart: impl Peripheral<P = impl Instance> + 'd, config: Config, rx: impl Peripheral<P = impl PeripheralInput> + 'd, tx: impl Peripheral<P = impl PeripheralOutput> + 'd, ) -> Result<Self, Error>

Create a new UART instance with configuration options in Blocking mode.

impl<'d, T> Uart<'d, Blocking, T>

where T: Instance,

pub fn new_typed( uart: impl Peripheral<P = T> + 'd, rx: impl Peripheral<P = impl PeripheralInput> + 'd, tx: impl Peripheral<P = impl PeripheralOutput> + 'd, ) -> Result<Self, Error>

Create a new UART instance in Blocking mode.

pub fn new_with_config_typed( uart: impl Peripheral<P = T> + 'd, config: Config, rx: impl Peripheral<P = impl PeripheralInput> + 'd, tx: impl Peripheral<P = impl PeripheralOutput> + 'd, ) -> Result<Self, Error>

Create a new UART instance with configuration options in Blocking mode.

pub fn into_async(self) -> Uart<'d, Async, T>

Reconfigures the driver to operate in Async mode.

impl<'d, T> Uart<'d, Async, T>

where T: Instance,

pub fn into_blocking(self) -> Uart<'d, Blocking, T>

Reconfigures the driver to operate in Blocking mode.

impl<'d, M, T> Uart<'d, M, T>

where T: Instance, M: Mode,

pub fn with_cts( self, cts: impl Peripheral<P = impl PeripheralInput> + 'd, ) -> Self

Configure CTS pin

pub fn with_rts( self, rts: impl Peripheral<P = impl PeripheralOutput> + 'd, ) -> Self

Configure RTS pin

pub fn split(self) -> (UartRx<'d, M, T>, UartTx<'d, M, T>)

Split the UART into a transmitter and receiver

This is particularly useful when having two tasks correlating to transmitting and receiving.

pub fn write_bytes(&mut self, data: &[u8]) -> Result<usize, Error>

Write bytes out over the UART

pub fn read_bytes(&mut self, buf: &mut [u8]) -> Result<(), Error>

Fill a buffer with received bytes

pub fn set_at_cmd(&mut self, config: AtCmdConfig)

Configures the AT-CMD detection settings

pub fn listen(&mut self, interrupts: impl Into<EnumSet<UartInterrupt>>)

Listen for the given interrupts

pub fn unlisten(&mut self, interrupts: impl Into<EnumSet<UartInterrupt>>)

Unlisten the given interrupts

pub fn interrupts(&mut self) -> EnumSet<UartInterrupt>

Gets asserted interrupts

pub fn clear_interrupts(&mut self, interrupts: EnumSet<UartInterrupt>)

Resets asserted interrupts

pub fn write_byte(&mut self, word: u8) -> Result<(), Error>

Write a byte out over the UART

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

Flush the transmit buffer of the UART

pub fn read_byte(&mut self) -> Result<u8, Error>

Read a byte from the UART

pub fn apply_config(&mut self, config: &Config) -> Result<(), Error>

Change the configuration.

impl<T> Uart<'_, Async, T>

where T: Instance,

pub async fn read_async(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Asynchronously reads data from the UART receive buffer into the provided buffer.

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

Asynchronously writes data to the UART transmit buffer.

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

Asynchronously flushes the UART transmit buffer.

Trait Implementations

impl<T, M> ErrorType for Uart<'_, M, T>

type Error = Error

Error type

impl<T, M> ErrorType for Uart<'_, M, T>

type Error = Error

Error type of all the IO operations on this type.

impl<T> InterruptConfigurable for Uart<'_, Blocking, T>

where T: Instance,

fn set_interrupt_handler(&mut self, handler: InterruptHandler)

Set the interrupt handler

impl<T> Read for Uart<'_, Async, T>

where T: Instance,

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

In contrast to the documentation of embedded_io_async::Read, this method blocks until an uart interrupt occurs. See UartRx::read_async for more details.

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

Read the exact number of bytes required to fill buf.

impl<T, M> Read for Uart<'_, M, T>

where T: Instance, M: Mode,

fn read(&mut self) -> Result<u8, Self::Error>

Reads a single word from the serial interface

impl<T, M> Read for Uart<'_, M, T>

where T: Instance, M: Mode,

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

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

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

Read the exact number of bytes required to fill buf.

impl<T, M> ReadReady for Uart<'_, M, T>

where T: Instance, M: Mode,

fn read_ready(&mut self) -> Result<bool, Self::Error>

Get whether the reader is ready for immediately reading.

impl<M, T> SetConfig for Uart<'_, M, T>

where T: Instance, M: Mode,

type Config = Config

The configuration type used by this driver.

type ConfigError = Error

The error type that can occur if set_config fails.

fn set_config(&mut self, config: &Self::Config) -> Result<(), Self::ConfigError>

Set the configuration of the driver.

impl<T> Write for Uart<'_, Async, T>

where T: Instance,

async fn write(&mut self, buf: &[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<T, M> Write for Uart<'_, M, T>

where T: Instance, M: Mode,

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.

impl<T, M> Write for Uart<'_, M, T>

where T: Instance, M: Mode,

fn write(&mut self, word: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface.

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

Ensures that none of the previously written words are still buffered.

impl<T, M> Write for Uart<'_, M, T>

where T: Instance, M: Mode,

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

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

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

Flush this output stream, blocking until all intermediately buffered contents reach their destination.

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

Write an entire buffer into this writer.

fn write_fmt( &mut self, fmt: Arguments<'_>, ) -> Result<(), WriteFmtError<Self::Error>>

Write a formatted string into this writer, returning any error encountered.

impl<T, M> Read<u8> for Uart<'_, M, T>

where T: Instance, M: Mode,

type Error = Error

Read error

fn read(&mut self) -> Result<u8, Self::Error>

Reads a single word from the serial interface

impl<T, M> Write<u8> for Uart<'_, M, T>

where T: Instance, M: Mode,

type Error = Error

Write error

fn write(&mut self, word: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface

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

Ensures that none of the previously written words are still buffered

impl<T, M> uWrite for Uart<'_, M, T>

where T: Instance, M: Mode,

type Error = Error

The error associated to this writer

fn write_str(&mut self, s: &str) -> Result<(), Self::Error>

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, ch: char) -> Result<(), Self::Error>

Writes a char into this writer, returning whether the write succeeded.