Merge branch 'dynamic_timing'

DHT.cpp

@@ -9,8 +9,9 @@ written by Adafruit Industries
 DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) {
   _pin = pin;
   _type = type;
-  _count = count;
+  _firstreading = true;
-  firstreading = true;
+  // Note that count is now ignored as the DHT reading algorithm adjusts itself
+  // basd on the speed of the processor.
 }
 
 void DHT::begin(void) {
@@ -22,31 +23,32 @@ void DHT::begin(void) {
 
 //boolean S == Scale.  True == Farenheit; False == Celcius
 float DHT::readTemperature(bool S) {
-  float f;
+  float f = NAN;
 
   if (read()) {
     switch (_type) {
     case DHT11:
       f = data[2];
-      if(S)
+      if(S) {
         f = convertCtoF(f);
-      	
+      }
-      return f;
+      break;
     case DHT22:
     case DHT21:
       f = data[2] & 0x7F;
       f *= 256;
       f += data[3];
       f /= 10;
-      if (data[2] & 0x80)
+      if (data[2] & 0x80) {
         f *= -1;
-      if(S)
+      }
+      if(S) {
         f = convertCtoF(f);
-
+      }
+      break;
+    }
+  }
   return f;
-    }
-  }
-  return NAN;
 }
 
 float DHT::convertCtoF(float c) {
@@ -58,22 +60,22 @@ float DHT::convertFtoC(float f) {
 }
 
 float DHT::readHumidity(void) {
-  float f;
+  float f = NAN;
   if (read()) {
     switch (_type) {
     case DHT11:
       f = data[0];
-      return f;
+      break;
     case DHT22:
     case DHT21:
       f = data[0];
       f *= 256;
       f += data[1];
       f /= 10;
+      break;
+    }
+  }
   return f;
-    }
-  }
-  return NAN;
 }
 
 float DHT::computeHeatIndex(float tempFahrenheit, float percentHumidity) {
@@ -90,90 +92,129 @@ float DHT::computeHeatIndex(float tempFahrenheit, float percentHumidity) {
           -0.00000199 * pow(tempFahrenheit, 2) * pow(percentHumidity, 2);
 }
 
-
 boolean DHT::read(void) {
-  uint8_t laststate = HIGH;
-  uint8_t counter = 0;
-  uint8_t j = 0, i;
-  unsigned long currenttime;
-
   // Check if sensor was read less than two seconds ago and return early
   // to use last reading.
-  currenttime = millis();
+  uint32_t currenttime = millis();
   if (currenttime < _lastreadtime) {
     // ie there was a rollover
     _lastreadtime = 0;
   }
-  if (!firstreading && ((currenttime - _lastreadtime) < 2000)) {
+  if (!_firstreading && ((currenttime - _lastreadtime) < 2000)) {
-    return true; // return last correct measurement
+    return _lastresult; // return last correct measurement
-    //delay(2000 - (currenttime - _lastreadtime));
   }
-  firstreading = false;
+  _firstreading = false;
-  /*
-    Serial.print("Currtime: "); Serial.print(currenttime);
-    Serial.print(" Lasttime: "); Serial.print(_lastreadtime);
-  */
   _lastreadtime = millis();
 
+  // Reset 40 bits of received data to zero.
   data[0] = data[1] = data[2] = data[3] = data[4] = 0;
 
-  // pull the pin high and wait 250 milliseconds
+  // 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);
 
-  // now pull it low for ~20 milliseconds
+  // First set data line low for 20 milliseconds.
   pinMode(_pin, OUTPUT);
   digitalWrite(_pin, LOW);
   delay(20);
+
+  // Turn off interrupts temporarily because the next sections are timing critical
+  // and we don't want any interruptions.
   noInterrupts();
+
+  // 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.
 
-  // read in timings
+  // First expect a low signal for ~80 microseconds followed by a high signal
-  for ( i=0; i< MAXTIMINGS; i++) {
+  // for ~80 microseconds again.
-    counter = 0;
+  if (expectPulse(LOW) == 0) {
-    while (digitalRead(_pin) == laststate) {
+    DEBUG_PRINTLN(F("Timeout waiting for start signal low pulse."));
-      counter++;
+    _lastresult = false;
-      delayMicroseconds(1);
+    return _lastresult;
-      if (counter == 255) {
-        break;
   }
-    }
+  if (expectPulse(HIGH) == 0) {
-    laststate = digitalRead(_pin);
+    DEBUG_PRINTLN(F("Timeout waiting for start signal high pulse."));
-
+    _lastresult = false;
-    if (counter == 255) break;
+    return _lastresult;
-
-    // ignore first 3 transitions
-    if ((i >= 4) && (i%2 == 0)) {
-      // shove each bit into the storage bytes
-      data[j/8] <<= 1;
-      if (counter > _count)
-        data[j/8] |= 1;
-      j++;
   }
 
+  // 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."));
+      _lastresult = false;
+      return _lastresult;
+    }
+    uint32_t highCycles = expectPulse(HIGH);
+    if (highCycles == 0) {
+      DEBUG_PRINTLN(F("Timeout waiting for bit high 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.
   }
 
+  // Re-enable interrupts, timing critical code is complete.
   interrupts();
 
-  /*
+  DEBUG_PRINTLN(F("Received:"));
-  Serial.println(j, DEC);
+  DEBUG_PRINT(data[0], HEX); DEBUG_PRINT(F(", "));
-  Serial.print(data[0], HEX); Serial.print(", ");
+  DEBUG_PRINT(data[1], HEX); DEBUG_PRINT(F(", "));
-  Serial.print(data[1], HEX); Serial.print(", ");
+  DEBUG_PRINT(data[2], HEX); DEBUG_PRINT(F(", "));
-  Serial.print(data[2], HEX); Serial.print(", ");
+  DEBUG_PRINT(data[3], HEX); DEBUG_PRINT(F(", "));
-  Serial.print(data[3], HEX); Serial.print(", ");
+  DEBUG_PRINT(data[4], HEX); DEBUG_PRINT(F(" =? "));
-  Serial.print(data[4], HEX); Serial.print(" =? ");
+  DEBUG_PRINTLN(data[0] + data[1] + data[2] + data[3], HEX);
-  Serial.println(data[0] + data[1] + data[2] + data[3], HEX);
-  */
 
-  // check we read 40 bits and that the checksum matches
+  // Check we read 40 bits and that the checksum matches.
-  if ((j >= 40) && 
+  if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
-      (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) ) {
+    _lastresult = true;
-    return true;
+    return _lastresult;
+  }
+  else {
+    DEBUG_PRINTLN(F("Checksum failure!"));
+    _lastresult = false;
+    return _lastresult;
   }
-  
+}
-
+
-  return false;
+// 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.
+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;
+    }
+  }
+  return count;
 }

DHT.h

@@ -1,32 +1,41 @@
+/* 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
 
-/* DHT library 
 
-MIT license
+// Uncomment to enable printing out nice debug messages.
-written by Adafruit Industries
+//#define DHT_DEBUG
-*/
 
-// how many timing transitions we need to keep track of. 2 * number bits + extra
+// Define where debug output will be printed.
-#define MAXTIMINGS 85
+#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 {
- private:
-  uint8_t data[6];
-  uint8_t _pin, _type, _count;
-  unsigned long _lastreadtime;
-  boolean firstreading;
 
+class DHT {
   public:
    DHT(uint8_t pin, uint8_t type, uint8_t count=6);
    void begin(void);
@@ -37,5 +46,15 @@ class DHT {
    float readHumidity(void);
    boolean read(void);
 
+ private:
+  uint8_t data[6];
+  uint8_t _pin, _type;
+  uint32_t _lastreadtime;
+  bool _firstreading;
+  bool _lastresult;
+
+  uint32_t expectPulse(bool level);
+
 };
+
 #endif

examples/DHTtester/DHTtester.ino

@@ -17,16 +17,11 @@
 // Connect pin 4 (on the right) of the sensor to GROUND
 // Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor
 
-// Initialize DHT sensor for normal 16mhz Arduino
+// Initialize DHT sensor.
+// Note that older versions of this library took an optional third parameter to
+// tweak the timings for faster processors.  This parameter is no longer needed
+// as the current DHT reading algorithm adjusts itself to work on faster procs.
 DHT dht(DHTPIN, DHTTYPE);
-// NOTE: For working with a faster chip, like an Arduino Due or Teensy, you
-// might need to increase the threshold for cycle counts considered a 1 or 0.
-// You can do this by passing a 3rd parameter for this threshold.  It's a bit
-// of fiddling to find the right value, but in general the faster the CPU the
-// higher the value.  The default for a 16mhz AVR is a value of 6.  For an
-// Arduino Due that runs at 84mhz a value of 30 works.
-// Example to initialize DHT sensor for Arduino Due:
-//DHT dht(DHTPIN, DHTTYPE, 30);
 
 void setup() {
   Serial.begin(9600);

keywords.txt

@@ -0,0 +1,22 @@
+###########################################
+# Syntax Coloring Map For DHT-sensor-library
+###########################################
+
+###########################################
+# Datatypes (KEYWORD1)
+###########################################
+
+DHT	KEYWORD1
+
+###########################################
+# Methods and Functions (KEYWORD2)
+###########################################
+
+begin KEYWORD2
+readTemperature KEYWORD2
+convertCtoF KEYWORD2
+convertFtoC KEYWORD2
+computeHeatIndex KEYWORD2
+readHumidity KEYWORD2
+read KEYWORD2
+

library.properties

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