add unity song

DHT/DHT.cpp

@@ -0,0 +1,179 @@
+/* DHT library 
+
+MIT license
+written by Adafruit Industries
+*/
+
+#include "DHT.h"
+
+DHT::DHT(uint8_t pin, uint8_t type, uint8_t count) {
+  _pin = pin;
+  _type = type;
+  _count = count;
+  firstreading = true;
+}
+
+void DHT::begin(void) {
+  // set up the pins!
+  pinMode(_pin, INPUT);
+  digitalWrite(_pin, HIGH);
+  _lastreadtime = 0;
+}
+
+//boolean S == Scale.  True == Farenheit; False == Celcius
+float DHT::readTemperature(bool S) {
+  float f;
+
+  if (read()) {
+    switch (_type) {
+    case DHT11:
+      f = data[2];
+      if(S)
+      	f = convertCtoF(f);
+      	
+      return f;
+    case DHT22:
+    case DHT21:
+      f = data[2] & 0x7F;
+      f *= 256;
+      f += data[3];
+      f /= 10;
+      if (data[2] & 0x80)
+	f *= -1;
+      if(S)
+	f = convertCtoF(f);
+
+      return f;
+    }
+  }
+  return NAN;
+}
+
+float DHT::convertCtoF(float c) {
+	return c * 9 / 5 + 32;
+}
+
+float DHT::convertFtoC(float f) {
+  return (f - 32) * 5 / 9; 
+}
+
+float DHT::readHumidity(void) {
+  float f;
+  if (read()) {
+    switch (_type) {
+    case DHT11:
+      f = data[0];
+      return f;
+    case DHT22:
+    case DHT21:
+      f = data[0];
+      f *= 256;
+      f += data[1];
+      f /= 10;
+      return f;
+    }
+  }
+  return NAN;
+}
+
+float DHT::computeHeatIndex(float tempFahrenheit, float percentHumidity) {
+  // Adapted from equation at: https://github.com/adafruit/DHT-sensor-library/issues/9 and
+  // Wikipedia: http://en.wikipedia.org/wiki/Heat_index
+  return -42.379 + 
+           2.04901523 * tempFahrenheit + 
+          10.14333127 * percentHumidity +
+          -0.22475541 * tempFahrenheit*percentHumidity +
+          -0.00683783 * pow(tempFahrenheit, 2) +
+          -0.05481717 * pow(percentHumidity, 2) + 
+           0.00122874 * pow(tempFahrenheit, 2) * percentHumidity + 
+           0.00085282 * tempFahrenheit*pow(percentHumidity, 2) +
+          -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();
+  if (currenttime < _lastreadtime) {
+    // ie there was a rollover
+    _lastreadtime = 0;
+  }
+  if (!firstreading && ((currenttime - _lastreadtime) < 2000)) {
+    return true; // return last correct measurement
+    //delay(2000 - (currenttime - _lastreadtime));
+  }
+  firstreading = false;
+  /*
+    Serial.print("Currtime: "); Serial.print(currenttime);
+    Serial.print(" Lasttime: "); Serial.print(_lastreadtime);
+  */
+  _lastreadtime = millis();
+
+  data[0] = data[1] = data[2] = data[3] = data[4] = 0;
+  
+  // pull the pin high and wait 250 milliseconds
+  digitalWrite(_pin, HIGH);
+  delay(250);
+
+  // now pull it low for ~20 milliseconds
+  pinMode(_pin, OUTPUT);
+  digitalWrite(_pin, LOW);
+  delay(20);
+  noInterrupts();
+  digitalWrite(_pin, HIGH);
+  delayMicroseconds(40);
+  pinMode(_pin, INPUT);
+
+  // read in timings
+  for ( i=0; i< MAXTIMINGS; i++) {
+    counter = 0;
+    while (digitalRead(_pin) == laststate) {
+      counter++;
+      delayMicroseconds(1);
+      if (counter == 255) {
+        break;
+      }
+    }
+    laststate = digitalRead(_pin);
+
+    if (counter == 255) break;
+
+    // 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++;
+    }
+
+  }
+
+  interrupts();
+  
+  /*
+  Serial.println(j, DEC);
+  Serial.print(data[0], HEX); Serial.print(", ");
+  Serial.print(data[1], HEX); Serial.print(", ");
+  Serial.print(data[2], HEX); Serial.print(", ");
+  Serial.print(data[3], HEX); Serial.print(", ");
+  Serial.print(data[4], HEX); Serial.print(" =? ");
+  Serial.println(data[0] + data[1] + data[2] + data[3], HEX);
+  */
+
+  // check we read 40 bits and that the checksum matches
+  if ((j >= 40) && 
+      (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) ) {
+    return true;
+  }
+  
+
+  return false;
+
+}

DHT/DHT.h

@@ -0,0 +1,41 @@
+#ifndef DHT_H
+#define DHT_H
+#if ARDUINO >= 100
+ #include "Arduino.h"
+#else
+ #include "WProgram.h"
+#endif
+
+/* DHT library 
+
+MIT license
+written by Adafruit Industries
+*/
+
+// how many timing transitions we need to keep track of. 2 * number bits + extra
+#define MAXTIMINGS 85
+
+#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;
+
+ public:
+  DHT(uint8_t pin, uint8_t type, uint8_t count=6);
+  void begin(void);
+  float readTemperature(bool S=false);
+  float convertCtoF(float);
+  float convertFtoC(float);
+  float computeHeatIndex(float tempFahrenheit, float percentHumidity);
+  float readHumidity(void);
+  boolean read(void);
+
+};
+#endif

DHT/README.txt

@@ -0,0 +1,3 @@
+This is an Arduino library for the DHT series of low cost temperature/humidity sensors. 
+
+To download. click the DOWNLOADS button in the top right corner, rename the uncompressed folder DHT. Check that the DHT folder contains DHT.cpp and DHT.h. Place the DHT library folder your <arduinosketchfolder>/libraries/ folder. You may need to create the libraries subfolder if its your first library. Restart the IDE.

DHT/examples/DHTtester/DHTtester.ino

@@ -0,0 +1,71 @@
+// Example testing sketch for various DHT humidity/temperature sensors
+// Written by ladyada, public domain
+
+#include "DHT.h"
+
+#define DHTPIN 2     // what pin we're connected to
+
+// Uncomment whatever type you're using!
+//#define DHTTYPE DHT11   // DHT 11 
+#define DHTTYPE DHT22   // DHT 22  (AM2302)
+//#define DHTTYPE DHT21   // DHT 21 (AM2301)
+
+// Connect pin 1 (on the left) of the sensor to +5V
+// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
+// to 3.3V instead of 5V!
+// Connect pin 2 of the sensor to whatever your DHTPIN is
+// 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
+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); 
+  Serial.println("DHTxx test!");
+ 
+  dht.begin();
+}
+
+void loop() {
+  // Wait a few seconds between measurements.
+  delay(2000);
+
+  // Reading temperature or humidity takes about 250 milliseconds!
+  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
+  float h = dht.readHumidity();
+  // Read temperature as Celsius
+  float t = dht.readTemperature();
+  // Read temperature as Fahrenheit
+  float f = dht.readTemperature(true);
+  
+  // Check if any reads failed and exit early (to try again).
+  if (isnan(h) || isnan(t) || isnan(f)) {
+    Serial.println("Failed to read from DHT sensor!");
+    return;
+  }
+
+  // Compute heat index
+  // Must send in temp in Fahrenheit!
+  float hi = dht.computeHeatIndex(f, h);
+
+  Serial.print("Humidity: "); 
+  Serial.print(h);
+  Serial.print(" %\t");
+  Serial.print("Temperature: "); 
+  Serial.print(t);
+  Serial.print(" *C ");
+  Serial.print(f);
+  Serial.print(" *F\t");
+  Serial.print("Heat index: ");
+  Serial.print(hi);
+  Serial.println(" *F");
+}