Struct esp_idf_svc::hal::uart::UartDriver

pub struct UartDriver<'d> { /* private fields */ }

Serial abstraction

Implementations

impl<'d> UartDriver<'d>

pub fn new<UART>( uart: impl Peripheral<P = UART> + 'd, tx: impl Peripheral<P = impl OutputPin> + 'd, rx: impl Peripheral<P = impl InputPin> + 'd, cts: Option<impl Peripheral<P = impl InputPin> + 'd>, rts: Option<impl Peripheral<P = impl OutputPin> + 'd>, config: &Config, ) -> Result<UartDriver<'d>, EspError>

where UART: Uart,

Create a new serial driver

pub fn event_queue(&self) -> Option<&Queue<UartEvent>>

Retrieves the event queue for this UART. Returns None if the config specified 0 for queue_size.

pub fn change_stop_bits( &self, stop_bits: StopBits, ) -> Result<&UartDriver<'d>, EspError>

Change the number of stop bits

pub fn stop_bits(&self) -> Result<StopBits, EspError>

Returns the current number of stop bits

pub fn change_data_bits( &self, data_bits: DataBits, ) -> Result<&UartDriver<'d>, EspError>

Change the number of data bits

pub fn data_bits(&self) -> Result<DataBits, EspError>

Return the current number of data bits

pub fn change_parity(&self, parity: Parity) -> Result<&UartDriver<'d>, EspError>

Change the type of parity checking

pub fn parity(&self) -> Result<Parity, EspError>

Returns the current type of parity checking

pub fn change_baudrate<T>( &self, baudrate: T, ) -> Result<&UartDriver<'d>, EspError>

where T: Into<Hertz> + Copy,

Change the baudrate.

Will automatically select the clock source. When possible the reference clock (1MHz) will be used, because this is constant when the clock source/frequency changes. However if one of the clock frequencies is below 10MHz or if the baudrate is above the reference clock or if the baudrate cannot be set within 1.5% then use the APB clock.

pub fn baudrate(&self) -> Result<Hertz, EspError>

Returns the current baudrate

pub fn split(&mut self) -> (UartTxDriver<'_>, UartRxDriver<'_>)

Split the serial driver in separate TX and RX drivers

pub fn into_split(self) -> (UartTxDriver<'d>, UartRxDriver<'d>)

Split the serial driver in separate TX and RX drivers.

Unlike [split], the halves are owned and reference counted.

pub fn read(&self, buf: &mut [u8], timeout: u32) -> Result<usize, EspError>

Read multiple bytes into a slice

pub fn write(&self, bytes: &[u8]) -> Result<usize, EspError>

Write multiple bytes from a slice

pub fn write_nb(&self, bytes: &[u8]) -> Result<usize, EspError>

Write multiple bytes from a slice directly to the TX FIFO hardware. Returns the number of bytes written, where 0 would mean that the TX FIFO is full.

NOTE: In case the UART TX buffer is enabled, this method might have unpredictable results when used together with method write, as the latter will push the data to be sent to the TX buffer first.

To avoid this, always call wait_done after the last call to write and before calling this method.

pub fn flush_read(&self) -> Result<(), EspError>

👎Deprecated since 0.41.3: Use UartDriver::clear_rx instead

Clears the receive buffer.

pub fn clear_rx(&self) -> Result<(), EspError>

Clears the receive buffer.

pub fn flush_write(&self) -> Result<(), EspError>

👎Deprecated since 0.41.3: Use UartDriver::wait_tx_done instead

Waits for the transmission to complete.

pub fn wait_tx_done(&self, timeout: u32) -> Result<(), EspError>

Waits until the transmission is complete or until the specified timeout expires.

pub fn port(&self) -> u32

pub fn remaining_read(&self) -> Result<usize, EspError>

Get count of remaining bytes in the receive ring buffer

pub fn remaining_write(&self) -> Result<usize, EspError>

Get count of remaining capacity in the transmit ring buffer

Trait Implementations

impl<'d> Drop for UartDriver<'d>

fn drop(&mut self)

Executes the destructor for this type.

impl<'d> ErrorType for UartDriver<'d>

type Error = SerialError

Error type

impl<'d> ErrorType for UartDriver<'d>

type Error = EspIOError

Error type of all the IO operations on this type.

impl<'d> Read<u8> for UartDriver<'d>

type Error = SerialError

Read error

fn read(&mut self) -> Result<u8, Error<<UartDriver<'d> as Read<u8>>::Error>>

Reads a single word from the serial interface

impl<'d> Read for UartDriver<'d>

fn read(&mut self) -> Result<u8, Error<<UartDriver<'d> as ErrorType>::Error>>

Reads a single word from the serial interface

impl<'d> Read for UartDriver<'d>

fn read( &mut self, buf: &mut [u8], ) -> Result<usize, <UartDriver<'d> as ErrorType>::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<'d> Write<u8> for UartDriver<'d>

type Error = SerialError

Write error

fn flush(&mut self) -> Result<(), Error<<UartDriver<'d> as Write<u8>>::Error>>

Ensures that none of the previously written words are still buffered

fn write( &mut self, byte: u8, ) -> Result<(), Error<<UartDriver<'d> as Write<u8>>::Error>>

Writes a single word to the serial interface

impl<'d> Write for UartDriver<'d>

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

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<'d> Write for UartDriver<'d>

fn write( &mut self, buf: &[u8], ) -> Result<usize, <UartDriver<'d> as ErrorType>::Error>

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

fn flush(&mut self) -> Result<(), <UartDriver<'d> as ErrorType>::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> Write for UartDriver<'d>

fn write( &mut self, byte: u8, ) -> Result<(), Error<<UartDriver<'d> as ErrorType>::Error>>

Writes a single word to the serial interface.

fn flush(&mut self) -> Result<(), Error<<UartDriver<'d> as ErrorType>::Error>>

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

impl<'d> Send for UartDriver<'d>

impl<'d> Sync for UartDriver<'d>