Type Alias atmega_hal::port::Pin

pub type Pin<MODE, PIN = Dynamic> = Pin<MODE, PIN>;

Type-alias for a pin type which can represent any concrete pin.

Sometimes it is easier to handle pins if they are all of the same type. By default, each pin gets its own distinct type in avr-hal, but by downgrading, you can cast them into this “dynamic” type. Do note, however, that using this dynamic type has a runtime cost.

Aliased Type

struct Pin<MODE, PIN = Dynamic> { /* private fields */ }

Implementations

impl<PIN> Pin<Analog, PIN>

where PIN: PinOps,

Analog Input

Some pins can be configured as ADC channels. For those pins, analog_read() can be used to read the voltage. analog_read() corresponds to a blocking ADC read:

let dp = atmega_hal::Peripherals::take().unwrap();
let pins = atmega_hal::pins!(dp);
let mut adc = atmega_hal::Adc::new(dp.ADC, Default::default());

let a0 = pins.pc0.into_analog_input(&mut adc);

let voltage = a0.analog_read(&mut adc);
// ^- this is equivalent to -v
let voltage = adc.read_blocking(&a0);

pub fn analog_read<H, ADC, CLOCK>(&self, adc: &mut Adc<H, ADC, CLOCK>) -> u16

where Pin<Analog, PIN>: AdcChannel<H, ADC>, ADC: AdcOps<H>, CLOCK: Clock,

pub fn into_channel<H, ADC>(self) -> Channel<H, ADC>

where Pin<Analog, PIN>: AdcChannel<H, ADC>, ADC: AdcOps<H>,

Convert this pin into a generic Channel type.

The generic channel type can be used to store multiple channels in an array.

pub fn into_digital<H, ADC, CLOCK>( self, adc: &mut Adc<H, ADC, CLOCK> ) -> Pin<Input<Floating>, PIN>

where Pin<Analog, PIN>: AdcChannel<H, ADC>, ADC: AdcOps<H>, CLOCK: Clock,

Convert this pin to a floating digital input pin.

The pin is re-enabled in the digital input buffer and is no longer usable as an analog input. You can get to other digital modes by calling one of the usual into_... methods on the return value of this function.

impl<PIN, IMODE> Pin<Input<IMODE>, PIN>

where PIN: PinOps,

Input-Mode Downgrading

There is a second kind of downgrading: In some cases it is not important whether an input pin is configured as mode::PullUp or mode::Floating. For this, you can “forget” the concrete input mode, leaving you with a type that is the same for pull-up or floating inputs:

use atmega_hal::port::{Pin, mode};

let dp = atmega_hal::Peripherals::take().unwrap();
let pins = atmega_hal::pins!(dp);

// This demo uses downgraded pins, but it works just as well
// with non-downgraded ones!
let input_pin1: Pin<mode::Input<mode::Floating>> = pins.pd0
    .into_floating_input()
    .downgrade();
let input_pin2: Pin<mode::Input<mode::Floating>> = pins.pd1
    .into_pull_up_input()
    .downgrade();

// With the input mode "forgotten", they have the same type now,
// even if electically different.
let any_inputs: [Pin<mode::Input>; 2] = [
    input_pin1.forget_imode(),
    input_pin2.forget_imode(),
];

pub fn forget_imode(self) -> Pin<Input, PIN>

“Erase” type-level information about whether the pin is currently a pull-up or a floating input.

impl<PIN, IMODE> Pin<Input<IMODE>, PIN>

where PIN: PinOps, IMODE: InputMode,

Digital Input

pub fn is_high(&self) -> bool

Check whether the pin is driven high.

pub fn is_low(&self) -> bool

Check whether the pin is driven low.

impl<PIN, MODE> Pin<MODE, PIN>

where PIN: PinOps, MODE: Io,

Configuration

To change the mode of a pin, use one of the following conversion functions. They consume the original Pin and return one with the desired mode. Only when a pin is in the correct mode, does it have the mode-relevant methods availailable (e.g. set_high() is only available for Output pins).

pub fn into_output(self) -> Pin<Output, PIN>

Convert this pin into an output pin, setting the state to low. See Digital Output.

pub fn into_output_high(self) -> Pin<Output, PIN>

Convert this pin into an output pin, setting the state to high. See Digital Output.

pub fn into_opendrain(self) -> Pin<OpenDrain, PIN>

Convert this pin into an open-drain output pin, setting the state to low. See Digital Output Open Drain

pub fn into_opendrain_high(self) -> Pin<OpenDrain, PIN>

Convert this pin into an open-drain output pin, setting the state to high. See Digital Output Open Drain

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

Convert this pin into a floating input pin. See Digital Input.

Note: To read deterministic values from the pin, it must be externally pulled to a defined level (either VCC or GND).

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

Convert this pin into a pulled-up input pin. See Digital Input.

With no external circuit pulling the pin low, it will be read high.

pub fn into_analog_input<H, ADC, CLOCK>( self, adc: &mut Adc<H, ADC, CLOCK> ) -> Pin<Analog, PIN>

where Pin<Analog, PIN>: AdcChannel<H, ADC>, ADC: AdcOps<H>, CLOCK: Clock,

Convert this pin into an analog input (ADC channel). See Analog Input.

Some pins can be repurposed as ADC channels. For those pins, the into_analog_input() method is available.

impl<PIN, MODE> Pin<MODE, PIN>

where PIN: PinOps, MODE: Io,

Downgrading

For applications where the exact pin is irrelevant, a specific pin can be downgraded to a “dynamic pin” which can represent any pin:

use atmega_hal::port::{Pin, mode};

let dp = atmega_hal::Peripherals::take().unwrap();
let pins = atmega_hal::pins!(dp);

let any_output_pin1: Pin<mode::Output> = pins.pd0.into_output().downgrade();
let any_output_pin2: Pin<mode::Output> = pins.pd1.into_output().downgrade();

// Because they now have the same type, you can, for example, stuff them into an array:
let pins: [Pin<mode::Output>; 2] = [any_output_pin1, any_output_pin2];

pub fn downgrade(self) -> Pin<MODE, <PIN as PinOps>::Dynamic>

“Erase” type-level information about which specific pin is represented.

Note: The returned “dynamic” pin has runtime overhead compared to a specific pin.

impl<PIN> Pin<OpenDrain, PIN>

where PIN: PinOps,

Digital Output Open Drain

pub fn set_high(&mut self)

Set the pin high (Input without PullUp so it is floating)

pub fn set_low(&mut self)

Set pin low (pull it to GND, Output to low).

pub fn is_high(&self) -> bool

Check whether the pin is set high.

Note: The electrical state of the pin might differ due to external circuitry.

pub fn is_low(&self) -> bool

Check whether the pin is set low.

Note: The electrical state of the pin might differ due to external circuitry.

impl<PIN> Pin<Output, PIN>

where PIN: PinOps,

Digital Output

pub fn set_high(&mut self)

Set pin high (pull it to supply voltage).

pub fn set_low(&mut self)

Set pin low (pull it to GND).

pub fn toggle(&mut self)

Toggle a high pin to low and a low pin to high.

pub fn is_set_high(&self) -> bool

Check whether the pin is set high.

Note: The electrical state of the pin might differ due to external circuitry.

pub fn is_set_low(&self) -> bool

Check whether the pin is set low.

Note: The electrical state of the pin might differ due to external circuitry.

impl<TC, PIN> Pin<PwmOutput<TC>, PIN>

where PIN: PwmPinOps<TC>,

pub fn enable(&mut self)

pub fn disable(&mut self)

pub fn get_duty(&self) -> <PIN as PwmPinOps<TC>>::Duty

pub fn get_max_duty(&self) -> <PIN as PwmPinOps<TC>>::Duty

pub fn set_duty(&mut self, duty: u8)

Trait Implementations

impl AdcChannel<Atmega, ADC> for Pin<Analog, PC0>

fn channel(&self) -> MUX_A

impl AdcChannel<Atmega, ADC> for Pin<Analog, PC1>

fn channel(&self) -> MUX_A

impl AdcChannel<Atmega, ADC> for Pin<Analog, PC2>

fn channel(&self) -> MUX_A

impl AdcChannel<Atmega, ADC> for Pin<Analog, PC3>

fn channel(&self) -> MUX_A

impl AdcChannel<Atmega, ADC> for Pin<Analog, PC4>

fn channel(&self) -> MUX_A

impl AdcChannel<Atmega, ADC> for Pin<Analog, PC5>

fn channel(&self) -> MUX_A

impl<PIN, IMODE> ErrorType for Pin<Input<IMODE>, PIN>

where PIN: PinOps, IMODE: InputMode,

type Error = Infallible

Error type

impl<PIN> ErrorType for Pin<OpenDrain, PIN>

where PIN: PinOps,

type Error = Infallible

Error type

impl<PIN> ErrorType for Pin<Output, PIN>

where PIN: PinOps,

type Error = Infallible

Error type

impl<TC, PIN> ErrorType for Pin<PwmOutput<TC>, PIN>

where PIN: PwmPinOps<TC>,

type Error = PwmError

Error type

impl<PIN, IMODE> InputPin for Pin<Input<IMODE>, PIN>

where PIN: PinOps, IMODE: InputMode,

type Error = Infallible

Error type

fn is_high(&self) -> Result<bool, <Pin<Input<IMODE>, PIN> as InputPin>::Error>

Is the input pin high?

fn is_low(&self) -> Result<bool, <Pin<Input<IMODE>, PIN> as InputPin>::Error>

Is the input pin low?

impl<PIN, IMODE> InputPin for Pin<Input<IMODE>, PIN>

where PIN: PinOps, IMODE: InputMode,

fn is_high( &mut self ) -> Result<bool, <Pin<Input<IMODE>, PIN> as ErrorType>::Error>

Is the input pin high?

fn is_low( &mut self ) -> Result<bool, <Pin<Input<IMODE>, PIN> as ErrorType>::Error>

Is the input pin low?

impl<PIN> InputPin for Pin<OpenDrain, PIN>

where PIN: PinOps,

type Error = Infallible

Error type

fn is_high(&self) -> Result<bool, <Pin<OpenDrain, PIN> as InputPin>::Error>

Is the input pin high?

fn is_low(&self) -> Result<bool, <Pin<OpenDrain, PIN> as InputPin>::Error>

Is the input pin low?

impl<PIN> InputPin for Pin<OpenDrain, PIN>

where PIN: PinOps,

fn is_high(&mut self) -> Result<bool, <Pin<OpenDrain, PIN> as ErrorType>::Error>

Is the input pin high?

fn is_low(&mut self) -> Result<bool, <Pin<OpenDrain, PIN> as ErrorType>::Error>

Is the input pin low?

impl<TC, PIN> IntoPwmPin<TC, PIN> for Pin<Output, PIN>

where PIN: PwmPinOps<TC>,

fn into_pwm(self, _timer: &TC) -> Pin<PwmOutput<TC>, PIN>

impl<PIN> OutputPin for Pin<OpenDrain, PIN>

where PIN: PinOps,

type Error = Infallible

Error type

fn set_high(&mut self) -> Result<(), <Pin<OpenDrain, PIN> as OutputPin>::Error>

Drives the pin high

fn set_low(&mut self) -> Result<(), <Pin<OpenDrain, PIN> as OutputPin>::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<PIN> OutputPin for Pin<OpenDrain, PIN>

where PIN: PinOps,

fn set_low(&mut self) -> Result<(), <Pin<OpenDrain, PIN> as ErrorType>::Error>

Drives the pin low.

fn set_high(&mut self) -> Result<(), <Pin<OpenDrain, PIN> as ErrorType>::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<PIN> OutputPin for Pin<Output, PIN>

where PIN: PinOps,

type Error = Infallible

Error type

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

Drives the pin high

fn set_low(&mut self) -> Result<(), <Pin<Output, PIN> as OutputPin>::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<PIN> OutputPin for Pin<Output, PIN>

where PIN: PinOps,

fn set_low(&mut self) -> Result<(), <Pin<Output, PIN> as ErrorType>::Error>

Drives the pin low.

fn set_high(&mut self) -> Result<(), <Pin<Output, PIN> as ErrorType>::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<TC, PIN> SetDutyCycle for Pin<PwmOutput<TC>, PIN>

where PIN: PwmPinOps<TC, Duty = u8>,

fn max_duty_cycle(&self) -> u16

Get the maximum duty cycle value.

fn set_duty_cycle( &mut self, duty: u16 ) -> Result<(), <Pin<PwmOutput<TC>, PIN> as ErrorType>::Error>

Set the duty cycle to duty / max_duty.

fn set_duty_cycle_fully_off(&mut self) -> Result<(), Self::Error>

Set the duty cycle to 0%, or always inactive.

fn set_duty_cycle_fully_on(&mut self) -> Result<(), Self::Error>

Set the duty cycle to 100%, or always active.

fn set_duty_cycle_fraction( &mut self, num: u16, denom: u16 ) -> Result<(), Self::Error>

Set the duty cycle to num / denom.

fn set_duty_cycle_percent(&mut self, percent: u8) -> Result<(), Self::Error>

Set the duty cycle to percent / 100

impl<PIN> StatefulOutputPin for Pin<OpenDrain, PIN>

where PIN: PinOps,

fn is_set_high( &mut self ) -> Result<bool, <Pin<OpenDrain, PIN> as ErrorType>::Error>

Is the pin in drive high mode?

fn is_set_low( &mut self ) -> Result<bool, <Pin<OpenDrain, PIN> as ErrorType>::Error>

Is the pin in drive low mode?

fn toggle(&mut self) -> Result<(), Self::Error>

Toggle pin output.

impl<PIN> StatefulOutputPin for Pin<Output, PIN>

where PIN: PinOps,

fn is_set_high( &mut self ) -> Result<bool, <Pin<Output, PIN> as ErrorType>::Error>

Is the pin in drive high mode?

fn is_set_low(&mut self) -> Result<bool, <Pin<Output, PIN> as ErrorType>::Error>

Is the pin in drive low mode?

fn toggle(&mut self) -> Result<(), Self::Error>

Toggle pin output.