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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Chip-Select GPIO support traits.

#![no_std]
#![forbid(unsafe_code)]
#![cfg_attr(docsrs, feature(doc_cfg))]

#[cfg(all(feature = "hal-0_2", feature = "hal-1_0"))]
compile_error!(
    "HAL feature \"hal-0_2\" and feature \"hal-1_0\" cannot be enabled at the same time"
);

#[cfg(not(any(feature = "hal-0_2", feature = "hal-1_0")))]
compile_error!("A HAL feature (\"hal-0_2\" or \"hal-1_0\") must be enabled");

#[cfg(feature = "hal-0_2")]
#[cfg_attr(docsrs, doc(cfg(feature = "hal-0_2")))]
use hal_0_2::digital::v2::OutputPin;

#[cfg(feature = "hal-1_0")]
#[cfg_attr(docsrs, doc(cfg(feature = "hal-1_0")))]
use hal_1_0::digital::OutputPin;

/// A chip-select trait.
pub trait ChipSelect {
    /// Indicates whether this instance is configured to auto-select the chip on communication.
    #[must_use]
    fn is_auto_select(&self) -> bool;

    /// Selects the chip if auto-select is enabled.
    fn auto_select(&mut self) {
        if self.is_auto_select() {
            self.select()
        }
    }

    /// Selects the chip, driving the line low.
    fn select(&mut self);

    /// Deselects the chip, driving the line high.
    fn deselect(&mut self);
}

/// Marker trait to indicate that a pin is active low.
pub trait ActiveLow {}

/// Marker trait to indicate that a pin is active high.
pub trait ActiveHigh {}

/// A chip select pin with active-low behavior.
pub struct ChipSelectActiveLow<Pin>(bool, Pin);

/// A chip select pin with active-high behavior.
pub struct ChipSelectActiveHigh<Pin>(bool, Pin);

impl<Pin> ChipSelectActiveLow<Pin>
where
    Pin: OutputPin,
{
    /// Initialize the chip select.
    pub const fn new(pin: Pin) -> Self {
        Self(false, pin)
    }

    /// Enables auto-select on the chip.
    pub fn with_auto_select(mut self, enabled: bool) -> Self {
        self.0 = enabled;
        self
    }

    /// Selects the chip if auto-select is enabled.
    pub fn auto_select(&mut self) {
        if self.0 {
            self.select()
        }
    }

    /// Selects the chip, driving the line low.
    pub fn select(&mut self) {
        <Pin as OutputPin>::set_low(&mut self.1).ok();
    }

    /// Deselects the chip, driving the line high.
    pub fn deselect(&mut self) {
        <Pin as OutputPin>::set_high(&mut self.1).ok();
    }

    /// Consumes self and returns the wrapped pin.
    #[must_use]
    pub fn into_inner(self) -> Pin {
        self.1
    }
}

impl<Pin> ChipSelectActiveHigh<Pin>
where
    Pin: OutputPin,
{
    /// Initialize the chip select.
    pub const fn new(pin: Pin) -> Self {
        Self(false, pin)
    }

    /// Enables auto-select on the chip.
    pub fn with_auto_select(mut self, enabled: bool) -> Self {
        self.0 = enabled;
        self
    }

    /// Selects the chip if auto-select is enabled.
    pub fn auto_select(&mut self) {
        if self.0 {
            self.select()
        }
    }

    /// Selects the chip, driving the line high.
    pub fn select(&mut self) {
        <Pin as OutputPin>::set_high(&mut self.1).ok();
    }

    /// Deselects the chip, driving the line low.
    pub fn deselect(&mut self) {
        <Pin as OutputPin>::set_low(&mut self.1).ok();
    }

    /// Consumes self and returns the wrapped pin.
    #[must_use]
    pub fn into_inner(self) -> Pin {
        self.1
    }
}

impl<Pin> From<Pin> for ChipSelectActiveLow<Pin>
where
    Pin: OutputPin,
{
    fn from(value: Pin) -> Self {
        Self::new(value)
    }
}

impl<Pin> From<Pin> for ChipSelectActiveHigh<Pin>
where
    Pin: OutputPin,
{
    fn from(value: Pin) -> Self {
        Self::new(value)
    }
}

impl<Pin> ActiveLow for ChipSelectActiveLow<Pin> where Pin: OutputPin {}

impl<Pin> ActiveHigh for ChipSelectActiveHigh<Pin> where Pin: OutputPin {}