From aa9fc5d81713ba2656c32a6a60647e32ce8ae9cc Mon Sep 17 00:00:00 2001 From: Harald Pichler Date: Fri, 20 Oct 2017 10:47:48 +0200 Subject: [PATCH] initial upload --- .../.github/ISSUE_TEMPLATE.md | 46 ++++ .../.github/PULL_REQUEST_TEMPLATE.md | 26 ++ .../DHT-sensor-library-master/DHT.cpp | 259 ++++++++++++++++++ .../DHT-sensor-library-master/DHT.h | 75 +++++ .../DHT-sensor-library-master/DHT_U.cpp | 179 ++++++++++++ .../DHT-sensor-library-master/DHT_U.h | 78 ++++++ .../DHT-sensor-library-master/README.md | 15 + .../DHT_Unified_Sensor/DHT_Unified_Sensor.ino | 84 ++++++ .../examples/DHTtester/DHTtester.ino | 69 +++++ .../DHT-sensor-library-master/keywords.txt | 22 ++ .../library.properties | 9 + examples/osd/arduino-trockenautomat/DHT.cpp | 259 ++++++++++++++++++ examples/osd/arduino-trockenautomat/DHT.h | 71 +++++ examples/osd/arduino-trockenautomat/Makefile | 64 +++++ examples/osd/arduino-trockenautomat/README.md | 11 + .../arduino-trockenautomat/arduino-example.c | 2 + .../arduino-trockenautomat.geany | 53 ++++ examples/osd/arduino-trockenautomat/flash.sh | 2 + .../osd/arduino-trockenautomat/project-conf.h | 106 +++++++ .../resources/res-dhtahum.c | 80 ++++++ .../resources/res-dhtatemp.c | 79 ++++++ .../resources/res-dhtbhum.c | 80 ++++++ .../resources/res-dhtbtemp.c | 79 ++++++ .../resources/res-dhtchum.c | 80 ++++++ .../resources/res-dhtctemp.c | 79 ++++++ examples/osd/arduino-trockenautomat/run.sh | 5 + .../osd/arduino-trockenautomat/sketch.pde | 137 +++++++++ 27 files changed, 2049 insertions(+) create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/.github/ISSUE_TEMPLATE.md create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/.github/PULL_REQUEST_TEMPLATE.md create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT.cpp create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT.h create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT_U.cpp create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT_U.h create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/README.md create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/examples/DHT_Unified_Sensor/DHT_Unified_Sensor.ino create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/examples/DHTtester/DHTtester.ino create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/keywords.txt create mode 100644 examples/osd/arduino-trockenautomat/DHT-sensor-library-master/library.properties create mode 100644 examples/osd/arduino-trockenautomat/DHT.cpp create mode 100644 examples/osd/arduino-trockenautomat/DHT.h create mode 100644 examples/osd/arduino-trockenautomat/Makefile create mode 100644 examples/osd/arduino-trockenautomat/README.md create mode 100644 examples/osd/arduino-trockenautomat/arduino-example.c create mode 100644 examples/osd/arduino-trockenautomat/arduino-trockenautomat.geany create mode 100755 examples/osd/arduino-trockenautomat/flash.sh create mode 100644 examples/osd/arduino-trockenautomat/project-conf.h create mode 100644 examples/osd/arduino-trockenautomat/resources/res-dhtahum.c create mode 100644 examples/osd/arduino-trockenautomat/resources/res-dhtatemp.c create mode 100644 examples/osd/arduino-trockenautomat/resources/res-dhtbhum.c create mode 100644 examples/osd/arduino-trockenautomat/resources/res-dhtbtemp.c create mode 100644 examples/osd/arduino-trockenautomat/resources/res-dhtchum.c create mode 100644 examples/osd/arduino-trockenautomat/resources/res-dhtctemp.c create mode 100755 examples/osd/arduino-trockenautomat/run.sh create mode 100644 examples/osd/arduino-trockenautomat/sketch.pde diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/.github/ISSUE_TEMPLATE.md b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/.github/ISSUE_TEMPLATE.md new file mode 100644 index 000000000..f0e26146f --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,46 @@ +Thank you for opening an issue on an Adafruit Arduino library repository. To +improve the speed of resolution please review the following guidelines and +common troubleshooting steps below before creating the issue: + +- **Do not use GitHub issues for troubleshooting projects and issues.** Instead use + the forums at http://forums.adafruit.com to ask questions and troubleshoot why + something isn't working as expected. In many cases the problem is a common issue + that you will more quickly receive help from the forum community. GitHub issues + are meant for known defects in the code. If you don't know if there is a defect + in the code then start with troubleshooting on the forum first. + +- **If following a tutorial or guide be sure you didn't miss a step.** Carefully + check all of the steps and commands to run have been followed. Consult the + forum if you're unsure or have questions about steps in a guide/tutorial. + +- **For Arduino projects check these very common issues to ensure they don't apply**: + + - For uploading sketches or communicating with the board make sure you're using + a **USB data cable** and **not** a **USB charge-only cable**. It is sometimes + very hard to tell the difference between a data and charge cable! Try using the + cable with other devices or swapping to another cable to confirm it is not + the problem. + + - **Be sure you are supplying adequate power to the board.** Check the specs of + your board and plug in an external power supply. In many cases just + plugging a board into your computer is not enough to power it and other + peripherals. + + - **Double check all soldering joints and connections.** Flakey connections + cause many mysterious problems. See the [guide to excellent soldering](https://learn.adafruit.com/adafruit-guide-excellent-soldering/tools) for examples of good solder joints. + + - **Ensure you are using an official Arduino or Adafruit board.** We can't + guarantee a clone board will have the same functionality and work as expected + with this code and don't support them. + +If you're sure this issue is a defect in the code and checked the steps above +please fill in the following fields to provide enough troubleshooting information. +You may delete the guideline and text above to just leave the following details: + +- Arduino board: **INSERT ARDUINO BOARD NAME/TYPE HERE** + +- Arduino IDE version (found in Arduino -> About Arduino menu): **INSERT ARDUINO + VERSION HERE** + +- List the steps to reproduce the problem below (if possible attach a sketch or + copy the sketch code in too): **LIST REPRO STEPS BELOW** diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/.github/PULL_REQUEST_TEMPLATE.md b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 000000000..7b641eb86 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,26 @@ +Thank you for creating a pull request to contribute to Adafruit's GitHub code! +Before you open the request please review the following guidelines and tips to +help it be more easily integrated: + +- **Describe the scope of your change--i.e. what the change does and what parts + of the code were modified.** This will help us understand any risks of integrating + the code. + +- **Describe any known limitations with your change.** For example if the change + doesn't apply to a supported platform of the library please mention it. + +- **Please run any tests or examples that can exercise your modified code.** We + strive to not break users of the code and running tests/examples helps with this + process. + +Thank you again for contributing! We will try to test and integrate the change +as soon as we can, but be aware we have many GitHub repositories to manage and +can't immediately respond to every request. There is no need to bump or check in +on a pull request (it will clutter the discussion of the request). + +Also don't be worried if the request is closed or not integrated--sometimes the +priorities of Adafruit's GitHub code (education, ease of use) might not match the +priorities of the pull request. Don't fret, the open source community thrives on +forks and GitHub makes it easy to keep your changes in a forked repo. + +After reviewing the guidelines above you can delete this text from the pull request. diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT.cpp b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT.cpp new file mode 100644 index 000000000..86ad91c43 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT.cpp @@ -0,0 +1,259 @@ +/* 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(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/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT.h b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT.h new file mode 100644 index 000000000..d81f6dbc9 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT.h @@ -0,0 +1,75 @@ +/* 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); + 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 diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT_U.cpp b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT_U.cpp new file mode 100644 index 000000000..efc7963c1 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT_U.cpp @@ -0,0 +1,179 @@ +// DHT Temperature & Humidity Unified Sensor Library +// Copyright (c) 2014 Adafruit Industries +// Author: Tony DiCola + +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: + +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. + +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +#include "DHT_U.h" + +DHT_Unified::DHT_Unified(uint8_t pin, uint8_t type, uint8_t count, int32_t tempSensorId, int32_t humiditySensorId): + _dht(pin, type, count), + _type(type), + _temp(this, tempSensorId), + _humidity(this, humiditySensorId) +{} + +void DHT_Unified::begin() { + _dht.begin(); +} + +void DHT_Unified::setName(sensor_t* sensor) { + switch(_type) { + case DHT11: + strncpy(sensor->name, "DHT11", sizeof(sensor->name) - 1); + break; + case DHT21: + strncpy(sensor->name, "DHT21", sizeof(sensor->name) - 1); + break; + case DHT22: + strncpy(sensor->name, "DHT22", sizeof(sensor->name) - 1); + break; + default: + // TODO: Perhaps this should be an error? However main DHT library doesn't enforce + // restrictions on the sensor type value. Pick a generic name for now. + strncpy(sensor->name, "DHT?", sizeof(sensor->name) - 1); + break; + } + sensor->name[sizeof(sensor->name)- 1] = 0; +} + +void DHT_Unified::setMinDelay(sensor_t* sensor) { + switch(_type) { + case DHT11: + sensor->min_delay = 1000000L; // 1 second (in microseconds) + break; + case DHT21: + sensor->min_delay = 2000000L; // 2 seconds (in microseconds) + break; + case DHT22: + sensor->min_delay = 2000000L; // 2 seconds (in microseconds) + break; + default: + // Default to slowest sample rate in case of unknown type. + sensor->min_delay = 2000000L; // 2 seconds (in microseconds) + break; + } +} + +DHT_Unified::Temperature::Temperature(DHT_Unified* parent, int32_t id): + _parent(parent), + _id(id) +{} + +bool DHT_Unified::Temperature::getEvent(sensors_event_t* event) { + // Clear event definition. + memset(event, 0, sizeof(sensors_event_t)); + // Populate sensor reading values. + event->version = sizeof(sensors_event_t); + event->sensor_id = _id; + event->type = SENSOR_TYPE_AMBIENT_TEMPERATURE; + event->timestamp = millis(); + event->temperature = _parent->_dht.readTemperature(); + + return true; +} + +void DHT_Unified::Temperature::getSensor(sensor_t* sensor) { + // Clear sensor definition. + memset(sensor, 0, sizeof(sensor_t)); + // Set sensor name. + _parent->setName(sensor); + // Set version and ID + sensor->version = DHT_SENSOR_VERSION; + sensor->sensor_id = _id; + // Set type and characteristics. + sensor->type = SENSOR_TYPE_AMBIENT_TEMPERATURE; + _parent->setMinDelay(sensor); + switch (_parent->_type) { + case DHT11: + sensor->max_value = 50.0F; + sensor->min_value = 0.0F; + sensor->resolution = 2.0F; + break; + case DHT21: + sensor->max_value = 80.0F; + sensor->min_value = -40.0F; + sensor->resolution = 0.1F; + break; + case DHT22: + sensor->max_value = 125.0F; + sensor->min_value = -40.0F; + sensor->resolution = 0.1F; + break; + default: + // Unknown type, default to 0. + sensor->max_value = 0.0F; + sensor->min_value = 0.0F; + sensor->resolution = 0.0F; + break; + } +} + +DHT_Unified::Humidity::Humidity(DHT_Unified* parent, int32_t id): + _parent(parent), + _id(id) +{} + +bool DHT_Unified::Humidity::getEvent(sensors_event_t* event) { + // Clear event definition. + memset(event, 0, sizeof(sensors_event_t)); + // Populate sensor reading values. + event->version = sizeof(sensors_event_t); + event->sensor_id = _id; + event->type = SENSOR_TYPE_RELATIVE_HUMIDITY; + event->timestamp = millis(); + event->relative_humidity = _parent->_dht.readHumidity(); + + return true; +} + +void DHT_Unified::Humidity::getSensor(sensor_t* sensor) { + // Clear sensor definition. + memset(sensor, 0, sizeof(sensor_t)); + // Set sensor name. + _parent->setName(sensor); + // Set version and ID + sensor->version = DHT_SENSOR_VERSION; + sensor->sensor_id = _id; + // Set type and characteristics. + sensor->type = SENSOR_TYPE_RELATIVE_HUMIDITY; + _parent->setMinDelay(sensor); + switch (_parent->_type) { + case DHT11: + sensor->max_value = 80.0F; + sensor->min_value = 20.0F; + sensor->resolution = 5.0F; + break; + case DHT21: + sensor->max_value = 100.0F; + sensor->min_value = 0.0F; + sensor->resolution = 0.1F; + break; + case DHT22: + sensor->max_value = 100.0F; + sensor->min_value = 0.0F; + sensor->resolution = 0.1F; + break; + default: + // Unknown type, default to 0. + sensor->max_value = 0.0F; + sensor->min_value = 0.0F; + sensor->resolution = 0.0F; + break; + } +} diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT_U.h b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT_U.h new file mode 100644 index 000000000..d9ee709cc --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/DHT_U.h @@ -0,0 +1,78 @@ +// DHT Temperature & Humidity Unified Sensor Library +// Copyright (c) 2014 Adafruit Industries +// Author: Tony DiCola + +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: + +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. + +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +#ifndef DHT_U_H +#define DHT_U_H + +#include +#include + +#define DHT_SENSOR_VERSION 1 + +class DHT_Unified { +public: + DHT_Unified(uint8_t pin, uint8_t type, uint8_t count=6, int32_t tempSensorId=-1, int32_t humiditySensorId=-1); + void begin(); + + class Temperature : public Adafruit_Sensor { + public: + Temperature(DHT_Unified* parent, int32_t id); + bool getEvent(sensors_event_t* event); + void getSensor(sensor_t* sensor); + + private: + DHT_Unified* _parent; + int32_t _id; + + }; + + class Humidity : public Adafruit_Sensor { + public: + Humidity(DHT_Unified* parent, int32_t id); + bool getEvent(sensors_event_t* event); + void getSensor(sensor_t* sensor); + + private: + DHT_Unified* _parent; + int32_t _id; + + }; + + Temperature temperature() { + return _temp; + } + + Humidity humidity() { + return _humidity; + } + +private: + DHT _dht; + uint8_t _type; + Temperature _temp; + Humidity _humidity; + + void setName(sensor_t* sensor); + void setMinDelay(sensor_t* sensor); + +}; + +#endif diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/README.md b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/README.md new file mode 100644 index 000000000..d32afdc69 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/README.md @@ -0,0 +1,15 @@ +This is an Arduino library for the DHT series of low cost temperature/humidity sensors. + +Tutorial: https://learn.adafruit.com/dht + +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 /libraries/ folder. You may need to create the libraries subfolder if its your first library. Restart the IDE. + +# Adafruit DHT Humidity & Temperature Unified Sensor Library + +This library also includes an optional class for the +[DHT humidity and temperature sensor](https://learn.adafruit.com/dht/overview) +which is designed to work with the [Adafruit unified sensor library](https://learn.adafruit.com/using-the-adafruit-unified-sensor-driver/introduction). + +You must have the following Arduino libraries installed to use this class: + +- [Adafruit Unified Sensor Library](https://github.com/adafruit/Adafruit_Sensor) diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/examples/DHT_Unified_Sensor/DHT_Unified_Sensor.ino b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/examples/DHT_Unified_Sensor/DHT_Unified_Sensor.ino new file mode 100644 index 000000000..4820f2e87 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/examples/DHT_Unified_Sensor/DHT_Unified_Sensor.ino @@ -0,0 +1,84 @@ +// DHT Temperature & Humidity Sensor +// Unified Sensor Library Example +// Written by Tony DiCola for Adafruit Industries +// Released under an MIT license. + +// Depends on the following Arduino libraries: +// - Adafruit Unified Sensor Library: https://github.com/adafruit/Adafruit_Sensor +// - DHT Sensor Library: https://github.com/adafruit/DHT-sensor-library + +#include +#include +#include + +#define DHTPIN 2 // Pin which is connected to the DHT sensor. + +// Uncomment the type of sensor in use: +//#define DHTTYPE DHT11 // DHT 11 +#define DHTTYPE DHT22 // DHT 22 (AM2302) +//#define DHTTYPE DHT21 // DHT 21 (AM2301) + +// See guide for details on sensor wiring and usage: +// https://learn.adafruit.com/dht/overview + +DHT_Unified dht(DHTPIN, DHTTYPE); + +uint32_t delayMS; + +void setup() { + Serial.begin(9600); + // Initialize device. + dht.begin(); + Serial.println("DHTxx Unified Sensor Example"); + // Print temperature sensor details. + sensor_t sensor; + dht.temperature().getSensor(&sensor); + Serial.println("------------------------------------"); + Serial.println("Temperature"); + Serial.print ("Sensor: "); Serial.println(sensor.name); + Serial.print ("Driver Ver: "); Serial.println(sensor.version); + Serial.print ("Unique ID: "); Serial.println(sensor.sensor_id); + Serial.print ("Max Value: "); Serial.print(sensor.max_value); Serial.println(" *C"); + Serial.print ("Min Value: "); Serial.print(sensor.min_value); Serial.println(" *C"); + Serial.print ("Resolution: "); Serial.print(sensor.resolution); Serial.println(" *C"); + Serial.println("------------------------------------"); + // Print humidity sensor details. + dht.humidity().getSensor(&sensor); + Serial.println("------------------------------------"); + Serial.println("Humidity"); + Serial.print ("Sensor: "); Serial.println(sensor.name); + Serial.print ("Driver Ver: "); Serial.println(sensor.version); + Serial.print ("Unique ID: "); Serial.println(sensor.sensor_id); + Serial.print ("Max Value: "); Serial.print(sensor.max_value); Serial.println("%"); + Serial.print ("Min Value: "); Serial.print(sensor.min_value); Serial.println("%"); + Serial.print ("Resolution: "); Serial.print(sensor.resolution); Serial.println("%"); + Serial.println("------------------------------------"); + // Set delay between sensor readings based on sensor details. + delayMS = sensor.min_delay / 1000; +} + +void loop() { + // Delay between measurements. + delay(delayMS); + // Get temperature event and print its value. + sensors_event_t event; + dht.temperature().getEvent(&event); + if (isnan(event.temperature)) { + Serial.println("Error reading temperature!"); + } + else { + Serial.print("Temperature: "); + Serial.print(event.temperature); + Serial.println(" *C"); + } + // Get humidity event and print its value. + dht.humidity().getEvent(&event); + if (isnan(event.relative_humidity)) { + Serial.println("Error reading humidity!"); + } + else { + Serial.print("Humidity: "); + Serial.print(event.relative_humidity); + Serial.println("%"); + } +} diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/examples/DHTtester/DHTtester.ino b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/examples/DHTtester/DHTtester.ino new file mode 100644 index 000000000..ae6c41a19 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/examples/DHTtester/DHTtester.ino @@ -0,0 +1,69 @@ +// Example testing sketch for various DHT humidity/temperature sensors +// Written by ladyada, public domain + +#include "DHT.h" + +#define DHTPIN 2 // what digital pin we're connected to + +// Uncomment whatever type you're using! +//#define DHTTYPE DHT11 // DHT 11 +#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321 +//#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. +// 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); + +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 (the default) + float t = dht.readTemperature(); + // Read temperature as Fahrenheit (isFahrenheit = true) + 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 in Fahrenheit (the default) + float hif = dht.computeHeatIndex(f, h); + // Compute heat index in Celsius (isFahreheit = false) + float hic = dht.computeHeatIndex(t, h, false); + + 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(hic); + Serial.print(" *C "); + Serial.print(hif); + Serial.println(" *F"); +} diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/keywords.txt b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/keywords.txt new file mode 100644 index 000000000..146d4fa6c --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/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 + diff --git a/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/library.properties b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/library.properties new file mode 100644 index 000000000..a54c1dc20 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT-sensor-library-master/library.properties @@ -0,0 +1,9 @@ +name=DHT sensor library +version=1.3.0 +author=Adafruit +maintainer=Adafruit +sentence=Arduino library for DHT11, DHT22, etc Temp & Humidity Sensors +paragraph=Arduino library for DHT11, DHT22, etc Temp & Humidity Sensors +category=Sensors +url=https://github.com/adafruit/DHT-sensor-library +architectures=* diff --git a/examples/osd/arduino-trockenautomat/DHT.cpp b/examples/osd/arduino-trockenautomat/DHT.cpp new file mode 100644 index 000000000..86ad91c43 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT.cpp @@ -0,0 +1,259 @@ +/* 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(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/examples/osd/arduino-trockenautomat/DHT.h b/examples/osd/arduino-trockenautomat/DHT.h new file mode 100644 index 000000000..4192aa74d --- /dev/null +++ b/examples/osd/arduino-trockenautomat/DHT.h @@ -0,0 +1,71 @@ +/* DHT library + +MIT license +written by Adafruit Industries +*/ +#ifndef DHT_H +#define DHT_H + +#include "Arduino.h" + + +// 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); + 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 diff --git a/examples/osd/arduino-trockenautomat/Makefile b/examples/osd/arduino-trockenautomat/Makefile new file mode 100644 index 000000000..d3d167ee0 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/Makefile @@ -0,0 +1,64 @@ +# Set this to the name of your sketch (without extension .pde) +SKETCH=sketch +EXE=arduino-example + +all: $(EXE) + +CONTIKI=../../.. + +# Contiki IPv6 configuration +CONTIKI_WITH_IPV6 = 1 + +CFLAGS += -DPROJECT_CONF_H=\"project-conf.h\" +LFLAGS += -lm + +PROJECT_SOURCEFILES += ${SKETCH}.cpp DHT.cpp + +# automatically build RESTful resources +REST_RESOURCES_DIR = ./resources +REST_RESOURCES_DIR_COMMON = ../resources-common +REST_RESOURCES_FILES= $(notdir \ + $(shell find $(REST_RESOURCES_DIR) -name '*.c') \ + $(shell find $(REST_RESOURCES_DIR_COMMON) -name '*.c') \ + ) + +PROJECTDIRS += $(REST_RESOURCES_DIR) $(REST_RESOURCES_DIR_COMMON) +PROJECT_SOURCEFILES += $(REST_RESOURCES_FILES) + +# variable for Makefile.include +ifneq ($(TARGET), minimal-net) +CFLAGS += -DUIP_CONF_IPV6_RPL=1 +else +# minimal-net does not support RPL under Linux and is mostly used to test CoAP only +${info INFO: compiling without RPL} +CFLAGS += -DUIP_CONF_IPV6_RPL=0 +CFLAGS += -DHARD_CODED_ADDRESS=\"fdfd::10\" +${info INFO: compiling with large buffers} +CFLAGS += -DUIP_CONF_BUFFER_SIZE=2048 +CFLAGS += -DREST_MAX_CHUNK_SIZE=1024 +CFLAGS += -DCOAP_MAX_HEADER_SIZE=640 +endif + +# linker optimizations +SMALL=1 + + +# REST Engine shall use Erbium CoAP implementation +APPS += er-coap +APPS += rest-engine +APPS += arduino + +include $(CONTIKI)/Makefile.include +include $(CONTIKI)/apps/arduino/Makefile.include + +$(CONTIKI)/tools/tunslip6: $(CONTIKI)/tools/tunslip6.c + (cd $(CONTIKI)/tools && $(MAKE) tunslip6) + +connect-router: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 aaaa::1/64 + +connect-router-cooja: $(CONTIKI)/tools/tunslip6 + sudo $(CONTIKI)/tools/tunslip6 -a 127.0.0.1 aaaa::1/64 + +connect-minimal: + sudo ip address add fdfd::1/64 dev tap0 diff --git a/examples/osd/arduino-trockenautomat/README.md b/examples/osd/arduino-trockenautomat/README.md new file mode 100644 index 000000000..e1490ed05 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/README.md @@ -0,0 +1,11 @@ +Arduino compatibility example +============================= + +This example shows that it is now possible to re-use arduino sketches in +Contiki. This example documents the necessary magic. Arduino specifies +two routines, `setup` and `loop`. Before `setup` is called, the +framework initializes hardware. In original Arduino, all this is done in +a `main` function (in C). For contiki we define a process that does the +same. + +See the documentation file in apps/contiki-compat/README.md diff --git a/examples/osd/arduino-trockenautomat/arduino-example.c b/examples/osd/arduino-trockenautomat/arduino-example.c new file mode 100644 index 000000000..ea74dd8b8 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/arduino-example.c @@ -0,0 +1,2 @@ +#include +AUTOSTART_PROCESSES(&arduino_sketch); diff --git a/examples/osd/arduino-trockenautomat/arduino-trockenautomat.geany b/examples/osd/arduino-trockenautomat/arduino-trockenautomat.geany new file mode 100644 index 000000000..6b8661190 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/arduino-trockenautomat.geany @@ -0,0 +1,53 @@ +[file_prefs] +final_new_line=true +ensure_convert_new_lines=false +strip_trailing_spaces=false +replace_tabs=false + +[indentation] +indent_width=4 +indent_type=1 +indent_hard_tab_width=8 +detect_indent=false +detect_indent_width=false +indent_mode=2 + +[project] +name=arduino-trockenautomat +base_path=/home/harald/install/osd-contiki/examples/osd/arduino-trockenautomat/ +description= +file_patterns= + +[long line marker] +long_line_behaviour=1 +long_line_column=72 + +[files] +current_page=0 +FILE_NAME_0=792;C++;0;EUTF-8;1;1;0;%2Fhome%2Fharald%2Finstall%2Fosd-contiki%2Fexamples%2Fosd%2Farduino-dht%2Fsketch.pde;0;4 + +[VTE] +last_dir=/home/harald + +[build-menu] +NF_00_LB=_Make +NF_00_CM=make TARGET=osd-merkur-256 +NF_00_WD= +NF_01_LB=Make flash +NF_01_CM=make TARGET=osd-merkur-256 flash +NF_01_WD= +NF_03_LB=Make Clean +NF_03_CM=make clean TARGET=osd-merkur-256 +NF_03_WD= +C++FT_00_LB=_Kompilieren +C++FT_00_CM=make TARGET=osd-merkur-256 +C++FT_00_WD= +C++FT_01_LB=_Erstellen +C++FT_01_CM=make TARGET=osd-merkur-256 flash +C++FT_01_WD= +filetypes=C++; + +[editor] +line_wrapping=false +line_break_column=72 +auto_continue_multiline=true diff --git a/examples/osd/arduino-trockenautomat/flash.sh b/examples/osd/arduino-trockenautomat/flash.sh new file mode 100755 index 000000000..e82962073 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/flash.sh @@ -0,0 +1,2 @@ +#!/bin/bash +make TARGET=osd-merkur-128 flash diff --git a/examples/osd/arduino-trockenautomat/project-conf.h b/examples/osd/arduino-trockenautomat/project-conf.h new file mode 100644 index 000000000..e25aed53c --- /dev/null +++ b/examples/osd/arduino-trockenautomat/project-conf.h @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2010, Swedish Institute of Computer Science. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * + */ + +#ifndef PROJECT_RPL_WEB_CONF_H_ +#define PROJECT_RPL_WEB_CONF_H_ + +#define PLATFORM_HAS_LEDS 1 +//#define PLATFORM_HAS_BUTTON 1 +#define PLATFORM_HAS_BATTERY 1 + +#define SICSLOWPAN_CONF_FRAG 1 + +#define LOOP_INTERVAL (10 * CLOCK_SECOND) + +/* Save energy */ +//#define RDC_CONF_PT_YIELD_OFF + +/* For Debug: Dont allow MCU sleeping between channel checks */ +//#undef RDC_CONF_MCU_SLEEP +//#define RDC_CONF_MCU_SLEEP 0 + +/* Disabling RDC for demo purposes. Core updates often require more memory. */ +/* For projects, optimize memory and enable RDC again. */ +// #undef NETSTACK_CONF_RDC +//#define NETSTACK_CONF_RDC nullrdc_driver + +/* Increase rpl-border-router IP-buffer when using more than 64. */ +#undef REST_MAX_CHUNK_SIZE +#define REST_MAX_CHUNK_SIZE 64 + +/* Estimate your header size, especially when using Proxy-Uri. */ +/* +#undef COAP_MAX_HEADER_SIZE +#define COAP_MAX_HEADER_SIZE 70 +*/ + +/* The IP buffer size must fit all other hops, in particular the border router. */ + +#undef UIP_CONF_BUFFER_SIZE +#define UIP_CONF_BUFFER_SIZE 256 + + +/* Multiplies with chunk size, be aware of memory constraints. */ +#undef COAP_MAX_OPEN_TRANSACTIONS +#define COAP_MAX_OPEN_TRANSACTIONS 4 + +/* Must be <= open transaction number, default is COAP_MAX_OPEN_TRANSACTIONS-1. */ +/* +#undef COAP_MAX_OBSERVERS +#define COAP_MAX_OBSERVERS 2 +*/ + +/* Filtering .well-known/core per query can be disabled to save space. */ +/* +#undef COAP_LINK_FORMAT_FILTERING +#define COAP_LINK_FORMAT_FILTERING 0 +*/ + +/* Save some memory for the sky platform. */ +/* +#undef NBR_TABLE_CONF_MAX_NEIGHBORS +#define NBR_TABLE_CONF_MAX_NEIGHBORS 10 +#undef UIP_CONF_MAX_ROUTES +#define UIP_CONF_MAX_ROUTES 10 +*/ + +/* Reduce 802.15.4 frame queue to save RAM. */ +/* +#undef QUEUEBUF_CONF_NUM +#define QUEUEBUF_CONF_NUM 4 +*/ + +/* +#undef SICSLOWPAN_CONF_FRAG +#define SICSLOWPAN_CONF_FRAG 1 +*/ + +#endif /* PROJECT_RPL_WEB_CONF_H_ */ diff --git a/examples/osd/arduino-trockenautomat/resources/res-dhtahum.c b/examples/osd/arduino-trockenautomat/resources/res-dhtahum.c new file mode 100644 index 000000000..061a7d832 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/resources/res-dhtahum.c @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_dhtahum, + "title=\"Moisture status\";rt=\"Moisture\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char dhta_hum_s[8]; + + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", dhta_hum_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'moisture':%s}", dhta_hum_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-trockenautomat/resources/res-dhtatemp.c b/examples/osd/arduino-trockenautomat/resources/res-dhtatemp.c new file mode 100644 index 000000000..c135fbe83 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/resources/res-dhtatemp.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_dhtatemp, + "title=\"Temperature status\";rt=\"Temperatur\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char dhta_temp_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", dhta_temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", dhta_temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-trockenautomat/resources/res-dhtbhum.c b/examples/osd/arduino-trockenautomat/resources/res-dhtbhum.c new file mode 100644 index 000000000..c2e0f87d2 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/resources/res-dhtbhum.c @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_dhtbhum, + "title=\"Moisture status\";rt=\"Moisture\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char dhtb_hum_s[8]; + + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", dhtb_hum_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'moisture':%s}", dhtb_hum_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-trockenautomat/resources/res-dhtbtemp.c b/examples/osd/arduino-trockenautomat/resources/res-dhtbtemp.c new file mode 100644 index 000000000..690e58456 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/resources/res-dhtbtemp.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_dhtbtemp, + "title=\"Temperature status\";rt=\"Temperatur\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char dhtb_temp_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", dhtb_temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", dhtb_temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-trockenautomat/resources/res-dhtchum.c b/examples/osd/arduino-trockenautomat/resources/res-dhtchum.c new file mode 100644 index 000000000..73c15d663 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/resources/res-dhtchum.c @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_dhtchum, + "title=\"Moisture status\";rt=\"Moisture\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char dhtc_hum_s[8]; + + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", dhtc_hum_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'moisture':%s}", dhtc_hum_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-trockenautomat/resources/res-dhtctemp.c b/examples/osd/arduino-trockenautomat/resources/res-dhtctemp.c new file mode 100644 index 000000000..3f8cf039b --- /dev/null +++ b/examples/osd/arduino-trockenautomat/resources/res-dhtctemp.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013, Institute for Pervasive Computing, ETH Zurich + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + */ + +/** + * \file + * Moisture resource + * \author + * Harald Pichler + */ + +#include "contiki.h" + +#include +#include "rest-engine.h" +#include "Arduino.h" + +static void res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset); + +/* A simple getter example. Returns the reading from the sensor with a simple etag */ +RESOURCE(res_dhtctemp, + "title=\"Temperature status\";rt=\"Temperatur\"", + res_get_handler, + NULL, + NULL, + NULL); + +extern char dhtc_temp_s[8]; + +static void +res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) +{ + + unsigned int accept = -1; + REST.get_header_accept(request, &accept); + + if(accept == -1 || accept == REST.type.TEXT_PLAIN) { + REST.set_header_content_type(response, REST.type.TEXT_PLAIN); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "%s", dhtc_temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else if(accept == REST.type.APPLICATION_JSON) { + REST.set_header_content_type(response, REST.type.APPLICATION_JSON); + snprintf((char *)buffer, REST_MAX_CHUNK_SIZE, "{'temperature':%s}", dhtc_temp_s); + + REST.set_response_payload(response, buffer, strlen((char *)buffer)); + } else { + REST.set_response_status(response, REST.status.NOT_ACCEPTABLE); + const char *msg = "Supporting content-types text/plain and application/json"; + REST.set_response_payload(response, msg, strlen(msg)); + } +} diff --git a/examples/osd/arduino-trockenautomat/run.sh b/examples/osd/arduino-trockenautomat/run.sh new file mode 100755 index 000000000..5d5cbbbb4 --- /dev/null +++ b/examples/osd/arduino-trockenautomat/run.sh @@ -0,0 +1,5 @@ +#!/bin/bash +# For the ages-old bootloader (before 2014) you want to use +# BOOTLOADER_GET_MAC=0x0001f3a0 as parameter to make below. +make clean TARGET=osd-merkur-128 +make TARGET=osd-merkur-128 diff --git a/examples/osd/arduino-trockenautomat/sketch.pde b/examples/osd/arduino-trockenautomat/sketch.pde new file mode 100644 index 000000000..fddc739ec --- /dev/null +++ b/examples/osd/arduino-trockenautomat/sketch.pde @@ -0,0 +1,137 @@ +/* + * Sample arduino sketch using contiki features. + * We turn the LED off + * We allow read the moisture sensor + * Unfortunately sleeping for long times in loop() isn't currently + * possible, something turns off the CPU (including PWM outputs) if a + * Proto-Thread is taking too long. We need to find out how to sleep in + * a Contiki-compatible way. + * Note that for a normal arduino sketch you won't have to include any + * of the contiki-specific files here, the sketch should just work. + */ + +#include +#include "DHT.h" + +extern "C" { +#include "arduino-process.h" +#include "rest-engine.h" +#include "net/netstack.h" + +extern resource_t res_dhtatemp, res_dhtahum, res_battery; +extern resource_t res_dhtbtemp, res_dhtbhum; +extern resource_t res_dhtctemp, res_dhtchum; + +#define LED_PIN 4 + +// Uncomment whatever type you're using! +//#define DHTTYPE DHT11 // DHT 11 +#define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321 +//#define DHTTYPE DHT21 // DHT 21 (AM2301) + +// Connect pin 1 (on the left) of the sensor to +3.3V +// 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) o +#define DHTPINA 7 // what digital pin we're connected to +DHT dhta(DHTPINA, DHTTYPE); + +#define DHTPINB 8 // what digital pin we're connected to +DHT dhtb(DHTPINB, DHTTYPE); + +#define DHTPINC 9 // what digital pin we're connected to +DHT dhtc(DHTPINC, DHTTYPE); + +float dhta_hum; +float dhta_temp; +char dhta_hum_s[8]; +char dhta_temp_s[8]; + +float dhtb_hum; +float dhtb_temp; +char dhtb_hum_s[8]; +char dhtb_temp_s[8]; + +float dhtc_hum; +float dhtc_temp; +char dhtc_hum_s[8]; +char dhtc_temp_s[8]; + +} + +void setup (void) +{ +// NETSTACK_MAC.off(1); // reciever always on + printf("DHT Sensor\n"); + // switch off the led + pinMode(LED_PIN, OUTPUT); + digitalWrite(LED_PIN, HIGH); + // DHT sensor + dhta.begin(); + dhtb.begin(); + dhtc.begin(); + // init coap resourcen + rest_init_engine (); +#pragma GCC diagnostic ignored "-Wwrite-strings" + rest_activate_resource (&res_dhtatemp, "s/tempa"); + rest_activate_resource (&res_dhtahum, "s/huma"); + rest_activate_resource (&res_dhtbtemp, "s/tempb"); + rest_activate_resource (&res_dhtbhum, "s/humb"); + rest_activate_resource (&res_dhtctemp, "s/tempc"); + rest_activate_resource (&res_dhtchum, "s/humc"); + rest_activate_resource (&res_battery, "s/battery"); +#pragma GCC diagnostic pop + mcu_sleep_set(128); // Power consumtion 278uA; average over 20 minutes +} + +// at project-conf.h +// LOOP_INTERVAL (30 * CLOCK_SECOND) +void loop (void) +{ + int errdht=0; + // Reading temperature or humidity takes about 250 milliseconds! + // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor) + dhta_hum = dhta.readHumidity(); + dhtb_hum = dhtb.readHumidity(); + dhtc_hum = dhtc.readHumidity(); + // Read temperature as Celsius (the default) + dhta_temp = dhta.readTemperature(); + dhtb_temp = dhtb.readTemperature(); + dhtc_temp = dhtc.readTemperature(); + + // Check if any reads failed and exit early (to try again). + if (isnan(dhta_hum) || isnan(dhta_temp)) { + printf("Failed to read from DHTa sensor!\n"); + errdht=1; + } + if (isnan(dhtb_hum) || isnan(dhtb_temp)) { + printf("Failed to read from DHTb sensor!\n"); + errdht=1; + } + if (isnan(dhtc_hum) || isnan(dhtc_temp)) { + printf("Failed to read from DHTc sensor!\n"); + errdht=1; + } + if (errdht){ + return; + } + + dtostrf(dhta_temp , 0, 2, dhta_temp_s ); + dtostrf(dhta_hum , 0, 2, dhta_hum_s ); + + dtostrf(dhtb_temp , 0, 2, dhtb_temp_s ); + dtostrf(dhtb_hum , 0, 2, dhtb_hum_s ); + + dtostrf(dhtc_temp , 0, 2, dhtc_temp_s ); + dtostrf(dhtc_hum , 0, 2, dhtc_hum_s ); + +// debug only + printf("Tempa: '%s'",dhta_temp_s); + printf("\t\tHuma: '%s'\n",dhta_hum_s); + + printf("Tempb: '%s'",dhtb_temp_s); + printf("\t\tHumb: '%s'\n",dhtb_hum_s); + + printf("Tempc: '%s'",dhtc_temp_s); + printf("\t\tHumc: '%s'\n",dhtc_hum_s); +}