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

//! Type definition

/// All possible errors in this crate
#[derive(Debug)]
pub enum Error<E> {
    /// I²C bus error
    I2C(E),
}

/// ADC conversion rate
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ConversionRate {
    /// 4 conversions per second
    Cps4,
    /// 2 conversions per second
    Cps2,
    /// 1 conversion per second (default)
    Cps1,
    /// 0.5 conversions per second
    Cps0_5,
    /// 0.25 conversions per second
    Cps0_25,
}

/// Data as read from the sensor.
///
/// These values can be used to calculate the object temperature as done in
/// [`read_object_temperature()`].
///
/// [`read_object_temperature()`]: struct.Tmp006.html#method.read_object_temperature
#[derive(Debug, Default, Clone, Copy, PartialEq)]
pub struct SensorData {
    /// Object voltage: `[-32768..32767]`
    pub object_voltage: i16,
    /// Ambient temperature: `[-8192..8191]`
    pub ambient_temperature: i16,
}

/// Possible slave addresses
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum SlaveAddr {
    /// Default slave address
    Default,
    /// Alternative slave address providing bit values for A2, A1 and A0
    ///
    /// Some of these combinations require connecting the ADDR0 pin to
    /// SCL or SDA. Check table 1 on page 7 of the datasheet: [TMP006/B].
    Alternative(bool, bool, bool),
}

impl Default for SlaveAddr {
    /// Default slave address
    fn default() -> Self {
        SlaveAddr::Default
    }
}

impl SlaveAddr {
    pub(crate) fn addr(self, default: u8) -> u8 {
        match self {
            SlaveAddr::Default => default,
            SlaveAddr::Alternative(a2, a1, a0) => {
                default | ((a2 as u8) << 2) | ((a1 as u8) << 1) | a0 as u8
            }
        }
    }
}

pub const DEVICE_BASE_ADDRESS: u8 = 0b100_0000;

pub struct Register;
impl Register {
    pub const V_OBJECT: u8 = 0x00;
    pub const TEMP_AMBIENT: u8 = 0x01;
    pub const CONFIG: u8 = 0x02;
    pub const MANUFAC_ID: u8 = 0xFE;
    pub const DEVICE_ID: u8 = 0xFE;
}

pub struct BitFlagsHigh;
impl BitFlagsHigh {
    pub const SW_RESET: u8 = 0b1000_0000;
    pub const MOD: u8 = 0b0111_0000;
    pub const CR2: u8 = 0b0000_1000;
    pub const CR1: u8 = 0b0000_0100;
    pub const CR0: u8 = 0b0000_0010;
    pub const DRDY_EN: u8 = 0b0000_0001;
}

pub struct BitFlagsLow;
impl BitFlagsLow {
    pub const DRDY: u8 = 0b1000_0000;
}

#[derive(Debug, Clone, Copy)]
pub struct ConfigHigh {
    pub bits: u8,
}

/// TMP006 device driver.
#[derive(Debug)]
pub struct Tmp006<I2C> {
    /// The concrete I²C device implementation.
    pub(crate) i2c: I2C,
    /// The I²C device address.
    pub(crate) address: u8,
    /// Configuration register status.
    pub(crate) config: ConfigHigh,
}

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

    #[test]
    fn can_get_default_address() {
        let addr = SlaveAddr::default();
        assert_eq!(DEVICE_BASE_ADDRESS, addr.addr(DEVICE_BASE_ADDRESS));
    }

    #[test]
    fn can_generate_alternative_addresses() {
        assert_eq!(
            0b100_0000,
            SlaveAddr::Alternative(false, false, false).addr(DEVICE_BASE_ADDRESS)
        );
        assert_eq!(
            0b100_0001,
            SlaveAddr::Alternative(false, false, true).addr(DEVICE_BASE_ADDRESS)
        );
        assert_eq!(
            0b100_0010,
            SlaveAddr::Alternative(false, true, false).addr(DEVICE_BASE_ADDRESS)
        );
        assert_eq!(
            0b100_0100,
            SlaveAddr::Alternative(true, false, false).addr(DEVICE_BASE_ADDRESS)
        );
        assert_eq!(
            0b100_0111,
            SlaveAddr::Alternative(true, true, true).addr(DEVICE_BASE_ADDRESS)
        );
    }
}