feat: read raw humidity from measurement

Author: zeldan

README.md

@@ -14,6 +14,14 @@ We’ve tested it with the ESP32-WROOM, and you can find a detailed example belo
 
 ## Getting Started
 
+### Tutorials
+
+Here are some general tutorials that provide brief introductions to embedded programming:
+
+- **Part 1 (Introduction)** - [Introduction to Embedded Systems with Rust: A Beginner's Guide Using ESP32](https://rust-dd.com/post/introduction-to-embedded-systems-with-rust-a-beginner-s-guide-using-esp32)
+- **Part 2 (LED + Button)** - [Building a Simple LED and Button Interface with Rust on ESP32](https://rust-dd.com/post/building-a-simple-led-and-button-interface-with-rust-on-esp32)
+
+
 ### Example - ESP32
 
 ```rust
@@ -131,6 +139,16 @@ After powering on, wait at least 100ms. Before reading the temperature and humid
 
 
 #### Step 2
+Wait for 10ms before sending the 0xAC command to trigger the measurement. The command consists of two bytes: the first byte is 0x33 and the second byte is 0x00.
+
+#### Step 3
+Wait for 80ms for the measurement to complete. If Bit [7] of the status word is 0, the measurement is done, and you can proceed to read six bytes continuously; if not, continue waiting.
+
+#### Step 4
+After receiving the six bytes, the following byte is the CRC check data, which can be read if needed. If the receiver requires CRC validation, an ACK is sent after the sixth byte is received; otherwise, send a NACK to terminate. The initial CRC value is 0xFF, and the CRC8 check uses the polynomial: CRC [7:0] = 1 + X^4 + X^5 + X^8.
+
+#### Step 5
+Compute the temperature and humidity values.
 
 
 ## Comparison of DHT11, DHT20, and DHT22 40-Bit Data Formats

src/dht20.rs

@@ -2,42 +2,71 @@ use embedded_hal::{delay::DelayNs, i2c::I2c};
 
 use crate::{SensorError, SensorReading};
 
-pub struct Dht20<P: I2c, D: DelayNs> {
-    pub pin: P,
+pub struct Dht20<I: I2c, D: DelayNs> {
+    pub i2c: I,
     pub delay: D,
 }
 
-impl<P: I2c, D: DelayNs> Dht20<P, D> {
-    pub fn new(pin: P, delay: D) -> Self {
+impl<I: I2c, D: DelayNs> Dht20<I, D> {
+    const SENSOR_ADDRESS: u8 = 0x38;
+
+    pub fn new(i2c: I, delay: D) -> Self {
         Self {
-            pin: pin,
-            delay: delay,
+            i2c,
+            delay,
         }
     }
 
-    pub fn read(&mut self) -> Result<SensorReading, SensorError> {
+    pub fn read(&mut self) -> Result<SensorReading<f32>, SensorError> {
         // Check status
-        let status_request: &[u8] = &[0x71];
         let mut status_response: [u8; 1] = [0; 1];
-
-        let _ = self.pin.write_read(0x38, status_request, &mut status_response);
+        let _ = self.i2c.write_read(Self::SENSOR_ADDRESS, &[0x71], &mut status_response);
+        
         if status_response[0] & 0x18 != 0x18 {
             // Callibration
-            let _ = self.pin.write(0x38, &[0x1B, 0, 0]);
-            let _ = self.pin.write(0x38, &[0x1C, 0, 0]);
-            let _ = self.pin.write(0x38, &[0x1E, 0, 0]);
+            let _ = self.i2c.write(Self::SENSOR_ADDRESS, &[0x1B, 0, 0]);
+            let _ = self.i2c.write(Self::SENSOR_ADDRESS, &[0x1C, 0, 0]);
+            let _ = self.i2c.write(Self::SENSOR_ADDRESS, &[0x1E, 0, 0]);
         }
 
-        
-
+        // Trigger the measurement
+        self.delay.delay_ms(10);
+        let _ = self.i2c.write(Self::SENSOR_ADDRESS, &[0xAC, 0x33, 0x00]);
 
+        // Read the measurement status
+        self.delay.delay_ms(80);
+        loop {
+            let mut measurement_status_response: [u8; 1] = [0; 1];
+            let _ = self.i2c.read(Self::SENSOR_ADDRESS, &mut measurement_status_response);
+            let status_word = measurement_status_response[0];
+            if status_word & 0b1000_0000 == 0 {
+                break;
+            }
+            self.delay.delay_ms(1);
+        }
 
+        // Read the measurement (1 status + 5 data + 1 crc)
+        let mut measurement_response: [u8; 7] = [0; 7];
+        let _ = self.i2c.read(Self::SENSOR_ADDRESS, &mut measurement_response);
 
-        // TODO
+        // Humidity 20 bits (8 + 8 + 4)
+        let mut raw_humidity = measurement_response[1] as u32;
+        raw_humidity = (raw_humidity << 8) + measurement_response[2] as u32;
+        raw_humidity = (raw_humidity << 4) + (measurement_response[3] >> 4) as u32;
         let humidity_percentage = 10.0;
-        // TODO
+
+
+        // Temperature 20 bits
+        let mut raw_temperature = (measurement_response[3] & 0b1111) as u32;
+        raw_temperature = (raw_temperature << 8) + measurement_response[4] as u32;
+        raw_temperature = (raw_temperature << 8) + measurement_response[5] as u32;
         let temperatue_percentage = 10.0;
 
+        // CRC 8 bits
+
+
+
+
         Ok(SensorReading {
             humidity: humidity_percentage as f32,
             temperature: temperatue_percentage as f32,