Struct gemma_m0::gpio::v2::Pin

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

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

Implementations§

source§

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

source

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

Convert the pin to the requested PinMode

source

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

Disable the pin and set it to float

source

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

Disable the pin and set it to pull down

source

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

Disable the pin and set it to pull up

source

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

Configure the pin to operate as a floating input

source

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

Configure the pin to operate as a pulled down input

source

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

Configure the pin to operate as a pulled up input

source

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

Configure the pin to operate as a floating interrupt

source

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

Configure the pin to operate as a pulled down interrupt

source

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

Configure the pin to operate as a pulled up interrupt

source

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

Configure the pin to operate as a push-pull output

source

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

Configure the pin to operate as a readable push pull output

source

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

Configure the pin to operate as the corresponding peripheral function.

The type C indicates the desired peripheral function.

source

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.

source

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§

source§

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

impl<P> AsMut<P> for Pin<<P as AnyPin>::Id, <P as AnyPin>::Mode>where P: AnyPin,

source§

fn as_mut(&mut self) -> &mut P

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<P> AsRef<P> for Pin<<P as AnyPin>::Id, <P as AnyPin>::Mode>where P: AnyPin,

source§

fn as_ref(&self) -> &P

Converts this type into a shared reference of the (usually inferred) input type.
source§

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

source§

fn id(&self) -> usize

source§

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

source§

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

Convert from AlternateB to AlternateC

source§

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

source§

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

Convert from AlternateB to AlternateD

source§

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

source§

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

Convert from AlternateB to AlternateE

source§

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

source§

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

Convert from AlternateB to AlternateF

source§

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

source§

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

Convert from AlternateB to AlternateG

source§

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

source§

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

Convert from AlternateB to AlternateH

source§

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

source§

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

source§

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

source§

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

Convert from AlternateB to PullUpDisabled

source§

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

source§

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

Convert from AlternateB to FloatingInput

source§

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

source§

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

Convert from AlternateB to PullDownInput

source§

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

source§

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

Convert from AlternateB to PullUpInput

source§

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

source§

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

source§

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

source§

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

Convert from AlternateB to PullUpInterrupt

source§

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

source§

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

Convert from AlternateB to PushPullOutput

source§

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

source§

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

Convert from AlternateB to ReadableOutput

source§

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

source§

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

Convert from AlternateC to AlternateB

source§

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

source§

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

Convert from AlternateC to AlternateD

source§

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

source§

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

Convert from AlternateC to AlternateE

source§

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

source§

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

Convert from AlternateC to AlternateF

source§

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

source§

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

Convert from AlternateC to AlternateG

source§

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

source§

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

Convert from AlternateC to AlternateH

source§

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

source§

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

source§

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

source§

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

Convert from AlternateC to PullUpDisabled

source§

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

source§

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

Convert from AlternateC to FloatingInput

source§

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

source§

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

Convert from AlternateC to PullDownInput

source§

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

source§

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

Convert from AlternateC to PullUpInput

source§

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

source§

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

source§

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

source§

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

Convert from AlternateC to PullUpInterrupt

source§

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

source§

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

Convert from AlternateC to PushPullOutput

source§

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

source§

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

Convert from AlternateC to ReadableOutput

source§

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

source§

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

Convert from AlternateD to AlternateB

source§

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

source§

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

Convert from AlternateD to AlternateC

source§

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

source§

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

Convert from AlternateD to AlternateE

source§

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

source§

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

Convert from AlternateD to AlternateF

source§

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

source§

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

Convert from AlternateD to AlternateG

source§

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

source§

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

Convert from AlternateD to AlternateH

source§

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

source§

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

source§

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

source§

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

Convert from AlternateD to PullUpDisabled

source§

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

source§

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

Convert from AlternateD to FloatingInput

source§

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

source§

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

Convert from AlternateD to PullDownInput

source§

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

source§

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

Convert from AlternateD to PullUpInput

source§

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

source§

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

source§

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

source§

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

Convert from AlternateD to PullUpInterrupt

source§

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

source§

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

Convert from AlternateD to PushPullOutput

source§

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

source§

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

Convert from AlternateD to ReadableOutput

source§

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

source§

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

Convert from AlternateE to AlternateB

source§

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

source§

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

Convert from AlternateE to AlternateC

source§

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

source§

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

Convert from AlternateE to AlternateD

source§

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

source§

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

Convert from AlternateE to AlternateF

source§

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

source§

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

Convert from AlternateE to AlternateG

source§

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

source§

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

Convert from AlternateE to AlternateH

source§

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

source§

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

source§

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

source§

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

Convert from AlternateE to PullUpDisabled

source§

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

source§

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

Convert from AlternateE to FloatingInput

source§

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

source§

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

Convert from AlternateE to PullDownInput

source§

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

source§

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

Convert from AlternateE to PullUpInput

source§

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

source§

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

source§

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

source§

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

Convert from AlternateE to PullUpInterrupt

source§

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

source§

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

Convert from AlternateE to PushPullOutput

source§

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

source§

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

Convert from AlternateE to ReadableOutput

source§

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

source§

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

Convert from AlternateF to AlternateB

source§

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

source§

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

Convert from AlternateF to AlternateC

source§

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

source§

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

Convert from AlternateF to AlternateD

source§

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

source§

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

Convert from AlternateF to AlternateE

source§

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

source§

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

Convert from AlternateF to AlternateG

source§

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

source§

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

Convert from AlternateF to AlternateH

source§

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

source§

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

source§

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

source§

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

Convert from AlternateF to PullUpDisabled

source§

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

source§

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

Convert from AlternateF to FloatingInput

source§

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

source§

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

Convert from AlternateF to PullDownInput

source§

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

source§

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

Convert from AlternateF to PullUpInput

source§

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

source§

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

source§

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

source§

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

Convert from AlternateF to PullUpInterrupt

source§

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

source§

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

Convert from AlternateF to PushPullOutput

source§

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

source§

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

Convert from AlternateF to ReadableOutput

source§

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

source§

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

Convert from AlternateG to AlternateB

source§

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

source§

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

Convert from AlternateG to AlternateC

source§

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

source§

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

Convert from AlternateG to AlternateD

source§

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

source§

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

Convert from AlternateG to AlternateE

source§

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

source§

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

Convert from AlternateG to AlternateF

source§

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

source§

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

Convert from AlternateG to AlternateH

source§

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

source§

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

source§

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

source§

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

Convert from AlternateG to PullUpDisabled

source§

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

source§

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

Convert from AlternateG to FloatingInput

source§

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

source§

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

Convert from AlternateG to PullDownInput

source§

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

source§

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

Convert from AlternateG to PullUpInput

source§

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

source§

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

source§

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

source§

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

Convert from AlternateG to PullUpInterrupt

source§

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

source§

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

Convert from AlternateG to PushPullOutput

source§

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

source§

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

Convert from AlternateG to ReadableOutput

source§

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

source§

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

Convert from AlternateH to AlternateB

source§

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

source§

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

Convert from AlternateH to AlternateC

source§

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

source§

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

Convert from AlternateH to AlternateD

source§

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

source§

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

Convert from AlternateH to AlternateE

source§

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

source§

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

Convert from AlternateH to AlternateF

source§

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

source§

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

Convert from AlternateH to AlternateG

source§

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

source§

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

source§

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

source§

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

Convert from AlternateH to PullUpDisabled

source§

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

source§

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

Convert from AlternateH to FloatingInput

source§

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

source§

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

Convert from AlternateH to PullDownInput

source§

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

source§

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

Convert from AlternateH to PullUpInput

source§

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

source§

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

source§

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

source§

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

Convert from AlternateH to PullUpInterrupt

source§

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

source§

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

Convert from AlternateH to PushPullOutput

source§

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

source§

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

Convert from AlternateH to ReadableOutput

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from PullUpDisabled to AlternateB

source§

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

source§

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

Convert from PullUpDisabled to AlternateC

source§

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

source§

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

Convert from PullUpDisabled to AlternateD

source§

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

source§

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

Convert from PullUpDisabled to AlternateE

source§

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

source§

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

Convert from PullUpDisabled to AlternateF

source§

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

source§

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

Convert from PullUpDisabled to AlternateG

source§

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

source§

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

Convert from PullUpDisabled to AlternateH

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from PullUpDisabled to PullUpInput

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from FloatingInput to AlternateB

source§

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

source§

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

Convert from FloatingInput to AlternateC

source§

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

source§

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

Convert from FloatingInput to AlternateD

source§

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

source§

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

Convert from FloatingInput to AlternateE

source§

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

source§

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

Convert from FloatingInput to AlternateF

source§

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

source§

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

Convert from FloatingInput to AlternateG

source§

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

source§

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

Convert from FloatingInput to AlternateH

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from FloatingInput to PullUpInput

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from PullDownInput to AlternateB

source§

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

source§

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

Convert from PullDownInput to AlternateC

source§

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

source§

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

Convert from PullDownInput to AlternateD

source§

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

source§

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

Convert from PullDownInput to AlternateE

source§

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

source§

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

Convert from PullDownInput to AlternateF

source§

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

source§

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

Convert from PullDownInput to AlternateG

source§

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

source§

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

Convert from PullDownInput to AlternateH

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from PullDownInput to PullUpInput

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from PullUpInput to AlternateB

source§

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

source§

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

Convert from PullUpInput to AlternateC

source§

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

source§

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

Convert from PullUpInput to AlternateD

source§

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

source§

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

Convert from PullUpInput to AlternateE

source§

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

source§

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

Convert from PullUpInput to AlternateF

source§

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

source§

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

Convert from PullUpInput to AlternateG

source§

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

source§

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

Convert from PullUpInput to AlternateH

source§

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

source§

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

source§

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

source§

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

Convert from PullUpInput to PullUpDisabled

source§

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

source§

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

Convert from PullUpInput to FloatingInput

source§

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

source§

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

Convert from PullUpInput to PullDownInput

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from PullUpInput to PushPullOutput

source§

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

source§

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

Convert from PullUpInput to ReadableOutput

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from PullUpInterrupt to AlternateB

source§

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

source§

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

Convert from PullUpInterrupt to AlternateC

source§

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

source§

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

Convert from PullUpInterrupt to AlternateD

source§

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

source§

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

Convert from PullUpInterrupt to AlternateE

source§

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

source§

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

Convert from PullUpInterrupt to AlternateF

source§

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

source§

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

Convert from PullUpInterrupt to AlternateG

source§

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

source§

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

Convert from PullUpInterrupt to AlternateH

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

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

source§

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

Convert from a v2::Pin to a v1::Pin

source§

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

Converts to this type from the input type.
source§

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

Convert from a v1::Pin to a v2::Pin

source§

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

Converts to this type from the input type.
source§

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

source§

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

Convert from PushPullOutput to AlternateB

source§

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

source§

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

Convert from PushPullOutput to AlternateC

source§

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

source§

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

Convert from PushPullOutput to AlternateD

source§

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

source§

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

Convert from PushPullOutput to AlternateE

source§

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

source§

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

Convert from PushPullOutput to AlternateF

source§

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

source§

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

Convert from PushPullOutput to AlternateG

source§

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

source§

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

Convert from PushPullOutput to AlternateH

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from PushPullOutput to PullUpInput

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from ReadableOutput to AlternateB

source§

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

source§

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

Convert from ReadableOutput to AlternateC

source§

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

source§

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

Convert from ReadableOutput to AlternateD

source§

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

source§

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

Convert from ReadableOutput to AlternateE

source§

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

source§

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

Convert from ReadableOutput to AlternateF

source§

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

source§

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

Convert from ReadableOutput to AlternateG

source§

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

source§

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

Convert from ReadableOutput to AlternateH

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Convert from ReadableOutput to PullUpInput

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Sercom = SERCOM1

§

type PadNum = Pad0

source§

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

§

type Sercom = SERCOM1

§

type PadNum = Pad1

source§

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

§

type Sercom = SERCOM0

§

type PadNum = Pad0

source§

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

§

type Sercom = SERCOM0

§

type PadNum = Pad1

source§

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

§

type Sercom = SERCOM0

§

type PadNum = Pad2

source§

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

§

type Sercom = SERCOM0

§

type PadNum = Pad3

source§

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

§

type Sercom = SERCOM0

§

type PadNum = Pad0

source§

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

§

type Sercom = SERCOM2

§

type PadNum = Pad0

source§

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

§

type Sercom = SERCOM0

§

type PadNum = Pad1

source§

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

§

type Sercom = SERCOM2

§

type PadNum = Pad1

source§

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

§

type Sercom = SERCOM0

§

type PadNum = Pad2

source§

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

§

type Sercom = SERCOM2

§

type PadNum = Pad2

source§

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

§

type Sercom = SERCOM0

§

type PadNum = Pad3

source§

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

§

type Sercom = SERCOM2

§

type PadNum = Pad3

source§

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

§

type Sercom = SERCOM2

§

type PadNum = Pad2

source§

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

§

type Sercom = SERCOM2

§

type PadNum = Pad3

source§

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

§

type Sercom = SERCOM1

§

type PadNum = Pad0

source§

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

§

type Sercom = SERCOM3

§

type PadNum = Pad0

source§

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

§

type Sercom = SERCOM1

§

type PadNum = Pad1

source§

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

§

type Sercom = SERCOM3

§

type PadNum = Pad1

source§

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

§

type Sercom = SERCOM1

§

type PadNum = Pad2

source§

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

§

type Sercom = SERCOM3

§

type PadNum = Pad2

source§

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

§

type Sercom = SERCOM1

§

type PadNum = Pad3

source§

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

§

type Sercom = SERCOM3

§

type PadNum = Pad3

source§

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

§

type Sercom = SERCOM3

§

type PadNum = Pad0

source§

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

§

type Sercom = SERCOM3

§

type PadNum = Pad1

source§

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

§

type Sercom = SERCOM3

§

type PadNum = Pad2

source§

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

§

type Sercom = SERCOM3

§

type PadNum = Pad3

source§

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

§

type Sercom = SERCOM1

§

type PadNum = Pad2

source§

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

§

type Sercom = SERCOM1

§

type PadNum = Pad3

source§

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

§

type Error = Infallible

Error type
source§

fn set_high(&mut self) -> Result<(), <Pin<I, Output<C>> as OutputPin>::Error>

Drives the pin high Read more
source§

fn set_low(&mut self) -> Result<(), <Pin<I, Output<C>> as OutputPin>::Error>

Drives the pin low Read more
source§

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

Drives the pin high or low depending on the provided value Read more
source§

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

source§

fn try_from(pin: DynPin) -> Result<Pin<I, M>, Error>

Try to recreate a type-level Pin from a value-level DynPin

There is no way for the compiler to know if the conversion will be successful at compile-time. We must verify the conversion at run-time or refuse to perform it.

§

type Error = Error

The type returned in the event of a conversion error.

Auto Trait Implementations§

§

impl<I, M> RefUnwindSafe for Pin<I, M>where I: RefUnwindSafe, M: RefUnwindSafe,

§

impl<I, M> Send for Pin<I, M>where I: Send, M: Send,

§

impl<I, M> Sync for Pin<I, M>where I: Sync, M: Sync,

§

impl<I, M> Unpin for Pin<I, M>where I: Unpin, M: Unpin,

§

impl<I, M> UnwindSafe for Pin<I, M>where I: UnwindSafe, M: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

impl<P> CompatiblePad for Pwhere P: IsPad,

§

type Sercom = <P as IsPad>::Sercom

§

type PadNum = <P as IsPad>::PadNum

source§

impl<P> ControlSS for Pwhere P: SomePin + OutputPin<Error = Infallible>,

source§

fn assert(&mut self)

If an SS pin is present, assert it by bringing it low
source§

fn deassert(&mut self)

If an SS pin is present, deassert it by bringing it high
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T> Is for Twhere T: Sealed + AsRef<T> + AsMut<T>,

§

type Type = T

source§

impl<P> OptionalPad for Pwhere P: IsPad,

§

type PadNum = <P as IsPad>::PadNum

source§

impl<P> OptionalPin for Pwhere P: AnyPin,

§

type Id = <P as AnyPin>::Id

source§

impl<T> Same<T> for T

§

type Output = T

Should always be Self
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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

§

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

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<P> SomePad for Pwhere P: IsPad,

source§

impl<P> SomePin for Pwhere P: AnyPin,