status-led 0.1.0

no_std monochrome status LED abstraction with type-safe polarity and optional PWM gamma correction.
Documentation 
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
123
124
125
126

use embedded_hal::digital::PinState;

mod sealed {
    pub trait Sealed {}
}

/// Compile-time logic-level polarity: maps logical ON/OFF to physical High/Low.
///
/// This trait is sealed; only the built-in [`ActiveHigh`] / [`ActiveLow`] markers
/// implement it.  For runtime polarity use [`PolarityMode`] with [`FlexLed`] or
/// [`FlexPwmLed`].
///
/// [`FlexLed`]: crate::FlexLed
/// [`FlexPwmLed`]: crate::pwm::FlexPwmLed
pub trait Polarity: sealed::Sealed {
    /// Physical pin level corresponding to logical ON (GPIO).
    fn physical_on() -> PinState;
    /// Physical pin level corresponding to logical OFF (GPIO).
    fn physical_off() -> PinState;
    /// Given a physical high level, return whether the LED is logically ON (GPIO).
    fn is_logical_on(physical_high: bool) -> bool;
    /// Map a gamma-corrected on-time fraction (0=off, 255=fully on) to a PWM duty
    /// fraction (0=0% duty, 255=100% duty).
    fn map_duty(brightness: u8) -> u8;
    /// The corresponding runtime [`PolarityMode`].
    const MODE: PolarityMode;
}

/// Active-high: LED is on when the pin is High (most common).
pub struct ActiveHigh;
impl sealed::Sealed for ActiveHigh {}
impl Polarity for ActiveHigh {
    const MODE: PolarityMode = PolarityMode::ActiveHigh;
    #[inline]
    fn physical_on() -> PinState {
        PinState::High
    }
    #[inline]
    fn physical_off() -> PinState {
        PinState::Low
    }
    #[inline]
    fn is_logical_on(physical_high: bool) -> bool {
        physical_high
    }
    #[inline]
    fn map_duty(brightness: u8) -> u8 {
        brightness
    }
}

/// Active-low: LED is on when the pin is Low (common on Nucleo, ESP32 boards).
pub struct ActiveLow;
impl sealed::Sealed for ActiveLow {}
impl Polarity for ActiveLow {
    const MODE: PolarityMode = PolarityMode::ActiveLow;
    #[inline]
    fn physical_on() -> PinState {
        PinState::Low
    }
    #[inline]
    fn physical_off() -> PinState {
        PinState::High
    }
    #[inline]
    fn is_logical_on(physical_high: bool) -> bool {
        !physical_high
    }
    #[inline]
    fn map_duty(brightness: u8) -> u8 {
        255 - brightness
    }
}

// ─── Runtime polarity ─────────────────────────────────

/// Runtime polarity mode, for use with [`FlexLed`] / [`FlexPwmLed`].
///
/// Unlike the compile-time [`ActiveHigh`] / [`ActiveLow`] markers, this enum is
/// suitable when the polarity is determined at runtime (e.g. from configuration).
///
/// [`FlexLed`]: crate::FlexLed
/// [`FlexPwmLed`]: crate::pwm::FlexPwmLed
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum PolarityMode {
    /// Active-high: pin High = LED on.
    ActiveHigh,
    /// Active-low: pin Low = LED on.
    ActiveLow,
}

impl PolarityMode {
    #[inline]
    pub(crate) fn physical_on(self) -> PinState {
        match self {
            Self::ActiveHigh => PinState::High,
            Self::ActiveLow => PinState::Low,
        }
    }

    #[inline]
    pub(crate) fn physical_off(self) -> PinState {
        match self {
            Self::ActiveHigh => PinState::Low,
            Self::ActiveLow => PinState::High,
        }
    }

    #[inline]
    pub(crate) fn is_logical_on(self, physical_high: bool) -> bool {
        match self {
            Self::ActiveHigh => physical_high,
            Self::ActiveLow => !physical_high,
        }
    }

    #[inline]
    #[allow(dead_code)] // only used when feature = "pwm"
    pub(crate) fn map_duty(self, brightness: u8) -> u8 {
        match self {
            Self::ActiveHigh => brightness,
            Self::ActiveLow => 255 - brightness,
        }
    }
}