added getTemperature and getHumidity

added upport for ESP I2C
added constants for status masks
added HARD reset
added setHeatTimeout
added heatUp
refactored

Author: RobTillaart

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Rob Tillaart
+Copyright (c) 2019-2020 Rob Tillaart
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,2 +1,25 @@
 # SHT31
+
 Arduino library for the SHT31 temperature and humidity sensor
+
+# Description
+
+The SHT3x family of sensors should work up to 1 MHz I2C
+
+This library should also work for SHT30 and SHT35 but these are 
+not tested yet.
+
+| SENSOR | Temperature accuracy | Humidity accuracy |
+|:----:|:----:|:----:|
+| SHT30 | ~0.3 | 2 |
+| SHT31 | ~0.3 | 1.5 |
+| SHT35 | ~0.2 | 1.5 |
+
+
+An elaborated library for the SHT31 sensor can be found here
+https://github.com/hawesg/SHT31D_Particle_Photon_ClosedCube
+
+# Operation
+
+See examples
+

SHT31.cpp

@@ -0,0 +1,211 @@
+//
+//    FILE: SHT31.cpp
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.2.0
+//    DATE: 2019-02-08
+// PURPOSE: Arduino library for the SHT31 temperature and humidity sensor
+//          https://www.adafruit.com/product/2857
+//     URL: https://github.com/RobTillaart/SHT31
+//
+// HISTORY:
+// 0.1.0   2019-02-08 initial version
+// 0.1.1   2019-02-18 add description readStatus(),
+//                    async interface
+// 0.1.2   2019-03-05 fix issue #123 - error in humidity
+//                    stable version
+// 0.2.0   2020-05-12 made humidity & temperature private;
+//                    support ESP32 I2C
+//
+
+
+#include "SHT31.h"
+
+// SUPPORTED COMMANDS - single shot mode only
+#define SHT31_READ_STATUS       0xF32D
+#define SHT31_CLEAR_STATUS      0x3041
+
+#define SHT31_SOFT_RESET        0x30A2
+#define SHT31_HARD_RESET        0x0006
+
+#define SHT31_MEASUREMENT_FAST  0x2416	// page 10 datasheet
+#define SHT31_MEASUREMENT_SLOW  0x2400	// no clock stretching
+
+#define SHT31_HEAT_ON           0x306D
+#define SHT31_HEAT_OFF          0x3066
+
+
+SHT31::SHT31()
+{
+  _addr = 0;
+  _lastRead = 0;
+  temperature = 0;
+  humidity = 0;
+  _heaterStart = 0;
+}
+
+#if defined(ESP8266) || defined(ESP32)
+bool SHT31::begin(const uint8_t address, const uint8_t dataPin, const uint8_t clockPin)
+{
+  if (address != 0x44 && address != 0x45) return false;
+  _addr = address;
+
+  _wire = &Wire;
+  if ((dataPin < 255) && (clockPin < 255))
+  {
+    _wire->begin(dataPin, clockPin);
+  } else {
+    _wire->begin();
+  }
+  reset();
+  return true;
+}
+#endif
+
+bool SHT31::begin(const uint8_t address)
+{
+  return begin(address, &Wire);
+}
+
+bool SHT31::begin(const uint8_t address,  TwoWire *wire)
+{
+  if (address != 0x44 && address != 0x45) return false;
+  _addr = address;
+  _wire = wire;
+  _wire->begin();
+  reset();
+  return true;
+}
+
+bool SHT31::read(bool fast)
+{
+  writeCmd(fast ? SHT31_MEASUREMENT_FAST : SHT31_MEASUREMENT_SLOW);
+  delay(fast ? 4 : 15); // table 4 datasheet
+  return readData(fast);
+}
+
+uint16_t SHT31::readStatus()
+{
+  uint32_t status = 0;
+  writeCmd(SHT31_READ_STATUS);        // page 13 datasheet
+  readBytes(3, (uint8_t*) &status);   // 16 bit status + CRC
+  // TODO CRC check
+
+  return (uint16_t) (status >> 8);
+
+  // bit - description
+  // ==================
+  // 15 Alert pending status
+  //    '0': no pending alerts
+  //    '1': at least one pending alert - default
+  // 14 Reserved ‘0’
+  // 13 Heater status
+  //    '0’ : Heater OFF - default
+  //    '1’ : Heater ON
+  // 12 Reserved '0’
+  // 11 Humidity tracking alert
+  //    '0’ : no alert - default
+  //    '1’ : alert
+  // 10 Temp tracking alert
+  //    '0’ : no alert - default
+  //    '1’ : alert
+  // 9:5 Reserved '00000’
+  // 4 System reset detected
+  //    '0': no reset since last ‘clear status register’ command
+  //    '1': reset detected (hard or soft reset command or supply fail) - default
+  // 3:2 Reserved ‘00’
+  // 1 Command status
+  //    '0': last cmd executed successfully
+  //    '1': last cmd not processed. Invalid or failed checksum
+  // 0 Write data checksum status
+  //    '0': checksum of last write correct
+  //    '1': checksum of last write transfer failed
+}
+
+void SHT31::reset(bool hard)
+{
+  if (hard)
+  {
+    writeCmd(SHT31_HARD_RESET);
+  } else {
+    writeCmd(SHT31_SOFT_RESET);
+  }
+  delay(1);  // table 4 datasheet
+}
+
+void SHT31::setHeatTimeout(uint8_t seconds)
+{
+  _heatTimeOut = min(180, seconds);
+}
+
+void SHT31::heatOn()
+{
+  writeCmd(SHT31_HEAT_ON);
+  _heaterStart = millis();
+}
+
+void SHT31::heatOff()
+{
+  writeCmd(SHT31_HEAT_OFF);
+  _heaterStart = 0;
+}
+
+bool SHT31::heatUp()
+{
+  if (_heaterStart == 0) return false;
+  // did not exceed time out
+  if (millis() - _heaterStart < (_heatTimeOut * 1000UL)) return true;
+  heatOff();
+  return false;
+}
+
+void SHT31::requestData()
+{
+  writeCmd(SHT31_MEASUREMENT_SLOW);
+  _lastRequest = millis();
+}
+
+bool SHT31::dataReady()
+{
+  return ((millis() - _lastRequest) > 15);
+}
+
+bool SHT31::readData(bool fast)
+{
+  uint8_t buffer[6];
+  readBytes(6, (uint8_t*) &buffer[0]);
+
+  uint16_t raw = (buffer[0] << 8) + buffer[1];
+  temperature = raw * (175.0 / 65535) - 45;
+  raw = (buffer[3] << 8) + buffer[4];
+  humidity = raw * (100.0 / 65535);
+
+  _lastRead = millis();
+
+  if (!fast)
+  {
+    // TODO check CRC here
+    // TODO rv = false;
+  }
+  return true;
+}
+
+//////////////////////////////////////////////////////////
+
+void SHT31::writeCmd(uint16_t cmd)
+{
+  _wire->beginTransmission(_addr);
+  _wire->write(cmd >> 8 );
+  _wire->write(cmd & 0xFF);
+  _wire->endTransmission();
+}
+
+void SHT31::readBytes(uint8_t n, uint8_t *val)
+{
+  _wire->requestFrom(_addr, (uint8_t) n);
+  for (uint8_t i = 0; i < n; i++)
+  {
+    val[i] = _wire->read();
+  }
+}
+
+// -- END OF FILE --

SHT31.h

@@ -0,0 +1,79 @@
+#pragma once
+//
+//    FILE: SHT31.h
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.2.0
+//    DATE: 2019-02-08
+// PURPOSE: Arduino library for the SHT31 temperature and humidity sensor
+//          https://www.adafruit.com/product/2857
+//     URL: https://github.com/RobTillaart/SHT31
+//
+
+#include "Arduino.h"
+#include "Wire.h"
+
+#define SHT31_LIB_VERSION "0.2.0"
+
+// fields readStatus
+#define SHT31_STATUS_ALERT_PENDING    (1 << 15)
+#define SHT31_STATUS_HEATER_ON        (1 << 13)
+#define SHT31_STATUS_HUM_TRACK_ALERT  (1 << 11)
+#define SHT31_STATUS_TEMP_TRACK_ALERT (1 << 10)
+#define SHT31_STATUS_SYSTEM_RESET     (1 << 4)
+#define SHT31_STATUS_COMMAND_STATUS   (1 << 1)
+#define SHT31_STATUS_WRITE_CRC_STATUS (1 << 0)
+
+class SHT31
+{
+public:
+  SHT31();
+
+#if defined(ESP8266) || defined(ESP32)
+  void begin(const uint8_t address, uint8_t dataPin, uint8_t clockPin);
+#endif
+  bool begin(const uint8_t address);
+  bool begin(const uint8_t address,  TwoWire *wire);
+
+  // blocks 15 milliseconds + actual read + math
+  bool read(bool fast = true);
+
+  // details see datasheet; summary in SHT31.cpp file
+  uint16_t readStatus();
+
+  // lastRead is in milliSeconds since start
+  uint32_t lastRead() { return _lastRead; };
+
+  void reset(bool hard = false);
+
+  // do not use heater for long periods,
+  // use it for max 3 minutes to heat up
+  // and let it cool down an equal period.
+  void setHeatTimeout(uint8_t seconds);
+  void heatOn();
+  void heatOff();
+  bool heatUp();  // is the sensor still heating up?
+
+  float getHumidity() { return humidity; };
+  float getTemperature() { return temperature; };
+
+  // ASYNC INTERFACE
+  void requestData();
+  bool dataReady();
+  bool readData(bool fast = true);
+
+private:
+  void writeCmd(uint16_t cmd);
+  void readBytes(uint8_t n, uint8_t *val);
+  TwoWire* _wire;
+	
+  uint8_t   _addr;
+  uint8_t   _heatTimeOut;   // seconds
+  uint32_t  _lastRead;
+  uint32_t  _lastRequest;   // for async interface
+  uint32_t  _heaterStart;
+
+  float humidity;
+  float temperature;
+};
+
+// -- END OF FILE --

examples/SHT31_I2Cspeed/SHT31_I2Cspeed.ino

@@ -0,0 +1,57 @@
+//
+//    FILE: SHT31_I2Cspeed
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.0.2
+// PURPOSE: testing the performance at different I2C speeds
+//
+
+#include "Wire.h"
+#include "SHT31.h"
+
+uint32_t start;
+uint32_t stop;
+
+SHT31 sht;
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println(__FILE__);
+  Serial.print("SHT31_LIB_VERSION: \t");
+  Serial.println(SHT31_LIB_VERSION);
+
+  Wire.begin();
+  sht.begin(0x44);
+  Wire.setClock(100000);
+
+  uint16_t stat = sht.readStatus();
+  Serial.print(stat, HEX);
+  Serial.println();
+}
+
+void loop()
+{
+  for (uint32_t I2Cfreq = 100000; I2Cfreq < 900000; I2Cfreq += 50000)
+  {
+    Serial.print(I2Cfreq/1000);
+    Wire.setClock(I2Cfreq);
+    test();
+  }
+}
+
+
+void test()
+{
+  start = micros();
+  sht.read(true);         // default = true/fast       slow = false
+  stop = micros();
+  Serial.print("\t");
+  Serial.print(stop - start);
+  Serial.print("\t");
+  Serial.print(sht.getTemperature(), 1);
+  Serial.print("\t");
+  Serial.println(sht.getHumidity(), 1);
+  delay(100);
+}
+
+// -- END OF FILE --