Bump library to 1.2.2 version.

As correctly stated by Mausy5043, the division is quite slow in most
microcontrollers, so I have replaced them with multiplications.

DHT.cpp

@@ -6,26 +6,34 @@ written by Adafruit Industries
 
 #include "DHT.h"
 
+#define MIN_INTERVAL 2000
+
 DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) {
   _pin = pin;
   _type = type;
-  _firstreading = true;
+  _bit = digitalPinToBitMask(pin);
+  _port = digitalPinToPort(pin);
+  _maxcycles = microsecondsToClockCycles(1000);  // 1 millisecond timeout for
+                                                 // reading pulses from DHT sensor.
   // Note that count is now ignored as the DHT reading algorithm adjusts itself
   // basd on the speed of the processor.
 }
 
 void DHT::begin(void) {
   // set up the pins!
-  pinMode(_pin, INPUT);
-  digitalWrite(_pin, HIGH);
-  _lastreadtime = 0;
+  pinMode(_pin, INPUT_PULLUP);
+  // Using this value makes sure that millis() - lastreadtime will be
+  // >= MIN_INTERVAL right away. Note that this assignment wraps around,
+  // but so will the subtraction.
+  _lastreadtime = -MIN_INTERVAL;
+  DEBUG_PRINT("Max clock cycles: "); DEBUG_PRINTLN(_maxcycles, DEC);
 }
 
 //boolean S == Scale.  True == Fahrenheit; False == Celcius
-float DHT::readTemperature(bool S) {
+float DHT::readTemperature(bool S, bool force) {
   float f = NAN;
 
-  if (read()) {
+  if (read(force)) {
     switch (_type) {
     case DHT11:
       f = data[2];
@@ -38,7 +46,7 @@ float DHT::readTemperature(bool S) {
       f = data[2] & 0x7F;
       f *= 256;
       f += data[3];
-      f /= 10;
+      f *= 0.1;
       if (data[2] & 0x80) {
         f *= -1;
       }
@@ -52,14 +60,14 @@ float DHT::readTemperature(bool S) {
 }
 
 float DHT::convertCtoF(float c) {
-  return c * 9 / 5 + 32;
+  return c * 1.8 + 32;
 }
 
 float DHT::convertFtoC(float f) {
-  return (f - 32) * 5 / 9;
+  return (f - 32) * 0.55555;
 }
 
-float DHT::readHumidity(void) {
+float DHT::readHumidity(bool force) {
   float f = NAN;
   if (read()) {
     switch (_type) {
@@ -71,7 +79,7 @@ float DHT::readHumidity(void) {
       f = data[0];
       f *= 256;
       f += data[1];
-      f /= 10;
+      f *= 0.1;
       break;
     }
   }
@@ -80,23 +88,17 @@ float DHT::readHumidity(void) {
 
 //boolean isFahrenheit: True == Fahrenheit; False == Celcius
 float DHT::computeHeatIndex(float temperature, float percentHumidity, bool isFahrenheit) {
-  // Adapted from equation at: https://github.com/adafruit/DHT-sensor-library/issues/9 and
-  // Wikipedia: http://en.wikipedia.org/wiki/Heat_index
-  if (!isFahrenheit) {
-    // Celsius heat index calculation.
-    return -8.784695 +
-             1.61139411 * temperature +
-             2.338549   * percentHumidity +
-            -0.14611605 * temperature*percentHumidity +
-            -0.01230809 * pow(temperature, 2) +
-            -0.01642482 * pow(percentHumidity, 2) +
-             0.00221173 * pow(temperature, 2) * percentHumidity +
-             0.00072546 * temperature*pow(percentHumidity, 2) +
-            -0.00000358 * pow(temperature, 2) * pow(percentHumidity, 2);
-  }
-  else {
-    // Fahrenheit heat index calculation.
-    return -42.379 +
+  // Using both Rothfusz and Steadman's equations
+  // http://www.wpc.ncep.noaa.gov/html/heatindex_equation.shtml
+  float hi;
+
+  if (!isFahrenheit)
+    temperature = convertCtoF(temperature);
+
+  hi = 0.5 * (temperature + 61.0 + ((temperature - 68.0) * 1.2) + (percentHumidity * 0.094)); 
+
+  if (hi > 79) {
+    hi = -42.379 +
              2.04901523 * temperature +
             10.14333127 * percentHumidity +
             -0.22475541 * temperature*percentHumidity +
@@ -105,22 +107,25 @@ float DHT::computeHeatIndex(float temperature, float percentHumidity, bool isFah
              0.00122874 * pow(temperature, 2) * percentHumidity +
              0.00085282 * temperature*pow(percentHumidity, 2) +
             -0.00000199 * pow(temperature, 2) * pow(percentHumidity, 2);
+
+    if((percentHumidity < 13) && (temperature >= 80.0) && (temperature <= 112.0))
+      hi -= ((13.0 - percentHumidity) * 0.25) * sqrt((17.0 - abs(temperature - 95.0)) * 0.05882);
+
+    else if((percentHumidity > 85.0) && (temperature >= 80.0) && (temperature <= 87.0))
+      hi += ((percentHumidity - 85.0) * 0.1) * ((87.0 - temperature) * 0.2);
   }
+
+  return isFahrenheit ? hi : convertFtoC(hi);
 }
 
-boolean DHT::read(void) {
+boolean DHT::read(bool force) {
   // Check if sensor was read less than two seconds ago and return early
   // to use last reading.
   uint32_t currenttime = millis();
-  if (currenttime < _lastreadtime) {
-    // ie there was a rollover
-    _lastreadtime = 0;
-  }
-  if (!_firstreading && ((currenttime - _lastreadtime) < 2000)) {
+  if (!force && ((currenttime - _lastreadtime) < 2000)) {
     return _lastresult; // return last correct measurement
   }
-  _firstreading = false;
-  _lastreadtime = millis();
+  _lastreadtime = currenttime;
 
   // Reset 40 bits of received data to zero.
   data[0] = data[1] = data[2] = data[3] = data[4] = 0;
@@ -138,48 +143,54 @@ boolean DHT::read(void) {
   digitalWrite(_pin, LOW);
   delay(20);
 
-  // Turn off interrupts temporarily because the next sections are timing critical
-  // and we don't want any interruptions.
-  noInterrupts();
+  uint32_t cycles[80];
+  {
+    // Turn off interrupts temporarily because the next sections are timing critical
+    // and we don't want any interruptions.
+    InterruptLock lock;
 
-  // End the start signal by setting data line high for 40 microseconds.
-  digitalWrite(_pin, HIGH);
-  delayMicroseconds(40);
+    // End the start signal by setting data line high for 40 microseconds.
+    digitalWrite(_pin, HIGH);
+    delayMicroseconds(40);
 
-  // Now start reading the data line to get the value from the DHT sensor.
-  pinMode(_pin, INPUT);
-  delayMicroseconds(10);  // Delay a bit to let sensor pull data line low.
+    // Now start reading the data line to get the value from the DHT sensor.
+    pinMode(_pin, INPUT_PULLUP);
+    delayMicroseconds(10);  // Delay a bit to let sensor pull data line low.
 
-  // First expect a low signal for ~80 microseconds followed by a high signal
-  // for ~80 microseconds again.
-  if (expectPulse(LOW) == 0) {
-    DEBUG_PRINTLN(F("Timeout waiting for start signal low pulse."));
-    _lastresult = false;
-    return _lastresult;
-  }
-  if (expectPulse(HIGH) == 0) {
-    DEBUG_PRINTLN(F("Timeout waiting for start signal high pulse."));
-    _lastresult = false;
-    return _lastresult;
-  }
-
-  // Now read the 40 bits sent by the sensor.  Each bit is sent as a 50
-  // microsecond low pulse followed by a variable length high pulse.  If the
-  // high pulse is ~28 microseconds then it's a 0 and if it's ~70 microseconds
-  // then it's a 1.  We measure the cycle count of the initial 50us low pulse
-  // and use that to compare to the cycle count of the high pulse to determine
-  // if the bit is a 0 (high state cycle count < low state cycle count), or a
-  // 1 (high state cycle count > low state cycle count).
-  for (int i=0; i<40; ++i) {
-    uint32_t lowCycles = expectPulse(LOW);
-    if (lowCycles == 0) {
-      DEBUG_PRINTLN(F("Timeout waiting for bit low pulse."));
+    // First expect a low signal for ~80 microseconds followed by a high signal
+    // for ~80 microseconds again.
+    if (expectPulse(LOW) == 0) {
+      DEBUG_PRINTLN(F("Timeout waiting for start signal low pulse."));
       _lastresult = false;
       return _lastresult;
     }
-    uint32_t highCycles = expectPulse(HIGH);
-    if (highCycles == 0) {
-      DEBUG_PRINTLN(F("Timeout waiting for bit high pulse."));
+    if (expectPulse(HIGH) == 0) {
+      DEBUG_PRINTLN(F("Timeout waiting for start signal high pulse."));
+      _lastresult = false;
+      return _lastresult;
+    }
+
+    // Now read the 40 bits sent by the sensor.  Each bit is sent as a 50
+    // microsecond low pulse followed by a variable length high pulse.  If the
+    // high pulse is ~28 microseconds then it's a 0 and if it's ~70 microseconds
+    // then it's a 1.  We measure the cycle count of the initial 50us low pulse
+    // and use that to compare to the cycle count of the high pulse to determine
+    // if the bit is a 0 (high state cycle count < low state cycle count), or a
+    // 1 (high state cycle count > low state cycle count). Note that for speed all
+    // the pulses are read into a array and then examined in a later step.
+    for (int i=0; i<80; i+=2) {
+      cycles[i]   = expectPulse(LOW);
+      cycles[i+1] = expectPulse(HIGH);
+    }
+  } // Timing critical code is now complete.
+
+  // Inspect pulses and determine which ones are 0 (high state cycle count < low
+  // state cycle count), or 1 (high state cycle count > low state cycle count).
+  for (int i=0; i<40; ++i) {
+    uint32_t lowCycles  = cycles[2*i];
+    uint32_t highCycles = cycles[2*i+1];
+    if ((lowCycles == 0) || (highCycles == 0)) {
+      DEBUG_PRINTLN(F("Timeout waiting for pulse."));
       _lastresult = false;
       return _lastresult;
     }
@@ -194,16 +205,13 @@ boolean DHT::read(void) {
     // stored data.
   }
 
-  // Re-enable interrupts, timing critical code is complete.
-  interrupts();
-
   DEBUG_PRINTLN(F("Received:"));
   DEBUG_PRINT(data[0], HEX); DEBUG_PRINT(F(", "));
   DEBUG_PRINT(data[1], HEX); DEBUG_PRINT(F(", "));
   DEBUG_PRINT(data[2], HEX); DEBUG_PRINT(F(", "));
   DEBUG_PRINT(data[3], HEX); DEBUG_PRINT(F(", "));
   DEBUG_PRINT(data[4], HEX); DEBUG_PRINT(F(" =? "));
-  DEBUG_PRINTLN(data[0] + data[1] + data[2] + data[3], HEX);
+  DEBUG_PRINTLN((data[0] + data[1] + data[2] + data[3]) & 0xFF, HEX);
 
   // Check we read 40 bits and that the checksum matches.
   if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
@@ -221,16 +229,29 @@ boolean DHT::read(void) {
 // return a count of loop cycles spent at that level (this cycle count can be
 // used to compare the relative time of two pulses).  If more than a millisecond
 // ellapses without the level changing then the call fails with a 0 response.
+// This is adapted from Arduino's pulseInLong function (which is only available
+// in the very latest IDE versions):
+//   https://github.com/arduino/Arduino/blob/master/hardware/arduino/avr/cores/arduino/wiring_pulse.c
 uint32_t DHT::expectPulse(bool level) {
   uint32_t count = 0;
-  uint32_t end = micros() + 1000;
-  // Loop while counting cycles until the level changes.
-  while (digitalRead(_pin) == level) {
-    count++;
-    if (micros() >= end) {
-      // Exceeded timeout waiting for level to change, fail.
-      return 0;
+  // On AVR platforms use direct GPIO port access as it's much faster and better
+  // for catching pulses that are 10's of microseconds in length:
+  #ifdef __AVR
+    uint8_t portState = level ? _bit : 0;
+    while ((*portInputRegister(_port) & _bit) == portState) {
+      if (count++ >= _maxcycles) {
+        return 0; // Exceeded timeout, fail.
+      }
     }
-  }
+  // Otherwise fall back to using digitalRead (this seems to be necessary on ESP8266
+  // right now, perhaps bugs in direct port access functions?).
+  #else
+    while (digitalRead(_pin) == level) {
+      if (count++ >= _maxcycles) {
+        return 0; // Exceeded timeout, fail.
+      }
+    }
+  #endif
+
   return count;
 }

DHT.h

@@ -39,22 +39,32 @@ class DHT {
   public:
    DHT(uint8_t pin, uint8_t type, uint8_t count=6);
    void begin(void);
-   float readTemperature(bool S=false);
+   float readTemperature(bool S=false, bool force=false);
    float convertCtoF(float);
    float convertFtoC(float);
    float computeHeatIndex(float temperature, float percentHumidity, bool isFahrenheit=true);
-   float readHumidity(void);
-   boolean read(void);
+   float readHumidity(bool force=false);
+   boolean read(bool force=false);
 
  private:
-  uint8_t data[6];
-  uint8_t _pin, _type;
-  uint32_t _lastreadtime;
-  bool _firstreading;
+  uint8_t data[5];
+  uint8_t _pin, _type, _bit, _port;
+  uint32_t _lastreadtime, _maxcycles;
   bool _lastresult;
 
   uint32_t expectPulse(bool level);
 
 };
 
+class InterruptLock {
+  public:
+   InterruptLock() {
+    noInterrupts();
+   }
+   ~InterruptLock() {
+    interrupts();
+   }
+
+};
+
 #endif

library.properties

@@ -1,5 +1,5 @@
 name=DHT sensor library
-version=1.1.0
+version=1.2.2
 author=Adafruit
 maintainer=Adafruit <info@adafruit.com>
 sentence=Arduino library for DHT11, DHT22, etc Temp & Humidity Sensors