Initial import

Author: kelnos

.github/workflows/ci.yaml

@@ -0,0 +1,52 @@
+on:
+  - push
+  - pull_request
+name: CI
+jobs:
+  janitorial:
+    name: janitorial
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          components: clippy
+          override: true
+      - uses: actions-rs/clippy-check@v1
+        with:
+          toolchain: stable
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-targets --all-features -- -D warnings
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --check
+  test:
+    name: test
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust:
+          - stable
+        target:
+          - arm-unknown-linux-gnueabihf
+          - armv7-unknown-linux-gnueabihf
+          - aarch64-unknown-linux-gnu
+          - x86_64-unknown-linux-gnu
+        feature_flags:
+          - ''
+          - '--features std'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          target: ${{ matrix.target }}
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: test
+          args: --release --target=${{ matrix.target }} ${{ matrix.feature_flags }}

.github/workflows/release.yaml

@@ -0,0 +1,20 @@
+on:
+  release:
+    types:
+      - published
+name: release
+jobs:
+  release:
+    name: Publish to crates.io
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: publish
+          args: --token ${{ secrets.CRATES_IO_TOKEN }}

.gitignore

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

Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "dht-embedded"
+version = "0.1.0"
+description = "Library for reading temperature and humidity from the DHT11 and DHT22 sensors"
+license = "MIT OR Apache-2.0"
+authors = ["Brian J. Tarricone <brian@tarricone.org>"]
+homepage = "https://github.com/kelnos/dht-embedded-rs"
+repository = "https://github.com/kelnos/dht-embedded-rs"
+readme = "README.md"
+categories = [ "embedded", "hardware-support" ]
+keywords = [ "temperature", "humidity", "sensor", "dht11", "dht22" ]
+edition = "2021"
+
+[features]
+default = []
+std = []
+
+[dependencies]
+embedded-hal = "=1.0.0-alpha.8"
+
+[dev-dependencies]
+anyhow = "1"
+gpio-cdev = "0.5"
+linux-embedded-hal = "0.3"
+serial = "0.4"

README.md

@@ -0,0 +1,65 @@
+# dht-embedded
+
+`dht-embedded` is a Rust crate that reads temperature and humidity data
+from the DHT11 and DHT22 sensors.
+
+## Prerequisites
+
+* You've connected the DHT sensor to your device (such as a Raspberry
+  Pi or ESP32) using a GPIO pin.
+
+## Usage
+
+Add the following to your `Cargo.toml`:
+
+```toml
+[dependencies]
+dht-embedded = "=0.1.0-alpha.1"
+```
+
+Note that this crate currently tracks the 1.0.0 alpha releases of
+`embedded-hal`, so things can change & break often, and your platform's
+`embedded-hal` implementation may not have trait impls for 1.0.0 alphas
+at all, let alone the current one this crate supports.
+
+You will need to use an `embedded-hal` implementation for your hardware.
+Here's a simple one using `linux-embedded-hal` and `gpio-cdev, which
+could be used on a Rasperry Pi.
+
+```rust,no_run,ignore
+use dht_embedded::{Dht22, DhtSensor, NoopInterruptControl};
+use gpio_cdev::{Chip, LineRequestFlags};
+use linux_embedded_hal::{CdevPin, Delay};
+use std::{thread::sleep, time::Duration};
+
+fn main() -> anyhow::Result<()> {
+    let mut gpiochip = Chip::new("/dev/gpiochip0")?;
+    let line = gpiochip.get_line(17)?;
+    let handle = line.request(LineRequestFlags::INPUT | LineRequestFlags::OUTPUT, 1, "dht-sensor")?;
+    let pin = CdevPin::new(handle)?;
+    let mut sensor = Dht22::new(NoopInterruptControl, Delay, pin);
+
+    loop {
+        match sensor.read() {
+            Ok(reading) => println!("{}°C, {}% RH", reading.temperature(), reading.humidity()),
+            Err(e) => eprintln!("Error: {}", e),
+        }
+
+        sleep(Duration::from_millis(2100));
+    }
+}
+```
+
+(To be fair, the Linux kernel includes a driver for DHT sensors, and
+honestly it's probably better to use that driver, since kernel space can
+disable interrupts and get much more precise timing than we can.)
+
+## Why
+
+A search of crates.io might yield several different implementations of
+this driver.  I wrote this because none of the others worked for me,
+and, upon examination of their code, I found they used a completely
+different protocols for reading from the sensor, protocols I couldn't
+find documented anywhere as what's supposed to work.  This crate
+implements one of the simpler protocols that doesn't require access to a
+system clock, but still seems to work most of the time.