Struct serpente::sercom::v2::uart::Pads

pub struct Pads<S, RX = NoneT, TX = NoneT, RTS = NoneT, CTS = NoneT> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    S: Sercom,  { /* fields omitted */ }

Container for a set of SERCOM Pads

See the module-level documentation for more details on specifying a Pads type and creating instances.

Implementations

impl<S, RX, TX, RTS, CTS> Pads<S, RX, TX, RTS, CTS> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    S: Sercom, 

pub fn free(self) -> (RX, TX, RTS, CTS)

Consume the Pads and return each individual Pad

impl<S, RX, TX, RTS, CTS> Pads<S, RX, TX, RTS, CTS> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    S: Sercom, 

pub fn rx<I>(
    self,
    pin: impl AnyPin<Id = I>
) -> Pads<S, Pin<I, <I as GetPad<S>>::PinMode>, TX, RTS, CTS> where
    I: GetPad<S>,
    Pin<I, <I as GetPad<S>>::PinMode>: IsPad, 

Set the RX Pad

pub fn tx<I>(
    self,
    pin: impl AnyPin<Id = I>
) -> Pads<S, RX, Pin<I, <I as GetPad<S>>::PinMode>, RTS, CTS> where
    I: GetPad<S>,
    Pin<I, <I as GetPad<S>>::PinMode>: IsPad, 

Set the TX Pad

pub fn rts<I>(
    self,
    pin: impl AnyPin<Id = I>
) -> Pads<S, RX, TX, Pin<I, <I as GetPad<S>>::PinMode>, CTS> where
    I: GetPad<S>,
    Pin<I, <I as GetPad<S>>::PinMode>: IsPad, 

Set the RTS Pad

pub fn cts<I>(
    self,
    pin: impl AnyPin<Id = I>
) -> Pads<S, RX, TX, RTS, Pin<I, <I as GetPad<S>>::PinMode>> where
    I: GetPad<S>,
    Pin<I, <I as GetPad<S>>::PinMode>: IsPad, 

Set the CTS Pad

Trait Implementations

impl<S> Default for Pads<S, NoneT, NoneT, NoneT, NoneT> where
    S: Sercom, 

pub fn default() -> Pads<S, NoneT, NoneT, NoneT, NoneT>

Returns the “default value” for a type.

impl<S, RX, TX, RTS, CTS> PadSet for Pads<S, RX, TX, RTS, CTS> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    S: Sercom, 

type Sercom = S

type Rx = RX

type Tx = TX

type Rts = RTS

type Cts = CTS

impl<S, RX, TX, RTS, CTS> RxpoTxpo for Pads<S, RX, TX, RTS, CTS> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    S: Sercom,
    (<RX as OptionalPad>::PadNum, <TX as OptionalPad>::PadNum, <RTS as OptionalPad>::PadNum, <CTS as OptionalPad>::PadNum): RxpoTxpo, 

Lift the implementations of RxpoTxpo from four-tuples of OptionalPadNums to the corresponding Pads types.

pub const RXPO: u8

RXPO field value

pub const TXPO: u8

RXPO field value

impl<S, RX, RTS> ValidPads for Pads<S, RX, NoneT, RTS, NoneT> where
    RX: SomePad,
    RTS: OptionalPad,
    S: Sercom,
    Pads<S, RX, NoneT, RTS, NoneT>: PadSet,
    Pads<S, RX, NoneT, RTS, NoneT>: RxpoTxpo, 

type Capability = Rx

impl<S, RX, TX, RTS, CTS> ValidPads for Pads<S, RX, TX, RTS, CTS> where
    RX: SomePad,
    TX: SomePad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    S: Sercom,
    Pads<S, RX, TX, RTS, CTS>: PadSet,
    Pads<S, RX, TX, RTS, CTS>: RxpoTxpo, 

type Capability = Duplex

impl<S, TX, CTS> ValidPads for Pads<S, NoneT, TX, NoneT, CTS> where
    TX: SomePad,
    CTS: OptionalPad,
    S: Sercom,
    Pads<S, NoneT, TX, NoneT, CTS>: PadSet,
    Pads<S, NoneT, TX, NoneT, CTS>: RxpoTxpo, 

type Capability = Tx