Struct UartRx

pub struct UartRx<'d, M: Mode> { /* private fields */ }

Rx-only UART Driver.

Can be obtained from Uart::split, or can be constructed independently, if you do not need the transmitting half of the driver.

Notes on embedded_io::Read

embedded_io::Read requires guarantees that this struct cannot provide:

• Any data received between calls to UartRx::read or UartRx::blocking_read will be thrown away, as UartRx is unbuffered. Users of embedded_io::Read are likely to not expect this behavior (for instance if they read multiple small chunks in a row).
• UartRx::read and UartRx::blocking_read only return once the entire buffer has been filled, whereas embedded_io::Read requires us to fill the buffer with what we already received, and only block/wait until the first byte arrived.
  While UartRx::read_until_idle does return early, it will still eagerly wait for data until the buffer is full or no data has been transmitted in a while, which may not be what users of embedded_io::Read expect.

[UartRx::into_ring_buffered] can be called to equip UartRx with a buffer, that it can then use to store data received between calls to read, provided you are using DMA already.

Alternatively, you can use BufferedUartRx, which is interrupt-based and which can also store data received between calls.

Also see this github comment.

Implementations

impl<'d> UartRx<'d, Async>

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

Create a new rx-only UART with no hardware flow control.

Useful if you only want Uart Rx. It saves 1 pin and consumes a little less power.

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

Create a new rx-only UART with a request-to-send pin

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

Initiate an asynchronous UART read

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

Initiate an asynchronous read with idle line detection enabled

impl<'d> UartRx<'d, Blocking>

pub fn new_blocking<T: Instance>( peri: impl Peripheral<P = T> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd, config: Config, ) -> Result<Self, ConfigError>

Create a new rx-only UART with no hardware flow control.

Useful if you only want Uart Rx. It saves 1 pin and consumes a little less power.

pub fn new_blocking_with_rts<T: Instance>( peri: impl Peripheral<P = T> + 'd, rx: impl Peripheral<P = impl RxPin<T>> + 'd, rts: impl Peripheral<P = impl RtsPin<T>> + 'd, config: Config, ) -> Result<Self, ConfigError>

Create a new rx-only UART with a request-to-send pin

impl<'d, M: Mode> UartRx<'d, M>

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

Reconfigure the driver

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

Perform a blocking read into buffer

Trait Implementations

impl<'d, M: Mode> Drop for UartRx<'d, M>

fn drop(&mut self)

Executes the destructor for this type.

impl<'d, M: Mode> ErrorType for UartRx<'d, M>

type Error = Error

Error type

impl<'d, M: Mode> Read for UartRx<'d, M>

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

Reads a single word from the serial interface

impl<'d, M: Mode> SetConfig for UartRx<'d, M>

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<'d, M: Mode> Read<u8> for UartRx<'d, M>

type Error = Error

Read error

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

Reads a single word from the serial interface