Struct stm32f1xx_hal::serial::Serial

pub struct Serial<USART, PINS> {
    pub tx: Tx<USART>,
    pub rx: Rx<USART>,
    pub token: ReleaseToken<USART, PINS>,
}

Serial abstraction

Fields

tx: Tx<USART>

rx: Rx<USART>

token: ReleaseToken<USART, PINS>

Implementations

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

pub fn new(
    usart: USART,
    pins: PINS,
    mapr: &mut MAPR,
    config: impl Into<Config>,
    clocks: &Clocks
) -> Selfwhere
    PINS: Pins<USART>,

Configures the serial interface and creates the interface struct.

Bps is the baud rate of the interface.

Clocks passes information about the current frequencies of the clocks. The existence of the struct ensures that the clock settings are fixed.

The serial struct takes ownership over the USARTX device registers and the specified PINS

MAPR and APBX are register handles which are passed for configuration. (MAPR is used to map the USART to the corresponding pins. APBX is used to reset the USART.)

pub fn reconfigure(
    &mut self,
    config: impl Into<Config>,
    clocks: &Clocks
) -> Result<(), Infallible>

Reconfigure the USART instance.

If a transmission is currently in progress, this returns nb::Error::WouldBlock.

pub fn release(self) -> (USART, PINS)

Returns ownership of the borrowed register handles

Examples

Basic usage:

let mut serial = Serial::new(usart, (tx_pin, rx_pin), &mut afio.mapr, 9600.bps(), &clocks);

// You can split the `Serial`
let Serial { tx, rx, token } = serial;

// You can reunite the `Serial` back
let serial = Serial { tx, rx, token };

// Release `Serial`
let (usart, (tx_pin, rx_pin)) = serial.release();

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

Separates the serial struct into separate channel objects for sending (Tx) and receiving (Rx)

If in the future it will be necessary to free up resources, then you need to use a different method of separation:

let Serial { tx, rx, token } = serial;

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

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

Starts listening to the USART by enabling the Received data ready to be read (RXNE) interrupt and Transmit data register empty (TXE) interrupt

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

Stops listening to the USART by disabling the Received data ready to be read (RXNE) interrupt and Transmit data register empty (TXE) interrupt

pub fn is_idle(&self) -> bool

Returns true if the line idle status is set

pub fn is_tx_empty(&self) -> bool

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

pub fn is_rx_not_empty(&self) -> bool

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

pub fn clear_idle_interrupt(&self)

Clear idle line interrupt flag

Trait Implementations

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

type Error = Error

Read error

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

Reads a single word from the serial interface

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

type Error = Error

Read error

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

Reads a single word from the serial interface

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

type Error = Infallible

Write error

fn write(&mut self, word: u16) -> Result<(), Self::Error>

Writes a single word to the serial interface

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

Ensures that none of the previously written words are still buffered

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

type Error = Infallible

The type of error that can occur when writing

fn bwrite_all(&mut self, buffer: &[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>

type Error = Infallible

Write error

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

Writes a single word to the serial interface

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

Ensures that none of the previously written words are still buffered

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

type Error = Infallible

The type of error that can occur when writing

fn bwrite_all(&mut self, buffer: &[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.