feat: return sensor reading; update readme

Author: zeldan

Cargo.lock

@@ -6,5 +6,4 @@ license = "Apache-2.0"
 
 [dependencies]
 embedded-hal = "1.0.0"
-panic-halt = "0.2.0"
 

Cargo.toml

@@ -1,5 +1,61 @@
 # embedded-dht-rs
 
+Welcome to `embedded-dht-rs`, a Rust library designed to make working with DHT sensors a breeze!
+
+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!
+
+We’ve tested it with the ESP32-WROOM, and you can find a detailed example below to help you get started.
+
+## Getting Started
+
+### Example 
+
+```rust
+#![no_std]
+#![no_main]
+
+use embedded_dht_rs::Dht11;
+use esp_backtrace as _;
+use esp_hal::{
+    clock::ClockControl,
+    delay::Delay,
+    gpio::{Io, Level, OutputOpenDrain, Pull},
+    peripherals::Peripherals,
+    prelude::*,
+    system::SystemControl,
+};
+#[entry]
+fn main() -> ! {
+    let peripherals = Peripherals::take();
+    let system = SystemControl::new(peripherals.SYSTEM);
+    let clocks = ClockControl::boot_defaults(system.clock_control).freeze();
+    let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
+
+    esp_println::logger::init_logger_from_env();
+
+    let delay = Delay::new(&clocks);
+
+    let gpio4 = OutputOpenDrain::new(io.pins.gpio4, Level::High, Pull::None);
+    let mut led_sensor = Dht11::new(gpio4, delay);
+
+    loop {
+        delay.delay(1000.millis());
+        let reading = led_sensor.read().unwrap();
+        log::info!(
+            "Temperature: {}, humidity: {}",
+            reading.temperature,
+            reading.humidity
+        );
+    }
+}
+```
+
+---
+
 ![steps](/docs/steps.png)
 
 ## Step 1

README.md

@@ -2,23 +2,28 @@
 
 use embedded_hal::{
     delay::DelayNs,
-    digital::{ErrorType, InputPin, OutputPin, PinState}
+    digital::{ErrorType, InputPin, OutputPin, PinState},
 };
 
 pub struct Dht11<P: InputPin + OutputPin, D: DelayNs> {
     pin: P,
     delay: D,
 }
 
+pub struct SensorReading {
+    pub humidity: u8,
+    pub temperature: i8,
+}
+
 impl<P: InputPin + OutputPin, D: DelayNs> Dht11<P, D> {
     pub fn new(pin: P, delay: D) -> Self {
-        Self { pin, delay }
+        Self { pin, delay }     
     }
 
-    pub fn read(&mut self) -> Result<bool, <P as ErrorType>::Error> {
+    pub fn read(&mut self) -> Result<SensorReading, <P as ErrorType>::Error> {
         // Start communication: pull pin low for 18ms, then release.
         let _ = self.pin.set_low();
-        self.delay.delay_ms(18); 
+        self.delay.delay_ms(18);
         let _ = self.pin.set_high();
 
         // Wait for sensor to respond.
@@ -36,12 +41,13 @@ impl<P: InputPin + OutputPin, D: DelayNs> Dht11<P, D> {
         let checksum = self.read_byte();
 
         // TODO
-        panic!("{:?} {:?} {:?} {:?} {:?}", humidity_integer, humidity_decimal, temperature_integer, temperature_decimal, checksum);
-
-        return self.pin.is_high();
+        // panic!("{:?} {:?} {:?} {:?} {:?}", humidity_integer, humidity_decimal, temperature_integer, temperature_decimal, checksum);
+        Ok(SensorReading {
+            humidity: humidity_integer.unwrap(),
+            temperature: temperature_integer.unwrap() as i8,
+        })
     }
 
-
     fn read_byte(&mut self) -> Result<u8, <P as ErrorType>::Error> {
         let mut byte: u8 = 0;
         for n in 0..8 {
@@ -64,15 +70,22 @@ impl<P: InputPin + OutputPin, D: DelayNs> Dht11<P, D> {
     /// # Arguments
     ///
     /// * `state` - The target `PinState` to wait for (either `Low` or `High`).
-    fn wait_until_state(&mut self, state: PinState) -> Result<(), <P as ErrorType>::Error>{
+    fn wait_until_state(&mut self, state: PinState) -> Result<(), <P as ErrorType>::Error> {
         loop {
             match state {
-                PinState::Low => if self.pin.is_low()? { break; },
-                PinState::High => if self.pin.is_high()? { break; }
+                PinState::Low => {
+                    if self.pin.is_low()? {
+                        break;
+                    }
+                }
+                PinState::High => {
+                    if self.pin.is_high()? {
+                        break;
+                    }
+                }
             };
             self.delay.delay_us(1);
         }
         Ok(())
     }
 }
-