Struct Serial

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

Serial abstraction

Implementations

impl<UART: Instance, WORD> Serial<UART, WORD>

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

where NoPin: Into<UART::Rx<PushPull>>,

impl<UART: Instance, WORD> Serial<UART, WORD>

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

where NoPin: Into<UART::Tx<PushPull>>,

impl<Serial_: Instance> Serial<Serial_>

pub fn use_dma<TX_STREAM, const TX_CH: u8, RX_STREAM, const RX_CH: u8>( self, tx_stream: TX_STREAM, rx_stream: RX_STREAM, ) -> SerialDma<Serial_, TxDMA<Serial_, TX_STREAM, TX_CH>, RxDMA<Serial_, RX_STREAM, RX_CH>>

where TX_STREAM: Stream, ChannelX<TX_CH>: Channel, Tx<Serial_>: DMASet<TX_STREAM, TX_CH, MemoryToPeripheral>, RX_STREAM: Stream, ChannelX<RX_CH>: Channel, Rx<Serial_>: DMASet<RX_STREAM, RX_CH, PeripheralToMemory>,

Converts blocking Serial to non-blocking SerialDma that use tx_stream and rx_stream to send/receive data

pub fn use_dma_tx<TX_STREAM, const TX_CH: u8>( self, tx_stream: TX_STREAM, ) -> SerialDma<Serial_, TxDMA<Serial_, TX_STREAM, TX_CH>, NoDMA>

where TX_STREAM: Stream, ChannelX<TX_CH>: Channel, Tx<Serial_>: DMASet<TX_STREAM, TX_CH, MemoryToPeripheral>,

Converts blocking Serial to non-blocking SerialDma that use tx_stream to only send data

pub fn use_dma_rx<RX_STREAM, const RX_CH: u8>( self, rx_stream: RX_STREAM, ) -> SerialDma<Serial_, NoDMA, RxDMA<Serial_, RX_STREAM, RX_CH>>

where RX_STREAM: Stream, ChannelX<RX_CH>: Channel, Rx<Serial_>: DMASet<RX_STREAM, RX_CH, PeripheralToMemory>,

Converts blocking Serial to non-blocking SerialDma that use rx_stream to only receive data

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

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

impl<UART: CommonPins, WORD> Serial<UART, WORD>

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

pub fn release(self) -> (UART, (UART::Tx<PushPull>, UART::Rx<PushPull>))

impl<UART: Instance> Serial<UART, u8>

pub fn with_u16_data(self) -> Serial<UART, 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<UART: Instance> Serial<UART, u16>

pub fn with_u8_data(self) -> Serial<UART, 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<UART: Instance, WORD> AsMut<Rx<UART, WORD>> for Serial<UART, WORD>

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

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

impl<UART: Instance, WORD> AsMut<Tx<UART, WORD>> for Serial<UART, WORD>

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

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

impl<UART: Instance, WORD> AsRef<Rx<UART, WORD>> for Serial<UART, WORD>

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

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

impl<UART: Instance, WORD> AsRef<Tx<UART, WORD>> for Serial<UART, WORD>

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

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

impl<UART: Instance, WORD> ClearFlags for Serial<UART, WORD>

type Flag = CFlag

Enum of manually clearable flags

fn clear_flags(&mut self, flags: impl Into<BitFlags<Self::Flag>>)

Clear interrupts flags with Self::Flagss

fn clear_all_flags(&mut self)

Clears all interrupts flags

impl<USART: Instance, WORD> ErrorType for Serial<USART, WORD>

type Error = Error

Error type

impl<USART: Instance, WORD> ErrorType for Serial<USART, WORD>

type Error = Error

Error type of all the IO operations on this type.

impl<UART: Instance, WORD> Listen for Serial<UART, WORD>

type Event = Event

Enum of bit flags associated with events

fn listen(&mut self, event: impl Into<BitFlags<Event>>)

Start listening for Events

fn listen_only(&mut self, event: impl Into<BitFlags<Self::Event>>)

Start listening for Events, stop all other

fn unlisten(&mut self, event: impl Into<BitFlags<Event>>)

Stop listening for Events

fn listen_all(&mut self)

Start listening all Events

fn unlisten_all(&mut self)

Stop listening all Events

impl<USART: Instance, WORD: Copy> Read<WORD> for Serial<USART, WORD>

where Rx<USART, WORD>: Read<WORD, Error = Error>,

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

Reads a single word from the serial interface

impl<UART: Instance, WORD> ReadFlags for Serial<UART, WORD>

type Flag = Flag

Enum of bit flags

fn flags(&self) -> BitFlags<Self::Flag>

Get all interrupts flags a once.

impl<UART: Instance, WORD> RxISR for Serial<UART, WORD>

where Rx<UART, WORD>: RxISR,

fn clear_idle_interrupt(&self)

This clears Idle, Overrun, Noise, FrameError and ParityError flags

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)

impl<UART: Instance, WORD> TxISR for Serial<UART, WORD>

where Tx<UART, WORD>: TxISR,

fn is_tx_empty(&self) -> bool

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

impl<USART: Instance, WORD: Copy> Write<WORD> for Serial<USART, WORD>

where Tx<USART, WORD>: Write<WORD, Error = 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<UART: Instance> Write for Serial<UART>

where Tx<UART>: Write,

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

where Tx<USART, u8>: 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> Write<u16> for Serial<USART, u16>

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

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: Instance> Write<u8> for Serial<USART, u8>

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

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

impl<USART: Instance, WORD> Read<WORD> for Serial<USART, WORD>

where Rx<USART, WORD>: Read<WORD, Error = Error>,

type Error = Error

Read error

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

Reads a single word from the serial interface

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

where 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