feat: add checksum checking; update docs

Author: zeldan

README.md

@@ -44,44 +44,49 @@ fn main() -> ! {
 
     loop {
         delay.delay(1000.millis());
-        let reading = led_sensor.read().unwrap();
-        log::info!(
-            "Temperature: {}, humidity: {}",
-            reading.temperature,
-            reading.humidity
-        );
+        match led_sensor.read() {
+            Ok(sensor_reading) => log::info!(
+                "Temperature: {}, humidity: {}",
+                sensor_reading.temperature,
+                sensor_reading.humidity
+            ),
+            Err(error) => log::error!("An error occurred while trying to read sensor: {:?}", error),
+        }
     }
 }
 ```
 
----
+![running](/docs/example_esp32_dht11_running.png)
+
+
+## Implementation Specification
 
 ![steps](/docs/steps.png)
 
-## Step 1
+### 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.
 
-## Step 2
+### 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:
 
 ![step2](/docs/step2.png)
 
 
-## Step 3
+### 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:
 
 ![step3](/docs/step3.png)
 
-## Step 4
+### 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.
 
 ![step4](/docs/step4.png)
 
-# End signal
+### 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.
 

docs/example_esp32_dht11_running.png

@@ -15,12 +15,17 @@ pub struct SensorReading {
     pub temperature: i8,
 }
 
+#[derive(Debug)]
+pub enum SensorError {
+    ChecksumMismatch,
+}
+
 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<SensorReading, <P as ErrorType>::Error> {
+    pub fn read(&mut self) -> Result<SensorReading, SensorError> {
         // Start communication: pull pin low for 18ms, then release.
         let _ = self.pin.set_low();
         self.delay.delay_ms(18);
@@ -34,21 +39,25 @@ impl<P: InputPin + OutputPin, D: DelayNs> Dht11<P, D> {
         let _ = self.wait_until_state(PinState::Low);
 
         // Start reading 40 bits
-        let humidity_integer = self.read_byte();
-        let humidity_decimal = self.read_byte();
-        let temperature_integer = self.read_byte();
-        let temperature_decimal = self.read_byte();
-        let checksum = self.read_byte();
+        let humidity_integer = self.read_byte()?;
+        let humidity_decimal = self.read_byte()?;
+        let temperature_integer = self.read_byte()?;
+        let temperature_decimal = self.read_byte()?;
+        let checksum = self.read_byte()?;
+
+        // Checksum
+        let sum = humidity_integer + humidity_decimal + temperature_integer + temperature_decimal;
+        if sum != checksum {
+            return Err(SensorError::ChecksumMismatch);
+        }
 
-        // TODO
-        // panic!("{:?} {:?} {:?} {:?} {:?}", humidity_integer, humidity_decimal, temperature_integer, temperature_decimal, checksum);
         Ok(SensorReading {
-            humidity: humidity_integer.unwrap(),
-            temperature: temperature_integer.unwrap() as i8,
+            humidity: humidity_integer,
+            temperature: temperature_integer as i8,
         })
     }
 
-    fn read_byte(&mut self) -> Result<u8, <P as ErrorType>::Error> {
+    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);