Struct Serial 

pub struct Serial<USART: Instance, Otype = PushPull, PULL = Floating> {
    pub tx: Tx<USART>,
    pub rx: Rx<USART>,
    pub token: ReleaseToken<USART, (Option<USART::Tx<Otype>>, Option<USART::Rx<PULL>>)>,
}

Serial abstraction

Fields

tx: Tx<USART>

rx: Rx<USART>

token: ReleaseToken<USART, (Option<USART::Tx<Otype>>, Option<USART::Rx<PULL>>)>

Implementations

impl<USART: Instance, Otype> Serial<USART, Otype, Floating>

pub fn tx<const R: u8>( usart: impl Into<Rmp<USART, R>>, tx_pin: impl RInto<USART::Tx<Otype>, R>, config: impl Into<Config>, rcc: &mut Rcc, ) -> Tx<USART>

impl<USART: Instance, PULL: UpMode> Serial<USART, PushPull, PULL>

pub fn rx<const R: u8>( usart: impl Into<Rmp<USART, R>>, rx_pin: impl RInto<USART::Rx<PULL>, R>, config: impl Into<Config>, rcc: &mut Rcc, ) -> Rx<USART>

impl<USART: Instance, Otype, PULL: UpMode> Serial<USART, Otype, PULL>

pub fn new<const R: u8>( usart: impl Into<Rmp<USART, R>>, pins: (impl RInto<USART::Tx<Otype>, R>, impl RInto<USART::Rx<PULL>, R>), config: impl Into<Config>, rcc: &mut Rcc, ) -> Self

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.)

impl<USART: Instance, Otype, PULL> Serial<USART, Otype, PULL>

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

Reconfigure the USART instance.

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

pub fn release( self, ) -> (USART, (Option<USART::Tx<Otype>>, Option<USART::Rx<PULL>>))

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(), &mut rcc);

// 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, Otype, PULL> Serial<USART, Otype, PULL>

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, Otype, PULL> ErrorType for Serial<USART, Otype, PULL>

type Error = Error

Error type

impl<USART: Instance, Otype, PULL> ErrorType for Serial<USART, Otype, PULL>

type Error = Error

Error type of all the IO operations on this type.

impl<USART: Instance, Otype, PULL> Read<u16> for Serial<USART, Otype, PULL>

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

Reads a single word from the serial interface

impl<USART: Instance, Otype, PULL> Read for Serial<USART, Otype, PULL>

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

Reads a single word from the serial interface

impl<USART: Instance, Otype, PULL> Write<u16> for Serial<USART, Otype, PULL>

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, Otype, PULL> Write for Serial<USART, Otype, PULL>

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, Otype, PULL> Write for Serial<USART, Otype, PULL>

where Tx<USART>: Write<Error = Error>,

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

Write a buffer into this writer, returning how many bytes were written.

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

Flush this output stream, blocking until all intermediately buffered contents reach their destination.

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

Write an entire buffer into this writer.

fn write_fmt( &mut self, fmt: Arguments<'_>, ) -> Result<(), WriteFmtError<Self::Error>>

Write a formatted string into this writer, returning any error encountered.

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.

impl<USART: Instance, Otype, PULL> Write<u16> for Serial<USART, Otype, PULL>

type Error = Error

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, Otype, PULL> Write<u8> for Serial<USART, Otype, PULL>

type Error = Error

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, Otype, PULL> Read<u16> for Serial<USART, Otype, PULL>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<USART: Instance, Otype, PULL> Read<u8> for Serial<USART, Otype, PULL>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<USART: Instance, Otype, PULL> Write<u16> for Serial<USART, Otype, PULL>

type Error = Error

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, Otype, PULL> Write<u8> for Serial<USART, Otype, PULL>

type Error = Error

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