Struct Serial

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

Serial abstraction

Implementations

impl<PINS> Serial<USART1, PINS>

pub fn usart1( usart: USART1, pins: PINS, config: Config, clocks: Clocks, ) -> Result<Self, InvalidConfig>

where PINS: Pins<USART1>,

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

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_txe(&self) -> bool

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

pub fn is_rxne(&self) -> bool

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

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

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

impl<PINS> Serial<USART2, PINS>

pub fn usart2( usart: USART2, pins: PINS, config: Config, clocks: Clocks, ) -> Result<Self, InvalidConfig>

where PINS: Pins<USART2>,

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

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_txe(&self) -> bool

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

pub fn is_rxne(&self) -> bool

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

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

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

impl<PINS> Serial<USART6, PINS>

pub fn usart6( usart: USART6, pins: PINS, config: Config, clocks: Clocks, ) -> Result<Self, InvalidConfig>

where PINS: Pins<USART6>,

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

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_txe(&self) -> bool

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

pub fn is_rxne(&self) -> bool

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

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

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

impl<PINS> Serial<USART3, PINS>

pub fn usart3( usart: USART3, pins: PINS, config: Config, clocks: Clocks, ) -> Result<Self, InvalidConfig>

where PINS: Pins<USART3>,

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

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_txe(&self) -> bool

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

pub fn is_rxne(&self) -> bool

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

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

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

impl<PINS> Serial<UART4, PINS>

pub fn uart4( usart: UART4, pins: PINS, config: Config, clocks: Clocks, ) -> Result<Self, InvalidConfig>

where PINS: Pins<UART4>,

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

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_txe(&self) -> bool

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

pub fn is_rxne(&self) -> bool

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

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

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

impl<PINS> Serial<UART5, PINS>

pub fn uart5( usart: UART5, pins: PINS, config: Config, clocks: Clocks, ) -> Result<Self, InvalidConfig>

where PINS: Pins<UART5>,

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

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_txe(&self) -> bool

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

pub fn is_rxne(&self) -> bool

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

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

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

impl<PINS> Serial<UART7, PINS>

pub fn uart7( usart: UART7, pins: PINS, config: Config, clocks: Clocks, ) -> Result<Self, InvalidConfig>

where PINS: Pins<UART7>,

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

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_txe(&self) -> bool

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

pub fn is_rxne(&self) -> bool

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

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

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

impl<PINS> Serial<UART8, PINS>

pub fn uart8( usart: UART8, pins: PINS, config: Config, clocks: Clocks, ) -> Result<Self, InvalidConfig>

where PINS: Pins<UART8>,

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

pub fn is_idle(&self) -> bool

Return true if the line idle status is set

pub fn is_txe(&self) -> bool

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

pub fn is_rxne(&self) -> bool

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

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

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

Trait Implementations

impl<PINS> Read<u8> for Serial<UART4, PINS>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<PINS> Read<u8> for Serial<UART5, PINS>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<PINS> Read<u8> for Serial<UART7, PINS>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<PINS> Read<u8> for Serial<UART8, PINS>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<PINS> Read<u8> for Serial<USART1, PINS>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<PINS> Read<u8> for Serial<USART2, PINS>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<PINS> Read<u8> for Serial<USART3, PINS>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<PINS> Read<u8> for Serial<USART6, PINS>

type Error = Error

Read error

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

Reads a single word from the serial interface

impl<PINS> Write<u8> for Serial<UART4, PINS>

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

Writes a single word to the serial interface

impl<PINS> Write<u8> for Serial<UART5, PINS>

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

Writes a single word to the serial interface

impl<PINS> Write<u8> for Serial<UART7, PINS>

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

Writes a single word to the serial interface

impl<PINS> Write<u8> for Serial<UART8, PINS>

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

Writes a single word to the serial interface

impl<PINS> Write<u8> for Serial<USART1, PINS>

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

Writes a single word to the serial interface

impl<PINS> Write<u8> for Serial<USART2, PINS>

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

Writes a single word to the serial interface

impl<PINS> Write<u8> for Serial<USART3, PINS>

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

Writes a single word to the serial interface

impl<PINS> Write<u8> for Serial<USART6, PINS>

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

Writes a single word to the serial interface