Struct atsamd_hal::sercom::uart::Uart

pub struct Uart<C, D>where
    C: ValidConfig,
    D: Capability,{ /* private fields */ }

Abstraction over a UART peripheral, allowing to perform UART transactions. The second type parameter, D, denotes what the struct’s Capability is.

• Rx or RxDuplex: Can perform receive transactions
• Tx or TxDuplex: Can perform transmit transactions
• Duplex: Can perform receive and transmit transactions. Additionally, you can call split to return a (Uart<C, RxDuplex>, Uart<C, TxDuplex>) tuple.

Implementations

impl<C, D> Uart<C, D>where
    C: ValidConfig,
    D: Capability,

pub fn read_flags(&self) -> Flags

Read the interrupt flags

pub fn clear_flags(&mut self, flags: Flags)

Clear interrupt status flags

Setting the ERROR, RXBRK, CTSIC, RXS, or TXC flag will clear the interrupts. This function has no effect on the DRE or RXC flags.

Note that only the flags pertinent to Self’s Capability will be cleared. The other flags will be SILENTLY IGNORED.

• Available flags for Receive capability: RXC, RXS, RXBRK and ERROR
• Available flags for Transmit capability: DRE and TXC. Note: The CTSIC flag can only be cleared if a CTS Pad was specified in the Config via the clear_ctsic method.
• Since Duplex Uarts are Receive + Transmit they have all flags available.

Warning: The implementation of of Write::flush waits on and clears the TXC flag. Manually clearing this flag could cause it to hang indefinitely.

pub fn enable_interrupts(&mut self, flags: Flags)

Enable interrupts for the specified flags.

Note that only the flags pertinent to Self’s Capability will be cleared. The other flags will be SILENTLY IGNORED.

• Available flags for Receive capability: RXC, RXS, RXBRK and ERROR
• Available flags for Transmit capability: DRE and TXC. Note: The CTSIC interrupt can only be enabled if a CTS Pad was specified in the Config via the enable_ctsic method.
• Since Duplex Uarts are Receive + Transmit they have all flags available.

pub fn disable_interrupts(&mut self, flags: Flags)

Disable interrupts for the specified flags.

Note that only the flags pertinent to Self’s Capability will be cleared. The other flags will be SILENTLY IGNORED

• Available flags for Receive capability: RXC, RXS, RXBRK and ERROR
• Available flags for Transmit capability: DRE and TXC. Note: The CTSIC interrupt can only be disabled if a CTS Pad was specified in the Config via the disable_ctsic method.
• Since Duplex Uarts are Receive + Transmit they have all flags available.

pub fn read_status(&self) -> Status

Read the status flags

pub fn clear_status(&mut self, status: Status)

Clear the status flags

Note that only the status flags pertinent to Self’s Capability will be cleared. The other stattus flags will be SILENTLY IGNORED.

• Available status flags for Receive capability: PERR, FERR, BUFOVF, ISF and COLL
• Transmit-only Uarts have no clearable status flags.
• Since Duplex Uarts are Receive + Transmit they have all status flags available.

impl<C, D> Uart<C, D>where
    C: ValidConfig,
    <C::Pads as PadSet>::Cts: SomePad,
    D: Transmit,

pub fn clear_ctsic(&mut self)

Clear the CTSIC interrupt flag

pub fn enable_ctsic(&mut self)

Enable the CTSIC interrupt

pub fn disable_ctsic(&mut self)

Disable the CTSIC interrupt

impl<C, D> Uart<C, D>where
    C: ValidConfig,
    D: Simplex,

pub fn disable(self) -> C

Disable the UART peripheral and return the underlying Config

pub fn reconfigure<U>(&mut self, update: U)where
    U: FnOnce(&mut SpecificConfig<C>),

Reconfigure the UART.

Calling this method will temporarily disable the SERCOM peripheral, as some registers are enable-protected. This may interrupt any ongoing transactions.

use atsamd_hal::sercom::uart::{BaudMode, Oversampling, Uart};
uart.reconfigure(|c| c.set_run_in_standby(false));

impl<C> Uart<C, Duplex>where
    C: ValidConfig,

pub fn split(self) -> (Uart<C, RxDuplex>, Uart<C, TxDuplex>)

Split the Uart into RxDuplex and TxDuplex halves

pub fn disable(self) -> C

Disable the UART peripheral and return the underlying Config

pub fn reconfigure<F>(&mut self, update: F)where
    F: FnOnce(&mut SpecificConfig<C>),

Update the UART Configuration.

Calling this method will temporarily disable the SERCOM peripheral, as some registers are enable-protected. This may interrupt any ongoing transactions.

use atsamd_hal::sercom::uart::{BaudMode, Oversampling, Uart};
uart.reconfigure(|c| c.set_run_in_standby(false));

pub fn join(rx: Uart<C, RxDuplex>, _tx: Uart<C, TxDuplex>) -> Self

Join RxDuplex and TxDuplex halves back into a full Uart<C, Duplex>

impl<C, D> Uart<C, D>where
    C: ValidConfig,
    D: Receive,
    DataReg: AsPrimitive<C::Word>,

pub unsafe fn read_data(&mut self) -> DataReg

Read from the DATA register

Safety

Reading from the data register directly is unsafe, because it will clear the RXC flag, which could break assumptions made elsewhere in this module.

pub fn flush_rx_buffer(&mut self)

Flush the RX buffer and clear RX errors.

Note: The datasheet states that disabling the receiver (RXEN) clears the RX buffer, and clears the BUFOVF, PERR and FERR bits. However, in practice, it seems like BUFOVF errors still pop up after a disable/enable cycle of the receiver, then immediately begin reading bytes from the DATA register. Instead, this method uses a workaround, which reads a few bytes to clear the RX buffer (3 bytes seems to be the trick), then manually clear the error bits.

impl<C, D> Uart<C, D>where
    C: ValidConfig,
    D: Transmit,

pub unsafe fn write_data(&mut self, data: DataReg)

Write to the DATA register

Safety

Writing to the data register directly is unsafe, because it will clear the DRE flag, which could break assumptions made elsewhere in this module.

Trait Implementations

impl<C: ValidConfig> AsMut<Uart<C, Duplex>> for (&mut Uart<C, RxDuplex>, &mut Uart<C, TxDuplex>)

fn as_mut(&mut self) -> &mut Uart<C, Duplex>

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

impl<C, D> AsRef<Config<<C as AnyConfig>::Pads, <C as AnyConfig>::CharSize>> for Uart<C, D>where
    C: ValidConfig,
    D: Capability,

fn as_ref(&self) -> &SpecificConfig<C>

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

impl<C, D> Read<<C as AnyConfig>::Word> for Uart<C, D>where
    C: ValidConfig,
    D: Receive,
    DataReg: AsPrimitive<C::Word>,

fn read(&mut self) -> Result<C::Word, Error>

Wait for an RXC flag, then read the word

type Error = Error

Read error

impl<C, D> Write<<C as AnyConfig>::Word> for Uart<C, D>where
    C: ValidConfig,
    D: Transmit,

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

Wait for a DRE flag, then write a word

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

Wait for a TXC flag

type Error = Infallible

Write error

impl<C, D> Default<<C as AnyConfig>::Word> for Uart<C, D>where
    C: ValidConfig,
    D: Transmit,
    Uart<C, D>: Write<C::Word>,