Struct LpUart 

pub struct LpUart<R> {
    pub regs: R,
    /* private fields */
}

Represents the USART peripheral, for serial communications.

Fields

regs: R

Implementations

impl<R> LpUart<R>

where R: Deref<Target = RegisterBlock> + RccPeriph + BaudPeriph,

pub fn new( regs: R, baud: u32, config: UsartConfig, clock_cfg: &Clocks, ) -> Result<Self>

Initialize a U[s]ART peripheral, including configuration register writes, and enabling and resetting its RCC peripheral clock. baud is the baud rate, in bytes-per-second.

impl<R> LpUart<R>

where R: Deref<Target = RegisterBlock> + BaudPeriph,

pub fn set_baud(&mut self, baud: u32, clock_cfg: &Clocks) -> Result<()>

Set the BAUD rate. Called during init, and can be called later to change BAUD during program execution.

impl<R> LpUart<R>

where R: Deref<Target = RegisterBlock> + RccPeriph,

pub fn enable(&mut self) -> Result<()>

Enable this U[s]ART peripheral.

pub fn disable(&mut self) -> Result<()>

Disable this U[s]ART peripheral.

pub fn write(&mut self, data: &[u8]) -> Result<()>

Transmit data, as a sequence of u8. See L44 RM, section 38.5.2: “Character transmission procedure”

pub fn write_one(&mut self, word: u8)

Write a single word, without waiting until ready for the next. Compared to the write() function, this does not block.

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

Receive data into a u8 buffer. See L44 RM, section 38.5.3: “Character reception procedure”

pub fn read_one(&mut self) -> u8

Read a single word, without waiting until ready for the next. Compared to the read() function, this does not block.

pub unsafe fn write_dma( &mut self, buf: &[u8], channel: DmaChannel, channel_cfg: ChannelCfg, dma_periph: DmaPeriph, ) -> Result<()>

Transmit data using DMA. (L44 RM, section 38.5.15) Note that the channel argument is unused on F3 and L4, since it is hard-coded, and can’t be configured using the DMAMUX peripheral. (dma::mux() fn).

pub unsafe fn read_dma( &mut self, buf: &mut [u8], channel: DmaChannel, channel_cfg: ChannelCfg, dma_periph: DmaPeriph, ) -> Result<()>

Receive data using DMA. (L44 RM, section 38.5.15; G4 RM section 37.5.19. Note that the channel argument is unused on F3 and L4, since it is hard-coded, and can’t be configured using the DMAMUX peripheral. (dma::mux() fn).

pub fn enable_interrupt(&mut self, interrupt: UsartInterrupt) -> Result<()>

Enable a specific type of interrupt. See G4 RM, Table 349: USART interrupt requests. If Some, the inner value of CharDetect sets the address of the char to match. If None, the interrupt is enabled without changing the char to match.

pub fn disable_interrupt(&mut self, interrupt: UsartInterrupt)

Disable a specific type of interrupt. See G4 RM, Table 349: USART interrupt requests. Note that the inner value of CharDetect doesn’t do anything here.

pub fn read_status(&self) -> u32

Print the (raw) contents of the status register.

pub fn clear_interrupt(&mut self, interrupt: UsartInterrupt)

Clears the interrupt pending flag for a specific type of interrupt. Note that it can also clear error flags, like Overrun and framing errors. See G4 RM, Table 349: USART interrupt requests. Note that the inner value of CharDetect doesn’t do anything here.

pub fn check_status_flag(&mut self, flag: UsartInterrupt) -> bool

Checks if a given status flag is set. Returns true if the status flag is set. Note that this preforms a read each time called. If checking multiple flags, this isn’t optimal.

Trait Implementations

impl<R> ErrorType for LpUart<R>

type Error = Error

Error type of all the IO operations on this type.

impl<R> Read for LpUart<R>

where R: Deref<Target = RegisterBlock> + RccPeriph + BaudPeriph, LpUart<R>: ReadReady,

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<R> ReadReady for LpUart<R>

where R: Deref<Target = RegisterBlock> + RccPeriph + BaudPeriph,

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

Get whether the reader is ready for immediately reading.

impl<R> Write for LpUart<R>

where R: Deref<Target = RegisterBlock> + RccPeriph + BaudPeriph,

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<R> WriteReady for LpUart<R>

where R: Deref<Target = RegisterBlock> + RccPeriph + BaudPeriph,

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

Get whether the writer is ready for immediately writing.