Struct rp2040_hal::uart::UartPeripheral

pub struct UartPeripheral<S: State, D: UartDevice, P: ValidUartPinout<D>> { /* private fields */ }

An UART Peripheral based on an underlying UART device.

Implementations

impl<S: State, D: UartDevice, P: ValidUartPinout<D>> UartPeripheral<S, D, P>

pub fn free(self) -> (D, P)

Releases the underlying device and pins.

impl<D: UartDevice, P: ValidUartPinout<D>> UartPeripheral<Disabled, D, P>

pub fn new( device: D, pins: P, resets: &mut RESETS ) -> UartPeripheral<Disabled, D, P>

Creates an UartPeripheral in Disabled state.

pub fn enable( self, config: UartConfig, frequency: HertzU32 ) -> Result<UartPeripheral<Enabled, D, P>, Error>

Enables the provided UART device with the given configuration.

impl<D: UartDevice, P: ValidUartPinout<D>> UartPeripheral<Enabled, D, P>

pub fn disable(self) -> UartPeripheral<Disabled, D, P>

Disable this UART Peripheral, falling back to the Disabled state.

pub fn set_fifos(&mut self, enable: bool)

Enable/disable the rx/tx FIFO

Unfortunately, it’s not possible to enable/disable rx/tx independently on this chip Default is false

pub fn set_rx_watermark(&mut self, watermark: FifoWatermark)

Set rx FIFO watermark

See DS: Table 423

pub fn set_tx_watermark(&mut self, watermark: FifoWatermark)

Set tx FIFO watermark

See DS: Table 423

pub fn enable_rx_interrupt(&mut self)

Enables the Receive Interrupt.

The relevant UARTx IRQ will fire when there is data in the receive register.

pub fn enable_tx_interrupt(&mut self)

Enables the Transmit Interrupt.

The relevant UARTx IRQ will fire when there is space in the transmit FIFO.

pub fn disable_rx_interrupt(&mut self)

Disables the Receive Interrupt.

pub fn disable_tx_interrupt(&mut self)

Disables the Transmit Interrupt.

pub fn uart_is_writable(&self) -> bool

Is there space in the UART TX FIFO for new data to be written?

pub fn uart_is_busy(&self) -> bool

Is the UART still busy transmitting data?

pub fn uart_is_readable(&self) -> bool

Is there data in the UART RX FIFO ready to be read?

pub fn write_raw<'d>(&self, data: &'d [u8]) -> Result<&'d [u8], Infallible>

Writes bytes to the UART. This function writes as long as it can. As soon that the FIFO is full, if :

• 0 bytes were written, a WouldBlock Error is returned
• some bytes were written, it is deemed to be a success Upon success, the remaining slice is returned.

pub fn read_raw<'b>(&self, buffer: &'b mut [u8]) -> Result<usize, ReadError<'b>>

Reads bytes from the UART. This function reads as long as it can. As soon that the FIFO is empty, if :

• 0 bytes were read, a WouldBlock Error is returned
• some bytes were read, it is deemed to be a success Upon success, it will return how many bytes were read.

pub fn write_full_blocking(&self, data: &[u8])

Writes bytes to the UART. This function blocks until the full buffer has been sent.

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

Reads bytes from the UART. This function blocks until the full buffer has been received.

pub fn join(reader: Reader<D, P>, writer: Writer<D, P>) -> Self

Join the reader and writer halves together back into the original Uart peripheral.

A reader/writer pair can be obtained by calling split.

impl<P: ValidUartPinout<UART0>> UartPeripheral<Enabled, UART0, P>

pub fn split(self) -> (Reader<UART0, P>, Writer<UART0, P>)

Split this peripheral into a separate reader and writer.

impl<P: ValidUartPinout<UART1>> UartPeripheral<Enabled, UART1, P>

pub fn split(self) -> (Reader<UART1, P>, Writer<UART1, P>)

Split this peripheral into a separate reader and writer.

Trait Implementations

impl<D: UartDevice, P: ValidUartPinout<D>> ErrorType for UartPeripheral<Enabled, D, P>

type Error = ReadErrorType

Error type of all the IO operations on this type.

impl<D: UartDevice, P: ValidUartPinout<D>> ErrorType for UartPeripheral<Enabled, D, P>

type Error = ReadErrorType

Error type

impl<D: UartDevice, P: ValidUartPinout<D>> Read for UartPeripheral<Enabled, D, P>

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

Reads a single word from the serial interface

impl<D: UartDevice, P: ValidUartPinout<D>> Read for UartPeripheral<Enabled, D, P>

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::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: UartDevice, P: ValidUartPinout<D>> Write for UartPeripheral<Enabled, D, P>

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

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

fn flush(&mut self) -> Result<(), Self::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: UartDevice, P: ValidUartPinout<D>> Write for UartPeripheral<Enabled, D, P>

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

Writes a single word to the serial interface.

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

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

impl<D: UartDevice, P: ValidUartPinout<D>> Write for UartPeripheral<Enabled, D, P>

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

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: UartDevice, P: ValidUartPinout<D>> Read<u8> for UartPeripheral<Enabled, D, P>

type Error = ReadErrorType

Read error

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

Reads a single word from the serial interface

impl<D: UartDevice, P: ValidUartPinout<D>> Write<u8> for UartPeripheral<Enabled, D, P>

type Error = Infallible

Write error

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

Writes a single word to the serial interface

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

Ensures that none of the previously written words are still buffered