Struct Output

pub struct Output<'d, P = AnyPin> { /* private fields */ }

Push-pull digital output.

This driver configures the GPIO pin to be a push-pull output driver. Push-pull means that the driver actively sets the output voltage level for both high and low logical Levels.

Implementations

impl<'d> Output<'d>

pub fn new( pin: impl Peripheral<P = impl OutputPin> + 'd, initial_output: Level, ) -> Self

Creates a new, type-erased GPIO output driver.

The initial_output parameter sets the initial output level of the pin.

Example

The following example configures GPIO5 to pulse a LED once. The example assumes that the LED is connected such that it is on when the pin is low.

use esp_hal::gpio::{Level, Output};
use esp_hal::delay::Delay;

fn blink_once(led: &mut Output<'_>, delay: &mut Delay) {
    led.set_low();
    delay.delay_millis(500);
    led.set_high();
}

let mut led = Output::new(peripherals.GPIO5, Level::High);
let mut delay = Delay::new();

blink_once(&mut led, &mut delay);

impl<'d, P> Output<'d, P>

where P: OutputPin,

pub fn new_typed( pin: impl Peripheral<P = P> + 'd, initial_output: Level, ) -> Self

Creates a new, typed GPIO output driver.

The initial_output parameter sets the initial output level of the pin.

This constructor is useful when you want to limit which GPIO pin can be used for a particular function.

Example

The following example configures GPIO5 to pulse a LED once. The example assumes that the LED is connected such that it is on when the pin is low.

use esp_hal::gpio::{GpioPin, Level, Output};
use esp_hal::delay::Delay;

fn blink_once(led: &mut Output<'_, GpioPin<5>>, delay: &mut Delay) {
    led.set_low();
    delay.delay_millis(500);
    led.set_high();
}

let mut led = Output::new_typed(peripherals.GPIO5, Level::High);
let mut delay = Delay::new();

blink_once(&mut led, &mut delay);

pub fn split(self) -> (InputSignal, OutputSignal)

Split the pin into an input and output signal.

Peripheral signals allow connecting peripherals together without using external hardware.

pub fn peripheral_input(&self) -> InputSignal

Returns a peripheral input connected to this pin.

The input signal can be passed to peripherals in place of an input pin.

pub fn into_peripheral_output(self) -> OutputSignal

Turns the pin object into a peripheral output.

The output signal can be passed to peripherals in place of an output pin.

pub fn set_high(&mut self)

Set the output as high.

pub fn set_low(&mut self)

Set the output as low.

pub fn set_level(&mut self, level: Level)

Set the output level.

pub fn is_set_high(&self) -> bool

Is the output pin set as high?

pub fn is_set_low(&self) -> bool

Is the output pin set as low?

pub fn output_level(&self) -> Level

What level output is set to

pub fn toggle(&mut self)

Toggle pin output

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

Configure the DriveStrength of the pin

Trait Implementations

impl<P> ErrorType for Output<'_, P>

where P: OutputPin,

type Error = Infallible

Error type

impl<P> OutputPin for Output<'_, P>

where P: OutputPin,

type Error = Infallible

Error type

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

Drives the pin high

fn set_low(&mut self) -> Result<(), Self::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<P> OutputPin for Output<'_, P>

where P: OutputPin,

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

Drives the pin low.

fn set_high(&mut self) -> Result<(), Self::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<'d, P> Peripheral for Output<'d, P>

type P = Flex<'d, P>

Peripheral singleton type

unsafe fn clone_unchecked(&self) -> Self::P

Unsafely clone (duplicate) a peripheral singleton.

fn into_ref<'a>(self) -> PeripheralRef<'a, Self::P>

where Self: 'a,

Convert a value into a PeripheralRef.

fn map_into<U>(self) -> U

where Self::P: Into<U>, U: Peripheral<P = U>,

Map the peripheral using Into.

impl<P> StatefulOutputPin for Output<'_, P>

where P: OutputPin,

fn is_set_high(&self) -> Result<bool, Self::Error>

Is the pin in drive high mode?

fn is_set_low(&self) -> Result<bool, Self::Error>

Is the pin in drive low mode?

impl<P> StatefulOutputPin for Output<'_, P>

where P: OutputPin,

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

Is the pin in drive high mode?

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

Is the pin in drive low mode?

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

Toggle pin output.

impl<P> ToggleableOutputPin for Output<'_, P>

where P: OutputPin,

type Error = Infallible

Error type

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

Toggle pin output.