Type Alias rp2040_combined::app::Spi0TxPin

source ·
type Spi0TxPin = Pin<Gpio19, FunctionSpi, PullDown>;

Aliased Type§

struct Spi0TxPin { /* private fields */ }

Implementations

§

impl<I, F, P> Pin<I, F, P>
where I: PinId, F: Function, P: PullType,

pub fn id(&self) -> DynPinId

Pin ID.

pub unsafe fn into_unchecked<F2, P2>(self) -> Pin<I, F2, P2>
where F2: Function, P2: PullType,

§Safety

This method does not check if the pin is actually configured as the target function or pull mode. This may lead to inconsistencies between the type-state and the actual state of the pin’s configuration.

pub fn reconfigure<F2, P2>(self) -> Pin<I, F2, P2>
where F2: Function, P2: PullType, I: ValidFunction<F2>,

Convert the pin from one state to the other.

pub fn into_mode<F2>(self) -> Pin<I, F2, P>
where F2: Function, I: ValidFunction<F2>,

👎Deprecated since 0.9.0: Misleading name mode when it changes the function. Please use into_function instead.

Convert the pin function.

pub fn into_function<F2>(self) -> Pin<I, F2, P>
where F2: Function, I: ValidFunction<F2>,

Convert the pin function.

pub fn into_pull_type<M2>(self) -> Pin<I, F, M2>
where M2: PullType,

Convert the pin pull type.

pub fn into_dyn_pin(self) -> Pin<DynPinId, F, P>

Erase the Pin ID type check.

pub fn pull_type(&self) -> DynPullType

Get the pin’s pull type.

pub fn into_floating_disabled(self) -> Pin<I, FunctionNull, PullNone>
where I: ValidFunction<FunctionNull>,

Disable the pin and set it to float

pub fn into_pull_down_disabled(self) -> Pin<I, FunctionNull, PullDown>
where I: ValidFunction<FunctionNull>,

Disable the pin and set it to pull down

pub fn into_pull_up_disabled(self) -> Pin<I, FunctionNull, PullUp>
where I: ValidFunction<FunctionNull>,

Disable the pin and set it to pull up

pub fn into_floating_input(self) -> Pin<I, FunctionSio<SioInput>, PullNone>
where I: ValidFunction<FunctionSio<SioInput>>,

Configure the pin to operate as a floating input

pub fn into_pull_down_input(self) -> Pin<I, FunctionSio<SioInput>, PullDown>
where I: ValidFunction<FunctionSio<SioInput>>,

Configure the pin to operate as a pulled down input

pub fn into_pull_up_input(self) -> Pin<I, FunctionSio<SioInput>, PullUp>
where I: ValidFunction<FunctionSio<SioInput>>,

Configure the pin to operate as a pulled up input

pub fn into_bus_keep_input(self) -> Pin<I, FunctionSio<SioInput>, PullBusKeep>
where I: ValidFunction<FunctionSio<SioInput>>,

Configure the pin to operate as a bus keep input

pub fn into_push_pull_output(self) -> Pin<I, FunctionSio<SioOutput>, P>
where I: ValidFunction<FunctionSio<SioOutput>>,

Configure the pin to operate as a push-pull output.

If you want to specify the initial pin state, use [Pin::into_push_pull_output_in_state].

pub fn into_push_pull_output_in_state( self, state: PinState, ) -> Pin<I, FunctionSio<SioOutput>, P>
where I: ValidFunction<FunctionSio<SioOutput>>,

Configure the pin to operate as a push-pull output, specifying an initial state which is applied immediately.

pub fn into_readable_output(self) -> Pin<I, FunctionSio<SioOutput>, P>
where I: ValidFunction<FunctionSio<SioOutput>>,

👎Deprecated since 0.9.0: All gpio are readable, use .into_push_pull_output() instead.

Configure the pin to operate as a readable push pull output.

If you want to specify the initial pin state, use [Pin::into_readable_output_in_state].

pub fn into_readable_output_in_state( self, state: PinState, ) -> Pin<I, FunctionSio<SioOutput>, P>
where I: ValidFunction<FunctionSio<SioOutput>>,

👎Deprecated since 0.9.0: All gpio are readable, use .into_push_pull_output_in_state() instead.

Configure the pin to operate as a readable push pull output, specifying an initial state which is applied immediately.

pub fn get_drive_strength(&self) -> OutputDriveStrength

Get the current drive strength of the pin.

pub fn set_drive_strength(&mut self, strength: OutputDriveStrength)

Set the drive strength for the pin.

pub fn get_slew_rate(&self) -> OutputSlewRate

Get the slew rate for the pin.

pub fn set_slew_rate(&mut self, rate: OutputSlewRate)

Set the slew rate for the pin.

pub fn get_schmitt_enabled(&self) -> bool

Get whether the schmitt trigger (hysteresis) is enabled.

pub fn set_schmitt_enabled(&self, enable: bool)

Enable/Disable the schmitt trigger.

pub fn get_output_disable(&mut self) -> bool

Get the state of the digital output circuitry of the pad.

pub fn set_output_disable(&mut self, disable: bool)

Set the digital output circuitry of the pad.

pub fn get_input_enable(&mut self) -> bool

Get the state of the digital input circuitry of the pad.

pub fn set_input_enable(&mut self, enable: bool)

Set the digital input circuitry of the pad.

pub fn get_input_override(&self) -> InputOverride

Get the input override.

pub fn set_input_override(&mut self, override_value: InputOverride)

Set the input override.

pub fn get_output_enable_override(&self) -> OutputEnableOverride

Get the output enable override.

pub fn set_output_enable_override( &mut self, override_value: OutputEnableOverride, )

Set the output enable override.

pub fn get_output_override(&self) -> OutputOverride

Get the output override.

pub fn set_output_override(&mut self, override_value: OutputOverride)

Set the output override.

pub fn get_interrupt_override(&self) -> InterruptOverride

Get the interrupt override.

pub fn set_interrupt_override(&mut self, override_value: InterruptOverride)

Set the interrupt override.

pub fn clear_interrupt(&mut self, interrupt: Interrupt)

Clear interrupt.

pub fn interrupt_status(&self, interrupt: Interrupt) -> bool

Interrupt status.

pub fn is_interrupt_enabled(&self, interrupt: Interrupt) -> bool

Is interrupt enabled.

pub fn set_interrupt_enabled(&self, interrupt: Interrupt, enabled: bool)

Enable or disable interrupt.

pub fn is_interrupt_forced(&self, interrupt: Interrupt) -> bool

Is interrupt forced.

pub fn set_interrupt_forced(&self, interrupt: Interrupt, forced: bool)

Force or release interrupt.

pub fn dormant_wake_status(&self, interrupt: Interrupt) -> bool

Dormant wake status.

pub fn is_dormant_wake_enabled(&self, interrupt: Interrupt) -> bool

Is dormant wake enabled.

pub fn set_dormant_wake_enabled(&self, interrupt: Interrupt, enabled: bool)

Enable or disable dormant wake.

pub fn is_dormant_wake_forced(&self, interrupt: Interrupt) -> bool

Is dormant wake forced.

pub fn set_dormant_wake_forced(&mut self, interrupt: Interrupt, forced: bool)

Force dormant wake.

pub fn as_input(&self) -> AsInputPin<'_, I, F, P>

Return a wrapper that implements InputPin.

This allows to read from the pin independent of the selected function. Depending on the pad configuration, reading from the pin may not return a meaningful result.

Calling this function does not set the pad’s input enable bit.

Trait Implementations

§

impl<I, F, P> AnyPin for Pin<I, F, P>
where I: PinId, F: Function, P: PullType,

§

type Id = I

[PinId] of the corresponding [Pin]
§

type Function = F

[func::Function] of the corresponding [Pin]
§

type Pull = P

[PullType] of the corresponding [Pin]
§

impl<I, F, P> Debug for Pin<I, F, P>
where I: Debug + PinId, F: Debug + Function, P: Debug + PullType,

§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more