Struct Writer 

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

Half of an UartPeripheral that is only capable of writing. Obtained by calling UartPeripheral::split()

Implementations

impl<D: UartDevice, P: ValidUartPinout<D>> Writer<D, P>

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 (unwritten) slice is returned.

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 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_tx_interrupt(&mut self)

Disables the Transmit Interrupt.

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.

Trait Implementations

impl<D: UartDevice, P: ValidUartPinout<D>> ErrorType for Writer<D, P>

type Error = Infallible

Error type of all the IO operations on this type.

impl<D: UartDevice, P: ValidUartPinout<D>> ErrorType for Writer<D, P>

type Error = Infallible

Error type

impl<D: UartDevice, P: ValidUartPinout<D>> Write for Writer<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 Writer<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 Writer<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>> WriteReady for Writer<D, P>

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

Get whether the writer is ready for immediately writing.

impl<D: UartDevice, P: ValidUartPinout<D>> WriteTarget for Writer<D, P>

type TransmittedWord = u8

Type which is transferred in a single DMA transfer.

fn tx_treq() -> Option<u8>

Returns the DREQ number for this data sink (None for memory buffers).

fn tx_address_count(&mut self) -> (u32, u32)

Returns the address and the maximum number of words that can be transferred from this data source in a single DMA operation.

fn tx_increment(&self) -> bool

Returns whether the address shall be incremented after each transfer.

impl<D: UartDevice, P: ValidUartPinout<D>> Write<u8> for Writer<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

impl<D: UartDevice, P: ValidUartPinout<D>> EndlessWriteTarget for Writer<D, P>