Struct stm32f0xx_hal::serial::Serial

pub struct Serial<USART, TXPIN, RXPIN> { /* fields omitted */ }

Serial abstraction

Implementations

impl<TXPIN, RXPIN> Serial<USART1, TXPIN, RXPIN> where
    TXPIN: TxPin<USART1>,
    RXPIN: RxPin<USART1>, 

pub fn usart1(
    usart: USART1,
    pins: (TXPIN, RXPIN),
    baud_rate: Bps,
    rcc: &mut Rcc
) -> Self

Creates a new serial instance

impl<TXPIN> Serial<USART1, TXPIN, ()> where
    TXPIN: TxPin<USART1>, 

pub fn usart1tx(
    usart: USART1,
    txpin: TXPIN,
    baud_rate: Bps,
    rcc: &mut Rcc
) -> Self

Creates a new tx-only serial instance

impl<RXPIN> Serial<USART1, (), RXPIN> where
    RXPIN: RxPin<USART1>, 

pub fn usart1rx(
    usart: USART1,
    rxpin: RXPIN,
    baud_rate: Bps,
    rcc: &mut Rcc
) -> Self

Creates a new rx-only serial instance

impl<TXPIN, RXPIN> Serial<USART1, TXPIN, RXPIN>

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

impl<TXPIN, RXPIN> Serial<USART2, TXPIN, RXPIN> where
    TXPIN: TxPin<USART2>,
    RXPIN: RxPin<USART2>, 

pub fn usart2(
    usart: USART2,
    pins: (TXPIN, RXPIN),
    baud_rate: Bps,
    rcc: &mut Rcc
) -> Self

Creates a new serial instance

impl<TXPIN> Serial<USART2, TXPIN, ()> where
    TXPIN: TxPin<USART2>, 

pub fn usart2tx(
    usart: USART2,
    txpin: TXPIN,
    baud_rate: Bps,
    rcc: &mut Rcc
) -> Self

Creates a new tx-only serial instance

impl<RXPIN> Serial<USART2, (), RXPIN> where
    RXPIN: RxPin<USART2>, 

pub fn usart2rx(
    usart: USART2,
    rxpin: RXPIN,
    baud_rate: Bps,
    rcc: &mut Rcc
) -> Self

Creates a new rx-only serial instance

impl<TXPIN, RXPIN> Serial<USART2, TXPIN, RXPIN>

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

impl<USART, TXPIN, RXPIN> Serial<USART, TXPIN, RXPIN> where
    USART: Deref<Target = RegisterBlock>, 

pub fn split(self) -> (Tx<USART>, Rx<USART>) where
    TXPIN: TxPin<USART>,
    RXPIN: RxPin<USART>, 

Splits the UART Peripheral in a Tx and an Rx part This is required for sending/receiving

pub fn release(self) -> (USART, (TXPIN, RXPIN))

Trait Implementations

impl<USART, TXPIN, RXPIN> Read<u8> for Serial<USART, TXPIN, RXPIN> where
    USART: Deref<Target = RegisterBlock>,
    RXPIN: RxPin<USART>, 

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

Tries to read a byte from the uart

type Error = Error

Read error

impl<USART, TXPIN, RXPIN> Write for Serial<USART, TXPIN, RXPIN> where
    USART: Deref<Target = RegisterBlock>,
    TXPIN: TxPin<USART>, 

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<USART, TXPIN, RXPIN> Write<u8> for Serial<USART, TXPIN, RXPIN> where
    USART: Deref<Target = RegisterBlock>,
    TXPIN: TxPin<USART>, 

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>

Tries to write a byte to the uart Fails if the transmit buffer is full

type Error = Infallible

Write error