Skip to main content

edrv_sht20/
lib.rs

1//! Driver for SHT20.
2
3#![no_std]
4
5use embedded_hal_async::delay::DelayNs;
6
7pub mod blocking;
8
9pub const ADDRESS: u8 = 0x40;
10
11/// Commands for SHT20
12pub mod cmds {
13    pub const TEMP_HOLD: u8 = 0xE3;
14    pub const HUM_HOLD: u8 = 0xE5;
15    pub const TEMP_NOHOLD: u8 = 0xF3;
16    pub const HUM_NOHOLD: u8 = 0xF5;
17    pub const WRITE_REG: u8 = 0xE6;
18    pub const READ_REG: u8 = 0xE7;
19    pub const SOFT_RESET: u8 = 0xFE;
20}
21
22#[derive(Debug)]
23pub enum Error<E> {
24    Bus(E),
25    CRC,
26}
27
28impl<E> From<E> for Error<E> {
29    fn from(error: E) -> Self {
30        Error::Bus(error)
31    }
32}
33
34#[allow(non_camel_case_types)]
35#[derive(Debug, Clone, Copy, Default)]
36pub enum Resolution {
37    #[default]
38    RH12_T14 = 0b0000_0000,
39    RH8_T12 = 0b0000_0001,
40    RH10_T13 = 0b1000_0000,
41    RH11_T11 = 0b1000_0001,
42}
43
44pub struct SHT20<I2C: embedded_hal_async::i2c::I2c> {
45    addr: u8,
46    i2c: I2C,
47    resolution: Resolution,
48}
49
50impl<I2C: embedded_hal_async::i2c::I2c> SHT20<I2C> {
51    pub fn new_primary(i2c: I2C) -> Self {
52        Self {
53            addr: ADDRESS,
54            i2c,
55            resolution: Resolution::RH12_T14,
56        }
57    }
58
59    pub async fn set_resolution(&mut self, resolution: Resolution) -> Result<(), Error<I2C::Error>> {
60        self.resolution = resolution;
61
62        let mut bits = resolution as u8;
63        bits |= 0b10; // disable on-chip heater, enable OTP reload
64
65        self.i2c.write(self.addr, &[cmds::WRITE_REG, bits]).await?;
66
67        Ok(())
68    }
69
70    pub async fn read_temperature(&mut self, mut delay: impl DelayNs) -> Result<f32, Error<I2C::Error>> {
71        let mut buf = [0u8; 3];
72        self.i2c.write(self.addr, &[cmds::TEMP_HOLD]).await?;
73
74        delay.delay_ms(100).await;
75
76        self.i2c.read(self.addr, &mut buf).await?;
77
78        let raw = u16::from_be_bytes([buf[0], buf[1]]);
79        let raw = raw & !0x0003;
80
81        let temp = -46.85 + 175.72 * (raw as f32 / 65536.0);
82        Ok(temp)
83    }
84
85    pub async fn read_humidity(&mut self, mut delay: impl DelayNs) -> Result<f32, Error<I2C::Error>> {
86        let mut buf = [0u8; 3];
87        self.i2c.write(self.addr, &[cmds::HUM_HOLD]).await?;
88        delay.delay_ms(40).await;
89        self.i2c.read(self.addr, &mut buf).await?;
90
91        let raw = u16::from_be_bytes([buf[0], buf[1]]);
92        let raw = raw & !0x0003;
93
94        let hum = -6.0 + 125.0 * (raw as f32 / 65536.0);
95        Ok(hum)
96    }
97}