Struct stm32l0xx_hal::serial::Serial

pub struct Serial<USART> { /* private fields */ }

Serial abstraction

Implementations

impl Serial<LPUART1>

pub fn lpuart1<TX, RX>(
    usart: LPUART1,
    tx: TX,
    rx: RX,
    config: Config,
    rcc: &mut Rcc
) -> Result<Self, InvalidConfig> where
    TX: TxPin<LPUART1>,
    RX: RxPin<LPUART1>, 

pub fn listen(&mut self, event: Event)

Starts listening for an interrupt event

pub fn unlisten(&mut self, event: Event)

Stop listening for an interrupt event

pub fn pending_event(&self) -> Option<Event>

Returns a pending and enabled Event.

Multiple Events can be signaled at the same time. In that case, an arbitrary pending event will be returned. Clearing the event condition will cause this method to return the other pending event(s).

For an event to be returned by this method, it must first be enabled by calling listen.

This method will never clear a pending event. If the event condition is not resolved by the user, it will be returned again by the next call to pending_event.

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

Checks for reception errors that may have occurred.

Note that multiple errors can be signaled at the same time. In that case, calling this function repeatedly will return the remaining errors.

pub fn clear_errors(&mut self)

Clears any signaled errors without returning them.

pub fn split(self) -> (Tx<LPUART1>, Rx<LPUART1>)

pub fn release(self) -> LPUART1

impl Serial<USART2>

pub fn usart2<TX, RX>(
    usart: USART2,
    tx: TX,
    rx: RX,
    config: Config,
    rcc: &mut Rcc
) -> Result<Self, InvalidConfig> where
    TX: TxPin<USART2>,
    RX: RxPin<USART2>, 

pub fn listen(&mut self, event: Event)

Starts listening for an interrupt event

pub fn unlisten(&mut self, event: Event)

Stop listening for an interrupt event

pub fn pending_event(&self) -> Option<Event>

Returns a pending and enabled Event.

Multiple Events can be signaled at the same time. In that case, an arbitrary pending event will be returned. Clearing the event condition will cause this method to return the other pending event(s).

For an event to be returned by this method, it must first be enabled by calling listen.

This method will never clear a pending event. If the event condition is not resolved by the user, it will be returned again by the next call to pending_event.

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

Checks for reception errors that may have occurred.

Note that multiple errors can be signaled at the same time. In that case, calling this function repeatedly will return the remaining errors.

pub fn clear_errors(&mut self)

Clears any signaled errors without returning them.

pub fn split(self) -> (Tx<USART2>, Rx<USART2>)

pub fn release(self) -> USART2

impl Serial<USART1>

pub fn usart1<TX, RX>(
    usart: USART1,
    tx: TX,
    rx: RX,
    config: Config,
    rcc: &mut Rcc
) -> Result<Self, InvalidConfig> where
    TX: TxPin<USART1>,
    RX: RxPin<USART1>, 

pub fn listen(&mut self, event: Event)

Starts listening for an interrupt event

pub fn unlisten(&mut self, event: Event)

Stop listening for an interrupt event

pub fn pending_event(&self) -> Option<Event>

Returns a pending and enabled Event.

Multiple Events can be signaled at the same time. In that case, an arbitrary pending event will be returned. Clearing the event condition will cause this method to return the other pending event(s).

For an event to be returned by this method, it must first be enabled by calling listen.

This method will never clear a pending event. If the event condition is not resolved by the user, it will be returned again by the next call to pending_event.

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

Checks for reception errors that may have occurred.

Note that multiple errors can be signaled at the same time. In that case, calling this function repeatedly will return the remaining errors.

pub fn clear_errors(&mut self)

Clears any signaled errors without returning them.

pub fn split(self) -> (Tx<USART1>, Rx<USART1>)

pub fn release(self) -> USART1

impl Serial<USART4>

pub fn usart4<TX, RX>(
    usart: USART4,
    tx: TX,
    rx: RX,
    config: Config,
    rcc: &mut Rcc
) -> Result<Self, InvalidConfig> where
    TX: TxPin<USART4>,
    RX: RxPin<USART4>, 

pub fn listen(&mut self, event: Event)

Starts listening for an interrupt event

pub fn unlisten(&mut self, event: Event)

Stop listening for an interrupt event

pub fn pending_event(&self) -> Option<Event>

Returns a pending and enabled Event.

Multiple Events can be signaled at the same time. In that case, an arbitrary pending event will be returned. Clearing the event condition will cause this method to return the other pending event(s).

For an event to be returned by this method, it must first be enabled by calling listen.

This method will never clear a pending event. If the event condition is not resolved by the user, it will be returned again by the next call to pending_event.

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

Checks for reception errors that may have occurred.

Note that multiple errors can be signaled at the same time. In that case, calling this function repeatedly will return the remaining errors.

pub fn clear_errors(&mut self)

Clears any signaled errors without returning them.

pub fn split(self) -> (Tx<USART4>, Rx<USART4>)

pub fn release(self) -> USART4

impl Serial<USART5>

pub fn usart5<TX, RX>(
    usart: USART5,
    tx: TX,
    rx: RX,
    config: Config,
    rcc: &mut Rcc
) -> Result<Self, InvalidConfig> where
    TX: TxPin<USART5>,
    RX: RxPin<USART5>, 

pub fn listen(&mut self, event: Event)

Starts listening for an interrupt event

pub fn unlisten(&mut self, event: Event)

Stop listening for an interrupt event

pub fn pending_event(&self) -> Option<Event>

Returns a pending and enabled Event.

Multiple Events can be signaled at the same time. In that case, an arbitrary pending event will be returned. Clearing the event condition will cause this method to return the other pending event(s).

For an event to be returned by this method, it must first be enabled by calling listen.

This method will never clear a pending event. If the event condition is not resolved by the user, it will be returned again by the next call to pending_event.

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

Checks for reception errors that may have occurred.

Note that multiple errors can be signaled at the same time. In that case, calling this function repeatedly will return the remaining errors.

pub fn clear_errors(&mut self)

Clears any signaled errors without returning them.

pub fn split(self) -> (Tx<USART5>, Rx<USART5>)

pub fn release(self) -> USART5

impl Serial<LPUART1>

pub fn use_lse(&mut self, rcc: &mut Rcc, _: &LSE)

Switches LPUART1 clock course to LSE

Consumes LSE token, to get guarantee that LSE clocks are configured.

At the moment configured baudrate is ignored and LPUART1 is forced to 9600 when clocked by LSE, assuming that LSE is 32768 (and it must be so according to RM).

Trait Implementations

impl Read<u8> for Serial<LPUART1>

type Error = Error

Read error

fn read(&mut self) -> Result<u8, Error>

Reads a single word from the serial interface

impl Read<u8> for Serial<USART1>

type Error = Error

Read error

fn read(&mut self) -> Result<u8, Error>

Reads a single word from the serial interface

impl Read<u8> for Serial<USART2>

type Error = Error

Read error

fn read(&mut self) -> Result<u8, Error>

Reads a single word from the serial interface

impl Read<u8> for Serial<USART4>

type Error = Error

Read error

fn read(&mut self) -> Result<u8, Error>

Reads a single word from the serial interface

impl Read<u8> for Serial<USART5>

type Error = Error

Read error

fn read(&mut self) -> Result<u8, Error>

Reads a single word from the serial interface

impl Write<u8> for Serial<LPUART1>

type Error = Error

Write error

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

Ensures that none of the previously written words are still buffered

fn write(&mut self, byte: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface

impl Write<u8> for Serial<USART1>

type Error = Error

Write error

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

Ensures that none of the previously written words are still buffered

fn write(&mut self, byte: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface

impl Write<u8> for Serial<USART2>

type Error = Error

Write error

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

Ensures that none of the previously written words are still buffered

fn write(&mut self, byte: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface

impl Write<u8> for Serial<USART4>

type Error = Error

Write error

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

Ensures that none of the previously written words are still buffered

fn write(&mut self, byte: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface

impl Write<u8> for Serial<USART5>

type Error = Error

Write error

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

Ensures that none of the previously written words are still buffered

fn write(&mut self, byte: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface

impl<USART> Write for Serial<USART> where
    Serial<USART>: Write<u8>, 

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.