pca9535 2.0.0

PCA 9535 IO-Expander driver using embedded-hal
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
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

//! Implements the standard interface for all types implementing the [`Expander`] trait.
use core::fmt::Debug;

use hal::i2c::I2c;

use super::{Expander, ExpanderError, GPIOBank, Register};

/// Standard expander interface not using [`hal`].
///
/// This interface does not track the state of the pins! Therefore, the user needs to ensure the pins are in input or output configuration before
/// proceeding to call functions related to input or output pins. Otherwise, the results of those functions might not cause the expected behavior of the device.
pub trait StandardExpanderInterface<I2C, E>: Expander<I2C>
where
    E: Debug,
    I2C: I2c<Error = E>,
{
    fn pin_set_high(&mut self, bank: GPIOBank, pin: u8) -> Result<(), ExpanderError<E>> {
        assert!(pin < 8);

        let register = match bank {
            GPIOBank::Bank0 => Register::OutputPort0,
            GPIOBank::Bank1 => Register::OutputPort1,
        };

        let mut reg_val: u8 = 0x00;

        self.read_byte(register, &mut reg_val)?;

        self.write_byte(register, reg_val | (0x01 << pin))
    }

    /// Drives given pin low.
    ///
    /// # Panics
    /// The function will panic if the provided pin is not in the allowed range of 0-7
    fn pin_set_low(&mut self, bank: GPIOBank, pin: u8) -> Result<(), ExpanderError<E>> {
        assert!(pin < 8);

        let register = match bank {
            GPIOBank::Bank0 => Register::OutputPort0,
            GPIOBank::Bank1 => Register::OutputPort1,
        };

        let mut reg_val: u8 = 0x00;

        self.read_byte(register, &mut reg_val)?;

        self.write_byte(register, reg_val & !(0x01 << pin))
    }

    /// Checks if the input state of the given pin is `high`. This function works with pins configured as inputs as well as outputs.
    ///
    /// The function result does not necessarily represent the logic level of the applied voltage at the given pin but the value inside the input register of the device.
    /// Which is `1` or `0` Depending on the current polarity inversion configuration of the pin.
    ///
    /// # Panics
    /// The function will panic if the provided pin is not in the allowed range of 0-7
    fn pin_is_high(&mut self, bank: GPIOBank, pin: u8) -> Result<bool, ExpanderError<E>> {
        assert!(pin < 8);

        let register = match bank {
            GPIOBank::Bank0 => Register::InputPort0,
            GPIOBank::Bank1 => Register::InputPort1,
        };

        let mut reg_val: u8 = 0x00;

        self.read_byte(register, &mut reg_val)?;

        match (reg_val >> pin) & 1 {
            1 => Ok(true),
            _ => Ok(false),
        }
    }

    /// Checks if the input state of the given pin is `low`. This function works with pins configured as inputs as well as outputs.
    ///
    /// The function result does not necessarily represent the logic level of the applied voltage at the given pin but the value inside the input register of the device.
    /// Which is `1` or `0` Depending on the current polarity inversion configuration of the pin.
    ///
    /// # Panics
    /// The function will panic if the provided pin is not in the allowed range of 0-7
    fn pin_is_low(&mut self, bank: GPIOBank, pin: u8) -> Result<bool, ExpanderError<E>> {
        assert!(pin < 8);

        let register = match bank {
            GPIOBank::Bank0 => Register::InputPort0,
            GPIOBank::Bank1 => Register::InputPort1,
        };

        let mut reg_val: u8 = 0x00;

        self.read_byte(register, &mut reg_val)?;

        match (reg_val >> pin) & 1 {
            1 => Ok(false),
            _ => Ok(true),
        }
    }

    /// Configures given pin as input.
    ///
    /// # Panics
    /// The function will panic if the provided pin is not in the allowed range of 0-7
    fn pin_into_input(&mut self, bank: GPIOBank, pin: u8) -> Result<(), ExpanderError<E>> {
        assert!(pin < 8);

        let register = match bank {
            GPIOBank::Bank0 => Register::ConfigurationPort0,
            GPIOBank::Bank1 => Register::ConfigurationPort1,
        };

        let mut reg_val: u8 = 0x00;

        self.read_byte(register, &mut reg_val)?;

        self.write_byte(register, reg_val | (0x01 << pin))
    }

    /// Configures the given pin as output.
    ///
    /// # Panics
    /// The function will panic if the provided pin is not in the allowed range of 0-7
    fn pin_into_output(&mut self, bank: GPIOBank, pin: u8) -> Result<(), ExpanderError<E>> {
        assert!(pin < 8);

        let register = match bank {
            GPIOBank::Bank0 => Register::ConfigurationPort0,
            GPIOBank::Bank1 => Register::ConfigurationPort1,
        };

        let mut reg_val: u8 = 0x00;

        self.read_byte(register, &mut reg_val)?;

        self.write_byte(register, reg_val & !(0x01 << pin))
    }

    /// Sets the input polarity of the given pin to inverted.
    ///
    /// A logic high voltage applied at this input pin results in a `0` written to the devices input register and thus being registered as `low` by the driver.
    ///
    /// # Panics
    /// The function will panic if the provided pin is not in the allowed range of 0-7
    fn pin_inverse_polarity(&mut self, bank: GPIOBank, pin: u8) -> Result<(), ExpanderError<E>> {
        assert!(pin < 8);

        let register = match bank {
            GPIOBank::Bank0 => Register::PolarityInversionPort0,
            GPIOBank::Bank1 => Register::PolarityInversionPort1,
        };

        let mut reg_val: u8 = 0x00;

        self.read_byte(register, &mut reg_val)?;

        self.write_byte(register, reg_val | (0x01 << pin))
    }

    /// Sets the input polarity of the given pin to normal.
    ///
    /// A logic high voltage applied at an input pin results in a `1` written to the device's input register, thus being registered as `high` by the driver.
    ///
    /// # Panics
    /// The function will panic if the provided pin is not in the allowed range of 0-7
    fn pin_normal_polarity(&mut self, bank: GPIOBank, pin: u8) -> Result<(), ExpanderError<E>> {
        assert!(pin < 8);

        let register = match bank {
            GPIOBank::Bank0 => Register::PolarityInversionPort0,
            GPIOBank::Bank1 => Register::PolarityInversionPort1,
        };

        let mut reg_val: u8 = 0x00;

        self.read_byte(register, &mut reg_val)?;

        self.write_byte(register, reg_val & !(0x01 << pin))
    }

    /// Sets the input polarity of all pins to inverted.
    ///
    /// A logic high voltage applied at an input pin results in a `0` written to the device's input register, thus being registered as `low` by the driver.
    fn inverse_polarity(&mut self) -> Result<(), ExpanderError<E>> {
        self.write_halfword(Register::PolarityInversionPort0, 0xFFFF_u16)
    }

    /// Sets the input polarity of all pins to normal.
    ///
    /// A logic high voltage applied at an input pin results in a `1` written to the device's input register, thus being registered as `high` by the driver.
    fn normal_polarity(&mut self) -> Result<(), ExpanderError<E>> {
        self.write_halfword(Register::PolarityInversionPort0, 0x0_u16)
    }
}