Trait stm32f407g_disc::hal::digital::v2::StatefulOutputPin

pub trait StatefulOutputPin: OutputPin {
    pub fn is_set_high(&self) -> Result<bool, Self::Error>;
    pub fn is_set_low(&self) -> Result<bool, Self::Error>;
}

Push-pull output pin that can read its output state

This trait is available if embedded-hal is built with the "unproven" feature.

Required methods

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

Is the pin in drive high mode?

NOTE this does not read the electrical state of the pin

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

Is the pin in drive low mode?

NOTE this does not read the electrical state of the pin

Loading content...

Implementors

impl<MODE> StatefulOutputPin for PA0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PA15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PA<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PA<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PA<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PB15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PB<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PB<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PB<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PC15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PC<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PC<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PC<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PD15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PD<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PD<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PD<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PE15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PE<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PE<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PE<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PF15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PF<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PF<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PF<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PG15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PG<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PG<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PG<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PH15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PH<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PH<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PH<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI0<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI0<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI0<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI1<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI1<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI1<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI2<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI2<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI2<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI3<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI3<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI3<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI4<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI4<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI4<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI5<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI5<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI5<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI6<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI6<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI6<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI7<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI7<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI7<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI8<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI8<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI8<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI9<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI9<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI9<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI10<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI10<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI10<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI11<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI11<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI11<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI12<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI12<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI12<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI13<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI13<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI13<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI14<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI14<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI14<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI15<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI15<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(
    &self
) -> Result<bool, <PI15<Output<MODE>> as OutputPin>::Error>

impl<MODE> StatefulOutputPin for PI<Output<MODE>>

pub fn is_set_high(
    &self
) -> Result<bool, <PI<Output<MODE>> as OutputPin>::Error>

pub fn is_set_low(&self) -> Result<bool, <PI<Output<MODE>> as OutputPin>::Error>

impl<T> StatefulOutputPin for T where
    T: StatefulOutputPin + OutputPin, 

Implementation of fallible v2::StatefulOutputPin for v1::StatefulOutputPin digital traits

pub fn is_set_low(&self) -> Result<bool, <T as OutputPin>::Error>

pub fn is_set_high(&self) -> Result<bool, <T as OutputPin>::Error>

Loading content...