Struct 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 AdcPin<Adc0> for Pin<PA02, AlternateB>

const CHANNEL: u8 = 0u8

impl AdcPin<Adc0> for Pin<PA03, AlternateB>

const CHANNEL: u8 = 1u8

impl AdcPin<Adc0> for Pin<PA04, AlternateB>

const CHANNEL: u8 = 4u8

impl AdcPin<Adc0> for Pin<PA05, AlternateB>

const CHANNEL: u8 = 5u8

impl AdcPin<Adc0> for Pin<PA06, AlternateB>

const CHANNEL: u8 = 6u8

impl AdcPin<Adc0> for Pin<PA07, AlternateB>

const CHANNEL: u8 = 7u8

impl AdcPin<Adc0> for Pin<PA08, AlternateB>

const CHANNEL: u8 = 8u8

impl AdcPin<Adc0> for Pin<PA09, AlternateB>

const CHANNEL: u8 = 9u8

impl AdcPin<Adc0> for Pin<PA10, AlternateB>

const CHANNEL: u8 = 10u8

impl AdcPin<Adc0> for Pin<PA11, AlternateB>

const CHANNEL: u8 = 11u8

impl AdcPin<Adc0> for Pin<PB00, AlternateB>

const CHANNEL: u8 = 12u8

impl AdcPin<Adc0> for Pin<PB01, AlternateB>

const CHANNEL: u8 = 13u8

impl AdcPin<Adc0> for Pin<PB02, AlternateB>

const CHANNEL: u8 = 14u8

impl AdcPin<Adc0> for Pin<PB03, AlternateB>

const CHANNEL: u8 = 15u8

impl AdcPin<Adc0> for Pin<PB08, AlternateB>

const CHANNEL: u8 = 2u8

impl AdcPin<Adc0> for Pin<PB09, AlternateB>

const CHANNEL: u8 = 3u8

impl AdcPin<Adc1> for Pin<PA08, AlternateB>

const CHANNEL: u8 = 2u8

impl AdcPin<Adc1> for Pin<PA09, AlternateB>

const CHANNEL: u8 = 3u8

impl AdcPin<Adc1> for Pin<PB04, AlternateB>

const CHANNEL: u8 = 6u8

impl AdcPin<Adc1> for Pin<PB05, AlternateB>

const CHANNEL: u8 = 7u8

impl AdcPin<Adc1> for Pin<PB06, AlternateB>

const CHANNEL: u8 = 8u8

impl AdcPin<Adc1> for Pin<PB07, AlternateB>

const CHANNEL: u8 = 9u8

impl AdcPin<Adc1> for Pin<PB08, AlternateB>

const CHANNEL: u8 = 0u8

impl AdcPin<Adc1> for Pin<PB09, AlternateB>

const CHANNEL: u8 = 1u8

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<M: PinMode> EicPin for Pin<PA00, M>

type Floating = ExtInt<Pin<PA00, Interrupt<Floating>>, <Pin<PA00, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA00, Interrupt<PullUp>>, <Pin<PA00, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA00, Interrupt<PullDown>>, <Pin<PA00, M> as EicPin>::ChId>

type ChId = Ch0

type InterruptSource = EIC_EXTINT_0

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA01, Interrupt<Floating>>, <Pin<PA01, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA01, Interrupt<PullUp>>, <Pin<PA01, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA01, Interrupt<PullDown>>, <Pin<PA01, M> as EicPin>::ChId>

type ChId = Ch1

type InterruptSource = EIC_EXTINT_1

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA02, Interrupt<Floating>>, <Pin<PA02, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA02, Interrupt<PullUp>>, <Pin<PA02, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA02, Interrupt<PullDown>>, <Pin<PA02, M> as EicPin>::ChId>

type ChId = Ch2

type InterruptSource = EIC_EXTINT_2

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA03, Interrupt<Floating>>, <Pin<PA03, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA03, Interrupt<PullUp>>, <Pin<PA03, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA03, Interrupt<PullDown>>, <Pin<PA03, M> as EicPin>::ChId>

type ChId = Ch3

type InterruptSource = EIC_EXTINT_3

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA04, Interrupt<Floating>>, <Pin<PA04, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA04, Interrupt<PullUp>>, <Pin<PA04, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA04, Interrupt<PullDown>>, <Pin<PA04, M> as EicPin>::ChId>

type ChId = Ch4

type InterruptSource = EIC_EXTINT_4

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA05, Interrupt<Floating>>, <Pin<PA05, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA05, Interrupt<PullUp>>, <Pin<PA05, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA05, Interrupt<PullDown>>, <Pin<PA05, M> as EicPin>::ChId>

type ChId = Ch5

type InterruptSource = EIC_EXTINT_5

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA06, Interrupt<Floating>>, <Pin<PA06, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA06, Interrupt<PullUp>>, <Pin<PA06, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA06, Interrupt<PullDown>>, <Pin<PA06, M> as EicPin>::ChId>

type ChId = Ch6

type InterruptSource = EIC_EXTINT_6

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA07, Interrupt<Floating>>, <Pin<PA07, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA07, Interrupt<PullUp>>, <Pin<PA07, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA07, Interrupt<PullDown>>, <Pin<PA07, M> as EicPin>::ChId>

type ChId = Ch7

type InterruptSource = EIC_EXTINT_7

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA09, Interrupt<Floating>>, <Pin<PA09, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA09, Interrupt<PullUp>>, <Pin<PA09, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA09, Interrupt<PullDown>>, <Pin<PA09, M> as EicPin>::ChId>

type ChId = Ch9

type InterruptSource = EIC_EXTINT_9

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA10, Interrupt<Floating>>, <Pin<PA10, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA10, Interrupt<PullUp>>, <Pin<PA10, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA10, Interrupt<PullDown>>, <Pin<PA10, M> as EicPin>::ChId>

type ChId = Ch10

type InterruptSource = EIC_EXTINT_10

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA11, Interrupt<Floating>>, <Pin<PA11, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA11, Interrupt<PullUp>>, <Pin<PA11, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA11, Interrupt<PullDown>>, <Pin<PA11, M> as EicPin>::ChId>

type ChId = Ch11

type InterruptSource = EIC_EXTINT_11

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA12, Interrupt<Floating>>, <Pin<PA12, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA12, Interrupt<PullUp>>, <Pin<PA12, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA12, Interrupt<PullDown>>, <Pin<PA12, M> as EicPin>::ChId>

type ChId = Ch12

type InterruptSource = EIC_EXTINT_12

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA13, Interrupt<Floating>>, <Pin<PA13, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA13, Interrupt<PullUp>>, <Pin<PA13, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA13, Interrupt<PullDown>>, <Pin<PA13, M> as EicPin>::ChId>

type ChId = Ch13

type InterruptSource = EIC_EXTINT_13

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA14, Interrupt<Floating>>, <Pin<PA14, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA14, Interrupt<PullUp>>, <Pin<PA14, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA14, Interrupt<PullDown>>, <Pin<PA14, M> as EicPin>::ChId>

type ChId = Ch14

type InterruptSource = EIC_EXTINT_14

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA15, Interrupt<Floating>>, <Pin<PA15, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA15, Interrupt<PullUp>>, <Pin<PA15, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA15, Interrupt<PullDown>>, <Pin<PA15, M> as EicPin>::ChId>

type ChId = Ch15

type InterruptSource = EIC_EXTINT_15

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA16, Interrupt<Floating>>, <Pin<PA16, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA16, Interrupt<PullUp>>, <Pin<PA16, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA16, Interrupt<PullDown>>, <Pin<PA16, M> as EicPin>::ChId>

type ChId = Ch0

type InterruptSource = EIC_EXTINT_0

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA17, Interrupt<Floating>>, <Pin<PA17, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA17, Interrupt<PullUp>>, <Pin<PA17, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA17, Interrupt<PullDown>>, <Pin<PA17, M> as EicPin>::ChId>

type ChId = Ch1

type InterruptSource = EIC_EXTINT_1

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA18, Interrupt<Floating>>, <Pin<PA18, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA18, Interrupt<PullUp>>, <Pin<PA18, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA18, Interrupt<PullDown>>, <Pin<PA18, M> as EicPin>::ChId>

type ChId = Ch2

type InterruptSource = EIC_EXTINT_2

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA19, Interrupt<Floating>>, <Pin<PA19, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA19, Interrupt<PullUp>>, <Pin<PA19, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA19, Interrupt<PullDown>>, <Pin<PA19, M> as EicPin>::ChId>

type ChId = Ch3

type InterruptSource = EIC_EXTINT_3

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA20, Interrupt<Floating>>, <Pin<PA20, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA20, Interrupt<PullUp>>, <Pin<PA20, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA20, Interrupt<PullDown>>, <Pin<PA20, M> as EicPin>::ChId>

type ChId = Ch4

type InterruptSource = EIC_EXTINT_4

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA21, Interrupt<Floating>>, <Pin<PA21, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA21, Interrupt<PullUp>>, <Pin<PA21, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA21, Interrupt<PullDown>>, <Pin<PA21, M> as EicPin>::ChId>

type ChId = Ch5

type InterruptSource = EIC_EXTINT_5

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA22, Interrupt<Floating>>, <Pin<PA22, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA22, Interrupt<PullUp>>, <Pin<PA22, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA22, Interrupt<PullDown>>, <Pin<PA22, M> as EicPin>::ChId>

type ChId = Ch6

type InterruptSource = EIC_EXTINT_6

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA23, Interrupt<Floating>>, <Pin<PA23, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA23, Interrupt<PullUp>>, <Pin<PA23, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA23, Interrupt<PullDown>>, <Pin<PA23, M> as EicPin>::ChId>

type ChId = Ch7

type InterruptSource = EIC_EXTINT_7

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA24, Interrupt<Floating>>, <Pin<PA24, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA24, Interrupt<PullUp>>, <Pin<PA24, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA24, Interrupt<PullDown>>, <Pin<PA24, M> as EicPin>::ChId>

type ChId = Ch8

type InterruptSource = EIC_EXTINT_8

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA25, Interrupt<Floating>>, <Pin<PA25, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA25, Interrupt<PullUp>>, <Pin<PA25, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA25, Interrupt<PullDown>>, <Pin<PA25, M> as EicPin>::ChId>

type ChId = Ch9

type InterruptSource = EIC_EXTINT_9

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA27, Interrupt<Floating>>, <Pin<PA27, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA27, Interrupt<PullUp>>, <Pin<PA27, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA27, Interrupt<PullDown>>, <Pin<PA27, M> as EicPin>::ChId>

type ChId = Ch11

type InterruptSource = EIC_EXTINT_11

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA30, Interrupt<Floating>>, <Pin<PA30, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA30, Interrupt<PullUp>>, <Pin<PA30, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA30, Interrupt<PullDown>>, <Pin<PA30, M> as EicPin>::ChId>

type ChId = Ch14

type InterruptSource = EIC_EXTINT_14

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PA31, Interrupt<Floating>>, <Pin<PA31, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PA31, Interrupt<PullUp>>, <Pin<PA31, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PA31, Interrupt<PullDown>>, <Pin<PA31, M> as EicPin>::ChId>

type ChId = Ch15

type InterruptSource = EIC_EXTINT_15

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB00, Interrupt<Floating>>, <Pin<PB00, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB00, Interrupt<PullUp>>, <Pin<PB00, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB00, Interrupt<PullDown>>, <Pin<PB00, M> as EicPin>::ChId>

type ChId = Ch0

type InterruptSource = EIC_EXTINT_0

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB01, Interrupt<Floating>>, <Pin<PB01, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB01, Interrupt<PullUp>>, <Pin<PB01, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB01, Interrupt<PullDown>>, <Pin<PB01, M> as EicPin>::ChId>

type ChId = Ch1

type InterruptSource = EIC_EXTINT_1

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB02, Interrupt<Floating>>, <Pin<PB02, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB02, Interrupt<PullUp>>, <Pin<PB02, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB02, Interrupt<PullDown>>, <Pin<PB02, M> as EicPin>::ChId>

type ChId = Ch2

type InterruptSource = EIC_EXTINT_2

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB03, Interrupt<Floating>>, <Pin<PB03, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB03, Interrupt<PullUp>>, <Pin<PB03, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB03, Interrupt<PullDown>>, <Pin<PB03, M> as EicPin>::ChId>

type ChId = Ch3

type InterruptSource = EIC_EXTINT_3

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB04, Interrupt<Floating>>, <Pin<PB04, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB04, Interrupt<PullUp>>, <Pin<PB04, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB04, Interrupt<PullDown>>, <Pin<PB04, M> as EicPin>::ChId>

type ChId = Ch4

type InterruptSource = EIC_EXTINT_4

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB05, Interrupt<Floating>>, <Pin<PB05, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB05, Interrupt<PullUp>>, <Pin<PB05, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB05, Interrupt<PullDown>>, <Pin<PB05, M> as EicPin>::ChId>

type ChId = Ch5

type InterruptSource = EIC_EXTINT_5

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB06, Interrupt<Floating>>, <Pin<PB06, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB06, Interrupt<PullUp>>, <Pin<PB06, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB06, Interrupt<PullDown>>, <Pin<PB06, M> as EicPin>::ChId>

type ChId = Ch6

type InterruptSource = EIC_EXTINT_6

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB07, Interrupt<Floating>>, <Pin<PB07, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB07, Interrupt<PullUp>>, <Pin<PB07, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB07, Interrupt<PullDown>>, <Pin<PB07, M> as EicPin>::ChId>

type ChId = Ch7

type InterruptSource = EIC_EXTINT_7

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB08, Interrupt<Floating>>, <Pin<PB08, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB08, Interrupt<PullUp>>, <Pin<PB08, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB08, Interrupt<PullDown>>, <Pin<PB08, M> as EicPin>::ChId>

type ChId = Ch8

type InterruptSource = EIC_EXTINT_8

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB09, Interrupt<Floating>>, <Pin<PB09, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB09, Interrupt<PullUp>>, <Pin<PB09, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB09, Interrupt<PullDown>>, <Pin<PB09, M> as EicPin>::ChId>

type ChId = Ch9

type InterruptSource = EIC_EXTINT_9

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB10, Interrupt<Floating>>, <Pin<PB10, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB10, Interrupt<PullUp>>, <Pin<PB10, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB10, Interrupt<PullDown>>, <Pin<PB10, M> as EicPin>::ChId>

type ChId = Ch10

type InterruptSource = EIC_EXTINT_10

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB11, Interrupt<Floating>>, <Pin<PB11, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB11, Interrupt<PullUp>>, <Pin<PB11, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB11, Interrupt<PullDown>>, <Pin<PB11, M> as EicPin>::ChId>

type ChId = Ch11

type InterruptSource = EIC_EXTINT_11

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB12, Interrupt<Floating>>, <Pin<PB12, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB12, Interrupt<PullUp>>, <Pin<PB12, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB12, Interrupt<PullDown>>, <Pin<PB12, M> as EicPin>::ChId>

type ChId = Ch12

type InterruptSource = EIC_EXTINT_12

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB13, Interrupt<Floating>>, <Pin<PB13, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB13, Interrupt<PullUp>>, <Pin<PB13, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB13, Interrupt<PullDown>>, <Pin<PB13, M> as EicPin>::ChId>

type ChId = Ch13

type InterruptSource = EIC_EXTINT_13

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB14, Interrupt<Floating>>, <Pin<PB14, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB14, Interrupt<PullUp>>, <Pin<PB14, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB14, Interrupt<PullDown>>, <Pin<PB14, M> as EicPin>::ChId>

type ChId = Ch14

type InterruptSource = EIC_EXTINT_14

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB15, Interrupt<Floating>>, <Pin<PB15, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB15, Interrupt<PullUp>>, <Pin<PB15, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB15, Interrupt<PullDown>>, <Pin<PB15, M> as EicPin>::ChId>

type ChId = Ch15

type InterruptSource = EIC_EXTINT_15

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB16, Interrupt<Floating>>, <Pin<PB16, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB16, Interrupt<PullUp>>, <Pin<PB16, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB16, Interrupt<PullDown>>, <Pin<PB16, M> as EicPin>::ChId>

type ChId = Ch0

type InterruptSource = EIC_EXTINT_0

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB17, Interrupt<Floating>>, <Pin<PB17, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB17, Interrupt<PullUp>>, <Pin<PB17, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB17, Interrupt<PullDown>>, <Pin<PB17, M> as EicPin>::ChId>

type ChId = Ch1

type InterruptSource = EIC_EXTINT_1

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB22, Interrupt<Floating>>, <Pin<PB22, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB22, Interrupt<PullUp>>, <Pin<PB22, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB22, Interrupt<PullDown>>, <Pin<PB22, M> as EicPin>::ChId>

type ChId = Ch6

type InterruptSource = EIC_EXTINT_6

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB23, Interrupt<Floating>>, <Pin<PB23, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB23, Interrupt<PullUp>>, <Pin<PB23, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB23, Interrupt<PullDown>>, <Pin<PB23, M> as EicPin>::ChId>

type ChId = Ch7

type InterruptSource = EIC_EXTINT_7

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB30, Interrupt<Floating>>, <Pin<PB30, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB30, Interrupt<PullUp>>, <Pin<PB30, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB30, Interrupt<PullDown>>, <Pin<PB30, M> as EicPin>::ChId>

type ChId = Ch14

type InterruptSource = EIC_EXTINT_14

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

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

type Floating = ExtInt<Pin<PB31, Interrupt<Floating>>, <Pin<PB31, M> as EicPin>::ChId>

type PullUp = ExtInt<Pin<PB31, Interrupt<PullUp>>, <Pin<PB31, M> as EicPin>::ChId>

type PullDown = ExtInt<Pin<PB31, Interrupt<PullDown>>, <Pin<PB31, M> as EicPin>::ChId>

type ChId = Ch15

type InterruptSource = EIC_EXTINT_15

fn into_floating_ei(self, channel: Channel<Self::ChId>) -> Self::Floating

Configure a pin as a floating external interrupt

fn into_pull_up_ei(self, channel: Channel<Self::ChId>) -> Self::PullUp

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, channel: Channel<Self::ChId>) -> Self::PullDown

Configure a pin as pulled-down external interrupt

impl<I, M> ErrorType for Pin<I, M>

where I: PinId, M: PinMode,

type Error = Infallible

Error type

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, AlternateH>

where I: PinId,

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

Convert from AlternateB to AlternateH

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateB to AlternateI

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateB to AlternateJ

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateB to AlternateK

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateB to AlternateL

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateB to AlternateM

impl<I> From<Pin<I, Alternate<B>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateB to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from AlternateC to AlternateH

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateC to AlternateI

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateC to AlternateJ

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateC to AlternateK

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateC to AlternateL

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateC to AlternateM

impl<I> From<Pin<I, Alternate<C>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateC to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from AlternateD to AlternateH

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateD to AlternateI

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateD to AlternateJ

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateD to AlternateK

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateD to AlternateL

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateD to AlternateM

impl<I> From<Pin<I, Alternate<D>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateD to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from AlternateE to AlternateH

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateE to AlternateI

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateE to AlternateJ

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateE to AlternateK

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateE to AlternateL

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateE to AlternateM

impl<I> From<Pin<I, Alternate<E>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateE to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from AlternateF to AlternateH

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateF to AlternateI

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateF to AlternateJ

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateF to AlternateK

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateF to AlternateL

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateF to AlternateM

impl<I> From<Pin<I, Alternate<F>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateF to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from AlternateG to AlternateH

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateG to AlternateI

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateG to AlternateJ

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateG to AlternateK

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateG to AlternateL

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateG to AlternateM

impl<I> From<Pin<I, Alternate<G>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateG to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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, Alternate<H>>> for Pin<I, AlternateB>

where I: PinId,

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

Convert from AlternateH to AlternateB

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateC>

where I: PinId,

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

Convert from AlternateH to AlternateC

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateD>

where I: PinId,

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

Convert from AlternateH to AlternateD

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateE>

where I: PinId,

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

Convert from AlternateH to AlternateE

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateF>

where I: PinId,

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

Convert from AlternateH to AlternateF

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateG>

where I: PinId,

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

Convert from AlternateH to AlternateG

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateH to AlternateI

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateH to AlternateJ

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateH to AlternateK

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateH to AlternateL

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateH to AlternateM

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateH to AlternateN

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, FloatingDisabled>

where I: PinId,

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

Convert from AlternateH to FloatingDisabled

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, PullDownDisabled>

where I: PinId,

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

Convert from AlternateH to PullDownDisabled

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, PullUpDisabled>

where I: PinId,

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

Convert from AlternateH to PullUpDisabled

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, FloatingInput>

where I: PinId,

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

Convert from AlternateH to FloatingInput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, PullDownInput>

where I: PinId,

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

Convert from AlternateH to PullDownInput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, PullUpInput>

where I: PinId,

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

Convert from AlternateH to PullUpInput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, FloatingInterrupt>

where I: PinId,

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

Convert from AlternateH to FloatingInterrupt

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, PullDownInterrupt>

where I: PinId,

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

Convert from AlternateH to PullDownInterrupt

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, PullUpInterrupt>

where I: PinId,

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

Convert from AlternateH to PullUpInterrupt

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, PushPullOutput>

where I: PinId,

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

Convert from AlternateH to PushPullOutput

impl<I> From<Pin<I, Alternate<H>>> for Pin<I, ReadableOutput>

where I: PinId,

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

Convert from AlternateH to ReadableOutput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateB>

where I: PinId,

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

Convert from AlternateI to AlternateB

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateC>

where I: PinId,

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

Convert from AlternateI to AlternateC

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateD>

where I: PinId,

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

Convert from AlternateI to AlternateD

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateE>

where I: PinId,

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

Convert from AlternateI to AlternateE

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateF>

where I: PinId,

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

Convert from AlternateI to AlternateF

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateG>

where I: PinId,

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

Convert from AlternateI to AlternateG

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateH>

where I: PinId,

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

Convert from AlternateI to AlternateH

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateI to AlternateJ

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateI to AlternateK

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateI to AlternateL

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateI to AlternateM

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateI to AlternateN

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, FloatingDisabled>

where I: PinId,

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

Convert from AlternateI to FloatingDisabled

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, PullDownDisabled>

where I: PinId,

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

Convert from AlternateI to PullDownDisabled

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, PullUpDisabled>

where I: PinId,

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

Convert from AlternateI to PullUpDisabled

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, FloatingInput>

where I: PinId,

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

Convert from AlternateI to FloatingInput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, PullDownInput>

where I: PinId,

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

Convert from AlternateI to PullDownInput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, PullUpInput>

where I: PinId,

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

Convert from AlternateI to PullUpInput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, FloatingInterrupt>

where I: PinId,

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

Convert from AlternateI to FloatingInterrupt

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, PullDownInterrupt>

where I: PinId,

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

Convert from AlternateI to PullDownInterrupt

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, PullUpInterrupt>

where I: PinId,

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

Convert from AlternateI to PullUpInterrupt

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, PushPullOutput>

where I: PinId,

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

Convert from AlternateI to PushPullOutput

impl<I> From<Pin<I, Alternate<I>>> for Pin<I, ReadableOutput>

where I: PinId,

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

Convert from AlternateI to ReadableOutput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateB>

where I: PinId,

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

Convert from AlternateJ to AlternateB

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateC>

where I: PinId,

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

Convert from AlternateJ to AlternateC

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateD>

where I: PinId,

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

Convert from AlternateJ to AlternateD

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateE>

where I: PinId,

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

Convert from AlternateJ to AlternateE

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateF>

where I: PinId,

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

Convert from AlternateJ to AlternateF

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateG>

where I: PinId,

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

Convert from AlternateJ to AlternateG

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateH>

where I: PinId,

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

Convert from AlternateJ to AlternateH

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateJ to AlternateI

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateJ to AlternateK

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateJ to AlternateL

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateJ to AlternateM

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateJ to AlternateN

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, FloatingDisabled>

where I: PinId,

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

Convert from AlternateJ to FloatingDisabled

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, PullDownDisabled>

where I: PinId,

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

Convert from AlternateJ to PullDownDisabled

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, PullUpDisabled>

where I: PinId,

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

Convert from AlternateJ to PullUpDisabled

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, FloatingInput>

where I: PinId,

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

Convert from AlternateJ to FloatingInput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, PullDownInput>

where I: PinId,

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

Convert from AlternateJ to PullDownInput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, PullUpInput>

where I: PinId,

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

Convert from AlternateJ to PullUpInput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, FloatingInterrupt>

where I: PinId,

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

Convert from AlternateJ to FloatingInterrupt

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, PullDownInterrupt>

where I: PinId,

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

Convert from AlternateJ to PullDownInterrupt

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, PullUpInterrupt>

where I: PinId,

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

Convert from AlternateJ to PullUpInterrupt

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, PushPullOutput>

where I: PinId,

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

Convert from AlternateJ to PushPullOutput

impl<I> From<Pin<I, Alternate<J>>> for Pin<I, ReadableOutput>

where I: PinId,

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

Convert from AlternateJ to ReadableOutput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateB>

where I: PinId,

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

Convert from AlternateK to AlternateB

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateC>

where I: PinId,

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

Convert from AlternateK to AlternateC

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateD>

where I: PinId,

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

Convert from AlternateK to AlternateD

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateE>

where I: PinId,

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

Convert from AlternateK to AlternateE

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateF>

where I: PinId,

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

Convert from AlternateK to AlternateF

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateG>

where I: PinId,

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

Convert from AlternateK to AlternateG

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateH>

where I: PinId,

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

Convert from AlternateK to AlternateH

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateK to AlternateI

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateK to AlternateJ

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateK to AlternateL

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateK to AlternateM

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateK to AlternateN

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, FloatingDisabled>

where I: PinId,

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

Convert from AlternateK to FloatingDisabled

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, PullDownDisabled>

where I: PinId,

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

Convert from AlternateK to PullDownDisabled

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, PullUpDisabled>

where I: PinId,

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

Convert from AlternateK to PullUpDisabled

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, FloatingInput>

where I: PinId,

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

Convert from AlternateK to FloatingInput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, PullDownInput>

where I: PinId,

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

Convert from AlternateK to PullDownInput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, PullUpInput>

where I: PinId,

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

Convert from AlternateK to PullUpInput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, FloatingInterrupt>

where I: PinId,

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

Convert from AlternateK to FloatingInterrupt

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, PullDownInterrupt>

where I: PinId,

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

Convert from AlternateK to PullDownInterrupt

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, PullUpInterrupt>

where I: PinId,

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

Convert from AlternateK to PullUpInterrupt

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, PushPullOutput>

where I: PinId,

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

Convert from AlternateK to PushPullOutput

impl<I> From<Pin<I, Alternate<K>>> for Pin<I, ReadableOutput>

where I: PinId,

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

Convert from AlternateK to ReadableOutput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateB>

where I: PinId,

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

Convert from AlternateL to AlternateB

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateC>

where I: PinId,

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

Convert from AlternateL to AlternateC

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateD>

where I: PinId,

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

Convert from AlternateL to AlternateD

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateE>

where I: PinId,

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

Convert from AlternateL to AlternateE

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateF>

where I: PinId,

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

Convert from AlternateL to AlternateF

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateG>

where I: PinId,

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

Convert from AlternateL to AlternateG

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateH>

where I: PinId,

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

Convert from AlternateL to AlternateH

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateL to AlternateI

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateL to AlternateJ

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateL to AlternateK

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateL to AlternateM

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateL to AlternateN

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, FloatingDisabled>

where I: PinId,

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

Convert from AlternateL to FloatingDisabled

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, PullDownDisabled>

where I: PinId,

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

Convert from AlternateL to PullDownDisabled

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, PullUpDisabled>

where I: PinId,

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

Convert from AlternateL to PullUpDisabled

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, FloatingInput>

where I: PinId,

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

Convert from AlternateL to FloatingInput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, PullDownInput>

where I: PinId,

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

Convert from AlternateL to PullDownInput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, PullUpInput>

where I: PinId,

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

Convert from AlternateL to PullUpInput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, FloatingInterrupt>

where I: PinId,

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

Convert from AlternateL to FloatingInterrupt

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, PullDownInterrupt>

where I: PinId,

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

Convert from AlternateL to PullDownInterrupt

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, PullUpInterrupt>

where I: PinId,

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

Convert from AlternateL to PullUpInterrupt

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, PushPullOutput>

where I: PinId,

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

Convert from AlternateL to PushPullOutput

impl<I> From<Pin<I, Alternate<L>>> for Pin<I, ReadableOutput>

where I: PinId,

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

Convert from AlternateL to ReadableOutput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateB>

where I: PinId,

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

Convert from AlternateM to AlternateB

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateC>

where I: PinId,

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

Convert from AlternateM to AlternateC

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateD>

where I: PinId,

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

Convert from AlternateM to AlternateD

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateE>

where I: PinId,

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

Convert from AlternateM to AlternateE

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateF>

where I: PinId,

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

Convert from AlternateM to AlternateF

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateG>

where I: PinId,

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

Convert from AlternateM to AlternateG

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateH>

where I: PinId,

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

Convert from AlternateM to AlternateH

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateM to AlternateI

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateM to AlternateJ

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateM to AlternateK

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateM to AlternateL

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from AlternateM to AlternateN

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, FloatingDisabled>

where I: PinId,

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

Convert from AlternateM to FloatingDisabled

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, PullDownDisabled>

where I: PinId,

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

Convert from AlternateM to PullDownDisabled

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, PullUpDisabled>

where I: PinId,

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

Convert from AlternateM to PullUpDisabled

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, FloatingInput>

where I: PinId,

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

Convert from AlternateM to FloatingInput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, PullDownInput>

where I: PinId,

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

Convert from AlternateM to PullDownInput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, PullUpInput>

where I: PinId,

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

Convert from AlternateM to PullUpInput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, FloatingInterrupt>

where I: PinId,

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

Convert from AlternateM to FloatingInterrupt

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, PullDownInterrupt>

where I: PinId,

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

Convert from AlternateM to PullDownInterrupt

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, PullUpInterrupt>

where I: PinId,

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

Convert from AlternateM to PullUpInterrupt

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, PushPullOutput>

where I: PinId,

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

Convert from AlternateM to PushPullOutput

impl<I> From<Pin<I, Alternate<M>>> for Pin<I, ReadableOutput>

where I: PinId,

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

Convert from AlternateM to ReadableOutput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateB>

where I: PinId,

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

Convert from AlternateN to AlternateB

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateC>

where I: PinId,

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

Convert from AlternateN to AlternateC

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateD>

where I: PinId,

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

Convert from AlternateN to AlternateD

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateE>

where I: PinId,

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

Convert from AlternateN to AlternateE

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateF>

where I: PinId,

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

Convert from AlternateN to AlternateF

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateG>

where I: PinId,

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

Convert from AlternateN to AlternateG

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateH>

where I: PinId,

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

Convert from AlternateN to AlternateH

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from AlternateN to AlternateI

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from AlternateN to AlternateJ

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from AlternateN to AlternateK

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from AlternateN to AlternateL

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from AlternateN to AlternateM

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, FloatingDisabled>

where I: PinId,

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

Convert from AlternateN to FloatingDisabled

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, PullDownDisabled>

where I: PinId,

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

Convert from AlternateN to PullDownDisabled

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, PullUpDisabled>

where I: PinId,

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

Convert from AlternateN to PullUpDisabled

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, FloatingInput>

where I: PinId,

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

Convert from AlternateN to FloatingInput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, PullDownInput>

where I: PinId,

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

Convert from AlternateN to PullDownInput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, PullUpInput>

where I: PinId,

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

Convert from AlternateN to PullUpInput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, FloatingInterrupt>

where I: PinId,

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

Convert from AlternateN to FloatingInterrupt

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, PullDownInterrupt>

where I: PinId,

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

Convert from AlternateN to PullDownInterrupt

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, PullUpInterrupt>

where I: PinId,

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

Convert from AlternateN to PullUpInterrupt

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, PushPullOutput>

where I: PinId,

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

Convert from AlternateN to PushPullOutput

impl<I> From<Pin<I, Alternate<N>>> for Pin<I, ReadableOutput>

where I: PinId,

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

Convert from AlternateN 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, AlternateH>

where I: PinId,

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

Convert from FloatingDisabled to AlternateH

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from FloatingDisabled to AlternateI

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from FloatingDisabled to AlternateJ

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from FloatingDisabled to AlternateK

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from FloatingDisabled to AlternateL

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from FloatingDisabled to AlternateM

impl<I> From<Pin<I, Disabled<Floating>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from FloatingDisabled to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from PullDownDisabled to AlternateH

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from PullDownDisabled to AlternateI

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from PullDownDisabled to AlternateJ

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from PullDownDisabled to AlternateK

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from PullDownDisabled to AlternateL

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from PullDownDisabled to AlternateM

impl<I> From<Pin<I, Disabled<PullDown>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from PullDownDisabled to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from PullUpDisabled to AlternateH

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from PullUpDisabled to AlternateI

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from PullUpDisabled to AlternateJ

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from PullUpDisabled to AlternateK

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from PullUpDisabled to AlternateL

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from PullUpDisabled to AlternateM

impl<I> From<Pin<I, Disabled<PullUp>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from PullUpDisabled to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from FloatingInput to AlternateH

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from FloatingInput to AlternateI

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from FloatingInput to AlternateJ

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from FloatingInput to AlternateK

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from FloatingInput to AlternateL

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from FloatingInput to AlternateM

impl<I> From<Pin<I, Input<Floating>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from FloatingInput to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from PullDownInput to AlternateH

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from PullDownInput to AlternateI

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from PullDownInput to AlternateJ

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from PullDownInput to AlternateK

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from PullDownInput to AlternateL

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from PullDownInput to AlternateM

impl<I> From<Pin<I, Input<PullDown>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from PullDownInput to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from PullUpInput to AlternateH

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from PullUpInput to AlternateI

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from PullUpInput to AlternateJ

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from PullUpInput to AlternateK

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from PullUpInput to AlternateL

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from PullUpInput to AlternateM

impl<I> From<Pin<I, Input<PullUp>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from PullUpInput to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from FloatingInterrupt to AlternateH

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from FloatingInterrupt to AlternateI

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from FloatingInterrupt to AlternateJ

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from FloatingInterrupt to AlternateK

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from FloatingInterrupt to AlternateL

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from FloatingInterrupt to AlternateM

impl<I> From<Pin<I, Interrupt<Floating>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from FloatingInterrupt to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from PullDownInterrupt to AlternateH

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from PullDownInterrupt to AlternateI

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from PullDownInterrupt to AlternateJ

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from PullDownInterrupt to AlternateK

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from PullDownInterrupt to AlternateL

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from PullDownInterrupt to AlternateM

impl<I> From<Pin<I, Interrupt<PullDown>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from PullDownInterrupt to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from PullUpInterrupt to AlternateH

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from PullUpInterrupt to AlternateI

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from PullUpInterrupt to AlternateJ

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from PullUpInterrupt to AlternateK

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from PullUpInterrupt to AlternateL

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from PullUpInterrupt to AlternateM

impl<I> From<Pin<I, Interrupt<PullUp>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from PullUpInterrupt to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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 DynPin

where 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, AlternateH>

where I: PinId,

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

Convert from PushPullOutput to AlternateH

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from PushPullOutput to AlternateI

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from PushPullOutput to AlternateJ

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from PushPullOutput to AlternateK

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from PushPullOutput to AlternateL

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from PushPullOutput to AlternateM

impl<I> From<Pin<I, Output<PushPull>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from PushPullOutput to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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, AlternateH>

where I: PinId,

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

Convert from ReadableOutput to AlternateH

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, AlternateI>

where I: PinId,

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

Convert from ReadableOutput to AlternateI

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, AlternateJ>

where I: PinId,

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

Convert from ReadableOutput to AlternateJ

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, AlternateK>

where I: PinId,

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

Convert from ReadableOutput to AlternateK

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, AlternateL>

where I: PinId,

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

Convert from ReadableOutput to AlternateL

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, AlternateM>

where I: PinId,

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

Convert from ReadableOutput to AlternateM

impl<I> From<Pin<I, Output<Readable>>> for Pin<I, AlternateN>

where I: PinId,

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

Convert from ReadableOutput to AlternateN

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, 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, 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, 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, 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, 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, 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, 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, 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,

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

Is the input pin high?

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

Is the input pin low?

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,

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

Is the input pin high?

fn is_low(&mut 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,

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

Is the input pin high?

fn is_low(&mut 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 IoSets for Pin<PA00, Alternate<D>>

type SetList = HCons<<IoSet4 as IoSet>::Order, HCons<<UndocIoSet2 as IoSet>::Order, HNil>>

impl IoSets for Pin<PA01, Alternate<D>>

type SetList = HCons<<IoSet4 as IoSet>::Order, HCons<<UndocIoSet2 as IoSet>::Order, HNil>>

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

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA06, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA07, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA10, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA10, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA11, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA11, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA12, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA12, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA13, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA13, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA14, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA15, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA16, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HCons<<UndocIoSet1 as IoSet>::Order, HNil>>

impl IoSets for Pin<PA16, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA17, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HCons<<UndocIoSet1 as IoSet>::Order, HNil>>

impl IoSets for Pin<PA17, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA18, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA18, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA19, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA19, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

impl IoSets for Pin<PA20, Alternate<C>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HNil>

impl IoSets for Pin<PA20, Alternate<D>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HNil>

impl IoSets for Pin<PA21, Alternate<C>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HNil>

impl IoSets for Pin<PA21, Alternate<D>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HNil>

impl IoSets for Pin<PA22, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA22, Alternate<D>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HCons<<IoSet3 as IoSet>::Order, HCons<<IoSet4 as IoSet>::Order, HNil>>>

impl IoSets for Pin<PA23, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA23, Alternate<D>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HCons<<IoSet3 as IoSet>::Order, HCons<<IoSet4 as IoSet>::Order, HNil>>>

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

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA24, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PA25, Alternate<D>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet4 as IoSet>::Order, HNil>

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

type SetList = HCons<<IoSet4 as IoSet>::Order, HNil>

impl IoSets for Pin<PB00, Alternate<D>>

type SetList = HCons<<IoSet5 as IoSet>::Order, HCons<<IoSet6 as IoSet>::Order, HNil>>

impl IoSets for Pin<PB01, Alternate<D>>

type SetList = HCons<<IoSet5 as IoSet>::Order, HCons<<IoSet6 as IoSet>::Order, HNil>>

impl IoSets for Pin<PB02, Alternate<D>>

type SetList = HCons<<IoSet6 as IoSet>::Order, HNil>

impl IoSets for Pin<PB03, Alternate<D>>

type SetList = HCons<<IoSet6 as IoSet>::Order, HNil>

impl IoSets for Pin<PB08, Alternate<D>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HNil>

impl IoSets for Pin<PB09, Alternate<D>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HNil>

impl IoSets for Pin<PB10, Alternate<D>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HNil>

impl IoSets for Pin<PB11, Alternate<D>>

type SetList = HCons<<IoSet2 as IoSet>::Order, HNil>

impl IoSets for Pin<PB12, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PB13, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PB14, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PB15, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PB16, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PB17, Alternate<C>>

type SetList = HCons<<IoSet1 as IoSet>::Order, HNil>

impl IoSets for Pin<PB22, Alternate<C>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HCons<<UndocIoSet1 as IoSet>::Order, HCons<<UndocIoSet2 as IoSet>::Order, HNil>>>

impl IoSets for Pin<PB22, Alternate<D>>

type SetList = HCons<<IoSet4 as IoSet>::Order, HNil>

impl IoSets for Pin<PB23, Alternate<C>>

type SetList = HCons<<IoSet3 as IoSet>::Order, HCons<<UndocIoSet1 as IoSet>::Order, HCons<<UndocIoSet2 as IoSet>::Order, HNil>>>

impl IoSets for Pin<PB23, Alternate<D>>

type SetList = HCons<<IoSet4 as IoSet>::Order, HNil>

impl IoSets for Pin<PB30, Alternate<D>>

type SetList = HCons<<IoSet5 as IoSet>::Order, HNil>

impl IoSets for Pin<PB31, Alternate<D>>

type SetList = HCons<<IoSet5 as IoSet>::Order, HNil>

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

type Sercom = Sercom1

type PadNum = Pad0

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

type Sercom = Sercom1

type PadNum = Pad1

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

type Sercom = Sercom0

type PadNum = Pad0

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

type Sercom = Sercom0

type PadNum = Pad1

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

type Sercom = Sercom0

type PadNum = Pad2

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

type Sercom = Sercom0

type PadNum = Pad3

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

type Sercom = Sercom0

type PadNum = Pad0

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

type Sercom = Sercom2

type PadNum = Pad1

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

type Sercom = Sercom0

type PadNum = Pad1

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

type Sercom = Sercom2

type PadNum = Pad0

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

type Sercom = Sercom0

type PadNum = Pad2

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

type Sercom = Sercom2

type PadNum = Pad2

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

type Sercom = Sercom0

type PadNum = Pad3

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

type Sercom = Sercom2

type PadNum = Pad3

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

type Sercom = Sercom2

type PadNum = Pad0

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

type Sercom = Sercom4

type PadNum = Pad1

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

type Sercom = Sercom2

type PadNum = Pad1

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

type Sercom = Sercom4

type PadNum = Pad0

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

type Sercom = Sercom2

type PadNum = Pad2

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

type Sercom = Sercom4

type PadNum = Pad2

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

type Sercom = Sercom2

type PadNum = Pad3

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

type Sercom = Sercom4

type PadNum = Pad3

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

type Sercom = Sercom1

type PadNum = Pad0

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

type Sercom = Sercom3

type PadNum = Pad1

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

type Sercom = Sercom1

type PadNum = Pad1

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

type Sercom = Sercom3

type PadNum = Pad0

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

type Sercom = Sercom1

type PadNum = Pad2

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

type Sercom = Sercom3

type PadNum = Pad2

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

type Sercom = Sercom1

type PadNum = Pad3

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

type Sercom = Sercom3

type PadNum = Pad3

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

type Sercom = Sercom5

type PadNum = Pad2

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

type Sercom = Sercom3

type PadNum = Pad2

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

type Sercom = Sercom5

type PadNum = Pad3

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

type Sercom = Sercom3

type PadNum = Pad3

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

type Sercom = Sercom3

type PadNum = Pad0

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

type Sercom = Sercom5

type PadNum = Pad1

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

type Sercom = Sercom3

type PadNum = Pad1

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

type Sercom = Sercom5

type PadNum = Pad0

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

type Sercom = Sercom3

type PadNum = Pad2

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

type Sercom = Sercom5

type PadNum = Pad2

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

type Sercom = Sercom3

type PadNum = Pad3

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

type Sercom = Sercom5

type PadNum = Pad3

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

type Sercom = Sercom1

type PadNum = Pad2

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

type Sercom = Sercom1

type PadNum = Pad3

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

type Sercom = Sercom5

type PadNum = Pad2

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

type Sercom = Sercom5

type PadNum = Pad3

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

type Sercom = Sercom5

type PadNum = Pad0

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

type Sercom = Sercom5

type PadNum = Pad1

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

type Sercom = Sercom4

type PadNum = Pad0

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

type Sercom = Sercom4

type PadNum = Pad1

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

type Sercom = Sercom4

type PadNum = Pad2

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

type Sercom = Sercom4

type PadNum = Pad3

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

type Sercom = Sercom4

type PadNum = Pad0

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

type Sercom = Sercom4

type PadNum = Pad1

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

type Sercom = Sercom4

type PadNum = Pad2

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

type Sercom = Sercom4

type PadNum = Pad3

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

type Sercom = Sercom5

type PadNum = Pad0

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

type Sercom = Sercom5

type PadNum = Pad1

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

type Sercom = Sercom1

type PadNum = Pad2

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

type Sercom = Sercom5

type PadNum = Pad2

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

type Sercom = Sercom1

type PadNum = Pad3

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

type Sercom = Sercom5

type PadNum = Pad3

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

type Sercom = Sercom5

type PadNum = Pad1

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

type Sercom = Sercom5

type PadNum = Pad0

impl<I, C> OutputPin for Pin<I, Output<C>>

where I: PinId, C: OutputConfig,

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

Drives the pin low.

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

Drives the pin high.

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

Drives the pin high or low depending on the provided value.

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(&mut self) -> Result<bool, Self::Error>

Is the pin in drive high mode?

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

Is the pin in drive low mode?

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

Toggle pin output.

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 InIoSet<IoSet1> for Pin<PA08, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA09, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA10, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA11, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA12, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA13, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA14, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA15, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA16, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA17, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA18, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA19, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA22, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA23, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA24, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PA25, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PB12, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PB13, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PB14, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PB15, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PB16, Alternate<C>>

impl InIoSet<IoSet1> for Pin<PB17, Alternate<C>>

impl InIoSet<IoSet2> for Pin<PA20, Alternate<C>>

impl InIoSet<IoSet2> for Pin<PA20, Alternate<D>>

impl InIoSet<IoSet2> for Pin<PA21, Alternate<C>>

impl InIoSet<IoSet2> for Pin<PA21, Alternate<D>>

impl InIoSet<IoSet2> for Pin<PA22, Alternate<D>>

impl InIoSet<IoSet2> for Pin<PA23, Alternate<D>>

impl InIoSet<IoSet2> for Pin<PB08, Alternate<D>>

impl InIoSet<IoSet2> for Pin<PB09, Alternate<D>>

impl InIoSet<IoSet2> for Pin<PB10, Alternate<D>>

impl InIoSet<IoSet2> for Pin<PB11, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA04, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA05, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA06, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA07, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA08, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA09, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA10, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA11, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA12, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA13, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA14, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA15, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA16, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA17, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA18, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA19, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA22, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA23, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA24, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PA25, Alternate<D>>

impl InIoSet<IoSet3> for Pin<PB22, Alternate<C>>

impl InIoSet<IoSet3> for Pin<PB23, Alternate<C>>

impl InIoSet<IoSet4> for Pin<PA00, Alternate<D>>

impl InIoSet<IoSet4> for Pin<PA01, Alternate<D>>

impl InIoSet<IoSet4> for Pin<PA22, Alternate<D>>

impl InIoSet<IoSet4> for Pin<PA23, Alternate<D>>

impl InIoSet<IoSet4> for Pin<PA30, Alternate<D>>

impl InIoSet<IoSet4> for Pin<PA31, Alternate<D>>

impl InIoSet<IoSet4> for Pin<PB22, Alternate<D>>

impl InIoSet<IoSet4> for Pin<PB23, Alternate<D>>

impl InIoSet<IoSet5> for Pin<PB00, Alternate<D>>

impl InIoSet<IoSet5> for Pin<PB01, Alternate<D>>

impl InIoSet<IoSet5> for Pin<PB30, Alternate<D>>

impl InIoSet<IoSet5> for Pin<PB31, Alternate<D>>

impl InIoSet<IoSet6> for Pin<PB00, Alternate<D>>

impl InIoSet<IoSet6> for Pin<PB01, Alternate<D>>

impl InIoSet<IoSet6> for Pin<PB02, Alternate<D>>

impl InIoSet<IoSet6> for Pin<PB03, Alternate<D>>

impl InIoSet<UndocIoSet1> for Pin<PA16, Alternate<C>>

impl InIoSet<UndocIoSet1> for Pin<PA17, Alternate<C>>

impl InIoSet<UndocIoSet1> for Pin<PB22, Alternate<C>>

impl InIoSet<UndocIoSet1> for Pin<PB23, Alternate<C>>

impl InIoSet<UndocIoSet2> for Pin<PA00, Alternate<D>>

impl InIoSet<UndocIoSet2> for Pin<PA01, Alternate<D>>

impl InIoSet<UndocIoSet2> for Pin<PB22, Alternate<C>>

impl InIoSet<UndocIoSet2> for Pin<PB23, Alternate<C>>

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

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

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

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

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

impl IsI2cPad for Pin<PA12, Alternate<D>>

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

impl IsI2cPad for Pin<PA13, Alternate<D>>

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

impl IsI2cPad for Pin<PA16, Alternate<D>>

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

impl IsI2cPad for Pin<PA17, Alternate<D>>

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

impl IsI2cPad for Pin<PA22, Alternate<D>>

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

impl IsI2cPad for Pin<PA23, Alternate<D>>

impl IsI2cPad for Pin<PB02, Alternate<D>>

impl IsI2cPad for Pin<PB03, Alternate<D>>