Initial commit

Author: plorefice

Diff for: .cargo/config

@@ -0,0 +1,2 @@
+[target.thumbv7em-none-eabihf]
+rustflags = ["-C", "link-arg=-Tlink.x"]

Diff for: .gitignore

@@ -0,0 +1,2 @@
+target/
+Cargo.lock

Diff for: Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+authors = ["Pietro Lorefice <[email protected]>"]
+categories = ["embedded", "hardware-support", "no-std"]
+description = "Platform-agnostic Rust driver for the DHT11 temperature and humidity sensor."
+edition = "2018"
+keywords = ["embedded-hal-driver"]
+license = "MIT OR Apache-2.0"
+name = "dht11"
+readme = "README.md"
+repository = "https://github.com/plorefice/dht11-rs"
+version = "0.1.0"
+
+[dependencies]
+embedded-hal = { version = "0.2", features = ["unproven"] }
+
+[dev-dependencies]
+cortex-m = "0.6"
+cortex-m-rt = "0.6"
+cortex-m-semihosting = "0.3"
+panic-semihosting = "0.5"
+
+[dev-dependencies.stm32f4xx-hal]
+version = "0.8"
+features = ["rt", "stm32f407"]
+
+[profile.release]
+lto = true

Diff for: README.md

@@ -0,0 +1,34 @@
+# dht11-rs
+
+Platform-agnostic Rust driver for the DHT11 temperature and humidity sensor,
+using [`embedded-hal`](https://github.com/rust-embedded/embedded-hal) traits.
+
+## Requirements
+
+- Rust 1.43+
+
+## Usage
+
+Include library as a dependency in your Cargo.toml
+
+```toml
+[dependencies]
+dht11 = "0.1.0"
+```
+
+```rust
+use dht11::Dht11;
+
+// Create an instance of the DHT11 device
+let mut dht11 = Dht11::new(pin);
+
+// Perform a sensor reading
+let measurement = dht11.perform_measurement(&mut delay).unwrap();
+println!("{:?}", measurement);
+```
+
+## Examples
+
+See the [examples](examples/) directory for an example on how to use this crate on an STM32F407 MCU.
+
+By default, semihosting is used to display the value of the readings, using OpenOCD or similar.

Diff for: examples/stm32f407.rs

@@ -0,0 +1,36 @@
+#![deny(unsafe_code)]
+#![no_main]
+#![no_std]
+
+extern crate panic_semihosting;
+
+use cortex_m_rt::entry;
+use cortex_m_semihosting::hprintln;
+use hal::{prelude::*, stm32};
+use stm32f4xx_hal as hal;
+
+use dht11::Dht11;
+
+#[entry]
+fn main() -> ! {
+    let dp = stm32::Peripherals::take().unwrap();
+    let cp = cortex_m::peripheral::Peripherals::take().unwrap();
+
+    // The DATA pin is connected to PE2.
+    let gpio = dp.GPIOE.split();
+    let pin = gpio.pe2.into_open_drain_output();
+
+    // Create a delay abstraction based on SysTick.
+    // We are using the HSE oscillator here for accurate delays.
+    let rcc = dp.RCC.constrain();
+    let clocks = rcc.cfgr.use_hse(8.mhz()).sysclk(168.mhz()).freeze();
+    let mut delay = hal::delay::Delay::new(cp.SYST, clocks);
+
+    // Create an instance of our device
+    let mut dht11 = Dht11::new(pin);
+
+    loop {
+        hprintln!("{:?}", dht11.perform_measurement(&mut delay)).unwrap();
+        delay.delay_ms(1000_u16);
+    }
+}

Diff for: memory.x

@@ -0,0 +1,6 @@
+# Memory layout for an STM32F407VG microcontroller
+MEMORY
+{
+  FLASH : ORIGIN = 0x08000000, LENGTH = 1024K
+  RAM : ORIGIN = 0x20000000, LENGTH = 128K
+}

Diff for: src/lib.rs

@@ -0,0 +1,157 @@
+//! Platform-agnostic Rust driver for the DHT11 temperature and humidity sensor,
+//! using [`embedded-hal`](https://github.com/rust-embedded/embedded-hal) traits.
+
+#![deny(unsafe_code)]
+#![deny(missing_docs)]
+#![cfg_attr(not(test), no_std)]
+
+use embedded_hal::{
+    blocking::delay::{DelayMs, DelayUs},
+    digital::v2::{InputPin, OutputPin},
+};
+
+/// How long to wait for a pulse on the data line (in microseconds).
+const TIMEOUT_US: u16 = 1_000;
+
+/// Error type for this crate.
+#[derive(Debug)]
+pub enum Error<E> {
+    /// Timeout during communication.
+    Timeout,
+    /// CRC mismatch.
+    CrcMismatch,
+    /// GPIO error.
+    Gpio(E),
+}
+
+/// A DHT11 device.
+pub struct Dht11<GPIO> {
+    /// The concrete GPIO pin implementation.
+    gpio: GPIO,
+}
+
+/// Results of a reading performed by the DHT11.
+#[derive(Debug)]
+pub struct Measurement {
+    /// The measured temperature.
+    pub temperature: f32,
+    /// The measured humidity.
+    pub humidity: f32,
+}
+
+impl<GPIO, E> Dht11<GPIO>
+where
+    GPIO: InputPin<Error = E> + OutputPin<Error = E>,
+{
+    /// Creates a new DHT11 device connected to the specified pin.
+    pub fn new(gpio: GPIO) -> Self {
+        Dht11 { gpio }
+    }
+
+    /// Destroys the driver, returning the GPIO instance.
+    pub fn destroy(self) -> GPIO {
+        self.gpio
+    }
+
+    /// Performs a reading of the sensor.
+    pub fn perform_measurement<D>(&mut self, delay: &mut D) -> Result<Measurement, Error<E>>
+    where
+        D: DelayUs<u16> + DelayMs<u16>,
+    {
+        let mut data = [0u8; 5];
+
+        // Perform initial handshake
+        self.perform_handshake(delay)?;
+
+        // Read bits
+        for i in 0..40 {
+            data[i / 8] <<= 1;
+            if self.read_bit(delay)? {
+                data[i / 8] |= 1;
+            }
+        }
+
+        // Finally wait for line to go idle again.
+        self.wait_for_pulse(true, delay)?;
+
+        // Check CRC
+        let crc = data[0]
+            .wrapping_add(data[1])
+            .wrapping_add(data[2])
+            .wrapping_add(data[3]);
+        if crc != data[4] {
+            return Err(Error::CrcMismatch);
+        }
+
+        // Compute temperature
+        let mut temp = (data[2] & 0x7f) as f32 + data[3] as f32 * 0.1;
+        if data[2] & 0x80 != 0 {
+            temp = -temp;
+        }
+
+        Ok(Measurement {
+            temperature: temp,
+            humidity: data[0] as f32 + data[1] as f32 * 0.1,
+        })
+    }
+
+    fn perform_handshake<D>(&mut self, delay: &mut D) -> Result<(), Error<E>>
+    where
+        D: DelayUs<u16> + DelayMs<u16>,
+    {
+        // Set pin as floating to let pull-up raise the line and start the reading process.
+        self.set_input()?;
+        delay.delay_ms(1);
+
+        // Pull line low for at least 18ms to send a start command.
+        self.set_low()?;
+        delay.delay_ms(20);
+
+        // Restore floating
+        self.set_input()?;
+        delay.delay_us(40);
+
+        // As a response, the device pulls the line low for 80us and then high for 80us.
+        self.read_bit(delay)?;
+
+        Ok(())
+    }
+
+    fn read_bit<D>(&mut self, delay: &mut D) -> Result<bool, Error<E>>
+    where
+        D: DelayUs<u16> + DelayMs<u16>,
+    {
+        let low = self.wait_for_pulse(true, delay)?;
+        let high = self.wait_for_pulse(false, delay)?;
+        Ok(high > low)
+    }
+
+    fn wait_for_pulse<D>(&mut self, level: bool, delay: &mut D) -> Result<u16, Error<E>>
+    where
+        D: DelayUs<u16> + DelayMs<u16>,
+    {
+        let mut count = 0;
+
+        while self.read_line()? != level {
+            count += 1;
+            if count > TIMEOUT_US {
+                return Err(Error::Timeout);
+            }
+            delay.delay_us(1);
+        }
+
+        Ok(count)
+    }
+
+    fn set_input(&mut self) -> Result<(), Error<E>> {
+        self.gpio.set_high().map_err(Error::Gpio)
+    }
+
+    fn set_low(&mut self) -> Result<(), Error<E>> {
+        self.gpio.set_low().map_err(Error::Gpio)
+    }
+
+    fn read_line(&self) -> Result<bool, Error<E>> {
+        self.gpio.is_high().map_err(Error::Gpio)
+    }
+}