Trait gd32vf103_hal::gpio::Unlock

pub trait Unlock {
    type Lock;
    type Output;
    fn unlock(self, lock: &mut Self::Lock) -> Self::Output;
}

Useful unlock methods for lock marked pins

Note: We design this trait other than giving all pins an unlock method because if we do so, the rust doc of struct Lock could be full of unlock methods (dozens of them) with full documents for each unlock functions, which could be confusing for users and costs much time to read and build. If any questions, please fire an issue to let us know.

Associated Types

type Lock

The lock controller register block, typically a LOCK struct with temporary variant bits for each pins.

type Output

Unlock output, typically a PXi struct with mode typestate.

Loading content...

Required methods

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

Mark the locked pin as unlocked to allow configurations of pin mode.

Typically this method uses a mutable borrow of LOCK struct of the gpio port. This function is not an actually unlock; it only clears the corresponding bit in a temporary variant in LOCK. To actually perform and freeze the lock, use freeze; see function lock for details.

The caller of this method must obtain a mutable reference of LOCK struct; if you have called the freeze method of that LOCK struct, the actually lock operation would perform and lock state of all pins would be no longer possible to change - see its documentation for details.

Loading content...

Implementors

impl<MODE> Unlock for Locked<PA0<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA0<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA1<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA1<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA2<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA2<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA3<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA3<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA4<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA4<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA5<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA5<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA6<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA6<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA7<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA7<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA8<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA8<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA9<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA9<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA10<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA10<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA11<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA11<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA12<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA12<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA13<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA13<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA14<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA14<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PA15<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PA15<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB0<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB0<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB1<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB1<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB2<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB2<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB3<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB3<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB4<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB4<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB5<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB5<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB6<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB6<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB7<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB7<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB8<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB8<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB9<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB9<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB10<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB10<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB11<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB11<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB12<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB12<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB13<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB13<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB14<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB14<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PB15<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PB15<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC0<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC0<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC1<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC1<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC2<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC2<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC3<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC3<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC4<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC4<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC5<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC5<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC6<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC6<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC7<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC7<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC8<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC8<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC9<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC9<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC10<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC10<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC11<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC11<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC12<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC12<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC13<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC13<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC14<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC14<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PC15<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PC15<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD0<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD0<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD1<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD1<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD2<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD2<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD3<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD3<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD4<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD4<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD5<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD5<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD6<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD6<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD7<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD7<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD8<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD8<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD9<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD9<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD10<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD10<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD11<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD11<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD12<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD12<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD13<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD13<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD14<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD14<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PD15<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PD15<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE0<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE0<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE1<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE1<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE2<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE2<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE3<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE3<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE4<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE4<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE5<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE5<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE6<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE6<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE7<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE7<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE8<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE8<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE9<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE9<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE10<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE10<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE11<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE11<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE12<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE12<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE13<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE13<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE14<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE14<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

impl<MODE> Unlock for Locked<PE15<MODE>> where
    MODE: Active, 

type Lock = LOCK

type Output = PE15<MODE>

fn unlock(self, lock: &mut Self::Lock) -> Self::Output

Loading content...