Type Alias SofPad

pub type SofPad = Pin<PA23, AlternateG>;

Emit SOF at 1Khz on this pin when configured as function G

Aliased Type

struct SofPad { /* 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<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<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, AlternateG>

where I: PinId,

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

Convert from AlternateB to AlternateG

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

where I: PinId,

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

Convert from ReadableOutput to AlternateG

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.