hk32-partial-hal 0.1.1

HK32 partial HAL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::pac::gpio::Gpio;
use core::{convert::Infallible, marker::PhantomData};

use super::Level;

pub trait PinGpio {
    const GPIO: Gpio;
    const MASK: u32;
}

pub struct FlashPin<G> {
    phantom: PhantomData<G>,
}

impl<G: PinGpio> FlashPin<G> {
    pub const fn new() -> Self {
        FlashPin {
            phantom: PhantomData,
        }
    }

    #[inline]
    pub fn set_high(&self) {
        super::pin_ctrl::pin_set_high(G::GPIO, G::MASK);
    }

    #[inline]
    pub fn set_low(&self) {
        super::pin_ctrl::pin_set_low(G::GPIO, G::MASK);
    }

    /// Set the output level.
    #[inline]
    pub fn set_level(&self, level: Level) {
        match level {
            Level::Low => self.set_low(),
            Level::High => self.set_high(),
        }
    }

    /// Is the output pin set as high?
    #[inline]
    pub fn is_set_high(&self) -> bool {
        super::pin_ctrl::pin_is_set_high(G::GPIO, G::MASK)
    }

    /// Is the output pin set as low?
    #[inline]
    pub fn is_set_low(&self) -> bool {
        super::pin_ctrl::pin_is_set_low(G::GPIO, G::MASK)
    }

    /// Toggle the output level.
    #[inline]
    pub fn toggle(&self) {
        if self.is_set_low() {
            self.set_high()
        } else {
            self.set_low()
        }
    }

    #[inline]
    pub fn is_high(&self) -> bool {
        super::pin_ctrl::pin_is_high(G::GPIO, G::MASK)
    }

    /// Get whether the pin input level is low.
    #[inline]
    pub fn is_low(&self) -> bool {
        super::pin_ctrl::pin_is_low(G::GPIO, G::MASK)
    }

    /// Get the current pin input level.
    #[inline]
    pub fn get_level(&self) -> Level {
        self.is_high().into()
    }
}

impl<G: PinGpio> embedded_hal::digital::ErrorType for FlashPin<G> {
    type Error = Infallible;
}

impl<G: PinGpio> embedded_hal::digital::InputPin for FlashPin<G> {
    #[inline]
    fn is_high(&mut self) -> Result<bool, Self::Error> {
        Ok(FlashPin::is_high(self))
    }

    #[inline]
    fn is_low(&mut self) -> Result<bool, Self::Error> {
        Ok(FlashPin::is_low(self))
    }
}

impl<G: PinGpio> embedded_hal::digital::OutputPin for FlashPin<G> {
    #[inline]
    fn set_high(&mut self) -> Result<(), Self::Error> {
        FlashPin::set_high(self);
        Ok(())
    }

    #[inline]
    fn set_low(&mut self) -> Result<(), Self::Error> {
        FlashPin::set_low(self);
        Ok(())
    }
}

impl<G: PinGpio> embedded_hal::digital::StatefulOutputPin for FlashPin<G> {
    #[inline]
    fn is_set_high(&mut self) -> Result<bool, Self::Error> {
        Ok(FlashPin::is_set_high(self))
    }

    /// Is the output pin set as low?
    #[inline]
    fn is_set_low(&mut self) -> Result<bool, Self::Error> {
        Ok(FlashPin::is_set_low(self))
    }
}