Struct grand_central_m4::sercom::v2::uart::Pads

pub struct Pads<S, I, RX = NoneT, TX = NoneT, RTS = NoneT, CTS = NoneT> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    I: IoSet,
    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, I, RX, TX, RTS, CTS> Pads<S, I, RX, TX, RTS, CTS> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    I: IoSet,
    S: Sercom, 

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

Set the RX Pad

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

Set the TX Pad

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

Set the RTS Pad, which is always Pad2

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

Set the CTS Pad, which is always Pad3

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

Consume the Pads and return each individual Pad

Trait Implementations

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

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

Returns the “default value” for a type.

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

type Sercom = S

type IoSet = I

type Rx = RX

type Tx = TX

type Rts = RTS

type Cts = CTS

impl<S, I, RX, TX, RTS, CTS> Rxpo for Pads<S, I, RX, TX, RTS, CTS> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    I: IoSet,
    S: Sercom,
    <RX as OptionalPad>::PadNum: Rxpo, 

Lift the implementations of Rxpo from OptionalPadNums to the corresponding Pads types.

pub const RXPO: RXPO_A

Corresponding variant from the PAC enum

impl<S, I, RX, TX, RTS, CTS> Txpo for Pads<S, I, RX, TX, RTS, CTS> where
    RX: OptionalPad,
    TX: OptionalPad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    I: IoSet,
    S: Sercom,
    <TX as OptionalPad>::PadNum: Txpo, 

Lift the implementations of Txpo from OptionalPadNums to the corresponding Pads types.

pub const TXPO: TXPO_A

Corresponding variant from the PAC enum

impl<S, I, RX, TX, RTS, CTS> ValidPads for Pads<S, I, RX, TX, RTS, CTS> where
    RX: SomePad,
    TX: SomePad,
    RTS: OptionalPad,
    CTS: OptionalPad,
    I: IoSet,
    S: Sercom,
    Pads<S, I, RX, TX, RTS, CTS>: PadSet,
    Pads<S, I, RX, TX, RTS, CTS>: Rxpo,
    Pads<S, I, RX, TX, RTS, CTS>: Txpo, 

type Capability = Duplex

impl<S, I, TX, CTS> ValidPads for Pads<S, I, NoneT, TX, NoneT, CTS> where
    TX: SomePad,
    CTS: OptionalPad,
    I: IoSet,
    S: Sercom,
    Pads<S, I, NoneT, TX, NoneT, CTS>: PadSet,
    Pads<S, I, NoneT, TX, NoneT, CTS>: Rxpo,
    Pads<S, I, NoneT, TX, NoneT, CTS>: Txpo, 

type Capability = Tx

impl<S, I, RX, RTS> ValidPads for Pads<S, I, RX, NoneT, RTS, NoneT> where
    RX: SomePad,
    RTS: OptionalPad,
    I: IoSet,
    S: Sercom,
    Pads<S, I, RX, NoneT, RTS, NoneT>: PadSet,
    Pads<S, I, RX, NoneT, RTS, NoneT>: Rxpo,
    Pads<S, I, RX, NoneT, RTS, NoneT>: Txpo, 

type Capability = Rx