Struct atsamd_hal::sercom::spi::Pads

pub struct Pads<S, I, DI = NoneT, DO = NoneT, CK = NoneT, SS = NoneT>where
    S: Sercom,
    I: IoSet,
    DI: OptionalPad,
    DO: OptionalPad,
    CK: OptionalPad,
    SS: OptionalPad,{ /* private fields */ }

Expand description

Container for a set of SERCOM pads

See the spi module documentation for more details on declaring and instantiating a Pads type.

Implementations

Set the DI pad

Set the DO pad

Set the SCK pad, which is always Pad1

Set the SS pad, which is always Pad2

Consume the Pads and return each individual Pin

Trait Implementations

Returns the “default value” for a type. Read more

Lift the implementations of DipoDopo from implementations on OptionalPadNums to the corresponding Pads types.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Should always be Self

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Struct atsamd_hal::sercom::spi::Pads

Implementations

impl<S, I, DI, DO, CK, SS> Pads<S, I, DI, DO, CK, SS>where S: Sercom, I: IoSet, DI: OptionalPad, DO: OptionalPad, CK: OptionalPad, SS: OptionalPad,

pub fn data_in<Id>( self, pin: impl AnyPin<Id = Id>) -> Pads<S, I, Pad<S, Id>, DO, CK, SS>where Id: GetPad<S>, Id::PadNum: Dipo, Pad<S, Id>: InIoSet<I>,

pub fn data_out<Id>( self, pin: impl AnyPin<Id = Id>) -> Pads<S, I, DI, Pad<S, Id>, CK, SS>where Id: GetPad<S>, Id::PadNum: Dopo, Pad<S, Id>: InIoSet<I>,

pub fn sclk<Id>( self, pin: impl AnyPin<Id = Id>) -> Pads<S, I, DI, DO, Pad<S, Id>, SS>where Id: GetPad<S, PadNum = Pad1>, Pad<S, Id>: InIoSet<I>,

pub fn ss<Id>( self, pin: impl AnyPin<Id = Id>) -> Pads<S, I, DI, DO, CK, Pad<S, Id>>where Id: GetPad<S, PadNum = Pad2>, Pad<S, Id>: InIoSet<I>,

pub fn free(self) -> (DI, DO, CK, SS)

Trait Implementations

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

fn default() -> Self

impl<S, I, DI, DO, CK, SS> DipoDopo for Pads<S, I, DI, DO, CK, SS>where S: Sercom, I: IoSet, DI: OptionalPad, DO: OptionalPad, CK: OptionalPad, SS: OptionalPad, DI::PadNum: Dipo, DO::PadNum: Dopo,

const DIPO_DOPO: (u8, u8) = _

impl<S, I, DI, DO, CK, SS> PadSet for Pads<S, I, DI, DO, CK, SS>where S: Sercom, I: IoSet, DI: OptionalPad, DO: OptionalPad, CK: OptionalPad, SS: OptionalPad,

type Sercom = S

type IoSet = I

type DataIn = DI

type DataOut = DO

type Sclk = CK

type SS = SS

impl<S, I, DI, DO, CK, SS> ValidPads for Pads<S, I, DI, DO, CK, SS>where S: Sercom, I: IoSet, DI: SomePad, DO: SomePad, CK: SomePad, SS: OptionalPad, Pads<S, I, DI, DO, CK, SS>: DipoDopo,

type Capability = Duplex

impl<S, I, DI, CK, SS> ValidPads for Pads<S, I, DI, NoneT, CK, SS>where S: Sercom, I: IoSet, DI: SomePad, CK: SomePad, SS: OptionalPad, Pads<S, I, DI, NoneT, CK, SS>: DipoDopo,

type Capability = Rx

impl<S, I, DO, CK, SS> ValidPads for Pads<S, I, NoneT, DO, CK, SS>where S: Sercom, I: IoSet, DO: SomePad, CK: SomePad, SS: OptionalPad, Pads<S, I, NoneT, DO, CK, SS>: DipoDopo,

type Capability = Tx

Auto Trait Implementations

impl<S, I, DI, DO, CK, SS> RefUnwindSafe for Pads<S, I, DI, DO, CK, SS>where CK: RefUnwindSafe, DI: RefUnwindSafe, DO: RefUnwindSafe, I: RefUnwindSafe, S: RefUnwindSafe, SS: RefUnwindSafe,

impl<S, I, DI, DO, CK, SS> Send for Pads<S, I, DI, DO, CK, SS>where CK: Send, DI: Send, DO: Send, I: Send, S: Send, SS: Send,

impl<S, I, DI, DO, CK, SS> Sync for Pads<S, I, DI, DO, CK, SS>where CK: Sync, DI: Sync, DO: Sync, I: Sync, S: Sync, SS: Sync,

impl<S, I, DI, DO, CK, SS> Unpin for Pads<S, I, DI, DO, CK, SS>where CK: Unpin, DI: Unpin, DO: Unpin, I: Unpin, S: Unpin, SS: Unpin,

impl<S, I, DI, DO, CK, SS> UnwindSafe for Pads<S, I, DI, DO, CK, SS>where CK: UnwindSafe, DI: UnwindSafe, DO: UnwindSafe, I: UnwindSafe, S: UnwindSafe, SS: UnwindSafe,

Blanket Implementations

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Same<T> for T

type Output = T

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<S, I, DI, DO, CK, SS> Pads<S, I, DI, DO, CK, SS>where
S: Sercom,
I: IoSet,
DI: OptionalPad,
DO: OptionalPad,
CK: OptionalPad,
SS: OptionalPad,

pub fn data_in<Id>(
self,
pin: impl AnyPin<Id = Id>
) -> Pads<S, I, Pad<S, Id>, DO, CK, SS>where
Id: GetPad<S>,
Id::PadNum: Dipo,
Pad<S, Id>: InIoSet<I>,

pub fn data_out<Id>(
self,
pin: impl AnyPin<Id = Id>
) -> Pads<S, I, DI, Pad<S, Id>, CK, SS>where
Id: GetPad<S>,
Id::PadNum: Dopo,
Pad<S, Id>: InIoSet<I>,

pub fn sclk<Id>(
self,
pin: impl AnyPin<Id = Id>
) -> Pads<S, I, DI, DO, Pad<S, Id>, SS>where
Id: GetPad<S, PadNum = Pad1>,
Pad<S, Id>: InIoSet<I>,

pub fn ss<Id>(
self,
pin: impl AnyPin<Id = Id>
) -> Pads<S, I, DI, DO, CK, Pad<S, Id>>where
Id: GetPad<S, PadNum = Pad2>,
Pad<S, Id>: InIoSet<I>,

impl<S, I, DI, DO, CK, SS> DipoDopo for Pads<S, I, DI, DO, CK, SS>where
S: Sercom,
I: IoSet,
DI: OptionalPad,
DO: OptionalPad,
CK: OptionalPad,
SS: OptionalPad,
DI::PadNum: Dipo,
DO::PadNum: Dopo,

impl<S, I, DI, DO, CK, SS> PadSet for Pads<S, I, DI, DO, CK, SS>where
S: Sercom,
I: IoSet,
DI: OptionalPad,
DO: OptionalPad,
CK: OptionalPad,
SS: OptionalPad,

impl<S, I, DI, DO, CK, SS> ValidPads for Pads<S, I, DI, DO, CK, SS>where
S: Sercom,
I: IoSet,
DI: SomePad,
DO: SomePad,
CK: SomePad,
SS: OptionalPad,
Pads<S, I, DI, DO, CK, SS>: DipoDopo,

impl<S, I, DI, CK, SS> ValidPads for Pads<S, I, DI, NoneT, CK, SS>where
S: Sercom,
I: IoSet,
DI: SomePad,
CK: SomePad,
SS: OptionalPad,
Pads<S, I, DI, NoneT, CK, SS>: DipoDopo,

impl<S, I, DO, CK, SS> ValidPads for Pads<S, I, NoneT, DO, CK, SS>where
S: Sercom,
I: IoSet,
DO: SomePad,
CK: SomePad,
SS: OptionalPad,
Pads<S, I, NoneT, DO, CK, SS>: DipoDopo,

impl<S, I, DI, DO, CK, SS> RefUnwindSafe for Pads<S, I, DI, DO, CK, SS>where
CK: RefUnwindSafe,
DI: RefUnwindSafe,
DO: RefUnwindSafe,
I: RefUnwindSafe,
S: RefUnwindSafe,
SS: RefUnwindSafe,

impl<S, I, DI, DO, CK, SS> Send for Pads<S, I, DI, DO, CK, SS>where
CK: Send,
DI: Send,
DO: Send,
I: Send,
S: Send,
SS: Send,

impl<S, I, DI, DO, CK, SS> Sync for Pads<S, I, DI, DO, CK, SS>where
CK: Sync,
DI: Sync,
DO: Sync,
I: Sync,
S: Sync,
SS: Sync,

impl<S, I, DI, DO, CK, SS> Unpin for Pads<S, I, DI, DO, CK, SS>where
CK: Unpin,
DI: Unpin,
DO: Unpin,
I: Unpin,
S: Unpin,
SS: Unpin,

impl<S, I, DI, DO, CK, SS> UnwindSafe for Pads<S, I, DI, DO, CK, SS>where
CK: UnwindSafe,
DI: UnwindSafe,
DO: UnwindSafe,
I: UnwindSafe,
S: UnwindSafe,
SS: UnwindSafe,

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,