Struct UartPeripheral 

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

An UART Peripheral based on an underlying UART device.

Implementations

impl<S, D, P> UartPeripheral<S, D, P>

where S: State, D: UartDevice, P: ValidUartPinout<D>,

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

Releases the underlying device and pins.

impl<D, P> UartPeripheral<Disabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

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: Rate<u32, 1, 1>, ) -> Result<UartPeripheral<Enabled, D, P>, Error>

Enables the provided UART device with the given configuration.

impl<D, P> UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

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], Error<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, Error<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 lowlevel_break_start(&mut self)

Initiates a break

If transmitting, this takes effect immediately after the current byte has completed.
For proper execution of the break command, this must be held for at least 2 complete frames worth of time.

The device won’t be able to send anything while breaking.

Example

serial.lowlevel_break_start();
// at 115_200Bps on 8N1 configuration, 20bits takes (20*10⁶)/115200 = 173.611…μs.
timer.delay_us(175);
serial.lowlevel_break_stop();
}

pub fn lowlevel_break_stop(&mut self)

Terminates a break condition.

See lowlevel_break_start for more details.

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

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> UartPeripheral<Enabled, UART0, P>

where P: ValidUartPinout<UART0>,

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

Split this peripheral into a separate reader and writer.

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

where P: ValidUartPinout<UART1>,

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

Split this peripheral into a separate reader and writer.

Trait Implementations

impl<D, P> ErrorType for UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

type Error = ReadErrorType

Error type

impl<D, P> ErrorType for UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

type Error = ReadErrorType

Error type of all the IO operations on this type.

impl<D, P> Read<u8> for UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

type Error = ReadErrorType

Read error

fn read( &mut self, ) -> Result<u8, Error<<UartPeripheral<Enabled, D, P> as Read<u8>>::Error>>

Reads a single word from the serial interface

impl<D, P> Read for UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

fn read( &mut self, ) -> Result<u8, Error<<UartPeripheral<Enabled, D, P> as ErrorType>::Error>>

Reads a single word from the serial interface

impl<D, P> Read for UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

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

where D: UartDevice, P: ValidUartPinout<D>,

fn read_ready( &mut self, ) -> Result<bool, <UartPeripheral<Enabled, D, P> as ErrorType>::Error>

Get whether the reader is ready for immediately reading.

impl<D, P> Write<u8> for UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

type Error = Infallible

Write error

fn write( &mut self, word: u8, ) -> Result<(), Error<<UartPeripheral<Enabled, D, P> as Write<u8>>::Error>>

Writes a single word to the serial interface

fn flush( &mut self, ) -> Result<(), Error<<UartPeripheral<Enabled, D, P> as Write<u8>>::Error>>

Ensures that none of the previously written words are still buffered

impl<D, P> Write for UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

fn write( &mut self, word: u8, ) -> Result<(), Error<<UartPeripheral<Enabled, D, P> as ErrorType>::Error>>

Writes a single word to the serial interface.

fn flush( &mut self, ) -> Result<(), Error<<UartPeripheral<Enabled, D, P> as ErrorType>::Error>>

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

impl<D, P> Write for UartPeripheral<Enabled, D, P>

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

where D: UartDevice, P: ValidUartPinout<D>,

fn write( &mut self, buf: &[u8], ) -> Result<usize, <UartPeripheral<Enabled, D, P> as ErrorType>::Error>

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

fn flush( &mut self, ) -> Result<(), <UartPeripheral<Enabled, D, P> 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, P> WriteReady for UartPeripheral<Enabled, D, P>

where D: UartDevice, P: ValidUartPinout<D>,

fn write_ready( &mut self, ) -> Result<bool, <UartPeripheral<Enabled, D, P> as ErrorType>::Error>

Get whether the writer is ready for immediately writing.