Struct stm32f4xx_hal::serial::Serial

pub struct Serial<USART, PINS, WORD = u8> { /* fields omitted */ }

Serial abstraction

Implementations

impl<USART, TX, RX, WORD, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX), WORD> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn new(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

pub fn release(self) -> (USART, (TX, RX))

impl<USART, TX, WORD, const TXA: u8> Serial<USART, (TX, NoPin), WORD> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    USART: Instance, 

pub fn tx(
    usart: USART,
    tx_pin: TX,
    config: Config,
    clocks: Clocks
) -> Result<Tx<USART, WORD>, InvalidConfig>

impl<USART, RX, WORD, const RXA: u8> Serial<USART, (NoPin, RX), WORD> where
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn rx(
    usart: USART,
    rx_pin: RX,
    config: Config,
    clocks: Clocks
) -> Result<Rx<USART, WORD>, InvalidConfig>

impl<USART, PINS, WORD> Serial<USART, PINS, WORD> where
    USART: Instance, 

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

Starts listening for an interrupt event

Note, you will also have to enable the corresponding interrupt in the NVIC to start receiving events.

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

Stop listening for an interrupt event

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_tx_empty(&self) -> bool

Return true if the tx register is empty (and can accept data)

pub fn is_txe(&self) -> bool

👎 Deprecated since 0.10.0

Return true if the tx register is empty (and can accept data)

pub fn is_rx_not_empty(&self) -> bool

Return true if the rx register is not empty (and can be read)

pub fn is_rxne(&self) -> bool

👎 Deprecated since 0.10.0

Return true if the rx register is not empty (and can be read)

pub fn clear_idle_interrupt(&self)

Clear idle line interrupt flag

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

impl<USART, PINS> Serial<USART, PINS, u8> where
    USART: Instance, 

pub fn with_u16_data(self) -> Serial<USART, PINS, u16>

Converts this Serial into a version that can read and write u16 values instead of u8s

This can be used with a word length of 9 bits.

impl<USART, PINS> Serial<USART, PINS, u16> where
    USART: Instance, 

pub fn with_u8_data(self) -> Serial<USART, PINS, u8>

Converts this Serial into a version that can read and write u8 values instead of u16s

This can be used with a word length of 8 bits.

impl<USART, TX, RX, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX)> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn usart1(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

👎 Deprecated since 0.10.0

impl<USART, TX, RX, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX)> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn usart2(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

👎 Deprecated since 0.10.0

impl<USART, TX, RX, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX)> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn usart6(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

👎 Deprecated since 0.10.0

impl<USART, TX, RX, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX)> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn usart3(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

👎 Deprecated since 0.10.0

impl<USART, TX, RX, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX)> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn uart4(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

👎 Deprecated since 0.10.0

impl<USART, TX, RX, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX)> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn uart5(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

👎 Deprecated since 0.10.0

impl<USART, TX, RX, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX)> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn uart7(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

👎 Deprecated since 0.10.0

impl<USART, TX, RX, const TXA: u8, const RXA: u8> Serial<USART, (TX, RX)> where
    TX: PinTx<USART, A = Const<TXA>> + SetAlternate<TXA>,
    RX: PinRx<USART, A = Const<RXA>> + SetAlternate<RXA>,
    USART: Instance, 

pub fn uart8(
    usart: USART,
    pins: (TX, RX),
    config: Config,
    clocks: Clocks
) -> Result<Self, InvalidConfig>

👎 Deprecated since 0.10.0

Trait Implementations

impl<USART, PINS, WORD> AsMut<Rx<USART, WORD>> for Serial<USART, PINS, WORD>

fn as_mut(&mut self) -> &mut Rx<USART, WORD>

Performs the conversion.

impl<USART, PINS, WORD> AsMut<Tx<USART, WORD>> for Serial<USART, PINS, WORD>

fn as_mut(&mut self) -> &mut Tx<USART, WORD>

Performs the conversion.

impl<USART, PINS, WORD> AsRef<Rx<USART, WORD>> for Serial<USART, PINS, WORD>

fn as_ref(&self) -> &Rx<USART, WORD>

Performs the conversion.

impl<USART, PINS, WORD> AsRef<Tx<USART, WORD>> for Serial<USART, PINS, WORD>

fn as_ref(&self) -> &Tx<USART, WORD>

Performs the conversion.

impl<USART, PINS, WORD> Read<WORD> for Serial<USART, PINS, WORD> where
    USART: Instance,
    Rx<USART, WORD>: Read<WORD, Error = Error>, 

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<USART, PINS> Write for Serial<USART, PINS> where
    Tx<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.

impl<USART, PINS, WORD> Write<WORD> for Serial<USART, PINS, WORD> where
    USART: Instance,
    Tx<USART, WORD>: Write<WORD, Error = Error>, 

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: WORD) -> Result<(), Self::Error>

Writes a single word to the serial interface

impl<USART, PINS> Write<u16> for Serial<USART, PINS, u16> where
    USART: Instance, 

type Error = Error

The type of error that can occur when writing

fn bwrite_all(&mut self, bytes: &[u16]) -> Result<(), Self::Error>

Writes a slice, blocking until everything has been written

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

Block until the serial interface has sent all buffered words

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

type Error = Error

The type of error that can occur when writing

fn bwrite_all(&mut self, bytes: &[u8]) -> Result<(), Self::Error>

Writes a slice, blocking until everything has been written

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

Block until the serial interface has sent all buffered words