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_timeout(&mut self, timeout: Option<u8>) -> Result<(), Error>

Configures the Receive Timeout detection setting

Arguments

timeout - the number of symbols (“bytes”) to wait for before triggering a timeout. Pass None to disable the timeout.

Errors

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

• esp32: Symbol size is fixed to 8, do not pass a value > 0x7F.
• esp32c2, esp32c3, esp32c6, esp32h2, esp32s2, esp32s3: The value you pass times the symbol size must be <= 0x3FF

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