Add asynchronous sensor API

Author: tazz4843

Cargo.toml

@@ -26,6 +26,10 @@ defmt = { version = "0.3.2", optional = true }
 embedded-hal = "0.2.7"
 fixed = "1.20.0"
 sensirion-i2c = "0.2"
+embedded-hal-async = { version = "1.0.0-rc.1", optional = true }
 
 [features]
+default = ["blocking"]
 defmt = ["dep:defmt"]
+blocking = []
+async = ["dep:embedded-hal-async"]

src/error.rs

@@ -1,4 +1,5 @@
 use embedded_hal::blocking::i2c::{Read, Write};
+use sensirion_i2c::crc8::Error as CrcError;
 use sensirion_i2c::i2c;
 
 /// Error conditions from accessing SHT4x sensors.
@@ -25,3 +26,11 @@ where
         }
     }
 }
+
+impl<E> From<CrcError> for Error<E> {
+    fn from(value: CrcError) -> Self {
+        match value {
+            CrcError::CrcError => Error::Crc,
+        }
+    }
+}

src/lib.rs

@@ -10,3 +10,6 @@ mod types;
 pub use crate::error::*;
 pub use crate::sht4x::*;
 pub use crate::types::*;
+
+#[cfg(all(feature = "blocking", feature = "async"))]
+compile_error!("Cannot enable both `blocking` and `async` features");

src/sht4x.rs

@@ -4,10 +4,17 @@ use crate::{
     types::{Address, HeatingDuration, HeatingPower, Measurement, Precision, SensorData},
 };
 use core::marker::PhantomData;
+#[cfg(feature = "blocking")]
 use embedded_hal::blocking::{
     delay::DelayMs,
     i2c::{Read, Write, WriteRead},
 };
+#[cfg(feature = "async")]
+use embedded_hal_async::{
+    delay::DelayUs,
+    i2c::{I2c, SevenBitAddress},
+};
+#[cfg(feature = "blocking")]
 use sensirion_i2c::i2c;
 
 const RESPONSE_LEN: usize = 6;
@@ -46,6 +53,7 @@ impl From<Precision> for Command {
     }
 }
 
+#[cfg(feature = "blocking")]
 impl<I, D, E> Sht4x<I, D>
 where
     I: Read<Error = E> + Write<Error = E> + WriteRead<Error = E>,
@@ -187,3 +195,157 @@ where
         Ok(())
     }
 }
+
+#[cfg(feature = "async")]
+impl<I, D, E> Sht4x<I, D>
+where
+    I: I2c<SevenBitAddress, Error = E>,
+    D: DelayUs,
+{
+    /// Creates a new driver instance using the given I2C bus. It configures the default I2C
+    /// address 0x44 used by most family members.
+    ///
+    /// For operating multiple devices on the same bus,
+    /// [`shared-bus`](https://github.com/Rahix/shared-bus) might come in handy.
+    pub fn new(i2c: I) -> Self {
+        Self::new_with_address(i2c, Address::Address0x44)
+    }
+
+    /// Crates a new driver instance using the given I2C bus and address. This constructor allows
+    /// to instantiate the driver for the SHT40-BD1B which uses the non-default I2C address 0x45.
+    ///
+    /// For operating multiple devices on the same bus,
+    /// [`shared-bus`](https://github.com/Rahix/shared-bus) might come in handy.
+    pub fn new_with_address(i2c: I, address: Address) -> Self {
+        Sht4x {
+            i2c,
+            address,
+            _delay: PhantomData,
+        }
+    }
+
+    /// Destroys the driver and returns the used I2C bus.
+    pub fn destroy(self) -> I {
+        self.i2c
+    }
+
+    /// Activates the heater and performs a measurement returning measurands in SI units.
+    ///
+    /// **Note:** The heater is designed to be used up to 10 % of the sensor's lifetime. Please
+    /// check the
+    /// [datasheet](https://sensirion.com/media/documents/33FD6951/624C4357/Datasheet_SHT4x.pdf),
+    /// section 4.9 _Heater Operation_ for details.
+    pub async fn heat_and_measure(
+        &mut self,
+        power: HeatingPower,
+        duration: HeatingDuration,
+        delay: &mut D,
+    ) -> Result<Measurement, Error<E>> {
+        let raw = self.heat_and_measure_raw(power, duration, delay).await?;
+
+        Ok(Measurement::from(raw))
+    }
+
+    /// Activates the heater and performs a measurement returning raw sensor data.
+    ///
+    /// **Note:** The heater is designed to be used up to 10 % of the sensor's lifetime. Please
+    /// check the
+    /// [datasheet](https://sensirion.com/media/documents/33FD6951/624C4357/Datasheet_SHT4x.pdf),
+    /// section 4.9 _Heater Operation_ for details.
+    pub async fn heat_and_measure_raw(
+        &mut self,
+        power: HeatingPower,
+        duration: HeatingDuration,
+        delay: &mut D,
+    ) -> Result<SensorData, Error<E>> {
+        let command = Command::from((power, duration));
+
+        self.write_command_and_delay_for_execution(command, delay)
+            .await?;
+        let response = self.read_response().await?;
+        let raw = self.sensor_data_from_response(&response);
+
+        Ok(raw)
+    }
+
+    /// Performs a measurement returning measurands in SI units.
+    pub async fn measure(
+        &mut self,
+        precision: Precision,
+        delay: &mut D,
+    ) -> Result<Measurement, Error<E>> {
+        let raw = self.measure_raw(precision, delay).await?;
+        Ok(Measurement::from(raw))
+    }
+
+    /// Performs a measurement returning raw sensor data.
+    pub async fn measure_raw(
+        &mut self,
+        precision: Precision,
+        delay: &mut D,
+    ) -> Result<SensorData, Error<E>> {
+        let command = Command::from(precision);
+
+        self.write_command_and_delay_for_execution(command, delay)
+            .await?;
+        let response = self.read_response().await?;
+        let raw = self.sensor_data_from_response(&response);
+
+        Ok(raw)
+    }
+
+    /// Reads the sensor's serial number.
+    pub async fn serial_number(&mut self, delay: &mut D) -> Result<u32, Error<E>> {
+        self.write_command_and_delay_for_execution(Command::SerialNumber, delay)
+            .await?;
+        let response = self.read_response().await?;
+
+        Ok(u32::from_be_bytes([
+            response[0],
+            response[1],
+            response[3],
+            response[4],
+        ]))
+    }
+
+    /// Performs a soft reset of the sensor.
+    pub async fn soft_reset(&mut self, delay: &mut D) -> Result<(), Error<E>> {
+        self.write_command_and_delay_for_execution(Command::SoftReset, delay)
+            .await
+    }
+
+    async fn read_response(&mut self) -> Result<[u8; RESPONSE_LEN], Error<E>> {
+        let mut response = [0; RESPONSE_LEN];
+
+        self.i2c
+            .read(self.address.into(), &mut response)
+            .await
+            .map_err(Error::I2c)?;
+        sensirion_i2c::crc8::validate(&response)?;
+
+        Ok(response)
+    }
+
+    fn sensor_data_from_response(&self, response: &[u8; RESPONSE_LEN]) -> SensorData {
+        SensorData {
+            temperature: u16::from_be_bytes([response[0], response[1]]),
+            humidity: u16::from_be_bytes([response[3], response[4]]),
+        }
+    }
+
+    async fn write_command_and_delay_for_execution(
+        &mut self,
+        command: Command,
+        delay: &mut D,
+    ) -> Result<(), Error<E>> {
+        let code = command.code();
+
+        self.i2c
+            .write(self.address.into(), &code.to_be_bytes())
+            .await
+            .map_err(Error::I2c)?;
+        delay.delay_ms(command.duration_ms() as u32).await;
+
+        Ok(())
+    }
+}