Struct atsamd_hal::gpio::pin::Pin

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

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

Implementations

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

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

Convert the pin to the requested PinMode

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

Disable the pin and set it to float

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

Disable the pin and set it to pull down

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

Disable the pin and set it to pull up

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

Configure the pin to operate as a floating input

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

Configure the pin to operate as a pulled down input

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

Configure the pin to operate as a pulled up input

pub fn into_floating_interrupt(self) -> Pin<I, FloatingInterrupt>

Configure the pin to operate as a floating interrupt

pub fn into_pull_down_interrupt(self) -> Pin<I, PullDownInterrupt>

Configure the pin to operate as a pulled down interrupt

pub fn into_pull_up_interrupt(self) -> Pin<I, PullUpInterrupt>

Configure the pin to operate as a pulled up interrupt

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

Configure the pin to operate as a push-pull output

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

Configure the pin to operate as a readable push pull output

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

Configure the pin to operate as the corresponding peripheral function.

The type C indicates the desired peripheral function.

pub fn get_drive_strength(&self) -> bool

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
    I: PinId,
    M: PinMode,

type Id = I

PinId of the corresponding Pin

type Mode = M

PinMode of the corresponding Pin

impl Channel<ADC> for Pin<PA02, AlternateB>

type ID = u8

Channel ID type

fn channel() -> u8

Get the specific ID that identifies this channel, for example 0_u8 for the first ADC channel, if Self::ID is u8.

impl Channel<ADC> for Pin<PA04, AlternateB>

type ID = u8

Channel ID type

fn channel() -> u8

Get the specific ID that identifies this channel, for example 0_u8 for the first ADC channel, if Self::ID is u8.

impl Channel<ADC> for Pin<PA05, AlternateB>

type ID = u8

Channel ID type

fn channel() -> u8

Get the specific ID that identifies this channel, for example 0_u8 for the first ADC channel, if Self::ID is u8.

impl Channel<ADC> for Pin<PA14, AlternateB>

type ID = u8

Channel ID type

fn channel() -> u8

Get the specific ID that identifies this channel, for example 0_u8 for the first ADC channel, if Self::ID is u8.

impl Channel<ADC> for Pin<PA15, AlternateB>

type ID = u8

Channel ID type

fn channel() -> u8

Get the specific ID that identifies this channel, for example 0_u8 for the first ADC channel, if Self::ID is u8.

impl<M: PinMode> EicPin for Pin<PA02, M>

type Floating = ExtInt2<Pin<PA02, Interrupt<Floating>>>

type PullUp = ExtInt2<Pin<PA02, Interrupt<PullUp>>>

type PullDown = ExtInt2<Pin<PA02, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> EicPin for Pin<PA04, M>

type Floating = ExtInt4<Pin<PA04, Interrupt<Floating>>>

type PullUp = ExtInt4<Pin<PA04, Interrupt<PullUp>>>

type PullDown = ExtInt4<Pin<PA04, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> EicPin for Pin<PA05, M>

type Floating = ExtInt5<Pin<PA05, Interrupt<Floating>>>

type PullUp = ExtInt5<Pin<PA05, Interrupt<PullUp>>>

type PullDown = ExtInt5<Pin<PA05, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> EicPin for Pin<PA08, M>

type Floating = ExtInt6<Pin<PA08, Interrupt<Floating>>>

type PullUp = ExtInt6<Pin<PA08, Interrupt<PullUp>>>

type PullDown = ExtInt6<Pin<PA08, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> EicPin for Pin<PA09, M>

type Floating = ExtInt7<Pin<PA09, Interrupt<Floating>>>

type PullUp = ExtInt7<Pin<PA09, Interrupt<PullUp>>>

type PullDown = ExtInt7<Pin<PA09, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> EicPin for Pin<PA15, M>

type Floating = ExtInt1<Pin<PA15, Interrupt<Floating>>>

type PullUp = ExtInt1<Pin<PA15, Interrupt<PullUp>>>

type PullDown = ExtInt1<Pin<PA15, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> EicPin for Pin<PA24, M>

type Floating = ExtInt4<Pin<PA24, Interrupt<Floating>>>

type PullUp = ExtInt4<Pin<PA24, Interrupt<PullUp>>>

type PullDown = ExtInt4<Pin<PA24, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> EicPin for Pin<PA25, M>

type Floating = ExtInt5<Pin<PA25, Interrupt<Floating>>>

type PullUp = ExtInt5<Pin<PA25, Interrupt<PullUp>>>

type PullDown = ExtInt5<Pin<PA25, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> EicPin for Pin<PA31, M>

type Floating = ExtInt3<Pin<PA31, Interrupt<Floating>>>

type PullUp = ExtInt3<Pin<PA31, Interrupt<PullUp>>>

type PullDown = ExtInt3<Pin<PA31, Interrupt<PullDown>>>

fn into_floating_ei(self) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<M: PinMode> ExternalInterrupt for Pin<PA02, M>

fn id(&self) -> ExternalInterruptID

impl<M: PinMode> ExternalInterrupt for Pin<PA04, M>

fn id(&self) -> ExternalInterruptID

impl<M: PinMode> ExternalInterrupt for Pin<PA05, M>

fn id(&self) -> ExternalInterruptID

impl<M: PinMode> ExternalInterrupt for Pin<PA08, M>

fn id(&self) -> ExternalInterruptID

impl<M: PinMode> ExternalInterrupt for Pin<PA09, M>

fn id(&self) -> ExternalInterruptID

impl<M: PinMode> ExternalInterrupt for Pin<PA15, M>

fn id(&self) -> ExternalInterruptID

impl<M: PinMode> ExternalInterrupt for Pin<PA24, M>

fn id(&self) -> ExternalInterruptID

impl<M: PinMode> ExternalInterrupt for Pin<PA25, M>

fn id(&self) -> ExternalInterruptID

impl<M: PinMode> ExternalInterrupt for Pin<PA31, M>

fn id(&self) -> ExternalInterruptID

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to AlternateC

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to AlternateD

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to AlternateE

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to AlternateF

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to AlternateG

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to FloatingDisabled

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to FloatingInput

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to FloatingInterrupt

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to PullDownDisabled

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to PullDownInput

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to PullDownInterrupt

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to PullUpDisabled

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to PullUpInput

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to PullUpInterrupt

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to PushPullOutput

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

fn from(pin: Pin<I, AlternateB>) -> Self

Convert from AlternateB to ReadableOutput

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to AlternateB

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to AlternateD

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to AlternateE

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to AlternateF

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to AlternateG

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to FloatingDisabled

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to FloatingInput

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to FloatingInterrupt

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to PullDownDisabled

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to PullDownInput

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to PullDownInterrupt

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to PullUpDisabled

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to PullUpInput

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to PullUpInterrupt

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to PushPullOutput

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

fn from(pin: Pin<I, AlternateC>) -> Self

Convert from AlternateC to ReadableOutput

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to AlternateB

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to AlternateC

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to AlternateE

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to AlternateF

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to AlternateG

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to FloatingDisabled

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to FloatingInput

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to FloatingInterrupt

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to PullDownDisabled

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to PullDownInput

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to PullDownInterrupt

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to PullUpDisabled

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to PullUpInput

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to PullUpInterrupt

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to PushPullOutput

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

fn from(pin: Pin<I, AlternateD>) -> Self

Convert from AlternateD to ReadableOutput

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to AlternateB

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to AlternateC

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to AlternateD

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to AlternateF

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to AlternateG

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to FloatingDisabled

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to FloatingInput

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to FloatingInterrupt

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to PullDownDisabled

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to PullDownInput

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to PullDownInterrupt

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to PullUpDisabled

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to PullUpInput

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to PullUpInterrupt

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to PushPullOutput

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

fn from(pin: Pin<I, AlternateE>) -> Self

Convert from AlternateE to ReadableOutput

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to AlternateB

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to AlternateC

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to AlternateD

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to AlternateE

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to AlternateG

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to FloatingDisabled

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to FloatingInput

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to FloatingInterrupt

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to PullDownDisabled

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to PullDownInput

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to PullDownInterrupt

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to PullUpDisabled

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to PullUpInput

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to PullUpInterrupt

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to PushPullOutput

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

fn from(pin: Pin<I, AlternateF>) -> Self

Convert from AlternateF to ReadableOutput

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to AlternateB

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to AlternateC

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to AlternateD

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to AlternateE

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to AlternateF

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to FloatingDisabled

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to FloatingInput

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to FloatingInterrupt

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to PullDownDisabled

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to PullDownInput

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to PullDownInterrupt

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to PullUpDisabled

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to PullUpInput

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to PullUpInterrupt

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to PushPullOutput

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

fn from(pin: Pin<I, AlternateG>) -> Self

Convert from AlternateG to ReadableOutput

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to AlternateB

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to AlternateC

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to AlternateD

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to AlternateE

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to AlternateF

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to AlternateG

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to FloatingInput

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to FloatingInterrupt

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to PullDownDisabled

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to PullDownInput

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to PullDownInterrupt

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to PullUpDisabled

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to PullUpInput

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to PullUpInterrupt

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to PushPullOutput

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

fn from(pin: Pin<I, FloatingDisabled>) -> Self

Convert from FloatingDisabled to ReadableOutput

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to AlternateB

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to AlternateC

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to AlternateD

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to AlternateE

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to AlternateF

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to AlternateG

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to FloatingDisabled

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to FloatingInput

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to FloatingInterrupt

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to PullDownInput

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to PullDownInterrupt

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to PullUpDisabled

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to PullUpInput

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to PullUpInterrupt

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to PushPullOutput

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

fn from(pin: Pin<I, PullDownDisabled>) -> Self

Convert from PullDownDisabled to ReadableOutput

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to AlternateB

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to AlternateC

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to AlternateD

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to AlternateE

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to AlternateF

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to AlternateG

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to FloatingDisabled

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to FloatingInput

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to FloatingInterrupt

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to PullDownDisabled

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to PullDownInput

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to PullDownInterrupt

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to PullUpInput

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to PullUpInterrupt

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to PushPullOutput

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

fn from(pin: Pin<I, PullUpDisabled>) -> Self

Convert from PullUpDisabled to ReadableOutput

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to AlternateB

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to AlternateC

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to AlternateD

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to AlternateE

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to AlternateF

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to AlternateG

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to FloatingDisabled

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to FloatingInterrupt

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to PullDownDisabled

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to PullDownInput

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to PullDownInterrupt

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to PullUpDisabled

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to PullUpInput

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to PullUpInterrupt

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to PushPullOutput

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

fn from(pin: Pin<I, FloatingInput>) -> Self

Convert from FloatingInput to ReadableOutput

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to AlternateB

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to AlternateC

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to AlternateD

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to AlternateE

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to AlternateF

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to AlternateG

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to FloatingDisabled

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to FloatingInput

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to FloatingInterrupt

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to PullDownDisabled

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to PullDownInterrupt

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to PullUpDisabled

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to PullUpInput

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to PullUpInterrupt

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to PushPullOutput

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

fn from(pin: Pin<I, PullDownInput>) -> Self

Convert from PullDownInput to ReadableOutput

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to AlternateB

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to AlternateC

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to AlternateD

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to AlternateE

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to AlternateF

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to AlternateG

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to FloatingDisabled

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to FloatingInput

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to FloatingInterrupt

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to PullDownDisabled

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to PullDownInput

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to PullDownInterrupt

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to PullUpDisabled

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to PullUpInterrupt

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to PushPullOutput

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

fn from(pin: Pin<I, PullUpInput>) -> Self

Convert from PullUpInput to ReadableOutput

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateB>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to AlternateB

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateC>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to AlternateC

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateD>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to AlternateD

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateE>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to AlternateE

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateF>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to AlternateF

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateG>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to AlternateG

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, FloatingDisabled>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to FloatingDisabled

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, FloatingInput>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to FloatingInput

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, PullDownDisabled>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to PullDownDisabled

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, PullDownInput>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to PullDownInput

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, PullDownInterrupt>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to PullDownInterrupt

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, PullUpDisabled>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to PullUpDisabled

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, PullUpInput>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to PullUpInput

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, PullUpInterrupt>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to PullUpInterrupt

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, PushPullOutput>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to PushPullOutput

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, ReadableOutput>where
    I: PinId,

fn from(pin: Pin<I, FloatingInterrupt>) -> Self

Convert from FloatingInterrupt to ReadableOutput

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateB>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to AlternateB

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateC>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to AlternateC

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateD>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to AlternateD

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateE>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to AlternateE

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateF>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to AlternateF

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateG>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to AlternateG

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, FloatingDisabled>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to FloatingDisabled

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, FloatingInput>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to FloatingInput

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, FloatingInterrupt>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to FloatingInterrupt

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, PullDownDisabled>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to PullDownDisabled

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, PullDownInput>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to PullDownInput

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, PullUpDisabled>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to PullUpDisabled

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, PullUpInput>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to PullUpInput

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, PullUpInterrupt>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to PullUpInterrupt

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, PushPullOutput>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to PushPullOutput

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, ReadableOutput>where
    I: PinId,

fn from(pin: Pin<I, PullDownInterrupt>) -> Self

Convert from PullDownInterrupt to ReadableOutput

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateB>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to AlternateB

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateC>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to AlternateC

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateD>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to AlternateD

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateE>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to AlternateE

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateF>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to AlternateF

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateG>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to AlternateG

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, FloatingDisabled>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to FloatingDisabled

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, FloatingInput>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to FloatingInput

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, FloatingInterrupt>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to FloatingInterrupt

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, PullDownDisabled>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to PullDownDisabled

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, PullDownInput>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to PullDownInput

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, PullDownInterrupt>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to PullDownInterrupt

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, PullUpDisabled>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to PullUpDisabled

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, PullUpInput>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to PullUpInput

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, PushPullOutput>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to PushPullOutput

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, ReadableOutput>where
    I: PinId,

fn from(pin: Pin<I, PullUpInterrupt>) -> Self

Convert from PullUpInterrupt to ReadableOutput

impl<I, M> From<Pin<I, M>> for DynPinwhere
    I: PinId,
    M: PinMode,

fn from(_pin: Pin<I, M>) -> Self

Erase the type-level information in a Pin and return a value-level DynPin

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to AlternateB

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to AlternateC

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to AlternateD

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to AlternateE

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to AlternateF

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to AlternateG

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to FloatingDisabled

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to FloatingInput

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to FloatingInterrupt

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to PullDownDisabled

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to PullDownInput

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to PullDownInterrupt

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to PullUpDisabled

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to PullUpInput

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to PullUpInterrupt

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

fn from(pin: Pin<I, PushPullOutput>) -> Self

Convert from PushPullOutput to ReadableOutput

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to AlternateB

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to AlternateC

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to AlternateD

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to AlternateE

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to AlternateF

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to AlternateG

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to FloatingDisabled

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to FloatingInput

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to FloatingInterrupt

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to PullDownDisabled

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to PullDownInput

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to PullDownInterrupt

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to PullUpDisabled

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to PullUpInput

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to PullUpInterrupt

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

fn from(pin: Pin<I, ReadableOutput>) -> Self

Convert from ReadableOutput to PushPullOutput

impl<I, C> InputPin for Pin<I, Input<C>>where
    I: PinId,
    C: InputConfig,

type Error = Infallible

Error type

fn is_high(&self) -> Result<bool, Self::Error>

Is the input pin high?

fn is_low(&self) -> Result<bool, Self::Error>

Is the input pin low?

impl<I, C> InputPin for Pin<I, Interrupt<C>>where
    I: PinId,
    C: InterruptConfig,

type Error = Infallible

Error type

fn is_high(&self) -> Result<bool, Self::Error>

Is the input pin high?

fn is_low(&self) -> Result<bool, Self::Error>

Is the input pin low?

impl<I> InputPin for Pin<I, ReadableOutput>where
    I: PinId,

type Error = Infallible

Error type

fn is_high(&self) -> Result<bool, Self::Error>

Is the input pin high?

fn is_low(&self) -> Result<bool, Self::Error>

Is the input pin low?

impl IsPad for Pin<PA04, Alternate<C>>

type Sercom = SERCOM0

type PadNum = Pad2

impl IsPad for Pin<PA04, Alternate<D>>

type Sercom = SERCOM0

type PadNum = Pad0

impl IsPad for Pin<PA05, Alternate<C>>

type Sercom = SERCOM0

type PadNum = Pad3

impl IsPad for Pin<PA05, Alternate<D>>

type Sercom = SERCOM0

type PadNum = Pad1

impl IsPad for Pin<PA08, Alternate<C>>

type Sercom = SERCOM1

type PadNum = Pad2

impl IsPad for Pin<PA08, Alternate<D>>

type Sercom = SERCOM0

type PadNum = Pad2

impl IsPad for Pin<PA09, Alternate<C>>

type Sercom = SERCOM1

type PadNum = Pad3

impl IsPad for Pin<PA09, Alternate<D>>

type Sercom = SERCOM0

type PadNum = Pad3

impl IsPad for Pin<PA14, Alternate<C>>

type Sercom = SERCOM0

type PadNum = Pad0

impl IsPad for Pin<PA15, Alternate<C>>

type Sercom = SERCOM0

type PadNum = Pad1

impl IsPad for Pin<PA24, Alternate<C>>

type Sercom = SERCOM1

type PadNum = Pad2

impl IsPad for Pin<PA25, Alternate<C>>

type Sercom = SERCOM1

type PadNum = Pad3

impl IsPad for Pin<PA30, Alternate<C>>

type Sercom = SERCOM1

type PadNum = Pad0

impl IsPad for Pin<PA30, Alternate<D>>

type Sercom = SERCOM1

type PadNum = Pad2

impl IsPad for Pin<PA31, Alternate<C>>

type Sercom = SERCOM1

type PadNum = Pad1

impl IsPad for Pin<PA31, Alternate<D>>

type Sercom = SERCOM1

type PadNum = Pad3

impl<I, C> OutputPin for Pin<I, Output<C>>where
    I: PinId,
    C: OutputConfig,

type Error = Infallible

Error type

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

Drives the pin high

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

Drives the pin low

fn set_state(&mut self, state: PinState) -> Result<(), Self::Error>

Drives the pin high or low depending on the provided value

impl<I, C> StatefulOutputPin for Pin<I, Output<C>>where
    I: PinId,
    C: OutputConfig,

fn is_set_high(&self) -> Result<bool, Self::Error>

Is the pin in drive high mode?

fn is_set_low(&self) -> Result<bool, Self::Error>

Is the pin in drive low mode?

impl<I, C> ToggleableOutputPin for Pin<I, Output<C>>where
    I: PinId,
    C: OutputConfig,

type Error = Infallible

Error type

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

Toggle pin output.

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

fn try_from(pin: DynPin) -> Result<Self, 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.

type Error = Error

The type returned in the event of a conversion error.

impl IsI2cPad for Pin<PA14, Alternate<C>>

impl IsI2cPad for Pin<PA15, Alternate<C>>