#![cfg_attr(docsrs, procmacros::doc_replace(

    "etm_availability" => {

        cfg(etm_driver_supported) => "The GPIO pins also provide tasks and events via the ETM interconnect system. For more information, see the [etm] module."

    }

))]

//! # General Purpose Input/Output (GPIO)

//!

//! ## Overview

//!

//! Each pin can be used as a general-purpose I/O, or be connected to one or

//! more internal peripheral signals.

//! # {etm_availability}

//! ## Working with pins

//!

//! After initializing the HAL, you can access the individual pins using the

//! [`crate::Peripherals`] struct. These pins can then be used as general

//! purpose digital IO using pin drivers, or they can be passed to peripherals

//! (such as SPI, UART, I2C, etc.), or can be [`split`]

//! into peripheral signals for advanced use.

//!

//! Pin drivers can be created using [`Flex::new`], [`Input::new`] and

//! [`Output::new`].

//!

//! Output pins can be configured to either push-pull or open-drain (active low)

//! mode, with configurable drive strength and pull-up/pull-down resistors.

//!

//! Each pin is a different type initially. Internally, `esp-hal` will erase

//! their types automatically, but they can also be converted into [`AnyPin`]

//! manually by calling [`Pin::degrade`].

//!

//! The [`Io`] struct can also be used to configure the interrupt handler for

//! GPIO interrupts. For more information, see the

//! [`InterruptConfigurable::set_interrupt_handler`](crate::interrupt::InterruptConfigurable::set_interrupt_handler).

//!

//! This driver also implements pin-related traits from [embedded-hal] and

//! [Wait](embedded_hal_async::digital::Wait) trait from [embedded-hal-async].

//!

//! ## GPIO interconnect

//!

//! Sometimes you may want to connect peripherals together without using

//! external hardware. The [`interconnect`] module provides tools to achieve

//! this using GPIO pins.

//!

//! To obtain peripheral signals, use the [`split`] method to split a

//! pin into an input and output signal. Alternatively, you may use

//! [`Flex::split`], [`Flex::into_peripheral_output`],

//! [`Flex::peripheral_input`], and similar methods to split a pin driver into

//! an input and output signal. You can then pass these signals to the

//! peripheral drivers similar to how you would pass a pin.

//!

//! [embedded-hal]: embedded_hal

//! [embedded-hal-async]: embedded_hal_async

//! [`split`]: crate::peripherals::GPIO0::split

crate::unstable_module! {

    pub mod interconnect;

    #[cfg(etm_driver_supported)]

    pub mod etm;

    #[cfg(lp_io_driver_supported)]

    pub mod lp_io;

    #[cfg(dedicated_gpio_driver_supported)]

    pub mod dedicated;

}

use interconnect::PeripheralOutput;

mod asynch;

mod embedded_hal_impls;

pub(crate) mod interrupt;

mod low_level;

use interrupt::*;

pub use low_level::GpioBank;

use low_level::{gpio_intr_enable, is_int_enabled, set_int_enable};

mod placeholder;

#[cfg(sleep_driver_supported)]

pub(crate) mod wakeup;

use core::fmt::Display;

use esp_sync::RawMutex;

pub use placeholder::NoPin;

#[cfg(sleep_driver_supported)]

#[instability::unstable]

pub use wakeup::WakeupConfig;

use crate::{

    asynch::AtomicWaker,

    interrupt::{InterruptHandler, Priority},

    peripherals::{GPIO, IO_MUX},

    private::{self, Sealed},

};

pub(crate) static GPIO_LOCK: RawMutex = RawMutex::new();

/// Represents a pin-peripheral connection that, when dropped, disconnects the

/// peripheral from the pin.

///

/// This only needs to be applied to output signals, as it is not possible to connect multiple

/// inputs to the same peripheral signal.

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub(crate) struct PinGuard {

}

impl crate::private::Sealed for PinGuard {}

impl PinGuard {

    // This must only be used with a pin currently configured for output, and the PinGuard must be

    // dropped before the pin can be reconfigured (e.g. for input).

    fn new(pin: AnyPin<'_>) -> Self {

        Self { pin: pin.number() }

    }

    pub(crate) const fn new_unconnected() -> Self {

        Self { pin: u8::MAX }

    }

    #[allow(unused)]

    pub(crate) fn pin_number(&self) -> Option<u8> {

            None

        } else {

            Some(self.pin)

        }

    }

}

impl Drop for PinGuard {

            let pin = unsafe { AnyPin::steal(self.pin) };

            pin.disconnect_from_peripheral_output();

        }

}

/// Event used to trigger interrupts.

#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

#[instability::unstable]

pub enum Event {

    /// Interrupts trigger on rising pin edge.

    RisingEdge  = 1,

    /// Interrupts trigger on falling pin edge.

    FallingEdge = 2,

    /// Interrupts trigger on either rising or falling pin edges.

    AnyEdge     = 3,

    /// Interrupts trigger on low level

    LowLevel    = 4,

    /// Interrupts trigger on high level

    HighLevel   = 5,

}

/// Digital input or output level.

///

/// `Level` can be used to control a GPIO output, and it can act as a peripheral

/// signal and be connected to peripheral inputs and outputs.

///

/// When connected to a peripheral

/// input, the peripheral will read the corresponding level from that signal.

///

/// When connected to a peripheral output, the level will be ignored.

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub enum Level {

    /// Low

    Low,

    /// High

    High,

}

impl Sealed for Level {}

impl core::ops::Not for Level {

    type Output = Self;

    fn not(self) -> Self {

        match self {

            Self::Low => Self::High,

            Self::High => Self::Low,

        }

    }

}

impl Level {

    /// Creates a new [`Level`] from [`bool`].

    ///

    /// Like `<Level as From<bool>>::from(val)`, but `const`.

    pub(crate) const fn const_from(val: bool) -> Self {

            true => Self::High,

            false => Self::Low,

        }

    }

    /// Converts a [`Level`] to [`bool`].

    ///

    /// Like `<bool as From<Level>>::from(self)`, but `const`.

    pub(crate) const fn const_into(self) -> bool {

        match self {

            Level::Low => false,

            Level::High => true,

        }

    }

}

impl From<bool> for Level {

    fn from(val: bool) -> Self {

        Self::const_from(val)

    }

}

impl From<Level> for bool {

    fn from(level: Level) -> bool {

        level.const_into()

    }

}

/// Errors that can occur when configuring a pin to be a wakeup source.

#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

#[instability::unstable]

#[non_exhaustive]

pub enum WakeConfigError {

    /// The pad has no low-power path. It cannot wake the chip while the high-performance GPIO

    /// peripheral is powered down.

    NoLowPowerPath,

}

impl Display for WakeConfigError {

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

        match self {

            WakeConfigError::NoLowPowerPath => {

                write!(f, "The pad is not a low-power pad")

            }

        }

    }

}

impl core::error::Error for WakeConfigError {}

/// Pull setting for a GPIO.

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub enum Pull {

    /// No pull

    None,

    /// Pull up

    Up,

    /// Pull down

    Down,

}

/// Drive strength (values are approximates)

#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash, PartialOrd, Ord)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub enum DriveStrength {

    /// Drive strength of approximately 5mA.

    _5mA  = 0,

    /// Drive strength of approximately 10mA.

    _10mA = 1,

    /// Drive strength of approximately 20mA.

    _20mA = 2,

    /// Drive strength of approximately 40mA.

    _40mA = 3,

}

/// Alternate functions

///

/// GPIO pins can be configured for various functions, such as GPIO

/// or being directly connected to a peripheral's signal like UART, SPI, etc.

/// The `AlternateFunction` enum allows selecting one of several functions that

/// a pin can perform, rather than using it as a general-purpose input or

/// output.

///

/// The different variants correspond to different functionality depending on

/// the chip and the specific pin. For more information, refer to the chip's

#[doc(hidden)]

#[doc = crate::trm_markdown_link!("iomuxgpio")]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub enum AlternateFunction {

    /// Alternate function 0.

    _0 = 0,

    /// Alternate function 1.

    _1 = 1,

    /// Alternate function 2.

    _2 = 2,

    /// Alternate function 3.

    _3 = 3,

    /// Alternate function 4.

    _4 = 4,

    /// Alternate function 5.

    _5 = 5,

}

impl AlternateFunction {

    pub(crate) const GPIO: Self = match Self::const_try_from(property!("gpio.gpio_function")) {

        Ok(func) => func,

        Err(_) => ::core::panic!("Invalid GPIO function"),

    };

    const fn const_try_from(value: usize) -> Result<Self, ()> {

        match value {

            0 => Ok(Self::_0),

            1 => Ok(Self::_1),

            2 => Ok(Self::_2),

            3 => Ok(Self::_3),

            4 => Ok(Self::_4),

            5 => Ok(Self::_5),

            _ => Err(()),

        }

    }

}

impl TryFrom<usize> for AlternateFunction {

    type Error = ();

    fn try_from(value: usize) -> Result<Self, Self::Error> {

        Self::const_try_from(value)

    }

}

/// Trait implemented by the pins that the low-power domain can reach.

///

/// The low-power domain has its own numbers for these pads, and the low-power registers take such a

/// number. Only some chips give a pad the same number in both domains, so do not mix the two

/// numbers. Give [`Self::lp_number`] to the low-power registers, and [`Pin::number`] to the digital

/// registers.

#[instability::unstable]

#[cfg(lp_io_driver_supported)]

pub trait LpPin: Pin {

    /// LP number of the pin

    fn lp_number(&self) -> u8;

}

/// Common trait implemented by pins

pub trait Pin: Sealed {

    /// GPIO number

    fn number(&self) -> u8;

    #[procmacros::doc_replace]

    /// Type-erases this pin into an [`AnyPin`].

    ///

    /// Converts pin singletons (`GPIO0<'_>`, …), which are all different types,

    /// into the same type. Useful for creating arrays of pins, or avoiding

    /// generics.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::{

    ///     delay::Delay,

    ///     gpio::{AnyPin, Level, Output, OutputConfig, Pin},

    /// };

    ///

    /// fn toggle_pins(pins: [AnyPin; 2], delay: &mut Delay) {

    ///     let [red, blue] = pins;

    ///     let mut red = Output::new(red, Level::High, OutputConfig::default());

    ///     let mut blue = Output::new(blue, Level::Low, OutputConfig::default());

    ///

    ///     loop {

    ///         red.toggle();

    ///         blue.toggle();

    ///         delay.delay_millis(500);

    ///     }

    /// }

    ///

    /// let pins: [AnyPin; 2] = [peripherals.GPIO5.degrade(), peripherals.GPIO4.degrade()];

    ///

    /// let mut delay = Delay::new();

    /// toggle_pins(pins, &mut delay);

    /// # {after_snippet}

    /// ```

    fn degrade<'d>(self) -> AnyPin<'d>

    where

        Self: Sized + 'd,

    {

    }

    #[doc(hidden)]

    fn output_signals(&self, _: private::Internal) -> &'static [(AlternateFunction, OutputSignal)];

    #[doc(hidden)]

    fn input_signals(&self, _: private::Internal) -> &'static [(AlternateFunction, InputSignal)];

}

/// Trait implemented by pins which can be used as inputs.

pub trait InputPin: Pin {

    #[doc(hidden)]

    fn waker(&self) -> &'static AtomicWaker;

}

/// Trait implemented by pins which can be used as outputs.

pub trait OutputPin: Pin {}

/// Trait implemented by pins which can be used as analog pins.

#[instability::unstable]

pub trait AnalogPin: Pin {

    /// Configures the pin for analog operation.

    #[doc(hidden)]

    fn set_analog(&self, _: private::Internal);

}

/// Trait implemented by pins which can be used as Touchpad pins.

#[cfg(touch_driver_supported)]

#[instability::unstable]

pub trait TouchPin: Pin {

    /// Configures the pin for analog operation.

    #[doc(hidden)]

    fn set_touch(&self, _: private::Internal);

    /// Reads the pin's touch measurement register.

    #[doc(hidden)]

    fn touch_measurement(&self, _: private::Internal) -> u16;

    /// Maps the pin nr to the touch pad nr.

    #[doc(hidden)]

    fn touch_nr(&self, _: private::Internal) -> u8;

    /// Sets a pins touch threshold for interrupts.

    #[doc(hidden)]

    fn set_threshold(&self, threshold: u16, _: private::Internal);

}

/// Any GPIO pin.

#[derive(Debug)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub struct AnyPin<'lt> {

    pub(crate) pin: u8,

    pub(crate) _lifetime: core::marker::PhantomData<&'lt mut ()>,

}

/// General Purpose Input/Output driver.

#[derive(Debug)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

#[instability::unstable]

pub struct Io<'d> {

    _io_mux: IO_MUX<'d>,

}

impl<'d> Io<'d> {

    /// Initializes the I/O driver.

    #[instability::unstable]

    pub fn new(_io_mux: IO_MUX<'d>) -> Self {

        Io { _io_mux }

    }

    #[doc = cfg_select!{

        any(single_core, esp32s3) => "Sets the interrupt priority and enables GPIO interrupts.",

        _ => "Sets the interrupt priority and enables GPIO interrupts on all cores.",

    }]

    #[instability::unstable]

    pub fn set_interrupt_priority(&self, prio: Priority) {

        low_level::set_interrupt_priority(prio);

    }

    #[doc = cfg_select!{

        any(single_core, esp32s3) => "Registers an interrupt handler for all GPIO pins.",

        _ => "Registers an interrupt handler for all GPIO pins. Enables interrupts on all cores.",

    }]

    #[doc = ""]

    /// When using interrupt handlers registered by this method, or by defining a

    /// `#[no_mangle] unsafe extern "C" fn GPIO()` function, the interrupt status

    /// register and the interrupt enable setting for the GPIO pin are **not**

    /// cleared automatically. Based on the use case, do one of the following:

    ///

    /// - Disabling the interrupt enable setting for the GPIO pin lets an event be handled once per

    ///   call to [`listen()`]. Using this method, the [`is_interrupt_set()`] method returns `true`

    ///   if the interrupt is set even after the handler has finished running.

    /// - Clearing the interrupt status register lets an event be handled repeatedly after

    ///   [`listen()`] is called. Using this method, [`is_interrupt_set()`] returns `false` after

    ///   the handler has finished running.

    ///

    /// [`listen()`]: Input::listen

    /// [`is_interrupt_set()`]: Input::is_interrupt_set

    #[instability::unstable]

    pub fn set_interrupt_handler(&mut self, handler: InterruptHandler) {

        USER_INTERRUPT_HANDLER.store(handler.handler().callback());

        low_level::enable_interrupt(InterruptHandler::new(

            user_gpio_interrupt_handler,

            handler.priority(),

        ));

}

impl crate::private::Sealed for Io<'_> {}

#[instability::unstable]

impl crate::interrupt::InterruptConfigurable for Io<'_> {

    fn set_interrupt_handler(&mut self, handler: InterruptHandler) {

        self.set_interrupt_handler(handler);

    }

}

/// Drives the GPIO async API from a user-installed raw GPIO interrupt handler.

///

/// Entry point for code that bypasses esp-hal's GPIO ISR dispatch (typically

/// by defining a custom `#[unsafe(no_mangle)] unsafe extern "C" fn GPIO()`, or

/// by registering a handler via [`crate::interrupt::bind_handler`]) and needs

/// the GPIO async API to keep working.

///

/// # Safety

///

/// Must be called from a GPIO interrupt context.

#[instability::unstable]

}

/// Completes any in-flight async wait on a single GPIO pin.

///

/// Per-pin counterpart of [`handle_gpio_interrupt`].

///

/// # Safety

///

/// Must be called from a GPIO interrupt context.

#[instability::unstable]

}

for_each_analog_function! {

    (($_ch:ident, ADCn_CHm, $_n:literal, $_m:literal), $gpio:ident) => {

        #[instability::unstable]

        impl $crate::gpio::AnalogPin for crate::peripherals::$gpio<'_> {

                cfg_select! {

                    xtensa => { self.set_analog_impl(); }

                    riscv => {

                        // Just configure as a floating GPIO.

                        io_mux_reg(self.number()).modify(|_, w| {

                            w.fun_wpu().clear_bit();

                            w.fun_wpd().clear_bit()

                        });

                    }

                }

        }

    };

}

/// The drive mode of the output pin.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub enum DriveMode {

    /// Push-pull output.

    ///

    /// The driver actively sets the output voltage level for both high and low

    /// logical [`Level`]s.

    PushPull,

    /// Open drain output.

    ///

    /// The driver actively pulls the output voltage level low for the low

    /// logical [`Level`], but leaves the high level floating, which is then

    /// determined by external hardware, or internal pull-up/pull-down

    /// resistors.

    #[cfg_attr(

        feature = "unstable",

        doc = "\n\nEnable the input related functionality by using [Output::into_flex] and enabling input via [Flex::set_input_enable]"

    )]

    OpenDrain,

}

/// Output pin configuration.

///

/// Configures the drive mode, drive strength, and pull direction of an output

/// pin. By default, the configuration is set to:

/// - Drive mode: [`DriveMode::PushPull`]

/// - Drive strength: [`DriveStrength::_20mA`]

/// - Pull direction: [`Pull::None`] (no pull resistors connected)

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

#[derive(Debug, Clone, Copy, PartialEq, Eq, procmacros::BuilderLite)]

#[non_exhaustive]

pub struct OutputConfig {

    /// Output drive mode.

    drive_mode: DriveMode,

    /// Pin drive strength.

    drive_strength: DriveStrength,

    /// Pin pull direction.

    pull: Pull,

}

impl Default for OutputConfig {

    fn default() -> Self {

        Self {

            drive_mode: DriveMode::PushPull,

            drive_strength: DriveStrength::_20mA,

            pull: Pull::None,

        }

    }

}

/// Push-pull digital output.

///

/// This driver configures the GPIO pin to be an output driver.

#[derive(Debug)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub struct Output<'d> {

    pin: Flex<'d>,

}

impl private::Sealed for Output<'_> {}

impl private::Sealed for &mut Output<'_> {}

impl<'d> Output<'d> {

    #[procmacros::doc_replace]

    /// Creates a new GPIO output driver.

    ///

    /// The `initial_level` parameter sets the initial output level of the pin.

    /// The `config` parameter sets the drive mode, drive strength, and pull

    /// direction of the pin.

    ///

    /// # Examples

    ///

    /// 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.

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::{

    ///     delay::Delay,

    ///     gpio::{Level, Output, OutputConfig},

    /// };

    ///

    /// fn blink_once(led: &mut Output<'_>, delay: &mut Delay) {

    ///     led.set_low();

    ///     delay.delay_millis(500);

    ///     led.set_high();

    /// }

    ///

    /// let config = OutputConfig::default();

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

    /// let mut delay = Delay::new();

    ///

    /// blink_once(&mut led, &mut delay);

    /// # {after_snippet}

    /// ```

    #[inline]

        // Set up the pin

        let mut this = Self {

            pin: Flex::new(pin),

        };

        this.set_level(initial_level);

        this.apply_config(&config);

        this.pin.pin.set_output_enable(true);

        this

    #[procmacros::doc_replace]

    /// Turns the pin object into a peripheral

    /// [output][interconnect::OutputSignal].

    ///

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

    /// pin.

    ///

    /// The returned signal is [frozen](interconnect::OutputSignal::freeze).

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Level, Output, OutputConfig};

    /// # let config = OutputConfig::default();

    /// let pin1_gpio = Output::new(peripherals.GPIO1, Level::High, config);

    /// let output = pin1_gpio.into_peripheral_output();

    /// # {after_snippet}

    /// ```

    #[inline]

    #[instability::unstable]

    pub fn into_peripheral_output(self) -> interconnect::OutputSignal<'d> {

        self.pin.into_peripheral_output()

    }

    #[procmacros::doc_replace]

    /// Changes the configuration.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{DriveMode, Level, Output, OutputConfig};

    /// let mut pin = Output::new(peripherals.GPIO5, Level::High, OutputConfig::default());

    ///

    /// pin.apply_config(&OutputConfig::default().with_drive_mode(DriveMode::OpenDrain));

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn apply_config(&mut self, config: &OutputConfig) {

        self.pin.apply_output_config(config)

    }

    #[procmacros::doc_replace]

    /// Sets the output as high.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Level, Output, OutputConfig};

    /// let mut pin = Output::new(peripherals.GPIO5, Level::Low, OutputConfig::default());

    /// pin.set_high();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn set_high(&mut self) {

        self.set_level(Level::High)

    }

    #[procmacros::doc_replace]

    /// Sets the output as low.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Level, Output, OutputConfig};

    /// let mut pin = Output::new(peripherals.GPIO5, Level::High, OutputConfig::default());

    /// pin.set_low();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn set_low(&mut self) {

        self.set_level(Level::Low)

    }

    #[procmacros::doc_replace]

    /// Sets the output level.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Level, Output, OutputConfig};

    /// let mut pin = Output::new(peripherals.GPIO5, Level::High, OutputConfig::default());

    /// pin.set_level(Level::Low);

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

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

        self.pin.set_level(level)

    }

    #[procmacros::doc_replace]

    /// Returns whether the pin is set to high level.

    ///

    /// Reads back the value set using `set_level`, `set_high` or `set_low`. Does

    /// not need the input stage to be enabled.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Level, Output, OutputConfig};

    /// let pin = Output::new(peripherals.GPIO5, Level::High, OutputConfig::default());

    /// let is_high = pin.is_set_high();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn is_set_high(&self) -> bool {

        self.output_level() == Level::High

    }

    #[procmacros::doc_replace]

    /// Returns whether the pin is set to low level.

    ///

    /// Reads back the value set using `set_level`, `set_high` or `set_low`. Does

    /// not need the input stage to be enabled.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Level, Output, OutputConfig};

    /// let pin = Output::new(peripherals.GPIO5, Level::High, OutputConfig::default());

    /// let is_low = pin.is_set_low();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn is_set_low(&self) -> bool {

        self.output_level() == Level::Low

    }

    #[procmacros::doc_replace]

    /// Returns which level the pin is set to.

    ///

    /// Reads back the value set using `set_level`, `set_high` or `set_low`. Does

    /// not need the input stage to be enabled.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Level, Output, OutputConfig};

    /// let pin = Output::new(peripherals.GPIO5, Level::High, OutputConfig::default());

    /// let level = pin.output_level();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn output_level(&self) -> Level {

        self.pin.output_level()

    }

    #[procmacros::doc_replace]

    /// Toggles the pin output.

    ///

    /// If the pin was previously set to high, it will be set to low, and vice

    /// versa.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Level, Output, OutputConfig};

    /// let mut pin = Output::new(peripherals.GPIO5, Level::High, OutputConfig::default());

    /// pin.toggle();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn toggle(&mut self) {

        self.pin.toggle();

    }

    /// Takes or releases the hold of the pad.

    ///

    /// A held pad keeps its level, its function and its resistors, and it ignores this driver.

    #[inline]

    #[instability::unstable]

    #[cfg(lp_io_driver_supported)]

    pub fn set_pad_hold(&mut self, enable: bool) {

        self.pin.set_pad_hold(enable);

    }

    /// Returns whether something holds the pad.

    #[inline]

    #[instability::unstable]

    #[cfg(lp_io_driver_supported)]

    pub fn is_pad_held(&self) -> bool {

        self.pin.is_pad_held()

    }

    /// Converts the pin driver into a [`Flex`] driver.

    #[inline]

    #[instability::unstable]

    pub fn into_flex(self) -> Flex<'d> {

        self.pin

    }

}

/// Configures the clock edge used in one of the two input synchronization stages to synchronize the

/// GPIO input signal to the system clock, reducing metastability.

///

/// See [`InputConfig::with_input_sync_stage1`] and

/// [`InputConfig::with_input_sync_stage2`].

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

#[instability::unstable]

#[cfg(gpio_has_input_sync)]

pub enum InputSync {

    /// Stage is disabled; the signal passes through without latching (hardware

    /// default).

    #[default]

    Disabled     = 0,

    /// Stage latches on the falling edge of the GPIO clock.

    NegativeEdge = 1,

    /// Stage latches on the rising edge of the GPIO clock.

    PositiveEdge = 2,

}

/// Input pin configuration.

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

#[non_exhaustive]

pub struct InputConfig {

    /// Initial pull of the pin.

    pull: Pull,

    /// First input synchronization stage.

    ///

    /// Default value: [`InputSync::Disabled`].

    #[cfg(gpio_has_input_sync)]

    #[builder_lite(unstable)]

    input_sync_stage1: InputSync,

    /// Second input synchronization stage.

    ///

    /// Default value: [`InputSync::Disabled`].

    #[cfg(gpio_has_input_sync)]

    #[builder_lite(unstable)]

    input_sync_stage2: InputSync,

}

impl Default for InputConfig {

    fn default() -> Self {

        Self {

            pull: Pull::None,

            #[cfg(gpio_has_input_sync)]

            input_sync_stage1: Default::default(),

            #[cfg(gpio_has_input_sync)]

            input_sync_stage2: Default::default(),

        }

    }

}

/// Digital input.

///

/// This driver configures the GPIO pin to be an input. Input drivers read the

/// voltage of their pins and convert it to a logical [`Level`].

#[derive(Debug)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

pub struct Input<'d> {

    pin: Flex<'d>,

}

impl private::Sealed for Input<'_> {}

impl private::Sealed for &mut Input<'_> {}

impl<'d> Input<'d> {

    #[procmacros::doc_replace]

    /// Creates a new GPIO input.

    ///

    /// The `pull` parameter configures internal pull-up or pull-down

    /// resistors.

    ///

    /// # Examples

    ///

    /// The following example configures `GPIO5` to read a button press. The

    /// example assumes that the button is connected such that the pin is low

    /// when the button is pressed.

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::{

    ///     delay::Delay,

    ///     gpio::{Input, InputConfig, Level, Pull},

    /// };

    ///

    /// fn print_when_pressed(button: &mut Input<'_>, delay: &mut Delay) {

    ///     let mut was_pressed = false;

    ///     loop {

    ///         let is_pressed = button.is_low();

    ///         if is_pressed && !was_pressed {

    ///             println!("Button pressed!");

    ///         }

    ///         was_pressed = is_pressed;

    ///         delay.delay_millis(100);

    ///     }

    /// }

    ///

    /// let config = InputConfig::default().with_pull(Pull::Up);

    /// let mut button = Input::new(peripherals.GPIO5, config);

    /// let mut delay = Delay::new();

    ///

    /// print_when_pressed(&mut button, &mut delay);

    /// # {after_snippet}

    /// ```

    #[inline]

        let mut pin = Flex::new(pin);

        pin.set_output_enable(false);

        pin.set_input_enable(true);

        pin.apply_input_config(&config);

        Self { pin }

    #[procmacros::doc_replace]

    /// Returns a peripheral [input][interconnect::InputSignal] connected to

    /// this pin.

    ///

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

    ///

    /// The returned signal is [frozen](interconnect::InputSignal::freeze).

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// #

    /// use esp_hal::gpio::{Input, InputConfig, Pull};

    /// let config = InputConfig::default().with_pull(Pull::Up);

    /// let pin1_gpio = Input::new(peripherals.GPIO1, config);

    /// let pin1 = pin1_gpio.peripheral_input();

    /// #

    /// # {after_snippet}

    /// ```

    #[inline]

    #[instability::unstable]

    pub fn peripheral_input(&self) -> interconnect::InputSignal<'d> {

        self.pin.peripheral_input()

    }

    #[procmacros::doc_replace]

    /// Returns whether the pin input level is high.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Input, InputConfig};

    /// let pin = Input::new(peripherals.GPIO5, InputConfig::default());

    /// let is_high = pin.is_high();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn is_high(&self) -> bool {

        self.level() == Level::High

    }

    #[procmacros::doc_replace]

    /// Returns whether the pin input level is low.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Input, InputConfig};

    /// let pin = Input::new(peripherals.GPIO5, InputConfig::default());

    /// let is_low = pin.is_low();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn is_low(&self) -> bool {

        self.level() == Level::Low

    }

    #[procmacros::doc_replace]

    /// Returns the current pin input level.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Input, InputConfig, Level};

    /// let pin = Input::new(peripherals.GPIO5, InputConfig::default());

    /// let level = pin.level();

    ///

    /// # {after_snippet}

    /// ```

    #[inline]

    pub fn level(&self) -> Level {

        self.pin.level()

    }

    #[procmacros::doc_replace]

    /// Changes the configuration.

    ///

    /// # Examples

    ///

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Input, InputConfig, Level, Pull};

    /// let mut pin = Input::new(peripherals.GPIO5, InputConfig::default());

    /// pin.apply_config(&InputConfig::default().with_pull(Pull::Up));

    ///

    /// # {after_snippet}

    /// ```

    pub fn apply_config(&mut self, config: &InputConfig) {

        self.pin.apply_input_config(config)

    #[procmacros::doc_replace]

    /// Listens for interrupts.

    ///

    /// The interrupts will be handled by the handler set using

    /// [`Io::set_interrupt_handler`]. All GPIO pins share the same

    /// interrupt handler.

    ///

    /// [`Event::LowLevel`] and [`Event::HighLevel`] are fired continuously when

    /// the pin is low or high, respectively. A custom interrupt handler is

    /// required to stop listening for these events; otherwise the program can

    /// remain in a loop as long as the pin reads the corresponding level.

    ///

    /// A listening pin also ends a light sleep. On most chips, sleep entry must give the trigger as

    /// a level, so an edge trigger becomes the level at the end of the edge. A rising edge becomes

    /// a high level, a falling edge becomes a low level, and any edge becomes the level that

    /// the pin is not at when the sleep starts. A pin that listens for a rising edge on a line

    /// that is already high therefore ends each light sleep immediately, and without an

    /// interrupt, because no edge occurred. Automatic light sleep then makes no sleep at all.

    ///

    /// # Examples

    ///

    /// ### Print something when a button is pressed.

    /// ```rust, no_run

    /// # {before_snippet}

    /// use esp_hal::gpio::{Event, Input, InputConfig, Io, Pull};

    ///

    /// let mut io = Io::new(peripherals.IO_MUX);

    /// io.set_interrupt_handler(handler);

    ///

    /// // Set up the input and store it in the static variable.

    /// // This example uses a push button that is high when not

    /// // pressed and low when pressed.

    /// let config = InputConfig::default().with_pull(Pull::Up);

    /// let mut button = Input::new(peripherals.GPIO5, config);

    ///

    /// critical_section::with(|cs| {

    ///     // Here we are listening for a low level to demonstrate

    ///     // that you need to stop listening for level interrupts,

    ///     // but usually you'd probably use `FallingEdge`.

    ///     button.listen(Event::LowLevel);

    ///     BUTTON.borrow_ref_mut(cs).replace(button);

    /// });

    /// # {after_snippet}

    ///

    /// // Outside of your `main` function:

    ///

    /// use core::cell::RefCell;

    ///

    /// use critical_section::Mutex;

    /// use esp_hal::gpio::Input;

    ///

    /// // You will need to store the `Input` object in a static variable so

    /// // that the interrupt handler can access it.

    /// static BUTTON: Mutex<RefCell<Option<Input>>> = Mutex::new(RefCell::new(None));

    ///

    /// #[esp_hal::handler]

    /// fn handler() {

    ///     critical_section::with(|cs| {

    ///         let mut button = BUTTON.borrow_ref_mut(cs);

    ///         let Some(button) = button.as_mut() else {

    ///             // Some other interrupt has occurred

    ///             // before the button was set up.

    ///             return;

    ///         };

    ///

    ///         if button.is_interrupt_set() {

    ///             print!("Button pressed");

    ///

    ///             // If you want to stop listening for interrupts, you need to

    ///             // call `unlisten` here. If you comment this line, the

    ///             // interrupt will fire continuously while the button

    ///             // is pressed.

    ///             button.unlisten();

    ///         }

    ///     });

    /// }

    /// ```

    #[inline]

    #[instability::unstable]

    pub fn listen(&mut self, event: Event) {

        self.pin.listen(event);

    }

    /// Stops listening for interrupts.

    #[inline]

    #[instability::unstable]

    pub fn unlisten(&mut self) {

        self.pin.unlisten();

    }

    /// Clears the interrupt status bit for this Pin.

    #[inline]

    #[instability::unstable]

    pub fn clear_interrupt(&mut self) {

        self.pin.clear_interrupt();

    }

    /// Returns whether the interrupt status bit for this Pin is set.

    #[inline]

    #[instability::unstable]

    pub fn is_interrupt_set(&self) -> bool {

        self.pin.is_interrupt_set()

    }

    /// Configures whether the pin can wake the chip from sleep.

    ///

    /// [`Flex::apply_wakeup_config`] describes the configuration, and the conditions that wake the

    /// chip.

    ///

    /// # Errors

    ///

    /// [`WakeConfigError::NoLowPowerPath`] when the configuration requests the low-power path

    /// for a pad that has no such path.

    #[cfg(sleep_driver_supported)]

    #[instability::unstable]

    #[inline]

    pub fn apply_wakeup_config(&mut self, config: &WakeupConfig) -> Result<(), WakeConfigError> {

        self.pin.apply_wakeup_config(config)

    }

    /// Returns whether this pin ended the most recent sleep.

    ///

    /// See [`Flex::caused_wakeup`].

    #[cfg(sleep_driver_supported)]

    #[instability::unstable]

    #[inline]

    pub fn caused_wakeup(&self) -> bool {

        self.pin.caused_wakeup()

    }

    /// Takes or releases the hold of the pad.

    ///

    /// A held pad keeps its level, its function and its resistors, and it ignores this driver.

    #[inline]

    #[instability::unstable]

    #[cfg(lp_io_driver_supported)]

    pub fn set_pad_hold(&mut self, enable: bool) {

        self.pin.set_pad_hold(enable);

    }

    /// Returns whether something holds the pad.

    #[inline]

    #[instability::unstable]

    #[cfg(lp_io_driver_supported)]

    pub fn is_pad_held(&self) -> bool {

        self.pin.is_pad_held()

    }

    /// Converts the pin driver into a [`Flex`] driver.

    #[inline]

    #[instability::unstable]

    pub fn into_flex(self) -> Flex<'d> {

        self.pin

    }

}

/// Flexible pin driver.

///

/// This pin driver can act as either input, or output, or both at the same

/// time. The input and output are (not counting the shared pull direction)

/// separately configurable, and they have independent enable states.

///

/// Enabling the input stage does not change the output stage, and vice versa.

/// Disabling the input or output stages do not forget their configuration.

/// Disabling the output stage will not change the output level, but it will

/// disable the driver.

#[derive(Debug)]

#[cfg_attr(feature = "defmt", derive(defmt::Format))]

#[instability::unstable]

pub struct Flex<'d> {

    pin: AnyPin<'d>,

}

impl private::Sealed for Flex<'_> {}

impl private::Sealed for &mut Flex<'_> {}

impl<'d> Flex<'d> {

    /// Creates flexible pin driver for a [Pin].

    /// No mode change happens.

    #[inline]

    #[instability::unstable]

    pub fn new(pin: impl Pin + 'd) -> Self {

        // Before each use, reset the GPIO to a known state.

        pin.init_gpio();

    }

    // Input functions

    /// Applies the given input configuration to the pin.

    ///

    /// Does not set the pin as input (does not enable the input buffer). The pull

    /// direction is common between the input and output configuration.

    #[inline]

    #[instability::unstable]

    pub fn apply_input_config(&mut self, config: &InputConfig) {

    }

    /// Enables or disables the GPIO pin input buffer.

    #[inline]

    #[instability::unstable]

    pub fn set_input_enable(&mut self, enable_input: bool) {

        self.pin.set_input_enable(enable_input);

    }

    /// Takes or releases the hold of the pad.

    ///

    /// A held pad keeps its level, its function and its resistors, and it ignores this driver.

    #[inline]

    #[instability::unstable]

    #[cfg(lp_io_driver_supported)]

    pub fn set_pad_hold(&mut self, enable: bool) {

    }

    /// Returns whether something holds the pad.

    #[inline]

    #[instability::unstable]

    #[cfg(lp_io_driver_supported)]

    pub fn is_pad_held(&self) -> bool {

    }

    /// Returns whether the pin input level is high.

    #[inline]

    #[instability::unstable]

    pub fn is_high(&self) -> bool {

        self.level() == Level::High

    }

    /// Returns whether the pin input level is low.

    #[inline]

    #[instability::unstable]

    pub fn is_low(&self) -> bool {

        self.level() == Level::Low

    }

    /// Returns the current pin input level.

    #[inline]

    #[instability::unstable]

    pub fn level(&self) -> Level {

        self.pin.is_input_high().into()