Struct stm32f4xx_hal::serial::Serial

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

Serial abstraction

Implementations

impl<USART, TX, RX, WORD> Serial<USART, (TX, RX), WORD>where
    (TX, RX): Pins<USART>,
    USART: Instance,

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

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

impl<USART, TX, WORD> Serial<USART, (TX, NoPin), WORD>where
    (TX, NoPin): Pins<USART>,
    USART: Instance,

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

impl<USART, RX, WORD> Serial<USART, (NoPin, RX), WORD>where
    (NoPin, RX): Pins<USART>,
    USART: Instance,

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

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

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 split(self) -> (Tx<USART, WORD>, Rx<USART, WORD>)

impl<USART: Instance, TX, RX, WORD> Serial<USART, (TX, RX), WORD>

pub fn split_nondestructive(
    self
) -> (UTx<USART, TX, WORD>, URx<USART, RX, WORD>)

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

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: Instance, PINS> Serial<USART, PINS, u16>

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.

Trait Implementations

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

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

Converts this type into a mutable reference of the (usually inferred) input type.

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

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

Converts this type into a mutable reference of the (usually inferred) input type.

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

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

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<USART, PINS, WORD> ErrorType for Serial<USART, PINS, WORD>

type Error = ErrorKind

Error type

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

type Error = ErrorKind

Read error

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

Reads a single word from the serial interface

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

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

Reads a single word from the serial interface

impl<USART: Instance, PINS, WORD> RxISR for Serial<USART, PINS, WORD>

fn is_idle(&self) -> bool

Return true if the line idle status is set

fn is_rx_not_empty(&self) -> bool

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

fn clear_idle_interrupt(&self)

Clear idle line interrupt flag

impl<USART: Instance, PINS, WORD> TxISR for Serial<USART, PINS, WORD>

fn is_tx_empty(&self) -> bool

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

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

type Error = ErrorKind

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, WORD: Copy> Write<WORD> for Serial<USART, PINS, WORD>where
    USART: Instance,
    Tx<USART, WORD>: Write<WORD> + ErrorType<Error = Self::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, WORD: Copy> Write<WORD> for Serial<USART, PINS, WORD>where
    USART: Instance,
    Tx<USART, WORD>: Write<WORD> + ErrorType<Error = Self::Error>,

fn write(&mut self, slice: &[WORD]) -> Result<(), Self::Error>

Writes a slice, blocking until everything has been written

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

Block until the serial interface has sent all buffered words

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

type Error = ErrorKind

The type of error that can occur when writing

fn bwrite_all(&mut self, slice: &[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: Instance, PINS> Write<u8> for Serial<USART, PINS, u8>

type Error = ErrorKind

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

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

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.