Struct trellis_m4::gpio::v2::pin::Pin

pub struct Pin<I, M> where
    M: PinMode,
    I: PinId,  { /* fields omitted */ }

A type-level GPIO pin, parameterized by PinId and PinMode types

Implementations

impl<I, M> Pin<I, M> where
    M: PinMode,
    I: PinId, 

pub fn as_any<P>(self) -> P where
    P: AnyPin<Id = I, Mode = M>, 

Convert a Pin to a type that implements AnyPin

Even though there is a one-to-one mapping between Pin<I, M> and AnyPin<Id = I, Mode = M>, the compiler doesn't know that. This method provides a way to convert from a Pin to an AnyPin. See the AnyPin trait for more details.

pub fn as_any_ref<P>(&self) -> &P where
    P: AnyPin<Id = I, Mode = M>, 

Implement as_any for references

pub fn as_any_mut<P>(&mut self) -> &mut P where
    P: AnyPin<Id = I, Mode = M>, 

Implement as_any for mutable references

pub fn into_mode<N>(self) -> Pin<I, N> where
    N: PinMode, 

Convert the pin to the requested PinMode

pub fn into_floating_disabled(self) -> Pin<I, Disabled<Floating>>

Disable the pin and set it to float

pub fn into_pull_down_disabled(self) -> Pin<I, Disabled<PullDown>>

Disable the pin and set it to pull down

pub fn into_pull_up_disabled(self) -> Pin<I, Disabled<PullUp>>

Disable the pin and set it to pull up

pub fn into_floating_input(self) -> Pin<I, Input<Floating>>

Configure the pin to operate as a floating input

pub fn into_pull_down_input(self) -> Pin<I, Input<PullDown>>

Configure the pin to operate as a pulled down input

pub fn into_pull_up_input(self) -> Pin<I, Input<PullUp>>

Configure the pin to operate as a pulled up input

pub fn into_push_pull_output(self) -> Pin<I, Output<PushPull>>

Configure the pin to operate as a push-pull output

pub fn into_readable_output(self) -> Pin<I, Output<Readable>>

Configure the pin to operate as a readable push pull output

pub fn into_alternate<C>(self) -> Pin<I, Alternate<C>> where
    C: AlternateConfig, 

Configure the pin to operate as the corresponding peripheral function.

The type C indicates the desired peripheral function.

pub fn get_drive_strength(&self)

Read the current drive strength of the pin.

The drive strength is reset to normal on every change in pin mode.

pub fn set_drive_strength(&mut self, stronger: bool)

Set the drive strength for the pin.

The drive strength is reset to normal on every change in pin mode.

Trait Implementations

impl<I, M> AnyPin for Pin<I, M> where
    M: PinMode,
    I: PinId, 

type Id = I

PinId of the corresponding Pin

type Mode = M

PinMode of the corresponding Pin

pub fn as_concrete(
    self
) -> Pin<<Pin<I, M> as AnyPin>::Id, <Pin<I, M> as AnyPin>::Mode>

Convert a type that implements AnyPin to a concrete Pin

pub fn as_concrete_ref(
    &self
) -> &Pin<<Pin<I, M> as AnyPin>::Id, <Pin<I, M> as AnyPin>::Mode>

Implement as_concrete for references

pub fn as_concrete_mut(
    &mut self
) -> &mut Pin<<Pin<I, M> as AnyPin>::Id, <Pin<I, M> as AnyPin>::Mode>

Implement as_concrete for mutable references

pub fn into_mode<N>(self) -> Pin<Self::Id, N> where
    N: PinMode, 

Convert the pin to the requested PinMode

pub fn into_floating_disabled(self) -> Pin<Self::Id, Disabled<Floating>>

Disable the pin and set it to float

pub fn into_pull_down_disabled(self) -> Pin<Self::Id, Disabled<PullDown>>

Disable the pin and set it to pull down

pub fn into_pull_up_disabled(self) -> Pin<Self::Id, Disabled<PullUp>>

Disable the pin and set it to pull up

pub fn into_floating_input(self) -> Pin<Self::Id, Input<Floating>>

Configure the pin to operate as a floating input

pub fn into_pull_down_input(self) -> Pin<Self::Id, Input<PullDown>>

Configure the pin to operate as a pulled down input

pub fn into_pull_up_input(self) -> Pin<Self::Id, Input<PullUp>>

Configure the pin to operate as a pulled up input

pub fn into_push_pull_output(self) -> Pin<Self::Id, Output<PushPull>>

Configure the pin to operate as a push-pull output

pub fn into_readable_output(self) -> Pin<Self::Id, Output<Readable>>

Configure the pin to operate as a readable push pull output

pub fn into_alternate<C>(self) -> Pin<Self::Id, Alternate<C>> where
    C: AlternateConfig, 

Configure the pin to operate as the corresponding peripheral function.

pub fn get_drive_strength(&self)

Read the current drive strength of the pin.

pub fn set_drive_strength(&mut self, stronger: bool)

Set the drive strength for the pin.

impl<S, P, M> From<Pad<S, P, M>> for Pin<<M as Map<S, P>>::Id, <M as Map<S, P>>::Mode> where
    P: PadNum,
    M: Map<S, P>,
    S: Sercom, 

pub fn from(
    pad: Pad<S, P, M>
) -> Pin<<M as Map<S, P>>::Id, <M as Map<S, P>>::Mode>

Convert from a Pad to its corresponding Pin.

This transformation is unique for a given Pad.

impl<S, P, M, O> From<Pin<<M as Map<S, P>>::Id, O>> for Pad<S, P, M> where
    P: PadNum,
    M: Map<S, P>,
    S: Sercom,
    O: PinMode,
    Pin<<M as Map<S, P>>::Id, O>: Into<Pin<<M as Map<S, P>>::Id, <M as Map<S, P>>::Mode>>, 

pub fn from(pin: Pin<<M as Map<S, P>>::Id, O>) -> Pad<S, P, M>

Convert from a Pin to its corresponding Pad.

This conversion is not necessarily unique for a given Pin

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateA to PullDownDisabled

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<J>>

Convert from AlternateA to AlternateJ

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Input<PullUp>>

Convert from AlternateA to PullUpInput

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<C>>

Convert from AlternateA to AlternateC

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<F>>

Convert from AlternateA to AlternateF

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Input<Floating>>

Convert from AlternateA to FloatingInput

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<E>>

Convert from AlternateA to AlternateE

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateA to FloatingDisabled

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<B>>

Convert from AlternateA to AlternateB

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Output<Readable>>

Convert from AlternateA to ReadableOutput

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<D>>

Convert from AlternateA to AlternateD

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Output<PushPull>>

Convert from AlternateA to PushPullOutput

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<L>>

Convert from AlternateA to AlternateL

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<M>>

Convert from AlternateA to AlternateM

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<H>>

Convert from AlternateA to AlternateH

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<I>>

Convert from AlternateA to AlternateI

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<N>>

Convert from AlternateA to AlternateN

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Input<PullDown>>

Convert from AlternateA to PullDownInput

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<K>>

Convert from AlternateA to AlternateK

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateA to PullUpDisabled

impl<I> From<Pin<I, Alternate<A>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<A>>) -> Pin<I, Alternate<G>>

Convert from AlternateA to AlternateG

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Output<Readable>>

Convert from AlternateB to ReadableOutput

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<M>>

Convert from AlternateB to AlternateM

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<G>>

Convert from AlternateB to AlternateG

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<D>>

Convert from AlternateB to AlternateD

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<C>>

Convert from AlternateB to AlternateC

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateB to PullUpDisabled

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Input<Floating>>

Convert from AlternateB to FloatingInput

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateB to FloatingDisabled

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Input<PullUp>>

Convert from AlternateB to PullUpInput

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<L>>

Convert from AlternateB to AlternateL

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<N>>

Convert from AlternateB to AlternateN

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Input<PullDown>>

Convert from AlternateB to PullDownInput

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<E>>

Convert from AlternateB to AlternateE

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<J>>

Convert from AlternateB to AlternateJ

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateB to PullDownDisabled

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<K>>

Convert from AlternateB to AlternateK

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<F>>

Convert from AlternateB to AlternateF

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<I>>

Convert from AlternateB to AlternateI

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Output<PushPull>>

Convert from AlternateB to PushPullOutput

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<A>>

Convert from AlternateB to AlternateA

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<B>>) -> Pin<I, Alternate<H>>

Convert from AlternateB to AlternateH

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Input<PullDown>>

Convert from AlternateC to PullDownInput

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<N>>

Convert from AlternateC to AlternateN

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Output<Readable>>

Convert from AlternateC to ReadableOutput

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<B>>

Convert from AlternateC to AlternateB

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<F>>

Convert from AlternateC to AlternateF

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<M>>

Convert from AlternateC to AlternateM

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Input<Floating>>

Convert from AlternateC to FloatingInput

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateC to PullUpDisabled

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateC to FloatingDisabled

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<A>>

Convert from AlternateC to AlternateA

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Input<PullUp>>

Convert from AlternateC to PullUpInput

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<E>>

Convert from AlternateC to AlternateE

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateC to PullDownDisabled

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<I>>

Convert from AlternateC to AlternateI

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<H>>

Convert from AlternateC to AlternateH

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<J>>

Convert from AlternateC to AlternateJ

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<G>>

Convert from AlternateC to AlternateG

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<L>>

Convert from AlternateC to AlternateL

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<K>>

Convert from AlternateC to AlternateK

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Output<PushPull>>

Convert from AlternateC to PushPullOutput

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<C>>) -> Pin<I, Alternate<D>>

Convert from AlternateC to AlternateD

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Input<Floating>>

Convert from AlternateD to FloatingInput

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Input<PullUp>>

Convert from AlternateD to PullUpInput

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateD to PullDownDisabled

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<C>>

Convert from AlternateD to AlternateC

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<G>>

Convert from AlternateD to AlternateG

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<B>>

Convert from AlternateD to AlternateB

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<J>>

Convert from AlternateD to AlternateJ

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<I>>

Convert from AlternateD to AlternateI

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Output<Readable>>

Convert from AlternateD to ReadableOutput

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<H>>

Convert from AlternateD to AlternateH

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Input<PullDown>>

Convert from AlternateD to PullDownInput

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<F>>

Convert from AlternateD to AlternateF

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<A>>

Convert from AlternateD to AlternateA

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateD to FloatingDisabled

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateD to PullUpDisabled

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<K>>

Convert from AlternateD to AlternateK

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Output<PushPull>>

Convert from AlternateD to PushPullOutput

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<N>>

Convert from AlternateD to AlternateN

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<M>>

Convert from AlternateD to AlternateM

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<L>>

Convert from AlternateD to AlternateL

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<D>>) -> Pin<I, Alternate<E>>

Convert from AlternateD to AlternateE

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<C>>

Convert from AlternateE to AlternateC

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Input<Floating>>

Convert from AlternateE to FloatingInput

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<K>>

Convert from AlternateE to AlternateK

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Input<PullDown>>

Convert from AlternateE to PullDownInput

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<A>>

Convert from AlternateE to AlternateA

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<M>>

Convert from AlternateE to AlternateM

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<I>>

Convert from AlternateE to AlternateI

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Input<PullUp>>

Convert from AlternateE to PullUpInput

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<L>>

Convert from AlternateE to AlternateL

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<G>>

Convert from AlternateE to AlternateG

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Output<Readable>>

Convert from AlternateE to ReadableOutput

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<D>>

Convert from AlternateE to AlternateD

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<N>>

Convert from AlternateE to AlternateN

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<J>>

Convert from AlternateE to AlternateJ

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateE to FloatingDisabled

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateE to PullDownDisabled

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Output<PushPull>>

Convert from AlternateE to PushPullOutput

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<B>>

Convert from AlternateE to AlternateB

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateE to PullUpDisabled

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<H>>

Convert from AlternateE to AlternateH

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<E>>) -> Pin<I, Alternate<F>>

Convert from AlternateE to AlternateF

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<I>>

Convert from AlternateF to AlternateI

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<G>>

Convert from AlternateF to AlternateG

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<A>>

Convert from AlternateF to AlternateA

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Output<PushPull>>

Convert from AlternateF to PushPullOutput

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<B>>

Convert from AlternateF to AlternateB

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Output<Readable>>

Convert from AlternateF to ReadableOutput

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateF to PullUpDisabled

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Input<PullDown>>

Convert from AlternateF to PullDownInput

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<H>>

Convert from AlternateF to AlternateH

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateF to PullDownDisabled

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Input<Floating>>

Convert from AlternateF to FloatingInput

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<E>>

Convert from AlternateF to AlternateE

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<N>>

Convert from AlternateF to AlternateN

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<D>>

Convert from AlternateF to AlternateD

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<L>>

Convert from AlternateF to AlternateL

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<C>>

Convert from AlternateF to AlternateC

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<M>>

Convert from AlternateF to AlternateM

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<J>>

Convert from AlternateF to AlternateJ

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Input<PullUp>>

Convert from AlternateF to PullUpInput

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateF to FloatingDisabled

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<F>>) -> Pin<I, Alternate<K>>

Convert from AlternateF to AlternateK

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateG to PullUpDisabled

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<A>>

Convert from AlternateG to AlternateA

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateG to PullDownDisabled

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Output<PushPull>>

Convert from AlternateG to PushPullOutput

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<D>>

Convert from AlternateG to AlternateD

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<H>>

Convert from AlternateG to AlternateH

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Output<Readable>>

Convert from AlternateG to ReadableOutput

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<K>>

Convert from AlternateG to AlternateK

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<C>>

Convert from AlternateG to AlternateC

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Input<PullUp>>

Convert from AlternateG to PullUpInput

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<J>>

Convert from AlternateG to AlternateJ

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<B>>

Convert from AlternateG to AlternateB

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<I>>

Convert from AlternateG to AlternateI

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<L>>

Convert from AlternateG to AlternateL

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Input<Floating>>

Convert from AlternateG to FloatingInput

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<M>>

Convert from AlternateG to AlternateM

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Input<PullDown>>

Convert from AlternateG to PullDownInput

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<F>>

Convert from AlternateG to AlternateF

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateG to FloatingDisabled

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<N>>

Convert from AlternateG to AlternateN

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<G>>) -> Pin<I, Alternate<E>>

Convert from AlternateG to AlternateE

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<E>>

Convert from AlternateH to AlternateE

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Input<PullDown>>

Convert from AlternateH to PullDownInput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<G>>

Convert from AlternateH to AlternateG

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<I>>

Convert from AlternateH to AlternateI

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<F>>

Convert from AlternateH to AlternateF

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateH to PullDownDisabled

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Output<PushPull>>

Convert from AlternateH to PushPullOutput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<J>>

Convert from AlternateH to AlternateJ

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<L>>

Convert from AlternateH to AlternateL

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<B>>

Convert from AlternateH to AlternateB

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateH to PullUpDisabled

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Input<PullUp>>

Convert from AlternateH to PullUpInput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<K>>

Convert from AlternateH to AlternateK

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateH to FloatingDisabled

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Input<Floating>>

Convert from AlternateH to FloatingInput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<C>>

Convert from AlternateH to AlternateC

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Output<Readable>>

Convert from AlternateH to ReadableOutput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<A>>

Convert from AlternateH to AlternateA

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<D>>

Convert from AlternateH to AlternateD

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<M>>

Convert from AlternateH to AlternateM

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<H>>) -> Pin<I, Alternate<N>>

Convert from AlternateH to AlternateN

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Output<PushPull>>

Convert from AlternateI to PushPullOutput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<L>>

Convert from AlternateI to AlternateL

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateI to FloatingDisabled

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateI to PullDownDisabled

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Output<Readable>>

Convert from AlternateI to ReadableOutput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Input<Floating>>

Convert from AlternateI to FloatingInput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<D>>

Convert from AlternateI to AlternateD

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Input<PullUp>>

Convert from AlternateI to PullUpInput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<H>>

Convert from AlternateI to AlternateH

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<J>>

Convert from AlternateI to AlternateJ

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<K>>

Convert from AlternateI to AlternateK

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<A>>

Convert from AlternateI to AlternateA

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Input<PullDown>>

Convert from AlternateI to PullDownInput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<C>>

Convert from AlternateI to AlternateC

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<E>>

Convert from AlternateI to AlternateE

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<G>>

Convert from AlternateI to AlternateG

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateI to PullUpDisabled

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<B>>

Convert from AlternateI to AlternateB

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<M>>

Convert from AlternateI to AlternateM

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<F>>

Convert from AlternateI to AlternateF

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<I>>) -> Pin<I, Alternate<N>>

Convert from AlternateI to AlternateN

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateJ to PullUpDisabled

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<G>>

Convert from AlternateJ to AlternateG

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateJ to PullDownDisabled

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<C>>

Convert from AlternateJ to AlternateC

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<K>>

Convert from AlternateJ to AlternateK

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<A>>

Convert from AlternateJ to AlternateA

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<H>>

Convert from AlternateJ to AlternateH

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Input<PullDown>>

Convert from AlternateJ to PullDownInput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<B>>

Convert from AlternateJ to AlternateB

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Input<PullUp>>

Convert from AlternateJ to PullUpInput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<M>>

Convert from AlternateJ to AlternateM

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<E>>

Convert from AlternateJ to AlternateE

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Output<PushPull>>

Convert from AlternateJ to PushPullOutput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<L>>

Convert from AlternateJ to AlternateL

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Input<Floating>>

Convert from AlternateJ to FloatingInput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Output<Readable>>

Convert from AlternateJ to ReadableOutput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<I>>

Convert from AlternateJ to AlternateI

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<F>>

Convert from AlternateJ to AlternateF

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateJ to FloatingDisabled

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<D>>

Convert from AlternateJ to AlternateD

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<J>>) -> Pin<I, Alternate<N>>

Convert from AlternateJ to AlternateN

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<N>>

Convert from AlternateK to AlternateN

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Input<PullUp>>

Convert from AlternateK to PullUpInput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<C>>

Convert from AlternateK to AlternateC

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateK to PullUpDisabled

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<G>>

Convert from AlternateK to AlternateG

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<M>>

Convert from AlternateK to AlternateM

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<B>>

Convert from AlternateK to AlternateB

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<A>>

Convert from AlternateK to AlternateA

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<F>>

Convert from AlternateK to AlternateF

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Input<PullDown>>

Convert from AlternateK to PullDownInput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<E>>

Convert from AlternateK to AlternateE

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<L>>

Convert from AlternateK to AlternateL

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Output<PushPull>>

Convert from AlternateK to PushPullOutput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateK to PullDownDisabled

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<J>>

Convert from AlternateK to AlternateJ

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Output<Readable>>

Convert from AlternateK to ReadableOutput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Input<Floating>>

Convert from AlternateK to FloatingInput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<D>>

Convert from AlternateK to AlternateD

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<H>>

Convert from AlternateK to AlternateH

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Alternate<I>>

Convert from AlternateK to AlternateI

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<K>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateK to FloatingDisabled

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<J>>

Convert from AlternateL to AlternateJ

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateL to PullUpDisabled

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateL to PullDownDisabled

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<B>>

Convert from AlternateL to AlternateB

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<C>>

Convert from AlternateL to AlternateC

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<G>>

Convert from AlternateL to AlternateG

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Output<Readable>>

Convert from AlternateL to ReadableOutput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<F>>

Convert from AlternateL to AlternateF

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Input<PullDown>>

Convert from AlternateL to PullDownInput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<E>>

Convert from AlternateL to AlternateE

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateL to FloatingDisabled

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Output<PushPull>>

Convert from AlternateL to PushPullOutput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<A>>

Convert from AlternateL to AlternateA

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<K>>

Convert from AlternateL to AlternateK

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Input<PullUp>>

Convert from AlternateL to PullUpInput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<H>>

Convert from AlternateL to AlternateH

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<I>>

Convert from AlternateL to AlternateI

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Input<Floating>>

Convert from AlternateL to FloatingInput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<D>>

Convert from AlternateL to AlternateD

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<M>>

Convert from AlternateL to AlternateM

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<L>>) -> Pin<I, Alternate<N>>

Convert from AlternateL to AlternateN

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<I>>

Convert from AlternateM to AlternateI

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<D>>

Convert from AlternateM to AlternateD

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateM to PullDownDisabled

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<B>>

Convert from AlternateM to AlternateB

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<E>>

Convert from AlternateM to AlternateE

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Input<PullUp>>

Convert from AlternateM to PullUpInput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateM to FloatingDisabled

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Input<Floating>>

Convert from AlternateM to FloatingInput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<L>>

Convert from AlternateM to AlternateL

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Output<PushPull>>

Convert from AlternateM to PushPullOutput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<K>>

Convert from AlternateM to AlternateK

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<A>>

Convert from AlternateM to AlternateA

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<J>>

Convert from AlternateM to AlternateJ

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<C>>

Convert from AlternateM to AlternateC

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<F>>

Convert from AlternateM to AlternateF

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<G>>

Convert from AlternateM to AlternateG

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<N>>

Convert from AlternateM to AlternateN

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Alternate<H>>

Convert from AlternateM to AlternateH

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Output<Readable>>

Convert from AlternateM to ReadableOutput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Input<PullDown>>

Convert from AlternateM to PullDownInput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<M>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateM to PullUpDisabled

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<A>>

Convert from AlternateN to AlternateA

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<M>>

Convert from AlternateN to AlternateM

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<B>>

Convert from AlternateN to AlternateB

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Output<Readable>>

Convert from AlternateN to ReadableOutput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<E>>

Convert from AlternateN to AlternateE

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<L>>

Convert from AlternateN to AlternateL

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<D>>

Convert from AlternateN to AlternateD

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Disabled<PullUp>>

Convert from AlternateN to PullUpDisabled

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<F>>

Convert from AlternateN to AlternateF

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<G>>

Convert from AlternateN to AlternateG

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<K>>

Convert from AlternateN to AlternateK

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<I>>

Convert from AlternateN to AlternateI

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Disabled<PullDown>>

Convert from AlternateN to PullDownDisabled

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<H>>

Convert from AlternateN to AlternateH

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Input<PullDown>>

Convert from AlternateN to PullDownInput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<J>>

Convert from AlternateN to AlternateJ

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Input<Floating>>

Convert from AlternateN to FloatingInput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Alternate<C>>

Convert from AlternateN to AlternateC

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Input<PullUp>>

Convert from AlternateN to PullUpInput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Output<PushPull>>

Convert from AlternateN to PushPullOutput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Alternate<N>>) -> Pin<I, Disabled<Floating>>

Convert from AlternateN to FloatingDisabled

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Output<PushPull>>

Convert from FloatingDisabled to PushPullOutput

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<L>>

Convert from FloatingDisabled to AlternateL

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<H>>

Convert from FloatingDisabled to AlternateH

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<C>>

Convert from FloatingDisabled to AlternateC

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<K>>

Convert from FloatingDisabled to AlternateK

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<E>>

Convert from FloatingDisabled to AlternateE

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<N>>

Convert from FloatingDisabled to AlternateN

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Input<PullDown>>

Convert from FloatingDisabled to PullDownInput

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<B>>

Convert from FloatingDisabled to AlternateB

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Input<PullUp>>

Convert from FloatingDisabled to PullUpInput

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Output<Readable>>

Convert from FloatingDisabled to ReadableOutput

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<F>>

Convert from FloatingDisabled to AlternateF

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<D>>

Convert from FloatingDisabled to AlternateD

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<J>>

Convert from FloatingDisabled to AlternateJ

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<M>>

Convert from FloatingDisabled to AlternateM

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<G>>

Convert from FloatingDisabled to AlternateG

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Input<Floating>>

Convert from FloatingDisabled to FloatingInput

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<A>>

Convert from FloatingDisabled to AlternateA

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Disabled<PullUp>>

Convert from FloatingDisabled to PullUpDisabled

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Disabled<PullDown>>

Convert from FloatingDisabled to PullDownDisabled

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<Floating>>) -> Pin<I, Alternate<I>>

Convert from FloatingDisabled to AlternateI

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<M>>

Convert from PullDownDisabled to AlternateM

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<D>>

Convert from PullDownDisabled to AlternateD

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Output<Readable>>

Convert from PullDownDisabled to ReadableOutput

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<K>>

Convert from PullDownDisabled to AlternateK

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<B>>

Convert from PullDownDisabled to AlternateB

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Disabled<PullUp>>

Convert from PullDownDisabled to PullUpDisabled

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<C>>

Convert from PullDownDisabled to AlternateC

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<G>>

Convert from PullDownDisabled to AlternateG

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Disabled<Floating>>

Convert from PullDownDisabled to FloatingDisabled

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<A>>

Convert from PullDownDisabled to AlternateA

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<J>>

Convert from PullDownDisabled to AlternateJ

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<L>>

Convert from PullDownDisabled to AlternateL

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Output<PushPull>>

Convert from PullDownDisabled to PushPullOutput

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<N>>

Convert from PullDownDisabled to AlternateN

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<E>>

Convert from PullDownDisabled to AlternateE

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<H>>

Convert from PullDownDisabled to AlternateH

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Input<PullUp>>

Convert from PullDownDisabled to PullUpInput

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Input<PullDown>>

Convert from PullDownDisabled to PullDownInput

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<I>>

Convert from PullDownDisabled to AlternateI

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Alternate<F>>

Convert from PullDownDisabled to AlternateF

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullDown>>) -> Pin<I, Input<Floating>>

Convert from PullDownDisabled to FloatingInput

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<F>>

Convert from PullUpDisabled to AlternateF

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<E>>

Convert from PullUpDisabled to AlternateE

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<N>>

Convert from PullUpDisabled to AlternateN

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<J>>

Convert from PullUpDisabled to AlternateJ

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<C>>

Convert from PullUpDisabled to AlternateC

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<I>>

Convert from PullUpDisabled to AlternateI

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<D>>

Convert from PullUpDisabled to AlternateD

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<H>>

Convert from PullUpDisabled to AlternateH

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<B>>

Convert from PullUpDisabled to AlternateB

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Input<PullDown>>

Convert from PullUpDisabled to PullDownInput

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Input<PullUp>>

Convert from PullUpDisabled to PullUpInput

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Disabled<Floating>>

Convert from PullUpDisabled to FloatingDisabled

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Disabled<PullDown>>

Convert from PullUpDisabled to PullDownDisabled

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<G>>

Convert from PullUpDisabled to AlternateG

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<K>>

Convert from PullUpDisabled to AlternateK

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Output<PushPull>>

Convert from PullUpDisabled to PushPullOutput

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<A>>

Convert from PullUpDisabled to AlternateA

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<M>>

Convert from PullUpDisabled to AlternateM

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Output<Readable>>

Convert from PullUpDisabled to ReadableOutput

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Input<Floating>>

Convert from PullUpDisabled to FloatingInput

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Disabled<PullUp>>) -> Pin<I, Alternate<L>>

Convert from PullUpDisabled to AlternateL

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Output<Readable>>

Convert from FloatingInput to ReadableOutput

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Input<PullUp>>

Convert from FloatingInput to PullUpInput

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<G>>

Convert from FloatingInput to AlternateG

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<J>>

Convert from FloatingInput to AlternateJ

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<E>>

Convert from FloatingInput to AlternateE

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<M>>

Convert from FloatingInput to AlternateM

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<L>>

Convert from FloatingInput to AlternateL

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<D>>

Convert from FloatingInput to AlternateD

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<C>>

Convert from FloatingInput to AlternateC

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Input<PullDown>>

Convert from FloatingInput to PullDownInput

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<H>>

Convert from FloatingInput to AlternateH

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Disabled<PullDown>>

Convert from FloatingInput to PullDownDisabled

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<N>>

Convert from FloatingInput to AlternateN

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<A>>

Convert from FloatingInput to AlternateA

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<B>>

Convert from FloatingInput to AlternateB

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<I>>

Convert from FloatingInput to AlternateI

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<K>>

Convert from FloatingInput to AlternateK

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Disabled<PullUp>>

Convert from FloatingInput to PullUpDisabled

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Alternate<F>>

Convert from FloatingInput to AlternateF

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Output<PushPull>>

Convert from FloatingInput to PushPullOutput

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<Floating>>) -> Pin<I, Disabled<Floating>>

Convert from FloatingInput to FloatingDisabled

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<F>>

Convert from PullDownInput to AlternateF

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<I>>

Convert from PullDownInput to AlternateI

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Disabled<Floating>>

Convert from PullDownInput to FloatingDisabled

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<N>>

Convert from PullDownInput to AlternateN

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<C>>

Convert from PullDownInput to AlternateC

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<L>>

Convert from PullDownInput to AlternateL

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Input<PullUp>>

Convert from PullDownInput to PullUpInput

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<E>>

Convert from PullDownInput to AlternateE

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<H>>

Convert from PullDownInput to AlternateH

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Input<Floating>>

Convert from PullDownInput to FloatingInput

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<B>>

Convert from PullDownInput to AlternateB

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Disabled<PullUp>>

Convert from PullDownInput to PullUpDisabled

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Output<PushPull>>

Convert from PullDownInput to PushPullOutput

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<G>>

Convert from PullDownInput to AlternateG

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<K>>

Convert from PullDownInput to AlternateK

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Output<Readable>>

Convert from PullDownInput to ReadableOutput

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<D>>

Convert from PullDownInput to AlternateD

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<A>>

Convert from PullDownInput to AlternateA

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<J>>

Convert from PullDownInput to AlternateJ

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Disabled<PullDown>>

Convert from PullDownInput to PullDownDisabled

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullDown>>) -> Pin<I, Alternate<M>>

Convert from PullDownInput to AlternateM

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Disabled<PullDown>>

Convert from PullUpInput to PullDownDisabled

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Input<Floating>>

Convert from PullUpInput to FloatingInput

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<B>>

Convert from PullUpInput to AlternateB

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Disabled<PullUp>>

Convert from PullUpInput to PullUpDisabled

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<A>>

Convert from PullUpInput to AlternateA

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<E>>

Convert from PullUpInput to AlternateE

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<G>>

Convert from PullUpInput to AlternateG

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<I>>

Convert from PullUpInput to AlternateI

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Output<Readable>>

Convert from PullUpInput to ReadableOutput

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<D>>

Convert from PullUpInput to AlternateD

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Input<PullDown>>

Convert from PullUpInput to PullDownInput

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<J>>

Convert from PullUpInput to AlternateJ

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Disabled<Floating>>

Convert from PullUpInput to FloatingDisabled

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<H>>

Convert from PullUpInput to AlternateH

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<M>>

Convert from PullUpInput to AlternateM

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Output<PushPull>>

Convert from PullUpInput to PushPullOutput

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<N>>

Convert from PullUpInput to AlternateN

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<K>>

Convert from PullUpInput to AlternateK

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<F>>

Convert from PullUpInput to AlternateF

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<L>>

Convert from PullUpInput to AlternateL

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Input<PullUp>>) -> Pin<I, Alternate<C>>

Convert from PullUpInput to AlternateC

impl<I, M> From<Pin<I, M>> for Pin<I, M> where
    M: PinMode,
    I: PinId, 

Convert from a v1::Pin to a v2::Pin

pub fn from(pin: Pin<I, M>) -> Pin<I, M>

Performs the conversion.

impl<I, M> From<Pin<I, M>> for DynPin where
    M: PinMode,
    I: PinId, 

pub fn from(_pin: Pin<I, M>) -> DynPin

Erase the type-level information in a Pin and return a value-level DynPin

impl<I, M> From<Pin<I, M>> for Pin<I, M> where
    M: PinMode,
    I: PinId, 

Convert from a v2::Pin to a v1::Pin

pub fn from(pin: Pin<I, M>) -> Pin<I, M>

Performs the conversion.

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<G>>

Convert from PushPullOutput to AlternateG

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<A>>

Convert from PushPullOutput to AlternateA

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<F>>

Convert from PushPullOutput to AlternateF

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Disabled<PullUp>>

Convert from PushPullOutput to PullUpDisabled

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<J>>

Convert from PushPullOutput to AlternateJ

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Disabled<PullDown>>

Convert from PushPullOutput to PullDownDisabled

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Input<Floating>>

Convert from PushPullOutput to FloatingInput

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<K>>

Convert from PushPullOutput to AlternateK

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<C>>

Convert from PushPullOutput to AlternateC

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<N>>

Convert from PushPullOutput to AlternateN

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<E>>

Convert from PushPullOutput to AlternateE

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<D>>

Convert from PushPullOutput to AlternateD

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<I>>

Convert from PushPullOutput to AlternateI

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<B>>

Convert from PushPullOutput to AlternateB

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<H>>

Convert from PushPullOutput to AlternateH

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Input<PullUp>>

Convert from PushPullOutput to PullUpInput

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<L>>

Convert from PushPullOutput to AlternateL

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Output<Readable>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Output<Readable>>

Convert from PushPullOutput to ReadableOutput

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Input<PullDown>>

Convert from PushPullOutput to PullDownInput

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Alternate<M>>

Convert from PushPullOutput to AlternateM

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<PushPull>>) -> Pin<I, Disabled<Floating>>

Convert from PushPullOutput to FloatingDisabled

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Disabled<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Disabled<PullDown>>

Convert from ReadableOutput to PullDownDisabled

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<I>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<I>>

Convert from ReadableOutput to AlternateI

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<B>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<B>>

Convert from ReadableOutput to AlternateB

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<H>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<H>>

Convert from ReadableOutput to AlternateH

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<M>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<M>>

Convert from ReadableOutput to AlternateM

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Input<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Input<Floating>>

Convert from ReadableOutput to FloatingInput

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<J>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<J>>

Convert from ReadableOutput to AlternateJ

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<A>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<A>>

Convert from ReadableOutput to AlternateA

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<C>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<C>>

Convert from ReadableOutput to AlternateC

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Disabled<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Disabled<PullUp>>

Convert from ReadableOutput to PullUpDisabled

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<K>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<K>>

Convert from ReadableOutput to AlternateK

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<G>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<G>>

Convert from ReadableOutput to AlternateG

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<L>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<L>>

Convert from ReadableOutput to AlternateL

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<E>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<E>>

Convert from ReadableOutput to AlternateE

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Input<PullUp>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Input<PullUp>>

Convert from ReadableOutput to PullUpInput

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<D>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<D>>

Convert from ReadableOutput to AlternateD

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Output<PushPull>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Output<PushPull>>

Convert from ReadableOutput to PushPullOutput

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Disabled<Floating>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Disabled<Floating>>

Convert from ReadableOutput to FloatingDisabled

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<N>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<N>>

Convert from ReadableOutput to AlternateN

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Alternate<F>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Alternate<F>>

Convert from ReadableOutput to AlternateF

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, Input<PullDown>> where
    I: PinId, 

pub fn from(pin: Pin<I, Output<Readable>>) -> Pin<I, Input<PullDown>>

Convert from ReadableOutput to PullDownInput

impl<I, C> InputPin for Pin<I, Input<C>> where
    C: InputConfig,
    I: PinId, 

type Error = Infallible

Error type

pub fn is_high(&self) -> Result<bool, <Pin<I, Input<C>> as InputPin>::Error>

Is the input pin high?

pub fn is_low(&self) -> Result<bool, <Pin<I, Input<C>> as InputPin>::Error>

Is the input pin low?

impl<I> InputPin for Pin<I, Output<Readable>> where
    I: PinId, 

type Error = Infallible

Error type

pub fn is_high(
    &self
) -> Result<bool, <Pin<I, Output<Readable>> as InputPin>::Error>

Is the input pin high?

pub fn is_low(
    &self
) -> Result<bool, <Pin<I, Output<Readable>> as InputPin>::Error>

Is the input pin low?

impl<I, C> OutputPin for Pin<I, Output<C>> where
    C: OutputConfig,
    I: PinId, 

type Error = Infallible

Error type

pub fn set_high(
    &mut self
) -> Result<(), <Pin<I, Output<C>> as OutputPin>::Error>

Drives the pin high

pub fn set_low(&mut self) -> Result<(), <Pin<I, Output<C>> as OutputPin>::Error>

Drives the pin low

impl<I, C> StatefulOutputPin for Pin<I, Output<C>> where
    C: OutputConfig,
    I: PinId, 

pub fn is_set_high(
    &self
) -> Result<bool, <Pin<I, Output<C>> as OutputPin>::Error>

Is the pin in drive high mode?

pub fn is_set_low(
    &self
) -> Result<bool, <Pin<I, Output<C>> as OutputPin>::Error>

Is the pin in drive low mode?

impl<I, C> ToggleableOutputPin for Pin<I, Output<C>> where
    C: OutputConfig,
    I: PinId, 

type Error = Infallible

Error type

pub fn toggle(
    &mut self
) -> Result<(), <Pin<I, Output<C>> as ToggleableOutputPin>::Error>

Toggle pin output.

impl<I, M> TryFrom<DynPin> for Pin<I, M> where
    M: PinMode,
    I: PinId, 

type Error = Error

The type returned in the event of a conversion error.

pub fn try_from(pin: DynPin) -> Result<Pin<I, M>, Error>

Try to recreate a type-level Pin from a value-level DynPin

There is no way for the compiler to know if the conversion will be successful at compile-time. We must verify the conversion at run-time or refuse to perform it.