Struct embassy_stm32::usart::Uart

pub struct Uart<'d, T: BasicInstance, TxDma = NoDma, RxDma = NoDma> { /* private fields */ }

Bidirectional UART Driver

Implementations

impl<'d, T: BasicInstance, TxDma, RxDma> Uart<'d, T, TxDma, RxDma>

pub fn new( peri: impl Peripheral<P = T> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd, tx: impl Peripheral<P = impl TxPin<T>> + 'd, _irq: impl Binding<T::Interrupt, InterruptHandler<T>> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd, config: Config ) -> Result<Self, ConfigError>

Create a new bidirectional UART

pub fn new_with_rtscts( peri: impl Peripheral<P = T> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd, tx: impl Peripheral<P = impl TxPin<T>> + 'd, _irq: impl Binding<T::Interrupt, InterruptHandler<T>> + 'd, rts: impl Peripheral<P = impl RtsPin<T>> + 'd, cts: impl Peripheral<P = impl CtsPin<T>> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd, config: Config ) -> Result<Self, ConfigError>

Create a new bidirectional UART with request-to-send and clear-to-send pins

pub fn new_with_de( peri: impl Peripheral<P = T> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd, tx: impl Peripheral<P = impl TxPin<T>> + 'd, _irq: impl Binding<T::Interrupt, InterruptHandler<T>> + 'd, de: impl Peripheral<P = impl DePin<T>> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd, config: Config ) -> Result<Self, ConfigError>

Create a new bidirectional UART with a driver-enable pin

pub fn new_half_duplex( peri: impl Peripheral<P = T> + 'd, tx: impl Peripheral<P = impl TxPin<T>> + 'd, _irq: impl Binding<T::Interrupt, InterruptHandler<T>> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd, config: Config ) -> Result<Self, ConfigError>

Create a single-wire half-duplex Uart transceiver on a single Tx pin.

See new_half_duplex_on_rx if you would prefer to use an Rx pin. There is no functional difference between these methods, as both allow bidirectional communication.

The pin is always released when no data is transmitted. Thus, it acts as a standard I/O in idle or in reception. Apart from this, the communication protocol is similar to normal USART mode. Any conflict on the line must be managed by software (for instance by using a centralized arbiter).

pub fn new_half_duplex_on_rx( peri: impl Peripheral<P = T> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd, _irq: impl Binding<T::Interrupt, InterruptHandler<T>> + 'd, tx_dma: impl Peripheral<P = TxDma> + 'd, rx_dma: impl Peripheral<P = RxDma> + 'd, config: Config ) -> Result<Self, ConfigError>

Create a single-wire half-duplex Uart transceiver on a single Rx pin.

See new_half_duplex if you would prefer to use an Tx pin. There is no functional difference between these methods, as both allow bidirectional communication.

The pin is always released when no data is transmitted. Thus, it acts as a standard I/O in idle or in reception. Apart from this, the communication protocol is similar to normal USART mode. Any conflict on the line must be managed by software (for instance by using a centralized arbiter).

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

where TxDma: TxDma<T>,

Initiate an asynchronous write

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

Perform a blocking write

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

Block until transmission complete

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

where RxDma: RxDma<T>,

Initiate an asynchronous read into buffer

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

Read a single u8 or return WouldBlock

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

Perform a blocking read into buffer

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

where RxDma: RxDma<T>,

Initiate an an asynchronous read with idle line detection enabled

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

Split the Uart into a transmitter and receiver, which is particularly useful when having two tasks correlating to transmitting and receiving.

Trait Implementations

impl<T, TxDma, RxDma> ErrorType for Uart<'_, T, TxDma, RxDma>

where T: BasicInstance,

type Error = Error

Error type of all the IO operations on this type.

impl<'d, T: BasicInstance, TxDma, RxDma> ErrorType for Uart<'d, T, TxDma, RxDma>

type Error = Error

Error type

impl<'d, T: BasicInstance, TxDma, RxDma> Read for Uart<'d, T, TxDma, RxDma>

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

Reads a single word from the serial interface

impl<'d, T: BasicInstance, TxDma, RxDma> SetConfig for Uart<'d, T, TxDma, RxDma>

type Config = Config

The configuration type used by this driver.

type ConfigError = ConfigError

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, TxDma, RxDma> Write for Uart<'_, T, TxDma, RxDma>

where T: BasicInstance, TxDma: TxDma<T>,

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, TxDma, RxDma> Write for Uart<'_, T, TxDma, RxDma>

where T: BasicInstance, TxDma: TxDma<T>,

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<'d, T: BasicInstance, TxDma, RxDma> Write for Uart<'d, T, TxDma, RxDma>

fn write(&mut self, char: 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<'d, T: BasicInstance, TxDma, RxDma> Write<u8> for Uart<'d, T, TxDma, RxDma>

type Error = Error

The type of error that can occur when writing

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

Writes a slice, blocking until everything has been written

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

Block until the serial interface has sent all buffered words

impl<'d, T: BasicInstance, TxDma, RxDma> Read<u8> for Uart<'d, T, TxDma, RxDma>

type Error = Error

Read error

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

Reads a single word from the serial interface