update dependencies and refactor DHT11 sensor for async support

Author: psytraxx

.github/workflows/rust_ci.yml

@@ -34,7 +34,7 @@ jobs:
           default: true
           buildtargets: esp32
           ldproxy: false
-          version: "1.84.0"
+          version: "1.85.0"
       - name: Enable caching
         uses: Swatinem/rust-cache@v2
       - name: Run build

Cargo.lock

@@ -10,7 +10,11 @@ esp-backtrace = { version = "0.15.0", features = [
     "panic-handler",
     "defmt",
 ] }
-esp-hal = { version = "1.0.0-beta.0", features = ["esp32s3", "defmt", "unstable"] }
+esp-hal = { version = "1.0.0-beta.0", features = [
+    "esp32s3",
+    "defmt",
+    "unstable",
+] }
 esp-alloc = { version = "0.7.0" }
 embassy-net = { version = "0.6.0", features = [
     "tcp",
@@ -43,6 +47,7 @@ rust-mqtt = { version = "0.3.0", default-features = false, features = [
 embedded-text = "0.7.2"
 embedded-graphics = { version = "0.8.1", features = ["defmt"] }
 embedded-hal = { version = "1.0.0", features = ["defmt-03"] }
+embedded-hal-async = { version = "1.0.0", features = ["defmt-03"] }
 serde = { version = "1.0.215", default-features = false, features = ["derive"] }
 serde_json = { version = "1.0.133", default-features = false, features = [
     "alloc",

Cargo.toml

@@ -1,10 +1,10 @@
-use embedded_hal::{
-    delay::DelayNs,
-    digital::{InputPin, OutputPin},
-};
+use embassy_time::{with_timeout, Duration, Instant};
+use embedded_hal::digital::{InputPin, OutputPin};
+use embedded_hal_async::delay::DelayNs;
+use embedded_hal_async::digital::Wait;
 
 /// How long to wait for a pulse on the data line (in microseconds).
-const TIMEOUT_US: u16 = 1_000;
+const TIMEOUT_US: u64 = 1_000;
 
 /// Error type for this crate.
 #[derive(Debug)]
@@ -39,7 +39,7 @@ pub struct Measurement {
 
 impl<GPIO, D, E> Dht11<GPIO, D>
 where
-    GPIO: InputPin<Error = E> + OutputPin<Error = E>,
+    GPIO: InputPin<Error = E> + OutputPin<Error = E> + Wait,
     D: DelayNs,
 {
     /// Creates a new DHT11 device connected to the specified pin.
@@ -48,22 +48,22 @@ where
     }
 
     /// Performs a reading of the sensor.
-    pub fn read(&mut self) -> Result<Measurement, Error<E>> {
+    pub async fn read(&mut self) -> Result<Measurement, Error<E>> {
         let mut data = [0u8; 5];
 
         // Perform initial handshake
-        self.perform_handshake()?;
+        self.perform_handshake().await?;
 
         // Read bits
         for i in 0..40 {
             data[i / 8] <<= 1;
-            if self.read_bit()? {
+            if self.read_bit().await? {
                 data[i / 8] |= 1;
             }
         }
 
         // Finally wait for line to go idle again.
-        self.wait_for_pulse(true)?;
+        self.wait_for_pulse(true).await?;
 
         // Check CRC
         let crc = data[0]
@@ -80,55 +80,50 @@ where
         })
     }
 
-    fn perform_handshake(&mut self) -> Result<(), Error<E>> {
+    async fn perform_handshake(&mut self) -> Result<(), Error<E>> {
         // Set pin as floating to let pull-up raise the line and start the reading process.
         self.gpio.set_high().map_err(Error::Gpio)?;
-        self.delay.delay_ms(1);
+        self.delay.delay_ms(1).await;
 
         // Pull line low for at least 18ms to send a start command.
         self.gpio.set_low().map_err(Error::Gpio)?;
-        self.delay.delay_ms(20);
+        self.delay.delay_ms(20).await;
 
         // Restore floating
         self.gpio.set_high().map_err(Error::Gpio)?;
-        self.delay.delay_us(40);
+        self.delay.delay_us(40).await;
 
         // As a response, the device pulls the line low for 80us and then high for 80us.
-        self.read_bit()?;
+        self.read_bit().await?;
 
         Ok(())
     }
 
-    fn read_bit(&mut self) -> Result<bool, Error<E>> {
-        let low = self.wait_for_pulse(true)?;
-        let high = self.wait_for_pulse(false)?;
+    async fn read_bit(&mut self) -> Result<bool, Error<E>> {
+        let low = self.wait_for_pulse(true).await?;
+        let high = self.wait_for_pulse(false).await?;
         Ok(high > low)
     }
 
-    fn wait_for_pulse(&mut self, level: bool) -> Result<u32, Error<E>> {
-        let mut count = 0;
+    async fn wait_for_pulse(&mut self, level: bool) -> Result<u64, Error<E>> {
+        let timeout_duration = Duration::from_micros(TIMEOUT_US);
+        let start = Instant::now();
 
-        while self.gpio.is_high().map_err(Error::Gpio)? != level {
-            count += 1;
-            if count > TIMEOUT_US {
-                return Err(Error::Timeout);
+        let wait_future = async {
+            if level {
+                self.gpio.wait_for_rising_edge().await.map_err(Error::Gpio)
+            } else {
+                self.gpio.wait_for_falling_edge().await.map_err(Error::Gpio)
             }
-            self.delay.delay_us(1);
-        }
+        };
 
-        Ok(u32::from(count))
-    }
-}
+        // Wait for the pulse with timeout.
+        with_timeout(timeout_duration, wait_future)
+            .await
+            .map_err(|_| Error::Timeout)??;
+        let elapsed = Instant::now() - start;
 
-impl<GPIO, D, E> Drop for Dht11<GPIO, D>
-where
-    GPIO: InputPin<Error = E> + OutputPin<Error = E>,
-    D: DelayNs,
-{
-    fn drop(&mut self) {
-        // Set pin high (floating with pull-up) as safe state
-        // Ignore errors during drop
-        let _ = self.gpio.set_high();
-        self.delay.delay_us(40);
+        // Using microseconds for finer measurement.
+        Ok(elapsed.as_micros())
     }
 }

src/dht11.rs

@@ -1,13 +1,12 @@
 use alloc::vec;
 use defmt::{error, info, warn};
 use embassy_sync::{blocking_mutex::raw::NoopRawMutex, channel::Sender};
-use embassy_time::{Duration, Timer};
+use embassy_time::{Delay, Duration, Timer};
 use esp_hal::{
     analog::adc::{
         Adc, AdcCalCurve, AdcCalLine, AdcCalScheme, AdcChannel, AdcConfig, AdcPin, Attenuation,
         RegisterAccess,
     },
-    delay::Delay,
     gpio::{DriveMode, GpioPin, Input, InputConfig, Level, Output, OutputConfig, Pull},
     peripherals::{ADC1, ADC2},
     Blocking,
@@ -42,9 +41,6 @@ pub async fn sensor_task(
     mut p: SensorPeripherals,
 ) {
     info!("Create");
-
-    let delay = Delay::new();
-
     let mut adc2_config = AdcConfig::new();
     let mut moisture_pin = adc2_config
         .enable_pin_with_cal::<_, AdcCalCurve<ADC2>>(p.moisture_analog_pin, Attenuation::_11dB);
@@ -95,11 +91,11 @@ pub async fn sensor_task(
                 .into_flex();
                 dht11_pin.enable_input(true);
 
-                let mut dht11_sensor = Dht11::new(dht11_pin, delay);
+                let mut dht11_sensor = Dht11::new(dht11_pin, Delay);
 
                 // DHT11 needs a longer initial delay
                 Timer::after(Duration::from_millis(DHT11_WARMUP_DELAY_MILLISECONDS)).await;
-                if let Ok(result) = dht11_sensor.read() {
+                if let Ok(result) = dht11_sensor.read().await {
                     air_temperature_samples.push(result.temperature);
                     air_humidity_samples.push(result.humidity);
                 }