Type Alias DmPad

pub type DmPad = Pin<PA24, AlternateH>;

Default USB D- pad

Aliased Type

struct DmPad { /* private fields */ }

Implementations

impl<I, M> Pin<I, M>

where I: PinId, M: PinMode,

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

Convert the pin to the requested PinMode

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

Disable the pin and set it to float

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

Disable the pin and set it to pull down

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

Disable the pin and set it to pull up

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

Configure the pin to operate as a floating input

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

Configure the pin to operate as a pulled down input

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

Configure the pin to operate as a pulled up input

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

Configure the pin to operate as a floating interrupt

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

Configure the pin to operate as a pulled down interrupt

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

Configure the pin to operate as a pulled up interrupt

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

Configure the pin to operate as a push-pull output

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

Configure the pin to operate as a readable push pull output

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

Configure the pin to operate as the corresponding peripheral function.

The type C indicates the desired peripheral function.

pub fn get_drive_strength(&self) -> bool

Read the current drive strength of the pin.

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

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

Set the drive strength for the pin.

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

Trait Implementations

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

where I: PinId, M: PinMode,

type Id = I

PinId of the corresponding Pin

type Mode = M

PinMode of the corresponding Pin

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

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

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

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

type ChId = Ch8

type InterruptSource = EIC_EXTINT_8

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

Configure a pin as a floating external interrupt

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

Configure a pin as pulled-up external interrupt

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

Configure a pin as pulled-down external interrupt

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

where I: PinId,

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

Convert from AlternateB to AlternateH

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<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<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<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<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<I>>> for Pin<I, AlternateH>

where I: PinId,

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

Convert from AlternateI to AlternateH

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

where I: PinId,

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

Convert from AlternateJ to AlternateH

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

where I: PinId,

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

Convert from AlternateK to AlternateH

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

where I: PinId,

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

Convert from AlternateL to AlternateH

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

where I: PinId,

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

Convert from AlternateM to AlternateH

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

where I: PinId,

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

Convert from AlternateN to AlternateH

impl<I> From<Pin<I, 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<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<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, 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<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<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, 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<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<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, 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<Readable>>> for Pin<I, AlternateH>

where I: PinId,

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

Convert from ReadableOutput to AlternateH

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.