#![deny(missing_docs)]
#![no_std]
use {
bitflags::bitflags,
crc_all::CrcAlgo,
embedded_hal_async::{delay::DelayNs, i2c::I2c},
};
const I2C_ADDRESS: u8 = 0x38;
bitflags! {
struct StatusFlags: u8 {
const BUSY = (1 << 7);
const MODE = ((1 << 6) | (1 << 5));
const CRC = (1 << 4);
const CALIBRATION_ENABLE = (1 << 3);
const FIFO_ENABLE = (1 << 2);
const FIFO_FULL = (1 << 1);
const FIFO_EMPTY = (1 << 0);
}
}
#[derive(Debug, Copy, Clone)]
pub enum Error<I2CERR> {
Uncalibrated,
Checksum,
I2c(I2CERR),
}
impl<E> core::convert::From<E> for Error<E> {
fn from(e: E) -> Self {
Error::I2c(e)
}
}
pub struct Humidity {
h: u32,
}
impl Humidity {
pub fn rh(&self) -> f32 {
100.0 * (self.h as f32) / ((1 << 20) as f32)
}
pub fn raw(&self) -> u32 {
self.h
}
}
pub struct Temperature {
t: u32,
}
impl Temperature {
pub fn celsius(&self) -> f32 {
(200.0 * (self.t as f32) / ((1 << 20) as f32)) - 50.0
}
pub fn raw(&self) -> u32 {
self.t
}
}
pub struct Aht20<I2C, D> {
i2c: I2C,
delay: D,
}
impl<I2C, D> Aht20<I2C, D>
where
I2C: I2c,
D: DelayNs,
{
pub async fn new(i2c: I2C, delay: D) -> Result<Self, Error<I2C::Error>> {
let mut dev = Self { i2c, delay };
dev.reset().await?;
dev.calibrate().await?;
Ok(dev)
}
async fn status(&mut self) -> Result<StatusFlags, I2C::Error> {
let buf = &mut [0u8; 1];
self.i2c.write_read(I2C_ADDRESS, &[0u8], buf).await?;
Ok(StatusFlags::from_bits_retain(buf[0]))
}
pub async fn calibrate(&mut self) -> Result<(), Error<I2C::Error>> {
self.i2c.write(I2C_ADDRESS, &[0xE1, 0x08, 0x00]).await?;
while self.status().await?.contains(StatusFlags::BUSY) {
self.delay.delay_ms(10).await;
}
if !self
.status()
.await?
.contains(StatusFlags::CALIBRATION_ENABLE)
{
return Err(Error::Uncalibrated);
}
Ok(())
}
pub async fn reset(&mut self) -> Result<(), I2C::Error> {
self.i2c.write(I2C_ADDRESS, &[0xBA]).await?;
self.delay.delay_ms(20).await;
Ok(())
}
pub async fn read(&mut self) -> Result<(Humidity, Temperature), Error<I2C::Error>> {
self.i2c.write(I2C_ADDRESS, &[0xAC, 0x33, 0x00]).await?;
while self.status().await?.contains(StatusFlags::BUSY) {
self.delay.delay_ms(10).await;
}
let buf = &mut [0u8; 7];
self.i2c.write_read(I2C_ADDRESS, &[0u8], buf).await?;
let crc = &mut 0u8;
let crc_hasher = CrcAlgo::<u8>::new(49, 8, 0xFF, 0x00, false);
crc_hasher.init_crc(crc);
if crc_hasher.update_crc(crc, &buf[..=5]) != buf[6] {
return Err(Error::Checksum);
};
let status = StatusFlags::from_bits_retain(buf[0]);
if !status.contains(StatusFlags::CALIBRATION_ENABLE) {
return Err(Error::Uncalibrated);
}
let hum = ((buf[1] as u32) << 12) | ((buf[2] as u32) << 4) | ((buf[3] as u32) >> 4);
let temp = (((buf[3] as u32) & 0x0f) << 16) | ((buf[4] as u32) << 8) | (buf[5] as u32);
Ok((Humidity { h: hum }, Temperature { t: temp }))
}
}