mcp9808 0.4.0

Platform agnostic Rust driver for the Microchip MCP9808 temperature sensor.
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

use bit_field::BitField;

#[derive(Debug, Copy, Clone)]
pub struct Register {
    /// points to a specific register in the sensor
    ptr: u8,
    /// register contents, either 1 or 2 bytes
    buf: [u8; 2],
    /// actual register size in bytes, either 1 or 2
    len: u8,
}

impl Register {
    pub fn new(ptr: u8, len: u8) -> Self {
        if ptr == 0 || ptr > 0b1000u8 {
            panic!("invalid pointer value: reserved")
        }

        if len > 2 {
            panic!("length > 2")
        }

        let buf = [0u8, 0];
        Register { ptr, buf, len }
    }

    pub fn get_buf(&self) -> &[u8] {
        &self.buf[0..self.len as usize]
    }

    pub fn set_buf(&mut self, val: [u8; 2]) {
        self.buf = val;
    }

    pub fn get_ptr(&self) -> u8 {
        self.ptr
    }

    pub fn get_len(&self) -> u8 {
        self.len
    }

    /// lower byte, bits 0-7, availability depends on register type
    pub fn get_lsb(&self) -> Option<u8> {
        if self.len < 2 {
            return None;
        }
        Some(self.buf[1])
    }

    pub fn set_lsb(&mut self, val: u8) {
        self.buf[1] = val;
    }

    /// upper byte, bits 8-15, always available
    pub fn get_msb(&self) -> u8 {
        self.buf[0]
    }

    pub fn set_msb(&mut self, val: u8) {
        self.buf[0] = val;
    }

    pub fn get_bit(&self, offset: usize) -> bool {
        if self.len == 1 {
            return self.get_msb().get_bit(offset);
        }

        if offset > 7 {
            self.get_msb().get_bit(offset - 8)
        } else {
            self.get_lsb().unwrap().get_bit(offset)
        }
    }

    /// datasheet numbers bits from lsb-0, we store them as msb
    pub fn set_bit(&mut self, offset: usize, val: bool) {
        if offset + 1 > self.len as usize * 8 {
            panic!("out of bounds access")
        }

        if self.len == 1 {
            self.buf[0].set_bit(offset, val);
        }

        if offset > 7 {
            self.buf[0].set_bit(offset - 8, val);
        } else {
            self.buf[1].set_bit(offset, val);
        }
    }

    pub fn as_u16(&self) -> u16 {
        let (lo, hi) = (self.get_lsb(), self.get_msb());
        if lo.is_none() {
            return self.get_msb() as u16;
        }
        ((hi as u16) << 8) + (lo.unwrap() as u16)
    }
}

#[allow(clippy::bool_assert_comparison)]
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn bitfield_manipulation() {
        let mut reg: Register = Register::new(1, 2);

        assert_eq!(reg.as_u16(), 0);

        assert_eq!(reg.get_bit(15), false);
        reg.set_bit(15, true);
        assert_eq!(reg.get_bit(15), true);

        assert_eq!(reg.get_bit(0), false);
        reg.set_bit(0, true);
        assert_eq!(reg.get_bit(0), true);
    }
}