Embassy
embassy-stm32

Crates

git

Versions

stm32f030c6

Flavors

Struct embassy_stm32::usart::Uart

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

Bidirectional UART Driver, which acts as a combination of UartTx and UartRx.

§Notes on embedded_io::Read

embedded_io::Read requires guarantees that the base UartRx cannot provide.

See UartRx for more details, and see BufferedUart and RingBufferedUartRx as alternatives that do provide the necessary guarantees for embedded_io::Read.

Implementations§

source§

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

source

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

source

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

source

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

source

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).

source

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).

source

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

Initiate an asynchronous write

source

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

Perform a blocking write

source

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

Block until transmission complete

source

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

Initiate an asynchronous read into buffer

source

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

Read a single u8 or return WouldBlock

source

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

Perform a blocking read into buffer

source

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

source

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§

source§

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.
source§

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

§

type Error = Error

Error type
source§

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

source§

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

Reads a single word from the serial interface
source§

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.
source§

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

Set the configuration of the driver.
source§

impl<T, TxDma, RxDma> Write for Uart<'_, T, TxDma, RxDma>
where T: BasicInstance,

source§

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

Write a buffer into this writer, returning how many bytes were written. Read more
source§

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

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

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

Write an entire buffer into this writer. Read more
source§

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

Write a formatted string into this writer, returning any error encountered. Read more
source§

impl<T, TxDma, RxDma> Write for Uart<'_, T, TxDma, RxDma>
where T: BasicInstance, TxDma: TxDma<T>,

source§

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

Write a buffer into this writer, returning how many bytes were written. Read more
source§

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

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

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

Write an entire buffer into this writer. Read more
source§

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

source§

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

Writes a single word to the serial interface.
source§

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

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

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
source§

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

Writes a slice, blocking until everything has been written Read more
source§

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

Block until the serial interface has sent all buffered words
source§

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

§

type Error = Error

Read error
source§

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

Reads a single word from the serial interface

Auto Trait Implementations§

§

impl<'d, T, TxDma, RxDma> Freeze for Uart<'d, T, TxDma, RxDma>
where RxDma: Freeze, T: Freeze, TxDma: Freeze,

§

impl<'d, T, TxDma, RxDma> RefUnwindSafe for Uart<'d, T, TxDma, RxDma>
where RxDma: RefUnwindSafe, T: RefUnwindSafe, TxDma: RefUnwindSafe,

§

impl<'d, T, TxDma, RxDma> Send for Uart<'d, T, TxDma, RxDma>
where RxDma: Send, TxDma: Send,

§

impl<'d, T, TxDma, RxDma> Sync for Uart<'d, T, TxDma, RxDma>
where RxDma: Sync, T: Sync, TxDma: Sync,

§

impl<'d, T, TxDma, RxDma> Unpin for Uart<'d, T, TxDma, RxDma>
where RxDma: Unpin, T: Unpin, TxDma: Unpin,

§

impl<'d, T, TxDma = NoDma, RxDma = NoDma> !UnwindSafe for Uart<'d, T, TxDma, RxDma>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.