Struct Tx 

pub struct Tx<I, State, Throttle> { /* private fields */ }

USART transmitter

Can be accessed through USART.

embedded-hal traits

• embedded_hal::serial::Write for non-blocking writes
• embedded_hal::blocking::serial::Write for blocking writes

Implementations

impl<I, W, Mode, Throttle> Tx<I, Enabled<W, Mode>, Throttle>

where I: Instance, W: Word,

pub fn enable_rts<P, S>( &mut self, function: Function<I::Rts, Unassigned>, pin: Pin<P, S>, swm: &mut Handle, ) -> (Function<I::Rts, Assigned<P>>, <Pin<P, S> as AssignFunction<I::Rts, <I::Rts as FunctionTrait<P>>::Kind>>::Assigned)

where P: Trait, S: State, Pin<P, S>: AssignFunction<I::Rts, <I::Rts as FunctionTrait<P>>::Kind>, I::Rts: FunctionTrait<P>,

Enable RTS signal

Configure the transmitter to assert the Request to Send (RTS) signal, when it is ready to send.

This is a convenience method that ensures the correct RTS function for this peripheral instance is assigned to a pin. The same effect can be achieved by just assigning the function using the SWM API.

pub fn disable_rts<P, S>( &mut self, function: Function<I::Rts, Assigned<P>>, pin: Pin<P, S>, swm: &mut Handle, ) -> (Function<I::Rts, Unassigned>, <Pin<P, S> as UnassignFunction<I::Rts, <I::Rts as FunctionTrait<P>>::Kind>>::Unassigned)

where P: Trait, S: State, Pin<P, S>: UnassignFunction<I::Rts, <I::Rts as FunctionTrait<P>>::Kind>, I::Rts: FunctionTrait<P>,

Disable RTS signal

Configure the transmitter to no longer assert the Request to Send (RTS) signal.

This is a convenience method that ensures the correct RTS function for this peripheral instance is unassigned. The same effect can be achieved by just unassigning the function using the SWM API.

pub fn is_flag_set(&self, flag: Flag) -> bool

Query whether the provided flag is set

Flags that need to be reset by software will be reset by this operation.

pub fn enable_interrupts(&mut self, interrupts: Interrupts)

Enable interrupts

Enables all interrupts set to true in interrupts. Interrupts set to false are not affected.

Example

use lpc8xx_hal::usart;

// Enable only RXRDY and TXRDY, leave other interrupts untouched.
usart.enable_interrupts(usart::Interrupts {
    RXRDY: true,
    TXRDY: true,
    .. usart::Interrupts::default()
});

pub fn disable_interrupts(&mut self, interrupts: Interrupts)

Disable interrupts

Disables all interrupts set to true in interrupts. Interrupts set to false are not affected.

Example

use lpc8xx_hal::usart;

// Disable only RXRDY and TXRDY, leave other interrupts untouched.
usart.disable_interrupts(usart::Interrupts {
    RXRDY: true,
    TXRDY: true,
    .. usart::Interrupts::default()
});

impl<I, W, Mode> Tx<I, Enabled<W, Mode>, NoThrottle>

where I: Instance, W: Word,

pub fn enable_cts_throttling<P>( self, function: Function<I::Cts, Assigned<P>>, ) -> Tx<I, Enabled<W, Mode>, CtsThrottle<Function<I::Cts, Assigned<P>>>>

Enable throttling via CTS signal

Configure the transmitter to only transmit, while the CTS signal is asserted.

impl<I, W, Mode, Function> Tx<I, Enabled<W, Mode>, CtsThrottle<Function>>

where I: Instance, W: Word,

pub fn disable_cts_throttling( self, ) -> (Tx<I, Enabled<W, Mode>, NoThrottle>, Function)

Disable throttling via CTS signal

Configure the transmitter to ignore the CTS signal. Returns the SWM function for the CTS signal, so it can be reused to enable CTS throttling again, or for something else.

impl<I, Mode, Throttle> Tx<I, Enabled<u8, Mode>, Throttle>

where I: Instance,

pub fn write_all( self, buffer: &'static [u8], channel: Channel<I::TxChannel, Enabled>, ) -> Transfer<Ready, I::TxChannel, &'static [u8], Self>

Writes the provided buffer using DMA

Panics

Panics, if the length of buffer is 0 or larger than 1024.

Trait Implementations

impl<I, Mode, Throttle> Dest for Tx<I, Enabled<u8, Mode>, Throttle>

where I: Instance,

type Error = Void

The error that can occur while finishing the transfer

fn is_valid(&self) -> bool

Indicates whether the destination is valid

fn is_full(&self) -> bool

Indicates whether the destination is full

fn increment(&self) -> DSTINC_A

The address increment during the transfer

fn transfer_count(&self) -> Option<u16>

The transfer count, as defined by XFERCFG.XFERCOUNT

fn end_addr(&mut self) -> *mut u8

The end address

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

Tell the destination to finish the transfer

impl<I, Mode, Throttle> Write for Tx<I, Enabled<u8, Mode>, Throttle>

where Self: BlockingWriteDefault<u8>, I: Instance,

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<I, W, Mode, Throttle> Write<W> for Tx<I, Enabled<W, Mode>, Throttle>

where I: Instance, W: Word,

type Error = Void

Write error

fn write(&mut self, word: W) -> 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<I, W, Mode, Throttle> Default<W> for Tx<I, Enabled<W, Mode>, Throttle>

where I: Instance, W: Word,