feat: add dht22 support

Author: zeldan

README.md

@@ -5,8 +5,8 @@ Welcome to `embedded-dht-rs`, a Rust library designed to make working with DHT s
 This library only depends on `embedded_hal`, making it versatile and compatible with virtually any microcontroller.
 
 ### Features:
-- **DHT11 sensor support**: Fully implemented and ready to use.
-- **DHT22 sensor support**: Currently in progress – stay tuned!
+
+- **DHT11 and DHT22 sensor support**: Both sensors are fully implemented and ready to use.
 
 We’ve tested it with the ESP32-WROOM, and you can find a detailed example below to help you get started.
 
@@ -18,7 +18,7 @@ We’ve tested it with the ESP32-WROOM, and you can find a detailed example belo
 #![no_std]
 #![no_main]
 
-use embedded_dht_rs::Dht11;
+use embedded_dht_rs::{dht11::Dht11, dht22::Dht22};
 use esp_backtrace as _;
 use esp_hal::{
     clock::ClockControl,
@@ -40,23 +40,38 @@ fn main() -> ! {
     let delay = Delay::new(&clocks);
 
     let gpio4 = OutputOpenDrain::new(io.pins.gpio4, Level::High, Pull::None);
-    let mut led_sensor = Dht11::new(gpio4, delay);
+    let gpio5 = OutputOpenDrain::new(io.pins.gpio5, Level::High, Pull::None);
+
+    let mut dht11 = Dht11::new(gpio4, delay);
+    let mut dht22 = Dht22::new(gpio5, delay);
 
     loop {
-        delay.delay(1000.millis());
-        match led_sensor.read() {
+        delay.delay(5000.millis());
+
+        match dht11.read() {
             Ok(sensor_reading) => log::info!(
-                "Temperature: {}, humidity: {}",
+                "DHT 11 Sensor - Temperature: {} °C, humidity: {} %",
                 sensor_reading.temperature,
                 sensor_reading.humidity
             ),
             Err(error) => log::error!("An error occurred while trying to read sensor: {:?}", error),
         }
+
+        match dht22.read() {
+            Ok(sensor_reading) => log::info!(
+                "DHT 22 Sensor - Temperature: {} °C, humidity: {} %",
+                sensor_reading.temperature,
+                sensor_reading.humidity
+            ),
+            Err(error) => log::error!("An error occurred while trying to read sensor: {:?}", error),
+        }
+
+        log::info!("-----");
     }
 }
 ```
 
-![running](/docs/example_esp32_dht11_running.png)
+![running](/docs/example_esp32_dht_running.png)
 
 
 ## Implementation Specification
@@ -68,30 +83,43 @@ We have gathered all the information you need to understand in order to implemen
 
 ### Step 1
 
-After powering on the DHT11 (once powered, allow 1 second to pass during which the sensor stabilizes; during this time, no commands should be sent), it measures the temperature and humidity of the surrounding environment and stores the data. Meanwhile, the DATA line of the DHT11 is kept high by a pull-up resistor. The DATA pin of the DHT11 is in input mode, ready to detect any external signals.
+After powering on the DHT11/DHT22 (once powered, allow 1 second to pass during which the sensor stabilizes; during this time, no commands should be sent), it measures the temperature and humidity of the surrounding environment and stores the data. Meanwhile, the DATA line of the DHT11/DHT22 is kept high by a pull-up resistor. The DATA pin of the DHT11/DHT22 is in input mode, ready to detect any external signals.
 
 ### Step 2
 
-The microprocessor's I/O pin is set to output mode and pulled low, holding this state for at least 18 milliseconds. Then, the microprocessor's I/O is switched to input mode. Due to the pull-up resistor, the microprocessor’s I/O line and the DHT11 DATA line will remain high, waiting for the DHT11 to respond with a signal, as illustrated below:
+The microprocessor's I/O pin is set to output mode and pulled low, holding this state for at least 18 milliseconds. Then, the microprocessor's I/O is switched to input mode. Due to the pull-up resistor, the microprocessor’s I/O line and the DHT11/DHT22 DATA line will remain high, waiting for the DHT11/DHT22 to respond with a signal, as illustrated below:
 
 ![step2](/docs/step2.png)
 
 
 ### Step 3
 
-The DHT11’s DATA pin detects an external signal and goes low, indicating that it is waiting for the external signal to complete. Once the signal ends, the DHT11’s DATA pin switches to output mode, producing a low signal for 80 microseconds as a response. This is followed by an 80-microsecond high signal, notifying the microprocessor that the sensor is ready to transmit data. At this point, the microprocessor's I/O pin, still in input mode, detects the low signal from the DHT11 (indicating the response) and then waits for the 80-microsecond high signal to start receiving data. The sequence of signal transmission is illustrated below:
+The DHT11/DHT22’s DATA pin detects an external signal and goes low, indicating that it is waiting for the external signal to complete. Once the signal ends, the DHT11/DHT22’s DATA pin switches to output mode, producing a low signal for 80 microseconds as a response. This is followed by an 80-microsecond high signal, notifying the microprocessor that the sensor is ready to transmit data. At this point, the microprocessor's I/O pin, still in input mode, detects the low signal from the DHT11/DHT22 (indicating the response) and then waits for the 80-microsecond high signal to start receiving data. The sequence of signal transmission is illustrated below:
 
 ![step3](/docs/step3.png)
 
 ### Step 4
 
-The DHT11 outputs 40 bits of data through the DATA pin, and the microprocessor receives these 40 data bits. The format for a data bit "0" consists of a low level lasting 50 microseconds, followed by a high level lasting 26-28 microseconds, depending on changes in the I/O level. For a data bit "1," the format includes a low level of 50 microseconds followed by a high level lasting up to 70 microseconds. The signal formats for data bits "0" and "1" are shown below.
+The DHT11/DHT22 outputs 40 bits of data through the DATA pin, and the microprocessor receives these 40 data bits. The format for a data bit "0" consists of a low level lasting 50 microseconds, followed by a high level lasting 26-28 microseconds, depending on changes in the I/O level. For a data bit "1," the format includes a low level of 50 microseconds followed by a high level lasting up to 70 microseconds. The signal formats for data bits "0" and "1" are shown below.
 
 ![step4](/docs/step4.png)
 
 ### End signal
 
-After outputting a low signal for 50 microseconds, the DHT11 completes sending the 40 bits of data and switches the DATA pin back to input mode, which, along with the pull-up resistor, returns to a high state. Meanwhile, the DHT11 internally re-measures the environmental temperature and humidity, records the new data, and waits for the next external signal.
+After outputting a low signal for 50 microseconds, the DHT11/DHT22 completes sending the 40 bits of data and switches the DATA pin back to input mode, which, along with the pull-up resistor, returns to a high state. Meanwhile, the DHT11/DHT22 internally re-measures the environmental temperature and humidity, records the new data, and waits for the next external signal.
+
+
+
+## Comparison of DHT11 and DHT22 40-Bit Data Formats
+
+| Feature               | DHT11                                                                                               | DHT22                                                                                           |
+|-----------------------|-----------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|
+| **Data Structure**    | - **Byte 1:** Humidity Integer Part<br>- **Byte 2:** Humidity Decimal Part (always 0)<br>- **Byte 3:** Temperature Integer Part<br>- **Byte 4:** Temperature Decimal Part (always 0)<br>- **Byte 5:** Checksum | - **Byte 1:** Humidity High Byte<br>- **Byte 2:** Humidity Low Byte<br>- **Byte 3:** Temperature High Byte<br>- **Byte 4:** Temperature Low Byte<br>- **Byte 5:** Checksum |
+| **Precision**         | Integer values only                                                                                | Includes decimal values for higher precision                                                   |
+| **Example Temperature** | 25°C                                                                                              | 25.6°C                                                                                          |
+| **Example Humidity**  | 60%                                                                                                 | 60.5%                                                                                           |
+| **Example Data Bytes**        | `60, 0, 25, 0, 85`                                                                                  | `2, 93, 1, 0, 96`                                                                               |
+| **Measurement Range** | - Temperature: 0–50°C<br>- Humidity: 20–90%                                                         | - Temperature: -40–80°C<br>- Humidity: 0–100%                                                   |
 
 
 ## Example Schematic 

docs/example_esp32_dht11_running.png

@@ -0,0 +1,75 @@
+use embedded_hal::{
+    delay::DelayNs,
+    digital::{ErrorType, InputPin, OutputPin, PinState},
+};
+
+use crate::SensorError;
+
+/// Common base struct for DHT sensors.
+pub struct Dht<P: InputPin + OutputPin, D: DelayNs> {
+    pub pin: P,
+    pub delay: D,
+}
+
+impl<P: InputPin + OutputPin, D: DelayNs> Dht<P, D> {
+    pub fn new(pin: P, delay: D) -> Self {
+        Self { pin, delay }
+    }
+
+    /// Reads a byte (8 bits) from the sensor.
+    ///
+    /// This method reads 8 bits sequentially from the sensor to construct a byte.
+    /// It follows the communication protocol of the DHT11/DHT22 sensors:
+    ///
+    /// For each bit:
+    /// - Waits for the pin to go **high** (start of bit transmission).
+    /// - Delays for **30 microseconds** to sample the bit value.
+    ///   - If the pin is **high** after the delay, the bit is interpreted as **'1'**.
+    ///   - If the pin is **low**, the bit is interpreted as **'0'**.
+    /// - Waits for the pin to go **low** (end of bit transmission).
+    ///
+    /// The bits are assembled into a byte, starting from the most significant bit (MSB).
+    ///
+    /// # Returns
+    ///
+    /// - `Ok(u8)`: The byte read from the sensor.
+    /// - `Err(SensorError<P::Error>)`: If a pin error occurs.
+    pub fn read_byte(&mut self) -> Result<u8, SensorError> {
+        let mut byte: u8 = 0;
+        for n in 0..8 {
+            let _ = self.wait_until_state(PinState::High);
+            self.delay.delay_us(30);
+            let is_bit_1 = self.pin.is_high();
+            if is_bit_1.unwrap() {
+                let bit_mask = 1 << (7 - (n % 8));
+                byte |= bit_mask;
+                let _ = self.wait_until_state(PinState::Low);
+            }
+        }
+        Ok(byte)
+    }
+
+    /// Waits until the pin reaches the specified state.
+    ///
+    /// This helper function continuously polls the pin until it reaches the desired `PinState`.
+    /// It introduces a **1-microsecond delay** between each poll to prevent excessive CPU usage.
+    ///
+    /// # Arguments
+    ///
+    /// - `state`: The target `PinState` to wait for (`PinState::High` or `PinState::Low`).
+    ///
+    /// # Returns
+    ///
+    /// - `Ok(())`: When the pin reaches the desired state.
+    /// - `Err(SensorError<P::Error>)`: If an error occurs while reading the pin state.
+    ///
+    pub fn wait_until_state(&mut self, state: PinState) -> Result<(), <P as ErrorType>::Error> {
+        while !match state {
+            PinState::Low => self.pin.is_low(),
+            PinState::High => self.pin.is_high(),
+        }? {
+            self.delay.delay_us(1);
+        }
+        Ok(())
+    }
+}

docs/example_esp32_dht_running.png

@@ -0,0 +1,53 @@
+use embedded_hal::{
+    delay::DelayNs,
+    digital::{InputPin, OutputPin, PinState},
+};
+
+use crate::{dht::Dht, SensorError, SensorReading};
+
+pub struct Dht11<P: InputPin + OutputPin, D: DelayNs> {
+    dht: Dht<P, D>,
+}
+
+impl<P: InputPin + OutputPin, D: DelayNs> Dht11<P, D> {
+    pub fn new(pin: P, delay: D) -> Self {
+        Self {
+            dht: Dht::new(pin, delay),
+        }
+    }
+
+    pub fn read(&mut self) -> Result<SensorReading, SensorError> {
+        // Start communication: pull pin low for 18ms, then release.
+        let _ = self.dht.pin.set_low();
+        self.dht.delay.delay_ms(18);
+        let _ = self.dht.pin.set_high();
+
+        // Wait for sensor to respond.
+        self.dht.delay.delay_us(48);
+
+        // Sync with sensor: wait for high then low signals.
+        let _ = self.dht.wait_until_state(PinState::High);
+        let _ = self.dht.wait_until_state(PinState::Low);
+
+        // Start reading 40 bits
+        let humidity_integer = self.dht.read_byte()?;
+        let humidity_decimal = self.dht.read_byte()?;
+        let temperature_integer = self.dht.read_byte()?;
+        let temperature_decimal = self.dht.read_byte()?;
+        let checksum = self.dht.read_byte()?;
+
+        // Checksum
+        let sum = humidity_integer
+            .wrapping_add(humidity_decimal)
+            .wrapping_add(temperature_integer)
+            .wrapping_add(temperature_decimal);
+        if sum != checksum {
+            return Err(SensorError::ChecksumMismatch);
+        }
+
+        Ok(SensorReading {
+            humidity: humidity_integer as f32,
+            temperature: temperature_integer as f32,
+        })
+    }
+}

src/dht.rs

@@ -0,0 +1,59 @@
+use embedded_hal::{
+    delay::DelayNs,
+    digital::{InputPin, OutputPin, PinState},
+};
+
+use crate::{dht::Dht, SensorError, SensorReading};
+
+pub struct Dht22<P: InputPin + OutputPin, D: DelayNs> {
+    dht: Dht<P, D>,
+}
+
+impl<P: InputPin + OutputPin, D: DelayNs> Dht22<P, D> {
+    pub fn new(pin: P, delay: D) -> Self {
+        Self {
+            dht: Dht::new(pin, delay),
+        }
+    }
+
+    pub fn read(&mut self) -> Result<SensorReading, SensorError> {
+        // Start communication: pull pin low for 18ms, then release.
+        let _ = self.dht.pin.set_low();
+        self.dht.delay.delay_ms(18);
+        let _ = self.dht.pin.set_high();
+
+        // Wait for sensor to respond.
+        self.dht.delay.delay_us(48);
+
+        // Sync with sensor: wait for high then low signals.
+        let _ = self.dht.wait_until_state(PinState::High);
+        let _ = self.dht.wait_until_state(PinState::Low);
+
+        // Start reading 40 bits
+        let humidity_high = self.dht.read_byte()?;
+        let humidity_low = self.dht.read_byte()?;
+        let temperature_high = self.dht.read_byte()?;
+        let temperature_low = self.dht.read_byte()?;
+        let checksum = self.dht.read_byte()?;
+
+        // Checksum
+        let sum = humidity_high
+            .wrapping_add(humidity_low)
+            .wrapping_add(temperature_high)
+            .wrapping_add(temperature_low);
+        if sum != checksum {
+            return Err(SensorError::ChecksumMismatch);
+        }
+
+        let humidity_value = ((humidity_high as u16) << 8) | (humidity_low as u16);
+        let humidity_percentage = humidity_value as f32 / 10.0;
+
+        let temperature_value = ((temperature_high as u16) << 8) | (temperature_low as u16);
+        let temperatue_percentage = temperature_value as f32 / 10.0;
+
+        Ok(SensorReading {
+            humidity: humidity_percentage as f32,
+            temperature: temperatue_percentage as f32,
+        })
+    }
+}