From d102824131c1155fcf2eb980b39605ff28b3f4fb Mon Sep 17 00:00:00 2001
From: Lee H-W <github@species5618.net>
Date: Tue, 9 May 2017 17:10:01 +0100
Subject: [PATCH 1/6] Update DHT.cpp

added void DHT::begin(uint8_t type)
---
 DHT.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/DHT.cpp b/DHT.cpp
index 86ad91c..fae1621 100644
--- a/DHT.cpp
+++ b/DHT.cpp
@@ -21,6 +21,18 @@ DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) {
   // basd on the speed of the processor.
 }
 
+void DHT::begin(uint8_t type) {
+  // set up the pins!
+  pinMode(_pin, INPUT_PULLUP);
+  _type = type;
+  // 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);
+}
+
+
 void DHT::begin(void) {
   // set up the pins!
   pinMode(_pin, INPUT_PULLUP);
@@ -31,6 +43,8 @@ void DHT::begin(void) {
   DEBUG_PRINT("Max clock cycles: "); DEBUG_PRINTLN(_maxcycles, DEC);
 }
 
+
+
 //boolean S == Scale.  True == Fahrenheit; False == Celcius
 float DHT::readTemperature(bool S, bool force) {
   float f = NAN;

From a19006b97e279595cf80abea9734059de345b3bd Mon Sep 17 00:00:00 2001
From: Lee H-W <github@species5618.net>
Date: Tue, 9 May 2017 17:10:47 +0100
Subject: [PATCH 2/6] Update DHT.h

void DHT::begin(uint8_t type);
---
 DHT.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DHT.h b/DHT.h
index d81f6db..17cf1c4 100644
--- a/DHT.h
+++ b/DHT.h
@@ -39,6 +39,7 @@ class DHT {
   public:
    DHT(uint8_t pin, uint8_t type, uint8_t count=6);
    void begin(void);
+   void DHT::begin(uint8_t type);
    float readTemperature(bool S=false, bool force=false);
    float convertCtoF(float);
    float convertFtoC(float);

From 0bdb6614a978b2fa91de3ec20a5f27d4a9dd7c21 Mon Sep 17 00:00:00 2001
From: Lee H-W <github@species5618.net>
Date: Tue, 9 May 2017 17:12:13 +0100
Subject: [PATCH 3/6] Update README.md

ADD Ability to change sensor type after instantiation for use with a configuration PCB i am developing
void DHT::begin(uint8_t type);
---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index d32afdc..05cae66 100644
--- a/README.md
+++ b/README.md
@@ -13,3 +13,7 @@ which is designed to work with the [Adafruit unified sensor library](https://lea
 You must have the following Arduino libraries installed to use this class:
 
 - [Adafruit Unified Sensor Library](https://github.com/adafruit/Adafruit_Sensor)
+
+
+ADD Ability to change sensor type after instantiation for use with a configuration PCB i am developing
+void DHT::begin(uint8_t type);

From 85655256fd1fdb2372a1d246bc36a866ca0b62f8 Mon Sep 17 00:00:00 2001
From: Lee H-W <github@species5618.net>
Date: Tue, 9 May 2017 17:12:40 +0100
Subject: [PATCH 4/6] Update README.md

typo
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 05cae66..053e2f3 100644
--- a/README.md
+++ b/README.md
@@ -15,5 +15,5 @@ You must have the following Arduino libraries installed to use this class:
 - [Adafruit Unified Sensor Library](https://github.com/adafruit/Adafruit_Sensor)
 
 
-ADD Ability to change sensor type after instantiation for use with a configuration PCB i am developing
+ADD Ability to change sensor type after instantiation for use with a configuraable PCB i am developing
 void DHT::begin(uint8_t type);

From a9ab0e8d7182d29340055203fc74cda28369c188 Mon Sep 17 00:00:00 2001
From: Lee H-W <github@species5618.net>
Date: Tue, 9 May 2017 17:24:55 +0100
Subject: [PATCH 5/6] Update DHT.h

copy and paste error
---
 DHT.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DHT.h b/DHT.h
index 17cf1c4..872a371 100644
--- a/DHT.h
+++ b/DHT.h
@@ -39,7 +39,7 @@ class DHT {
   public:
    DHT(uint8_t pin, uint8_t type, uint8_t count=6);
    void begin(void);
-   void DHT::begin(uint8_t type);
+   void begin(uint8_t type);
    float readTemperature(bool S=false, bool force=false);
    float convertCtoF(float);
    float convertFtoC(float);

From a9683948bc6a7a1525c674d59a9e18999921924e Mon Sep 17 00:00:00 2001
From: Lee H-W <github@species5618.net>
Date: Mon, 12 Jun 2017 09:25:43 +0100
Subject: [PATCH 6/6] //add begin with device type, so device type can be set
 in SETUP() after being read from a config source

---
 DHT.cpp | 547 ++++++++++++++++++++++++++++----------------------------
 DHT.h   | 153 ++++++++--------
 2 files changed, 351 insertions(+), 349 deletions(-)

diff --git a/DHT.cpp b/DHT.cpp
index fae1621..e439d82 100644
--- a/DHT.cpp
+++ b/DHT.cpp
@@ -1,273 +1,274 @@
-/* DHT library
-
-MIT license
-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;
-  #ifdef __AVR
-    _bit = digitalPinToBitMask(pin);
-    _port = digitalPinToPort(pin);
-  #endif
-  _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(uint8_t type) {
-  // set up the pins!
-  pinMode(_pin, INPUT_PULLUP);
-  _type = type;
-  // 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);
-}
-
-
-void DHT::begin(void) {
-  // set up the pins!
-  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, bool force) {
-  float f = NAN;
-
-  if (read(force)) {
-    switch (_type) {
-    case DHT11:
-      f = data[2];
-      if(S) {
-        f = convertCtoF(f);
-      }
-      break;
-    case DHT22:
-    case DHT21:
-      f = data[2] & 0x7F;
-      f *= 256;
-      f += data[3];
-      f *= 0.1;
-      if (data[2] & 0x80) {
-        f *= -1;
-      }
-      if(S) {
-        f = convertCtoF(f);
-      }
-      break;
-    }
-  }
-  return f;
-}
-
-float DHT::convertCtoF(float c) {
-  return c * 1.8 + 32;
-}
-
-float DHT::convertFtoC(float f) {
-  return (f - 32) * 0.55555;
-}
-
-float DHT::readHumidity(bool force) {
-  float f = NAN;
-  if (read()) {
-    switch (_type) {
-    case DHT11:
-      f = data[0];
-      break;
-    case DHT22:
-    case DHT21:
-      f = data[0];
-      f *= 256;
-      f += data[1];
-      f *= 0.1;
-      break;
-    }
-  }
-  return f;
-}
-
-//boolean isFahrenheit: True == Fahrenheit; False == Celcius
-float DHT::computeHeatIndex(float temperature, float percentHumidity, bool isFahrenheit) {
-  // 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 +
-            -0.00683783 * pow(temperature, 2) +
-            -0.05481717 * pow(percentHumidity, 2) +
-             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(bool force) {
-  // Check if sensor was read less than two seconds ago and return early
-  // to use last reading.
-  uint32_t currenttime = millis();
-  if (!force && ((currenttime - _lastreadtime) < 2000)) {
-    return _lastresult; // return last correct measurement
-  }
-  _lastreadtime = currenttime;
-
-  // Reset 40 bits of received data to zero.
-  data[0] = data[1] = data[2] = data[3] = data[4] = 0;
-
-  // Send start signal.  See DHT datasheet for full signal diagram:
-  //   http://www.adafruit.com/datasheets/Digital%20humidity%20and%20temperature%20sensor%20AM2302.pdf
-
-  // Go into high impedence state to let pull-up raise data line level and
-  // start the reading process.
-  digitalWrite(_pin, HIGH);
-  delay(250);
-
-  // First set data line low for 20 milliseconds.
-  pinMode(_pin, OUTPUT);
-  digitalWrite(_pin, LOW);
-  delay(20);
-
-  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);
-
-    // 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). 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;
-    }
-    data[i/8] <<= 1;
-    // Now compare the low and high cycle times to see if the bit is a 0 or 1.
-    if (highCycles > lowCycles) {
-      // High cycles are greater than 50us low cycle count, must be a 1.
-      data[i/8] |= 1;
-    }
-    // Else high cycles are less than (or equal to, a weird case) the 50us low
-    // cycle count so this must be a zero.  Nothing needs to be changed in the
-    // stored data.
-  }
-
-  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]) & 0xFF, HEX);
-
-  // Check we read 40 bits and that the checksum matches.
-  if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
-    _lastresult = true;
-    return _lastresult;
-  }
-  else {
-    DEBUG_PRINTLN(F("Checksum failure!"));
-    _lastresult = false;
-    return _lastresult;
-  }
-}
-
-// Expect the signal line to be at the specified level for a period of time and
-// 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;
-  // 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 library
+
+MIT license
+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;
+  #ifdef __AVR
+    _bit = digitalPinToBitMask(pin);
+    _port = digitalPinToPort(pin);
+  #endif
+  _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.
+}
+
+//add begin with device type, so device type can be set in SETUP() after being read from a config source
+void DHT::begin(uint8_t type) {
+  // set up the pins!
+  pinMode(_pin, INPUT_PULLUP);
+  _type = type;
+  // 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);
+}
+
+
+void DHT::begin(void) {
+  // set up the pins!
+  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, bool force) {
+  float f = NAN;
+
+  if (read(force)) {
+    switch (_type) {
+    case DHT11:
+      f = data[2];
+      if(S) {
+        f = convertCtoF(f);
+      }
+      break;
+    case DHT22:
+    case DHT21:
+      f = data[2] & 0x7F;
+      f *= 256;
+      f += data[3];
+      f *= 0.1;
+      if (data[2] & 0x80) {
+        f *= -1;
+      }
+      if(S) {
+        f = convertCtoF(f);
+      }
+      break;
+    }
+  }
+  return f;
+}
+
+float DHT::convertCtoF(float c) {
+  return c * 1.8 + 32;
+}
+
+float DHT::convertFtoC(float f) {
+  return (f - 32) * 0.55555;
+}
+
+float DHT::readHumidity(bool force) {
+  float f = NAN;
+  if (read()) {
+    switch (_type) {
+    case DHT11:
+      f = data[0];
+      break;
+    case DHT22:
+    case DHT21:
+      f = data[0];
+      f *= 256;
+      f += data[1];
+      f *= 0.1;
+      break;
+    }
+  }
+  return f;
+}
+
+//boolean isFahrenheit: True == Fahrenheit; False == Celcius
+float DHT::computeHeatIndex(float temperature, float percentHumidity, bool isFahrenheit) {
+  // 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 +
+            -0.00683783 * pow(temperature, 2) +
+            -0.05481717 * pow(percentHumidity, 2) +
+             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(bool force) {
+  // Check if sensor was read less than two seconds ago and return early
+  // to use last reading.
+  uint32_t currenttime = millis();
+  if (!force && ((currenttime - _lastreadtime) < 2000)) {
+    return _lastresult; // return last correct measurement
+  }
+  _lastreadtime = currenttime;
+
+  // Reset 40 bits of received data to zero.
+  data[0] = data[1] = data[2] = data[3] = data[4] = 0;
+
+  // Send start signal.  See DHT datasheet for full signal diagram:
+  //   http://www.adafruit.com/datasheets/Digital%20humidity%20and%20temperature%20sensor%20AM2302.pdf
+
+  // Go into high impedence state to let pull-up raise data line level and
+  // start the reading process.
+  digitalWrite(_pin, HIGH);
+  delay(250);
+
+  // First set data line low for 20 milliseconds.
+  pinMode(_pin, OUTPUT);
+  digitalWrite(_pin, LOW);
+  delay(20);
+
+  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);
+
+    // 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). 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;
+    }
+    data[i/8] <<= 1;
+    // Now compare the low and high cycle times to see if the bit is a 0 or 1.
+    if (highCycles > lowCycles) {
+      // High cycles are greater than 50us low cycle count, must be a 1.
+      data[i/8] |= 1;
+    }
+    // Else high cycles are less than (or equal to, a weird case) the 50us low
+    // cycle count so this must be a zero.  Nothing needs to be changed in the
+    // stored data.
+  }
+
+  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]) & 0xFF, HEX);
+
+  // Check we read 40 bits and that the checksum matches.
+  if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
+    _lastresult = true;
+    return _lastresult;
+  }
+  else {
+    DEBUG_PRINTLN(F("Checksum failure!"));
+    _lastresult = false;
+    return _lastresult;
+  }
+}
+
+// Expect the signal line to be at the specified level for a period of time and
+// 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;
+  // 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;
+}
diff --git a/DHT.h b/DHT.h
index 872a371..2f3f03e 100644
--- a/DHT.h
+++ b/DHT.h
@@ -1,76 +1,77 @@
-/* DHT library
-
-MIT license
-written by Adafruit Industries
-*/
-#ifndef DHT_H
-#define DHT_H
-
-#if ARDUINO >= 100
- #include "Arduino.h"
-#else
- #include "WProgram.h"
-#endif
-
-
-// Uncomment to enable printing out nice debug messages.
-//#define DHT_DEBUG
-
-// Define where debug output will be printed.
-#define DEBUG_PRINTER Serial
-
-// Setup debug printing macros.
-#ifdef DHT_DEBUG
-  #define DEBUG_PRINT(...) { DEBUG_PRINTER.print(__VA_ARGS__); }
-  #define DEBUG_PRINTLN(...) { DEBUG_PRINTER.println(__VA_ARGS__); }
-#else
-  #define DEBUG_PRINT(...) {}
-  #define DEBUG_PRINTLN(...) {}
-#endif
-
-// Define types of sensors.
-#define DHT11 11
-#define DHT22 22
-#define DHT21 21
-#define AM2301 21
-
-
-class DHT {
-  public:
-   DHT(uint8_t pin, uint8_t type, uint8_t count=6);
-   void begin(void);
-   void begin(uint8_t type);
-   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(bool force=false);
-   boolean read(bool force=false);
-
- private:
-  uint8_t data[5];
-  uint8_t _pin, _type;
-  #ifdef __AVR
-    // Use direct GPIO access on an 8-bit AVR so keep track of the port and bitmask
-    // for the digital pin connected to the DHT.  Other platforms will use digitalRead.
-    uint8_t _bit, _port;
-  #endif
-  uint32_t _lastreadtime, _maxcycles;
-  bool _lastresult;
-
-  uint32_t expectPulse(bool level);
-
-};
-
-class InterruptLock {
-  public:
-   InterruptLock() {
-    noInterrupts();
-   }
-   ~InterruptLock() {
-    interrupts();
-   }
-
-};
-
-#endif
+/* DHT library
+
+MIT license
+written by Adafruit Industries
+*/
+#ifndef DHT_H
+#define DHT_H
+
+#if ARDUINO >= 100
+ #include "Arduino.h"
+#else
+ #include "WProgram.h"
+#endif
+
+
+// Uncomment to enable printing out nice debug messages.
+//#define DHT_DEBUG
+
+// Define where debug output will be printed.
+#define DEBUG_PRINTER Serial
+
+// Setup debug printing macros.
+#ifdef DHT_DEBUG
+  #define DEBUG_PRINT(...) { DEBUG_PRINTER.print(__VA_ARGS__); }
+  #define DEBUG_PRINTLN(...) { DEBUG_PRINTER.println(__VA_ARGS__); }
+#else
+  #define DEBUG_PRINT(...) {}
+  #define DEBUG_PRINTLN(...) {}
+#endif
+
+// Define types of sensors.
+#define DHT11 11
+#define DHT22 22
+#define DHT21 21
+#define AM2301 21
+
+
+class DHT {
+  public:
+   DHT(uint8_t pin, uint8_t type, uint8_t count=6);
+   void begin(void);
+//add begin with device type, so device type can be set in SETUP() after being read from a config source
+   void begin(uint8_t type);
+   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(bool force=false);
+   boolean read(bool force=false);
+
+ private:
+  uint8_t data[5];
+  uint8_t _pin, _type;
+  #ifdef __AVR
+    // Use direct GPIO access on an 8-bit AVR so keep track of the port and bitmask
+    // for the digital pin connected to the DHT.  Other platforms will use digitalRead.
+    uint8_t _bit, _port;
+  #endif
+  uint32_t _lastreadtime, _maxcycles;
+  bool _lastresult;
+
+  uint32_t expectPulse(bool level);
+
+};
+
+class InterruptLock {
+  public:
+   InterruptLock() {
+    noInterrupts();
+   }
+   ~InterruptLock() {
+    interrupts();
+   }
+
+};
+
+#endif