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 = 16u8

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

const CHANNEL: u8 = 17u8

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

const CHANNEL: u8 = 18u8

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

const CHANNEL: u8 = 19u8

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

const CHANNEL: u8 = 10u8

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

const CHANNEL: u8 = 11u8

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

const CHANNEL: u8 = 2u8

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

const CHANNEL: u8 = 3u8

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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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 = Ch12

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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 = Ch13

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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 = Ch15

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

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

Configure a pin as pulled-down external interrupt

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

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

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

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

type ChId = Ch8

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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 = Ch10

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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 = Ch11

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

fn into_pull_down_ei(self, chan: 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 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 = Pad0

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 = Pad1

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 = Pad0

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 = Pad1

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 = Pad0

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 = Pad1

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 = Pad0

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 = Pad1

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<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<PB22, Alternate<D>>

type Sercom = Sercom5

type PadNum = Pad2

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

type Sercom = Sercom5

type PadNum = Pad3

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