Struct BufferedUart 

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

Buffered UART driver.

Implementations

impl<'d> BufferedUart<'d>

pub fn new<T: Instance>( _uart: Peri<'d, T>, tx: Peri<'d, impl TxPin<T>>, rx: Peri<'d, impl RxPin<T>>, _irq: impl Binding<T::Interrupt, BufferedInterruptHandler<T>>, tx_buffer: &'d mut [u8], rx_buffer: &'d mut [u8], config: Config, ) -> Self

Create a buffered UART instance.

pub fn new_with_rtscts<T: Instance>( _uart: Peri<'d, T>, tx: Peri<'d, impl TxPin<T>>, rx: Peri<'d, impl RxPin<T>>, rts: Peri<'d, impl RtsPin<T>>, cts: Peri<'d, impl CtsPin<T>>, _irq: impl Binding<T::Interrupt, BufferedInterruptHandler<T>>, tx_buffer: &'d mut [u8], rx_buffer: &'d mut [u8], config: Config, ) -> Self

Create a buffered UART instance with flow control.

pub async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Read from UART RX buffer.

Waits until at least one byte is available, then reads as many bytes as are available (up to buf.len()) and returns the number of bytes read.

pub async fn fill_buf(&mut self) -> Result<&[u8], Error>

Wait until data is available in the RX buffer, and return a slice to it.

Call consume afterwards to mark bytes as read.

pub fn consume(&mut self, amt: usize)

Mark amt bytes returned by fill_buf as read.

pub fn read_ready(&mut self) -> Result<bool, Error>

Check whether data is available in the RX buffer, i.e. whether a read would not block.

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

Write to UART TX buffer.

Waits until there is space in the TX buffer, then writes as many bytes as fit (up to buf.len()) and returns the number of bytes written.

pub async fn flush(&mut self) -> Result<(), Error>

Wait until all written bytes have been fully transmitted on the wire.

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

Write to UART TX buffer blocking execution until done.

pub fn blocking_flush(&mut self) -> Result<(), Error>

Flush UART TX blocking execution until done.

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

Read from UART RX buffer blocking execution until done.

pub fn busy(&self) -> bool

Check if UART is busy transmitting.

pub async fn send_break(&mut self, bits: u32)

Wait until TX is empty and send break condition.

pub fn set_baudrate(&mut self, baudrate: u32)

sets baudrate on runtime

pub fn set_config(&mut self, config: Config)

Set the configuration at runtime (ignores pin inversions)

pub fn split(self) -> (BufferedUartTx<'d>, BufferedUartRx<'d>)

Split into separate RX and TX handles.

pub fn split_ref(&mut self) -> (BufferedUartTx<'_>, BufferedUartRx<'_>)

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

Trait Implementations

impl<'d> BufRead for BufferedUart<'d>

async fn fill_buf(&mut self) -> Result<&[u8], Self::Error>

Return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(&mut self, amt: usize)

Tell this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to fill_buf.

impl<'d> ErrorType for BufferedUart<'d>

type Error = Error

Error type of all the IO operations on this type.

impl<'d> Read for BufferedUart<'d>

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

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<'d> Read for BufferedUart<'d>

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> ReadReady for BufferedUart<'d>

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

Get whether the reader is ready for immediately reading.

impl<'d> Write for BufferedUart<'d>

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

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

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

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

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

Write an entire buffer into this writer.

impl<'d> Write for BufferedUart<'d>

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

type Error = Error

The type of error that can occur when writing

fn bwrite_all(&mut self, buffer: &[u8]) -> Result<(), Self::Error>

Writes a slice, blocking until everything has been written

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

Block until the serial interface has sent all buffered words