Struct esp32_hal::Uart

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

UART driver

Implementations

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

where T: Instance,

pub fn new_with_config<P>( _uart: impl Peripheral<P = T> + 'd, config: Config, pins: Option<P>, clocks: &Clocks<'_> ) -> Uart<'d, T>

where P: UartPins,

Create a new UART instance with defaults

pub fn new( uart: impl Peripheral<P = T> + 'd, clocks: &Clocks<'_> ) -> Uart<'d, T>

Create a new UART instance with defaults

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

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

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

Writes bytes

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

Configures the AT-CMD detection settings.

pub fn set_rx_fifo_full_threshold( &mut self, threshold: u16 ) -> Result<(), Error>

Configures the RX-FIFO threshold

Errors

Err(Error::InvalidArgument) if provided value exceeds maximum value for SOC :

• esp32 0x7F
• esp32c6, esp32h2 0xFF
• esp32c3, esp32c2, esp32s2 0x1FF
• esp32s3 0x3FF

pub fn listen_at_cmd(&mut self)

Listen for AT-CMD interrupts

pub fn unlisten_at_cmd(&mut self)

Stop listening for AT-CMD interrupts

pub fn listen_tx_done(&mut self)

Listen for TX-DONE interrupts

pub fn unlisten_tx_done(&mut self)

Stop listening for TX-DONE interrupts

pub fn listen_rx_fifo_full(&mut self)

Listen for RX-FIFO-FULL interrupts

pub fn unlisten_rx_fifo_full(&mut self)

Stop listening for RX-FIFO-FULL interrupts

pub fn at_cmd_interrupt_set(&self) -> bool

Checks if AT-CMD interrupt is set

pub fn tx_done_interrupt_set(&self) -> bool

Checks if TX-DONE interrupt is set

pub fn rx_fifo_full_interrupt_set(&self) -> bool

Checks if RX-FIFO-FULL interrupt is set

pub fn reset_at_cmd_interrupt(&self)

Reset AT-CMD interrupt

pub fn reset_tx_done_interrupt(&self)

Reset TX-DONE interrupt

pub fn reset_rx_fifo_full_interrupt(&self)

Reset RX-FIFO-FULL interrupt

pub fn change_stop_bits(&mut self, stop_bits: StopBits) -> &mut Uart<'d, T>

Change the number of stop bits

Trait Implementations

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

type Error = Error

Error type of all the IO operations on this type.

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

where T: Instance,

fn read( &mut self, buf: &mut [u8] ) -> Result<usize, <Uart<'_, T> 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<T> Write for Uart<'_, T>

where T: Instance,

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

where T: Instance,

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

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

fn flush(&mut self) -> Result<(), <Uart<'_, T> 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<T> Read<u8> for Uart<'_, T>

where T: Instance,

type Error = Error

Read error

fn read(&mut self) -> Result<u8, Error<<Uart<'_, T> as Read<u8>>::Error>>

Reads a single word from the serial interface

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

where T: Instance,

type Error = Error

Write error

fn write( &mut self, word: u8 ) -> Result<(), Error<<Uart<'_, T> as Write<u8>>::Error>>

Writes a single word to the serial interface

fn flush(&mut self) -> Result<(), Error<<Uart<'_, T> as Write<u8>>::Error>>

Ensures that none of the previously written words are still buffered