embedded-sht3x 0.2.0

Platform-agnostic Rust driver for the SHT3x temperature and humidity sensors.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

[![crates.io](https://img.shields.io/crates/v/embedded-sht3x.svg)](https://crates.io/crates/embedded-sht3x)
[![Github status](https://github.com/ghismary/embedded-sht3x/actions/workflows/general.yml/badge.svg)](https://github.com/ghismary/embedded-sht3x)
[![codecov](https://codecov.io/gh/ghismary/embedded-sht3x/graph/badge.svg?token=q9CQS0eM3c)](https://codecov.io/gh/ghismary/embedded-sht3x)
[![License](https://img.shields.io/crates/l/embedded-sht3x.svg)](https://crates.io/crates/embedded-sht3x)
[![Documentation](https://docs.rs/embedded-sht3x/badge.svg)](https://docs.rs/embedded-sht3x)

# embedded-sht3x

This is a platform agnostic Rust driver the SHT3x (SHT30, SHT31 and SHT35) digital
humidity and temperature sensors using the [`embedded-hal`] and
[`embedded-hal-async`] traits.

[`embedded-hal`]: https://github.com/rust-embedded/embedded-hal
[`embedded-hal-async`]: https://github.com/rust-embedded/embedded-hal

This driver can be used both synchronously or asynchronously. It defaults to the
synchronous implementation, but you can switch to the asynchronous one by using
the `async` feature.

## The device

The sensors of the SHT3x family are humidity and temperature sensors,
that are fully calibrated and working with wide range of supply voltages,
from 2.15 V to 5.5 V, and using an I²C interface.

They procure fast start-up and measurement times, and great accuracy.
The typical accuracies are the following:

| SHT30            | SHT31            | SHT35              |
| ---------------- | ---------------- | ------------------ |
| ±2 %RH / ±0.2 °C | ±2 %RH / ±0.2 °C | ±1.5 %RH / ±0.1 °C |

The SHT3x is equipped with an internal heater which can increase the
temperature in the range of a few degrees centigrade, and that is useful
for plausibility checks.

### Documentation:

- [Datasheet](https://sensirion.com/media/documents/213E6A3B/63A5A569/Datasheet_SHT3x_DIS.pdf)
- [Arduino driver](https://github.com/Sensirion/arduino-sht)

## Features

- [x] Get the status of the sensor.
- [x] Clear the status of the sensor.
- [x] Enable the internal heater.
- [x] Disable the internal heater.
- [x] Perform a single-shot measurement of temperature and relative humidity.
- [x] Do a software reset.
- [x] Convert temperatures between °C and °F.
- [x] Calculate the absolute humidity from a measurement.
- [ ] Perform periodic measurement of temperature and relative humidity.

## Usage

To use this driver, import what you need from this crate and an `embedded-hal`
implementation, then instantiate the device.

```rust,no_run
#[cfg(target_os = "linux")]
mod linux {
    use embedded_sht3x::{Repeatability::High, Sht3x, Temperature, DEFAULT_I2C_ADDRESS};
    use linux_embedded_hal as hal;

    pub fn main() -> Result<(), embedded_sht3x::Error<hal::I2CError>> {
        // Create the I2C device from the chosen embedded-hal implementation,
        // in this case linux-embedded-hal
        let mut i2c = match hal::I2cdev::new("/dev/i2c-1") {
            Err(err) => {
                eprintln!("Could not create I2C device: {}", err);
                std::process::exit(1);
            }
            Ok(i2c) => i2c,
        };
        if let Err(err) = i2c.set_slave_address(DEFAULT_I2C_ADDRESS as u16) {
            eprintln!("Could not set I2C slave address: {}", err);
            std::process::exit(1);
        }

        // Create the sensor and configure its repeatability
        let mut sensor = Sht3x::new(i2c, DEFAULT_I2C_ADDRESS, hal::Delay {})?;
        sensor.repeatability = High;

        // Perform a temperature and humidity measurement
        let measurement = sensor.single_measurement()?;
        println!(
            "Temperature: {:.2} °C, Relative humidity: {:.2} %",
            measurement.temperature.celsius().value(),
            measurement.relative_humidity.value()
        );
        Ok(())
    }
}
fn main() {
    #[cfg(target_os = "linux")]
    let _ = linux::main();
    #[cfg(not(target_os = "linux"))]
    println!("This example only works on Linux");
}
```

## License

Licensed under either of

- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
  <http://www.apache.org/licenses/LICENSE-2.0>)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)

at your option.

### Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.