http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                        Wels, am 2018-03-31

Temperatur und relative Luftfeuchtigkeit %r.F (RH)

absolute Luftfeuchtigkeit  Luftfeuchtigkeit g/m3

********************************************************I*

Thermohygrometer

********************************************************I*

Temperatur und Luftfeuchte Sensoren   (Hymidity Sensor)

********************************************************I*

Kalibrieren von Feuchtesensoren

testo therm Type 0554 0660  (1994)  € 349,00

Kontroll- und Abgleich-Set für testo Feuchtefühler, Salzlösung - Kontroll- und Feuchteabgleich-Set

testo therm Type 0554 0636 (1994)

Sensoren werden mit einzelnen gesättigten Salzlösungen in einem luftdicht verschlossenen Behälter platziert.

75,4% NaCl Natriumchlorid

Optionale Kalibrierung

Normalerweise ist keine neue Kalibrierung des Sensors notwendig.
Er ist ab Werk auf die gespeicherte Kalibrierung eingestellt.
Für größte Genauigkeit kann der Sensor kalibriert werden.

Der einfachste Weg ist die Kalibrierung mit einem Vergleichsinstrument für relative Feuchte (Hygrometer oder Psychrometer).

Ein anderer Weg ist die Kalibrierung mit Hilfe einer Salzlösung.
Es kommt eine Zweipunkt-Kalibrierung, wie bei den meisten Sensoren, zur Anwendung.
Die Salzlösungen sorgen für eine Umgebung mit bekannter relativer Feuchte.

Wenn Sie feuchtes Salz in einem Behälter einschließen, wird die Luft darin einen bestimmten Wert für die relative Luft-Feuchte annehmen.

Die relative Luft-Feuchte ist ein wenig temperaturabhängig.
Deshalb sind in der Tabelle verschiedene Temperaturen aufgeführt.
1. Legen Sie eine Handvoll Salz auf den Boden eines Behälters (ca. 1L Volumen)
2. Fügen Sie so viel Wasser zu, dass das Salz feucht wird. Das Salz sollte nicht vollständig gelöst sein.
3. Platzieren Sie den Sensor über das Salz. Er darf das Salz nicht berühren.
4. Verschließen Sie den Behälter (wir verwenden Plastikfolie und Gummibänder).
5. Warten Sie 6h, bis die Luft im Behälter die korrekte relative Feuchte erreicht hat.
6. Wählen Sie nun den ersten Kalibrierungspunkt und geben Sie hier den Wert aus der Tabelle ein.
7. Wiederholen Sie den Vorgang mit einem anderen Salz. Lassen Sie dem Sensor genügend Zeit, sich auf den neuen Wert einzustellen.

http://vernier-in-der-schule.at/fileadmin/PDFs/RH-BTA_deutsch.pdf

Hygrometer kalibrieren in Salzlösung

https://hygrometer-test.de/hygrometer-kalibrieren

http://forum.hanfburg.de/fhb/showthread.php?t=189512

Warmes Wasser, Salz rein, rühren und wenn ein kleiner Salzberg am Boden bleibt, ist alles OK.
360 g Kochsalz auf 1 L Wasser bei 25 °C.  Rühren beschleunigt die Auflösung

********************************************************I*

Arduino Projekte

1) DHT22: Temperatur und Luftfeuchtigkeit messen

Beispiel-Schaltung des DHT22

Beispielcode

********************************************************I*

2) Temperatur und Luftfeuchtigkeit mit dem Arduino Uno messen

https://www.reichelt.de/magazin/how-to/arduino-uno-temperatur-luftfeuchtigkeit-messen/

https://www.reichelt.de/www.reichelt.at/Kombosensoren/BME-280/3/index.html?ACTION=3&GROUPID=6845&ARTICLE=159825

********************************************************I*

3) Temperatur- und Luftfeuchtemessung mit dem Sensor DHT22 - Teil 1

********************************************************I*

4) WLAN Logger für Lufttemperatur und Feuchtigkeit

http://blog.thesen.eu/wlan-lufttemperatur-und-feuchte-logger-mit-grafischer-darstellung-fuer-esp8266/

********************************************************I*

11) Luftdruck-/Luftfeuchtesensor BME280

BOSCH Luftdrucksensor BME280   BOSCH Barometor-Sensor BME280

********************************************************I*

15.1) Perfektes Klima mit dem Arduino

15.2) Arduino-Saunatimer
mit Temperatur-/Luftfeuchteanzeige und Audioausgabe

400_b_Arduino-x_Saunatimer. mit Temperatur- Luftfeuchteanzeige und Audioausgabe (6 Seiten)_1a.pdf
www.elvjournal,de 3/2014
https://www.elv.at/Arduino-Saunatimer-mit-Temperatur-Luftfeuchteanzeige-und-Audioausgabe/x.aspx/cid_726/detail_47496

********************************************************I*

16) Temperaturmessung und Luftfeuchte mit dem Arduino UNO DHT11 DHT22

Temperaturmessung mit dem Arduino UNO  LM35  DS18B20

die Temperaturwert des DHT22 sind genauer als die OneWire Dalles DS18B20.

Schaltplan Arduino mit DHT22 und LCD Display

Benötigte Elemente

• DHT22/AM2302 digital Sensor
• Original Arduino Uno Rev.3 oder UNO-R3 Rev3 Arduino kompatibles Board
• Nettes Set mit Potis, Widerständen und Schaltern
• Steckboard (Breadboard) oder als Set: Breadboard + Kabelbrücken

Sketch Arduino mit DHT22

//ACHTUNG: Leerstelle in Include vor/nach spitzer Klammer entfernen!#include < LiquidCrystal.h >//LCD DisplayLiquidCrystal lcd(12, 11, 5, 4, 3, 2); //Adafruit DHT library https://github.com/nethoncho/Arduino-DHT22/tree/a655c6299b019cf53173139dad824466486591c8#include "DHT.h"#define DHTPIN 8 // Ich nutze Digital-PIN 8#define DHTTYPE DHT22 // DHT 22 (AM2302)DHT dht(DHTPIN, DHTTYPE); void setup() {lcd.begin(16, 2);} void loop() { //Wartedelay(2000); // Lese die Luftfeuchtigkeitfloat h = dht.readHumidity(); // Lese die Temperatur in Celsiusfloat t = dht.readTemperature(); lcd.setCursor(0, 0);lcd.print("Temperatur:");lcd.setCursor(0, 1);lcd.print("Humidity:"); lcd.setCursor(11, 0);lcd.print(t);lcd.setCursor(11, 1);lcd.print(h);}

********************************************************I*

https://github.com/adidax/dht11

// Libraries einbinden#include <dht11.h>#include <LiquidCrystal.h> dht11 DHT11;#define DHT11PIN 8 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);   void setup(){  lcd.begin(16, 2);  lcd.print("Initialisierung...");  lcd.clear();} void loop(){  int chk = DHT11.read(DHT11PIN);   lcd.setCursor(0, 0);  lcd.print("Temp: ");  lcd.print((float)DHT11.temperature, 2);  lcd.print(" C");    lcd.setCursor(0, 1);  lcd.print("RelF: ");  lcd.print((float)DHT11.humidity, 2);  lcd.print(" %");    delay(2000);}

17.2) Wetterstation mit dem Arduino basteln

Die aktuelle Version des Arduino Sketch ist noch sehr einfach.

Der Sketch macht alle 2 Minuten eine Messung und überträgt diese an einen bei thingspeak.com eingerichteten Channel zur Erfassung und Anzeige der Messdaten.

DHT11 – Temperatur und Luftfeuchtigkeit (Tutorial)
Digitaler, vorkalibrierter Sensor. Benötigt am Arduino nur 1 Pin zum Auslesen der Daten.

https://github.com/adafruit/DHT-sensor-library

MPL3115A2 – Luftdruck und Temperatur
I²C-Sensor, misst die Temperatur genauer als der DHT11

https://github.com/sparkfun/MPL3115A2_Breakout (da gibt’s auch einen Hookup-Guide etc.)

TSL45315 – Lux / Lichteinfall (Tutorial)
I²C-Sensor, misst die Lichtmenge pro Fläche (Lux)

https://github.com/adidax/Makerblog_TSL45315 (noch sehr rudimentär, aber bei mir funktioniert’s)

Seed Studio Feuchtigkeitssensor – Bodenfeuchtigkeit
Analoger Sensor, gibt einen mit der Feuchtigkeit des Mediums steigenden Wert an einem Analogpin zurück

DHT11 fuer Temperatur und LuftfeuchtigkeitTSL45315 Lux Sensor fuer HelligkeitMPL3115A2 Barometer fuer Luftdruck und TemperaturMoisture Sensor fuer BodenfeuchteEthernet Board zur Datenuebertragung

********************************************************I*

http://deskfactory.de/temperatur-und-luftfeuchtigkeit-messen-dht11

/**************************************************************//

http://deskfactory.de/temperatur-und-luftfeuchtigkeit-messen-dht11

********************************************************I*

19.2) Eine Mini-Wetterstation mit Analoganzeige Teil 2 von 2

Analoge Temperatur-Groß-Anzeige mit Modellbau-Servo

http://deskfactory.de/wetterstation-servo-arduino

********************************************************I*

20) DHT22 / AM2302-Luftfeuchte und Temperatursensor

Datenblatt DHT22 (PDF)
  Weiteres Datenblatt DHT22 (PDF)

           +5,0V  Data  n.c.  GND

Pin 1 und Pin2 werden mit einem 10k Ohm Widerstand verbunden

Technische Daten:

• Digital Temperatur und Luftfeuchtigkeit ermitteln
• Chip Typ DHT22
• Betriebsspannung: DC 3.3-5.5V
• Luftfeuchtigkeitsmessbereich : 0 bis 100% relative Luftfeuchte
• Feuchtemessgenauigkeit: ±2% RH
• Temperaturbereich: -40 bis +80 C
• Temperaturmessgenauigkeit ±0.5
• Single-Bus – Digitalsignalausgang, bidirektionale serielle Daten
• zahlreiche Beispielprogramme für gängige Board im Internet verfügbar
• Maße: 28mm x 12mm x 10mm

Der DHT ist im Sketch an pin9 angeschlossen nicht an pin2 wi im schaltbild

#include "DHT.h" #define DHTPIN 9 #define DHTTYPE DHT22 //DHT11, DHT21, DHT22 DHT dht(DHTPIN, DHTTYPE); void setup() { Serial.begin(9600);  Serial.println("DHT22 - Test!");  dht.begin();} void loop() { float h = dht.readHumidity(); //Luftfeuchte auslesen float t = dht.readTemperature(); //Temperatur auslesen  // Prüfen ob eine gültige Zahl zurückgegeben wird. Wenn NaN (not a number) zurückgegeben wird, dann Fehler ausgeben. if (isnan(t) || isnan(h))  { Serial.println("DHT22 konnte nicht ausgelesen werden"); }  else { Serial.print("Luftfeuchte: ");  Serial.print(h); Serial.print(" %\t"); Serial.print("Temperatur: ");  Serial.print(t); Serial.println(" C"); }}

• Library für Arduino
• Blog mit Beispielprogramm für Arduino
• RN-Wissen Sensorarten

********************************************************I*

21.2) Arduino – Temperatur messen mit 1Wire Sensor

OneWire Sensor  DS18S20   DS18B20    DS1820

********************************************************I*

22) Schimmelwarner mit DHT22 MLX90614 und 40x4 LCD Display

// Einbinden des DHT22
#include <i2cmaster.h>
#include "DHT.h"                            // Library für DHT Sensor aufgerufen
#define DHTPIN 7                            // DHT Sensor wird aus PIN 9 ausgelesen
#define DHTTYPE DHT22                       // DHT Type wird auf DHT22 festgelegt
DHT dht22(DHTPIN, DHTTYPE);                 // DHTPIN und DHTTYE in dht22 definiert

#include <LiquidCrystalFast.h>

LiquidCrystalFast lcd(12, 11, 10, 9, 5, 4, 3, 2);
        // LCD pins: RS  RW  EN1 EN2 D4 D5 D6 D7

// make some custom characters:
byte ue[8] = {   // 0 off, 1 set pixel
  0b00000,       // in 5x7 caracter 8. row is unused
  0b01010,
  0b00000,
  0b10001,
  0b10001,
  0b10011,
  0b01101,
  0b00000
};

void setup(){
  // create a new character
  lcd.createChar(0, ue);

  i2c_init(); //Initialise the i2c bus
  PORTC = (1 << PORTC4) | (1 << PORTC5);//enable pullups  
  lcd.begin(40, 4);

dht22.begin();                              // Auslesen des DHT22 beginnt
}

void loop()
{
  float t = dht22.readTemperature();        // Die Temperatur wird vom DHT22 ausgelesen, Wert in "t" schreiben
  float h = dht22.readHumidity();           // Die Luftfeuchte wird vom DHT22 ausgelesen, Wert in "h" schreiben
  float a = 17.271;
  float b = 237.7;
  float taupunktTemp = (a * t) / (b + t) + log(h/100);
  float p = (b * taupunktTemp) / (a - taupunktTemp);
  
    int dev = 0x5A<<1;
    int data_low = 0; 
    int data_high = 0;
    int pec = 0;
    
    i2c_start_wait(dev+I2C_WRITE);
    i2c_write(0x07);
    
    // read
    i2c_rep_start(dev+I2C_READ);
    data_low = i2c_readAck(); //Read 1 byte and then send ack
    data_high = i2c_readAck(); //Read 1 byte and then send ack
    pec = i2c_readNak();
    i2c_stop();
    
    //This converts high and low bytes together and processes temperature, MSB is a error bit and is ignored for temps
    double tempFactor = 0.02; // 0.02 degrees per LSB (measurement resolution of the MLX90614)
    double tempData = 0x0000; // zero out the data
    int frac; // data past the decimal point
    
    // This masks off the error bit of the high byte, then moves it left 8 bits and adds the low byte.
    tempData = (double)(((data_high & 0x007F) << 8) + data_low);
    tempData = (tempData * tempFactor)-0.01;
    
    float celcius = 1.38*(tempData - 273.15);
    float fahrenheit = (celcius*1.8) + 32;

lcd.setCursor(0, 0);                       // Anfang auf Stelle 0, Zeile 0 setzen
lcd.print("Lufttemp.  :");                      // Temp. : auf LCD ausgeben
lcd.setCursor(13, 0);                       // Anfang auf Stelle 9, Zeile 0 setzen
lcd.print(t ,1);                              // Wert aus "t" ausgeben (Temperatur)
lcd.setCursor(17, 0);                      // Anfang auf Stelle 15, Zeile 0 setzen
lcd.write(0xD0 + 15);                      // Grad-Zeichen (Arduino 1.00)
lcd.print("C   Wandtermp.: ");               // C auf LCD ausgeben
lcd.print(celcius ,1);
lcd.write(0xD0 + 15);                      // Grad-Zeichen (Arduino 1.00)
lcd.setCursor(39, 0); 
lcd.print("C");

lcd.setCursor(0, 1);                       // Anfang auf Stelle 0, Zeile 1 setzen
lcd.print("Luftfeuchte:");                      // Luft.: auf LCD ausgeben
lcd.setCursor(13, 1);                       // Anfang auf Stelle 9, Zeile 1 setzen
lcd.print(h ,1);                              // Wert aus "h" ausgeben (Luftfeuchtigkeit)
lcd.setCursor(18, 1);                      // Anfang auf Stelle 15, Zeile 1 setzen
lcd.print("%   Taupunkt  : ");                          // % auf LCD ausgeben
lcd.print(p ,1);
lcd.write(0xD0 + 15);
lcd.print("C");
lcd.setCursor(1, 3);
// if(celcius - taupunktTemp < 0)  // richtige Formel
if(celcius - taupunktTemp > 0) // zum Testen
{
lcd.print("!!! Achtung L");
lcd.write(0);
lcd.print("ften, Schimmelgefahr !!!");
delay(1500);
lcd.setCursor(1, 3);
lcd.print("                                      ");
//delay(500);
}}

Quelle:
https://forum.arduino.cc/index.php?topic=227838.0

********************************************************I*

23) Temperatur und Luftfeuchtigkeit messen mit dem Arduino

// Beispielcode, um Temperatur/Luftfeuchtigkeit// eines DHT22 auf einem Sparkfun SerialLCD auszugeben #include "DHT.h"#include <SoftwareSerial.h> #define DHTPIN 2     // Pin für den DHT22SoftwareSerial mySerial(4,3); // SoftwareSerial für das LCD #define DHTTYPE DHT22   // DHT 22  (AM2302)DHT dht(DHTPIN, DHTTYPE); void setup() {  mySerial.begin(9600); // starte LCD Verbindung  Serial.begin(9600); // starte zus. serielle Verbindung  delay(500); // wait for display to boot up   mySerial.write(254); // setze Cursor in die erste Zeile  mySerial.write(128);   mySerial.write("                "); // clear LCD  mySerial.write("                ");  delay(500);  mySerial.write("  DHT22 Sensor");   dht.begin();} char tempstring[10], humstring[10]; void loop() {  float h = dht.readHumidity();  float t = dht.readTemperature();  delay(5000); // lese alle 5 Sekunden ein   // check if returns are valid, if they are NaN (not a number) then something went wrong!  if (isnan(t) || isnan(h)) {    mySerial.write(254); // move cursor to beginning of first line    mySerial.write(128);    mySerial.println("DHT22 nicht gefunden");  } else {    mySerial.write(254); // move cursor to beginning of first line    mySerial.write(128);    mySerial.write("                "); // clear display    mySerial.write("                ");    mySerial.write(254); // move cursor to beginning of first line    mySerial.write(128);     mySerial.print("Luftf: ");      mySerial.print(h);    mySerial.print(" %");          Serial.println(h);    mySerial.write(254); // move cursor to beginning of 2nd line    mySerial.write(192);    mySerial.print("Temp: ");      mySerial.print(t);    mySerial.print(" *C");       Serial.println(t);  }}

https://www.uweziegenhagen.de/?p=2821

********************************************************I*

include <dht.h> // DHT Library von Arduino

https://draeger-it.blog/sainsmart-lektion-6-sensor-dht11-temperatur-und-relative-luftfeuchtigkeit-messen/

********************************************************I*

25) Temperatur / Luftfeuchte messen und auf Serial LCD ausgeben

ich möchte euch an einem kleinen Beispiel mal demonstrieren, wie ihr die Temperatur und die Luftfeuchtigkeit mit Hilfe eines DHT22 auslest und die Daten auf einem I2C 1602 LCD ausgebt und zusätzlich am seriellen Monitor euch ansehen könnt.

Folgende Bauteile habe ich verwendet:
1x SainSmart I2C 1602 Serial LCD Module
1x DHT22 Temperatur Luftfeuchte-Sensor
1x 10k Widerstand
ein paar Anschlusskabel

Angeschlossen werden die Komponenten wie folgt:
   

Folgende Library habe ich verwendet:
Library für DHT22
Library für I2C 1602 LCD
Library Wire aus Arduino 1.0.3

Hier der verwendete Sketch mit Hinweisen:

// Einbinden des DHT22
#include "DHT.h"                            // Library für DHT Sensor aufgerufen
#define DHTPIN 2                            // DHT Sensor wird aus pin2 (pin9) ausgelesen
#define DHTTYPE DHT22                       // DHT Type wird auf DHT22 festgelegt
DHT dht22(DHTPIN, DHTTYPE);                 // DHTPIN und DHTTYE in dht22 definiert

// Einbinden des LCD
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

#define I2C_ADDR    0x27
#define BACKLIGHT_PIN     3
#define En_pin  2
#define Rw_pin  1
#define Rs_pin  0
#define D4_pin  4
#define D5_pin  5
#define D6_pin  6
#define D7_pin  7

int n = 1;

LiquidCrystal_I2C    lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);


void setup()
{
  Serial.begin(9600);                       // Serielle Ausgabe beginnen mit 9600baud
  Serial.println("DHT22 Serielle Ausgabe"); // Begrüßung beim Aufruf vom seriellen Monitor
dht22.begin();                              // Auslesen des DHT22 beginnt
lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
lcd.setBacklight(HIGH);
lcd.home ();                                // go home

  lcd.begin(16, 2);                          // LCD Hintergrundbeleuchtung aktivieren
}

void loop()
{
  float t = dht22.readTemperature();        // Die Temperatur wird vom DHT22 ausgelesen, Wert in "t" schreiben
  float h = dht22.readHumidity();           // Die Luftfeuchte wird vom DHT22 ausgelesen, Wert in "h" schreiben
  
  Serial.print("Temperatur: ");             // Ausgabe im Seriellen Monitor
  Serial.print(t);                          // Ausgabe im Seriellen Monitor
  Serial.print(" C\t");                     // Ausgabe im Seriellen Monitor  
  Serial.print("Luftfeuchte: ");            // Ausgabe im Seriellen Monitor
  Serial.print(h);                          // Ausgabe im Seriellen Monitor
  Serial.println(" %");                     // Ausgabe im Seriellen Monitor
  
lcd.setCursor(0, 0);                       // Anfang auf Stelle 0, Zeile 0 setzen
lcd.print("Temp. :");                      // Temp. : auf LCD ausgeben
lcd.setCursor(9, 0);                       // Anfang auf Stelle 9, Zeile 0 setzen
lcd.print(t);                              // Wert aus "t" ausgeben (Temperatur)
lcd.setCursor(15, 0);                      // Anfang auf Stelle 15, Zeile 0 setzen
lcd.print("C");                            // C auf LCD ausgeben
lcd.setCursor(0, 1);                       // Anfang auf Stelle 0, Zeile 1 setzen
lcd.print("Luftf.:");                      // Luft.: auf LCD ausgeben
lcd.setCursor(9, 1);                       // Anfang auf Stelle 9, Zeile 1 setzen
lcd.print(h);                              // Wert aus "h" ausgeben (Luftfeuchtigkeit)
lcd.setCursor(15, 1);                      // Anfang auf Stelle 15, Zeile 1 setzen
lcd.print("%");                            // % auf LCD ausgeben
}

********************************************************I*

26) Lueftersteuerung um den Keller zu trocknen

___________________________________                                                                                                                        
Verwendete Teile:

Arduino R3
Sainsmart 1602 LCD Keypad Shield
optoelektronisches Relais
2x DHT22
___________________________________
Key Codes (in left-to-right order):

None   - 0
Select - 1
Left   - 2
Up     - 3
Down   - 4
Right  - 5
___________________________________

*/

#include <dht.h>
#include <LiquidCrystal.h>
#include <DFR_Key.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);


dht DHT;
DFR_Key keypad;

#define dhtA 12
#define dhtI 13
#define relais 11


int localKey = 0;      //Tastenerkennung
String keyString = ""; //??

double dewPointFast(double celsius, double humidity) //Taupunkt berechnung
{
        double a = 17.271;
        double b = 237.7;
        double temp = (a * celsius) / (b + celsius) + log(humidity/100);
        double Td = (b * temp) / (a - temp);
        return Td;
}

float dewI = 0; //Taupunkt Innen
float dewA = 0; //Taupunkt Aussen
float tempI = 0;//Temperatur Innen
float tempA = 0;//Temperatur Aussen
float humI = 0; //Luftfeuchtigkeit Innen
float humA = 0; //Luftfeuchtigkeit Aussen
int hysterese = 1; //Hysterse (mal 2) für die Schaltung 

long count = 0;  //Counter fuer die Eingabe
int statL = 0;  //Status der Luefter 
int menueH = 0; //Durchs Hauptmenue gehen
//int menueS = 0; //Menue bei Select
int menueC = 0;
int intro = 0;

long previousMillis = 0;
long milliMil = 0;
long milliMin = 0;
long milliStd = 0;



void setup()
{
  Serial.begin(115200); //Verbindung Computer
  pinMode(relais, OUTPUT);
  digitalWrite(relais, HIGH);

  
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Fan Control");
  lcd.setCursor(0, 1);
  lcd.print("Version 0.1.9");
  
  while(intro < 5)
  {
    lcd.setCursor(15, 1);
    lcd.print((char)0x7C);
    delay(500);
    lcd.setCursor(15, 1);
    lcd.print((char)0x2D);
    delay(500);    
    intro++;
  }
  
  delay(2500);  
}

void loop()
{
  unsigned long currentMillis = millis();
  milliMil = currentMillis - previousMillis;
  milliMin = milliMil / 60000;
  milliStd = milliMin / 60;
  
  
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Hello Dave,");
  lcd.setCursor(0, 1);
  lcd.print("I'm very busy");
  
  

    
  DHT.read22(dhtI); //Sensor Innen auslesen
  //delay(500);
  //DHT.read22(dhtI);
  float humI = DHT.humidity;
  float tempI = DHT.temperature;
  float dewI = (dewPointFast(DHT.temperature, DHT.humidity));    
  
  delay(1500);
  
  DHT.read22(dhtA); //Sensor Aussen auslesen
  //delay(500);
  //DHT.read22(dhtA);
  float humA = DHT.humidity;
  float tempA = DHT.temperature;
  float dewA = (dewPointFast(DHT.temperature, DHT.humidity)); 
  
  //dewA = dewA - 5; //Test!!!!!!!!!!!!!!!!!!!
 
  if (dewA <= dewI - hysterese)  //Ueberprueft die Luftfeuchtigkeit schaltet die Luefter und speichert den Status in statL
  {   
    digitalWrite(relais, LOW); //Luefter einschalten
    
    if (statL == 0)
    {
    previousMillis = millis();
    }
    statL = 1;
  }
  
  else if (dewA > dewI + hysterese)
  {
    digitalWrite(relais, HIGH); //Lufter ausschalten
    
    if (statL == 1)
    {
    previousMillis  = millis();
    }
    statL = 0;
    
  }
  
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("HAL:Im waiting");
    lcd.setCursor(0, 1);
    lcd.print("    for command");
    
    
    count = 0; 
 
  while(count < 300000) //Menuefunktion
  {
    keypad.getKey();
    menueH = keypad.getKey();
        
    switch (menueH) //Einzelne Menuepunkte
    {
      case 1:
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Luefter:");
      lcd.setCursor(9, 0);
      Serial.println(statL);//loeschen
      if(statL == 1)
      {
        lcd.print("AN");
      }
      if(statL == 0)
      {
        lcd.print("AUS");
      }
      
      lcd.setCursor(0, 1);
      lcd.print(milliStd);
      lcd.print("Std ");
      lcd.print(milliMin);
      lcd.print("Min ");
      delay(1000);
      break;          
      
      case 2: //Relais ausschalten Pfeil nach links
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Luefter: Aus");
      digitalWrite(relais, HIGH); //Schalte Relais AUS
      delay(1000);//Verzögere um erneute Eingabe zu verhindern
      
      menueC = 0; //setze Schaltzustand auf 0      
      while(menueC != 1) //Manueller Luefter
      {
        keypad.getKey();
        localKey = keypad.getKey();
         
        if (localKey == 2) //Wenn 2 gedrückt wird wird die Schleife beendet
        {
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("Automatikmodus");
          lcd.setCursor(0, 1);
          lcd.print("ist AN");
          previousMillis  = millis(); //setze Timer auf Null
          digitalWrite(relais, HIGH); //Schaltet Luefter wegen Hysterese aus!
          delay(1000);
          menueC = 1; //beende Schleife
        }
         
      }
      break;
      
        
      case 3: //Anzeige Daten Aussen Pfeil nach oben
  
      //Erste Zeile
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Aussen: ");
      
      lcd.print(dewA);
      lcd.print((char)223);
      lcd.print("C");
  
      //Zweite Zeile
      lcd.setCursor(0, 1);
      lcd.print(tempA);
      lcd.print((char)223);
      lcd.print("C ");
  
      lcd.print(humA);
      lcd.print((char)0x25);
      delay(1000);
      break;
      
      case 4: //Anzeige Daten Keller Pfeil nach unten
  
      //Erste Zeile
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Keller: ");
  
      lcd.print(dewI);
      lcd.print((char)223);
      lcd.print("C");
  
      //Zweite Zeile
      lcd.setCursor(0, 1);
  
      lcd.print(tempI);
      lcd.print((char)223);
      lcd.print("C ");
  
      lcd.print(humI);
      lcd.print((char)0x25);
      delay(1000);
      break;
      
      case 5: //Luefter einschalten Pfeil nach rechts
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Luefter: An");
      digitalWrite(relais, LOW); //Schalte Relais AN
      delay(1000);//Verzögere um erneute Eingabe zu verhindern
      
      menueC = 0; //setze Schaltzustand auf 0      
      while(menueC != 1) //Manueller Luefter
      {
        keypad.getKey();
        localKey = keypad.getKey();
         
        if (localKey == 5) //Wenn 5 gedrückt wird wird die Schleife beendet
        {
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("Automatikmodus");
          lcd.setCursor(0, 1);
          lcd.print("ist AN");
          previousMillis  = millis(); //setze Timer auf Null
          digitalWrite(relais, HIGH); //Schaltet Luefter wegen Hysterese aus!
          delay(1000);
          menueC = 1; //beende Schleife
        }
         
      }
      break;
    }
      
    if(menueH != SAMPLE_WAIT) //Setzt den Counter auf Null wenn Eingabe erfolgt ist.
    {
      count = 0;
    }
    
    
    else   
    {
      count++; //Ohne Einmgabe laueft der Counter
    } 
    
    
 }
 
 
  Serial.println ("Innensensor:");
  Serial.print ("humI: ");
  Serial.println (humI);
  Serial.print ("tempI: ");
  Serial.println (tempI);
  Serial.print ("dewI: ");
  Serial.println (dewI);
  Serial.println ("");
  
 
  Serial.println ("Aussensensor:");
  Serial.print ("humA: ");
  Serial.println (humA);
  Serial.print ("tempA: ");
  Serial.println (tempA);
  Serial.print ("dewA: ");
  Serial.println (dewA);
  Serial.println ("____________________");

}

http://forum.arduino.cc/index.php?topic=175778.15

********************************************************I*
27.1)Temperatur- und Feuchtigkeitsdaten auf SD-Karte zu schreiben

Datenlogger / Datalogger

DHT22

SD card Temp & Humidity datalogger

/*
SD card Temp & Humidity datalogger

This example shows how to log data from
a DHT11 temperature and humidity sensor
to an SD card using the SD library.

It also uses the Adafruit DHT sensor library from
https://github.com/adafruit/DHT-sensor-library

The circuit:
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 53
* DHT11 sensor connected as follows:
** Ground connected to 5
** Voltage connected to 8
** data out connected to 7
** 10K resistor connected from 7 to +5V


*/

#include <SD.h>
#include "DHT.h"
#include <Time.h>
#include <Wire.h>
#include <DS1307RTC.h>

#define DHTPIN 24 // what pin the sensor is connected to
#define DHTTYPE DHT11 // Which type of DHT sensor you're using:
#define DHT_GND 26 // ground pin of the sensor
#define DHT_VCC 22 // voltage pin of the sensor
#define TEMPERATURE 1 // for the DHT sensor
#define HUMIDITY 0 // for the DHT sensor
#define fehler 13

// initialize the sensor:
DHT dht(DHTPIN, DHTTYPE);
// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 53; // 4,10,53

void setup() {
pinMode(fehler, OUTPUT);
setSyncProvider(RTC.get); // the function to get the time from the RTC

if (startSDCard() == true) {
pinMode(DHT_VCC, OUTPUT);
pinMode(DHT_GND, OUTPUT);
digitalWrite(DHT_VCC, HIGH);
digitalWrite(DHT_GND, LOW);
dht.begin();
}
}

void loop()
{
// Get the current time in ms:

long currentTime = millis();
delay(29250);// normalmodus
// delay(250); //test schnelle ergebnisse
digitalWrite(fehler, HIGH);
delay(250);
digitalWrite(fehler, LOW);
delay(250);
digitalWrite(fehler, HIGH);
delay(250);
digitalWrite(fehler, LOW);
float humidity = readSensor (HUMIDITY);
float temperature = readSensor(TEMPERATURE);
File dataFile = SD.open("datalog.csv", FILE_WRITE);
dataFile.print(humidity);
dataFile.print(";");
dataFile.println(temperature);
dataFile.print("; ");
dataFile.print(day());
dataFile.print(":");
dataFile.print(month());
dataFile.print(":");
dataFile.print(year());
dataFile.print("; ");
dataFile.print(hour());
dataFile.print(":");
dataFile.print(minute());
dataFile.print(":");
dataFile.print(second());
dataFile.print("; ");

dataFile.close();

}


boolean startSDCard() {
boolean result = false;
// Serial.print("Initializing SD card...");
// make sure that the default chip select pin is set to
// output, even if you don't use it:
pinMode(53, OUTPUT);

// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
result = false;
}
else {
File dataFile = SD.open("datalog.csv", FILE_WRITE);
if (dataFile) {
dataFile.close();
result = true;
}
}
return result;
}


float readSensor( int thisValue) {
float result;

if (thisValue == TEMPERATURE) {
result = dht.readTemperature();
}
else if (thisValue == HUMIDITY) {
// read sensor:
result = dht.readHumidity();
}

if (isnan(result)) {
result = -273.0;
}
return result;
}

https://www.arduinoforum.de/arduino-Thread-Programm-um-Temperatur-und-Feuchtigkeitsdaten-auf-Sd-Karte-zu-schreiben

27.2) Luftfeuchtigkeitsregulierung mit Arduino

// Written by Mark Kingery (Mark(AT)Kingery.de), GPLV3
// DHT22 Library written by ladyada, public domain
//https://github.com/adafruit/DHT-sensor-library

// Abs. Feuchte=13,233*rel.Feuchte*((10^((7,5*T)/(237+T)))/(273,16+T))
//T=Lufttemperatur
// Sensor 1 indoor
// Sensor 2 outdoor
// this program may not be good looking but I`m staisfied

#include "DHT.h"
#include <math.h>
#include <SPI.h> // needed in Arduino 0019 or later
#include <Ethernet.h>
#include <Twitter.h>
#define DHTPIN1 6   // what pin we're connected to
#define DHTPIN2 7   // 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)
// Ethernet Shield Settings
byte mac[] = { 0x00, 0x80, 0x41, 0x3F, 0x1E, 0xED }; //Robotron MAC Adresse

// If you don't specify the IP address, DHCP is used(only in Arduino 1.0 or later).
byte ip[] = { 192, 168, 1, 10 };

// Your Token to Tweet (get it from http://arduino-tweet.appspot.com/)
Twitter twitter("xxx"); //xxx durch eigenen Token ersetzen


// Connect pin 1 (on the left) of the sensor to +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
int led = 5;
DHT dht1(DHTPIN1, DHTTYPE);
DHT dht2(DHTPIN2, DHTTYPE);

char tmp[10];
char tosend[140];

void setup() {
  Serial.begin(9600);
  Serial.println("DHTxx test!");
pinMode(led, OUTPUT);

  dht1.begin();
  dht2.begin();
}

void loop() {
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h1 = dht1.readHumidity();
  int t1 = dht1.readTemperature();
float h2 = dht2.readHumidity();
  float t2 = dht2.readTemperature();
float hA1 = 0;
float hA2 = 0;

  // check if returns are valid, if they are NaN (not a number) then something went wrong!
  if (isnan(t1) || isnan(h1)) {
    Serial.println("Failed to read from DHT");
  } else {
    
  double x = 0;
  double y = 0;
  double z = 0;
  x= 13.233*h1;
  y=7.5*t1;
  z = 237+t1;
  y = y/z;
float m = pow(10,y);
  z = 273+t1;
  m=m/z;

  hA1=m*x;
    Serial.print("Humidity1: ");
    Serial.print(h1);
    Serial.print(" %\t");
    Serial.print("Temperature1: ");
    Serial.print(t1);
    Serial.println(" *C");
    Serial.print("HumidityA1: ");
    Serial.print(hA1);
    Serial.println(" g");
  }





  if (isnan(t2) || isnan(h2)) {
    Serial.println("Failed to read from DHT");
  } else {
  
  double x = 0;
  double y = 0;
  double z = 0;
  x= 13.233*h2;
  y=7.5*t2;
  z = 237+t2;
  y = y/z;
float m = pow(10,y);
  z = 273+t2;
  m=m/z;

  hA2=m*x;
    Serial.print("Humidity2: ");
    Serial.print(h2);
    Serial.print(" %\t");
    Serial.print("Temperature1: ");
    Serial.print(t2);
    Serial.println(" *C");
    Serial.print("HumidityA2: ");
    Serial.print(hA2);
    Serial.println(" g");
  }



  if (hA1 > hA2)
  {
  Serial.println(" fan on !");
  strcat (tosend, "fan K1 on !!! ");
  digitalWrite(led, LOW);   // turn the LED on (HIGH is the voltage level)
  } else {
    Serial.println(" fan off !");
    strcat (tosend, "fan K1 off !!! ");
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  }
  //strcat (tosend, "                                                                                                                                        ");

  strcat (tosend, "Temp. inside ");
  itoa((int)t1, tmp, 10); strcat (tosend, tmp);
  strcat (tosend, "°c ");
  strcat (tosend, "Hum. inside ");
  itoa((float)h1, tmp, 10); strcat (tosend, tmp);
  strcat (tosend, "% ");
  strcat (tosend, "H2O ");
  itoa((float)hA1, tmp, 10); strcat (tosend, tmp);
  strcat (tosend, "g/m^3 ");

    strcat (tosend, "Temp. outside ");
  itoa((float)t2, tmp, 10); strcat (tosend, tmp);
  strcat (tosend, "°c ");
  strcat (tosend, "Hum. outside ");
  itoa((float)h2, tmp, 10); strcat (tosend, tmp);
  strcat (tosend, "% ");
    strcat (tosend, "H2O ");
  itoa((float)hA2, tmp, 10); strcat (tosend, tmp);
  strcat (tosend, "g/m^3 ");
  Serial.print(tosend);
  delay(86400);//1000 mal am Tag Twittern
  //delay(10000);
  Ethernet.begin(mac, ip);
  // or you can use DHCP for autoomatic IP address configuration.
  // Ethernet.begin(mac);

  if (twitter.post(tosend)) {
    // Specify &Serial to output received response to Serial.
    // If no output is required, you can just omit the argument, e.g.
    // int status = twitter.wait();
    int status = twitter.wait(&Serial);
    if (status == 200) {
      Serial.println("OK.");
    } else {
      Serial.print("failed : code ");
      Serial.println(status);
    }
  } else {
    Serial.println("connection failed.");
  }
tosend[0] = '\0';
}

https://www.arduinoforum.de/arduino-Thread-Luftfeuchtigkeitsregulierung-mit-Arduino

********************************************************I*

28) BOSCH Barometer Sensor BME280 - Erfahrungen

Ich möchte hier kurz meine Erfahrungen mit dem BME280 von Bosch mitteilen.
Um Freude zu haben, sollte man einige Punkte beachten:

1. Der gemessene Luftdruck (zuerst die Temperatur auslesen, sonst fehlt der notwendige Kalibrierwert!) stimmt erstens und zeigt zweitens den Luftdruck an dem Ort an, wo der Sensor sich tatsächlich befindet.
Also bitte nicht im Zimmer messen, wenn man eine Wetterstation für draußen bauen will.
Der ausgegebene Wert für den Luftdruck entspricht aber jenem für die aktuelle Höhe und die aktuelle Temperatur.
Das ev vorhandene Barometer zeigt aber wahrscheinlich den auf Meeresniveau "reduzierten" Wert (ist also höher als der vom BME280 angezeigte Wert).
Will man überprüfen, ob beide Geräte übereinstimmen, muß man den vom BME280 ausgegebenen Wert auf "Meeresniveau" umrechnen.

Ch hat einen Wert von 0.12 K/hPa

Das geht so:pNN = ph * e (g*h/(R*(T+Ch*E+a*h/2)))E = 6,112hPa * e (17,62*t(°C)/(243,12+t(°C)))   ACHTUNG: Magnusformel mit Koeffizienten für t = -45 bis +60°Ca = (Tm-Tb)/(hm-hb)    m ... Meßort  b ... Bezugsort- pNN ist der auf Meeresniveau umgerechnete Luftdruckwert in hPa- ph ist der vom BME280 ausgegebene tatsächliche Luftdruckwert am Meßort - in hPa- e ist die e-Funktion- g ist die Erdbeschleunigung, am 50. Breitengrad beträgt g=9,80665 m/s²- h ist die Höhe (m) über Meeresniveau am Meßort- R ist die Gaskonstante der Luft 287,058 J/(kg*K)- t(°C) ist die Temperatur in °C am Meßort- T ist die Temperatur in Kelvin T(K)=273,15+t(°C)- Ch ist der Beiwert zu E zur Berücksichtigung der mittleren Dampfdruckänderung mit der Höhe (K/hPa)- E (hPa) ist der Wasserdampfpartialdruck- a (K/m) ist der vertikale Temperaturgradienta ist oft unter Durchschnitts-Meeresniveau-Stardardbedingungen (t=15°C, pb=1013.25hPa, h=0m) mit 0.0065 angegeben - stimmt jedoch nicht wirklich, da durchaus in der Realität beträchtliche Abweichungen auftreten können >> also: besser selber berechnen!Zur Überprüfung kann man den Meßwert des BME280 mit dem aus der Barometrischen Höhenformel ausgerechneten Wert vergleichen:pz=pb*((1-a*(hz-hb)/(273,15+tb))^(0,03416/a))a wird wie weiter oben berechnet, z bedeutet Werte am Zielort, b sind BEKANNTE Werte am Bezugsort (von einer offiziellen, naheliegenden meteorologischen Station abzufragen)2. die gemessene Temperatur gibt lediglich einen Anhalt über die Umgebungstemperatur des BME280 (siehe Datenblatt). Wer genaue Werte für die Lufttemperatur haben will, muß schon einen externen Sensor (zB DS18B20) bemühen.3. man findet in Softwarebibliotheken (va Arduino-Bibliotheken - Adafruit weist jedoch darauf hin!) häufig Funktionen, welche die Seehöhe=Höhe über Meeresniveau, berechnet aus den BME280-Meßwerten, ausgeben. Das ist leider völlig falsch!! Ohne einen genau bekannten Referenzpunkt (p,T auf Seehöhe oder besser einen naheliegenden Ort plus p,T am Zielort) kann die Höhe am Zielort aus den Sensorwerten NICHT ermittelt werden.4. man kann weiters auch die Absolute LuftfeuchteaF(kg/m³)=rF*E/(Rw*T)*10mit Rw=461,51 J/(kg*K) und rF (relative Feuchte) als Quotient (nicht als%-Zahl!)und den Taupunkt (wieder Magnusformel für t=-45 bis +60°C heranziehen)τ(φ,ϑ) = K3 ⋅ ((K2 ⋅ ϑ)/(K3 + ϑ) + ln⁡ φ)/(K2 ⋅ K3/(K3 + ϑ) − lnφ)φ: relative Luftfeuchte (Quotient)     ϑ: Temperatur in °CK1=6.112hPaK2=17,62K3=243,12Kaus den Meßwerten herleiten (Details bitte aus dem Internet entnehmen).
Anbei ein rasch zusammengezimmertes Beispiel für obige Überlegungen mit der Sparkfun-Bibliothek und dem umgebauten Sparkfun-Beispiel:

******************************************************************************Board:  Arduino UNOSensor: BME280ACHTUNG: bei der Berechnung der Seehöhe muß man den aktuellen Luftdruckwert (Pa)          auf Meeresniveau als Parameter übergeben >> sonst kommt Mist heraus******************************************************************************/#include <stdint.h>#include "SparkFunBME280.h"//Library allows either I2C or SPI, so include both.#include "Wire.h"#include "SPI.h"#include <math.h>#define a 0.00602      // ACHTUNG: 0.0065 gilt nur für Standardbedingungen h=0m T=15°C p=1013,25hPa                      // besser aktuell berechnen: a= (Tz-Tb)/(hz-hb)   z=Zielpunkt   b=Bezugspunkt (kann Ort am Meer sein)#define pSL 100800.0//Global sensor objectBME280 mySensor;float La, RH, TP, E, H, T, pNN, pH;void setup(){  //***Driver settings********************************//  //commInterface can be I2C_MODE or SPI_MODE  //specify chipSelectPin using arduino pin names  //specify I2C address.  Can be 0x77(default) or 0x76    //For I2C, enable the following and disable the SPI section  //mySensor.settings.commInterface = I2C_MODE;  //mySensor.settings.I2CAddress = 0x77;    //For SPI enable the following and dissable the I2C section  mySensor.settings.commInterface = SPI_MODE;  mySensor.settings.chipSelectPin = 10;  //***Operation settings*****************************//    //renMode can be:  //  0, Sleep mode  //  1 or 2, Forced mode  //  3, Normal mode  mySensor.settings.runMode = 3; //Normal mode    //tStandby can be:  //  0, 0.5ms  //  1, 62.5ms  //  2, 125ms  //  3, 250ms  //  4, 500ms  //  5, 1000ms  //  6, 10ms  //  7, 20ms  mySensor.settings.tStandby = 0;    //filter can be off or number of FIR coefficients to use:  //  0, filter off  //  1, coefficients = 2  //  2, coefficients = 4  //  3, coefficients = 8  //  4, coefficients = 16  mySensor.settings.filter = 0;    //tempOverSample can be:  //  0, skipped  //  1 through 5, oversampling *1, *2, *4, *8, *16 respectively  mySensor.settings.tempOverSample = 1;  //pressOverSample can be:  //  0, skipped  //  1 through 5, oversampling *1, *2, *4, *8, *16 respectively    mySensor.settings.pressOverSample = 1;    //humidOverSample can be:  //  0, skipped  //  1 through 5, oversampling *1, *2, *4, *8, *16 respectively  mySensor.settings.humidOverSample = 1;    Serial.begin(57600);  Serial.print("Program Started\n");  Serial.print("Starting BME280... result of .begin(): 0x");    //Calling .begin() causes the settings to be loaded  delay(10);  //Make sure sensor had enough time to turn on. BME280 requires 2ms to start up.  Serial.println(mySensor.begin(), HEX);  Serial.print("Displaying ID, reset and ctrl regs\n");    Serial.print("ID(0xD0): 0x");  Serial.println(mySensor.readRegister(BME280_CHIP_ID_REG), HEX);  Serial.print("Reset register(0xE0): 0x");  Serial.println(mySensor.readRegister(BME280_RST_REG), HEX);  Serial.print("ctrl_meas(0xF4): 0x");  Serial.println(mySensor.readRegister(BME280_CTRL_MEAS_REG), HEX);  Serial.print("ctrl_hum(0xF2): 0x");  Serial.println(mySensor.readRegister(BME280_CTRL_HUMIDITY_REG), HEX);  Serial.print("\n\n");  Serial.print("Displaying all regs\n");  uint8_t memCounter = 0x80;  uint8_t tempReadData;  for(int rowi = 8; rowi < 16; rowi++ )  {    Serial.print("0x");    Serial.print(rowi, HEX);    Serial.print("0:");    for(int coli = 0; coli < 16; coli++ )    {      tempReadData = mySensor.readRegister(memCounter);      Serial.print((tempReadData >> 4) & 0x0F, HEX);//Print first hex nibble      Serial.print(tempReadData & 0x0F, HEX);//Print second hex nibble      Serial.print(" ");      memCounter++;    }    Serial.print("\n");  }      Serial.print("\n\n");    Serial.print("Displaying concatenated calibration words\n");  Serial.print("dig_T1, uint16: ");  Serial.println(mySensor.calibration.dig_T1);  Serial.print("dig_T2, int16: ");  Serial.println(mySensor.calibration.dig_T2);  Serial.print("dig_T3, int16: ");  Serial.println(mySensor.calibration.dig_T3);    Serial.print("dig_P1, uint16: ");  Serial.println(mySensor.calibration.dig_P1);  Serial.print("dig_P2, int16: ");  Serial.println(mySensor.calibration.dig_P2);  Serial.print("dig_P3, int16: ");  Serial.println(mySensor.calibration.dig_P3);  Serial.print("dig_P4, int16: ");  Serial.println(mySensor.calibration.dig_P4);  Serial.print("dig_P5, int16: ");  Serial.println(mySensor.calibration.dig_P5);  Serial.print("dig_P6, int16: ");  Serial.println(mySensor.calibration.dig_P6);  Serial.print("dig_P7, int16: ");  Serial.println(mySensor.calibration.dig_P7);  Serial.print("dig_P8, int16: ");  Serial.println(mySensor.calibration.dig_P8);  Serial.print("dig_P9, int16: ");  Serial.println(mySensor.calibration.dig_P9);    Serial.print("dig_H1, uint8: ");  Serial.println(mySensor.calibration.dig_H1);  Serial.print("dig_H2, int16: ");  Serial.println(mySensor.calibration.dig_H2);  Serial.print("dig_H3, uint8: ");  Serial.println(mySensor.calibration.dig_H3);  Serial.print("dig_H4, int16: ");  Serial.println(mySensor.calibration.dig_H4);  Serial.print("dig_H5, int16: ");  Serial.println(mySensor.calibration.dig_H5);  Serial.print("dig_H6, uint8: ");  Serial.println(mySensor.calibration.dig_H6);      Serial.println();  delay(5000);}void loop(){  //Each loop, take a reading.  //Start with temperature, as that data is needed for accurate compensation.  //Reading the temperature updates the compensators of the other functions  //in the background.  T=mySensor.readTempC();  Serial.print("Temperatur: ");  Serial.print(T,2);  Serial.println(" °C");  /*Serial.print("Temperature: ");  Serial.print(mySensor.readTempF(), 2);  Serial.println(" degrees F");*/  pH=mySensor.readFloatPressure()/100.0;  Serial.print("Luftdruck vor Ort: ");  Serial.print(pH, 2);  Serial.println(" hPa");  H=mySensor.readFloatAltitudeMeters(pSL);  E=6.112*exp((17.62*T)/(243.12+T));  pNN=pH*exp(9.80665*H/(287.058*((273.15+T)+0.12*E+a*H/2)));  Serial.print("Luftdruck reduziert: ");  Serial.print(pNN, 2);  Serial.println(" hPa");  Serial.print("Höhe über Meer: ");  Serial.print(H, 2);  Serial.println("m");  /*Serial.print("Altitude: ");  Serial.print(mySensor.readFloatAltitudeFeet(), 2);  Serial.println("ft"); */  RH=mySensor.readFloatHumidity();  Serial.print("Relative Luftfeuchte: ");  Serial.print(RH, 2);  Serial.println(" %");  La=RH*E/(461.51*(273.15+T))*10000.0;  Serial.print("Absolute Luftfeuchte: ");  Serial.print(La, 2);  Serial.println(" g/m³");  TP=243.12*((17.62*T)/(243.12+T)+log(RH/100.0))/((17.62*243.12)/(243.12+T)-log(RH/100.0));  Serial.print("Taupunkt: ");  Serial.print(TP, 2);  Serial.println(" °C");        Serial.println();    delay(5000);}

https://www.mikrocontroller.net/topic/415860

********************************************************I*

********************************************************I*

30) Schimmelvermeidung - Richtig Lüften und Entfeuchten

• Absolute Luftfeuchtigkeit:
  
• Sagt aus, wieviel Masse an Wasser ist in einem bestimmten Volumen Luft enthalten ist.
  
• Dieser Wert ist nicht temperaturabhäng - was logisch ist: Heizt man einen luftdichten Raum auf, ist danach die gleiche Masse Wasser in der Luft wie vorher. Ändert man also nur die Lufttemperatur, bleibt die absolute Luftfeuchte gleich.
  
• Die absolute Luftfeuchte in einem Raum kann also nur durch Lüften oder Entfeuchten geändert werden.
  
• Relative Luftfeuchtigkeit:
  
•  Man stelle sich die Luft als Schwamm vor.
  
• Die relative Luftfeuchtigkeit gibt in Prozent an, wie voll der Schwamm (die Luft) in Prozent mit Wasser vollgesogen ist. Bei 100% ist der Schwamm voll und tropft - im Fall der Luft bedeutet das: Das Wasser kondensiert. Die Fähigkeit der Luft, Wasser zu speichern, ist stark temperaturabhäng. Kalte Luft kann kaum Wasser aufnehmen (die 100% sind schnell erreicht), warme Luft viel mehr.
  
• Man kann die relative Luftfeuchtigkeit also - im Gegensatz zur absoluten - auch durch Heizen senken.
• Taupunkttemperatur:
  
• Das ist die hypothetische Temperatur, bei der die relative Luftfeuchte - ausgehend von einer aktuellen Temperatur und gleichzeitig gemessener Luftfeuchtigkeit - genau 100% betragen würde.
  
• Ist eine Stelle im Raum kälter, ist dort die Luftfeuchtigkeit bei über 100% und Wassertropfen kondensieren.

https://forum.fhem.de/index.php?topic=29773.0

********************************************************I*

31) Absolute Luftfeuchtigkeit berechnen

• I1 ... Temperatur (in °C)
• I2 ... Relative Luftfeuchtigkeit (in %)
• I3 ... Aktueller Luftdruck (in Millibar)
• Für den Vergleich Innen <-> Außen benötigst du die Temperatur und die relative Luftfeuchtigkeit von innen und außen.
  
• Den Luftdruck benötigst du nur einmal, da der innen und außen gleich ist.
  
• Die Daten für außen können natürlich auch von einem Wetterdienst kommen.

Der Ausgang gibt Gramm Wasser pro Kubikmeter Luft (g/m³) aus.

Loxone Konfiguration

Beispiel-Download: Abs Feuchte.zip

Formel

********************************************************I*

32) Experimente im Physikunterricht unter Verwendung der ARDUINO Entwicklungsumgebung

Diplomarbeit  2016-09  UNI Graz   +++ (1A) Grundlagen unbedingt lesen

********************************************************I*

33) Arduino – Temperatur und Luftfeuchtigkeit mit dem DHT22 prüfen

https://github.com/adafruit/DHT-sensor-library

http://fluuux.de/2012/10/arduino-temperatur-und-luftfeuchtigkeit-mit-dem-dht22-prufen/

********************************************************I*

34.1) Feuchte Wände

Die meisten Altbaubewohner kennen das Problem: Die Wand fühlt sich kalt und feucht an, erste Spuren von Schimmel sind vielleicht schon vorhanden. Das Bekämpfen der Symptome mittels Schimmelentferner hat keinen langfristigen Erfolg. Aber um das Übel an der Wurzel zu packen, muss die Ursache bekannt sein. Dieser Artikel soll Ihnen bei der “Spurensuche” helfen.

Angenommen, wir haben unsere Raumluft auf 22°C aufgeheizt, um die “Kältestrahlung” der nicht isolierten Wände zu kompensieren.
Während wir schlafen produzieren wir 50g Wasserdampf pro Stunde.
Nach einer Nacht mit geschlossenem Fenster beträgt die relative Luftfeuchtigkeit im Schlafzimmer 70%.
Der Taupunkt liegt dementsprechend bei 16,3°C.
Die Schlafzimmeraußenwand kühlt in kalten Nächten auf unter 15°C ab.
Luft, die hier vorbeistreicht, kühlt unter die Taupunkttemperatur von 16,3°C ab.
Das überschüssige Wasser kondensiert an der Wand und wird von der Tapete aufgenommen.

http://www.bastelitis.de/feuchte-wande/

34.2) Temperaturen messen mit dem Arduino

1Wire-Temperatursensoren DS18S20

Sketch für die Arduino-Entwicklungsumgebung

********************************************************I*

35) Das h,x-Diagramm nach Mollier

400_d_Acker-x_Das h,x-Diagramm nach Mollier - Aufbau und Anwendung (42 Seiten)_1a.pdf

********************************************************I*

36) ARDUINO Temperature Sensors DHT22 versus DS18B20

/*www.geekstips.comTemperature sensor comparison - DHT22 vs DS18B20 | Arduino tutorial*/#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");}

https://www.geekstips.com/temperature-sensor-dht22-ds18b20-arduino-tutorial/#more-190

********************************************************I*

37) Temperaturüberwachung mit  TMP36 auf pin-A0

Frost- und Hitzealarm  (UGW IO OGW)   4°C & 25°C

http://ecotronics.ch.honorius.sui-inter.net/wordpress/2012/arduino-projekt-temperaturuberwachung/

********************************************************I*

https://funduino.de/

38) Arduino: Temperatur & Luftfeuchtigkeit auf einem LCD-Display

Anleitung zum LCD Display mit I2C Anschluss

I2C / Schnittstellen LCD1602 2004 LCD-Adapterplatte für Arduino

Verbinden des LCD-Displays mit dem Portexpander PCF8574

https://dev-blog.vcp.de/temperatur-luftfeuchtigkeit-auf-einem-lcd-display/

********************************************************I*

39) Temperatur mit DS18S20, Kommastellen

https://www.arduinoforum.de/arduino-Thread-Temperatur-mit-DS18S20-Kommastellen

********************************************************I*

40) Arduino und DHT22 (AM2302) Temperaturmessung

https://www.roboter-bausatz.de/2358/uno-plus-verbessertes-arduino-board

Waveshare UNO PLUS  - verbessertes ARDUINO UNO R3 Board  EXP-R63-033   € 19,95

https://www.exp-tech.de/en/platforms/arduino/7516/uno-plus-arduino-uno-r3-compatible

ist ARDUINO Uno R3 Kompatibel

UNO+

www.hobbycomponents.com  

https://www.waveshare.com/wiki/UNO_PLUS

https://www.waveshare.com/wiki/UNO_PLUS

https://www.waveshare.com/w/upload/0/0d/UNO-PLUS-Schematic.pdf

    1. ATmega328P-AU
    2. AMS1117-3.3:             3,3V  Spannungsregler
    3. NCP1117ST50T3G:    5,0V Spannungsregler
    4. FT232RL: USB zu UART Konverter / Wandler
    5. Arduino-Schnittstelle
        kompatibel mit Standard-Arduino-Schnittstelle mit zwei zusätzlichen Analog-Eingängen A6 (Config der CFG), A7
        Lötpads auf der Unterseite, um das Board mit Hilfe von Stiftleisten Breadboardtauglich zu machen

    6. ICSP-Schnittstelle
    7. Micro-USB-Anschluss: zum Hochladen von Programm- oder seriellen Port-Debugging
    8. Leistungsausgang: 3,3 V ODER 5,0 V, Spannungspegel, konfiguriert durch den Onboard-Leistungskonfigurationsschalter, verwendet als Leistungsausgang ODER gemeinsame Erdung mit anderen Boards

8.Power output header : 3.3V ODER 5V Power output oder common ground für andere Boards, der Spannungspegel wird durch den power jumper(#15) bestimmt.

   9. FT232 Pins: zum Brennen des Bootloaders auf den Chip /  in den Mikrocontroller
    10. Gleichstrom-Eingang: 7,0Vdc bis 12Vdc
    11. Reset-Knopf
    12. Power Anzeige  = Betriebsanzeige
    13. Serielle Schnittstelle Rx / Tx-Anzeige
    14. Benutzer-LED
    15. Stromkonfigurationsschalter: zum Konfigurieren der Betriebsspannung / Power jumper : zum Einstellen des Spannungspegel

    16. Bootloader-Auswahlschalter
        Einschalten: Die Karte wird zurückgesetzt, wenn das Einschalten oder andere USB-Geräte erkannt wurden, die mit dem PC verbunden sind
        Ausschalten: Das Onboard-Programm läuft sofort nach dem Einschalten und die Karte wird nicht zurückgesetzt, wenn andere USB-Geräte erkannt wurden, die eine Verbindung zum PC herstellen

https://www.waveshare.com/UNO-PLUS.htm
https://www.waveshare.com/wiki/UNO_PLUS

UNO PLUS Features

UNO PLUS is a development board compatible with the Arduino UNO R3, an improved & enhanced alternative solution for Arduino UNO R3.

UNO PLUS Vs UNO R3：

********************************************************I*

41) Eine Wetterstation mit dem Arduino selbst erstellen und programmieren

KURD

In dieser Lernumgebung baust du selber eine kleine Wetterstation. Dabei lernst du Schritt für Schritt wie man einen Arduino programmiert und die wichtigsten physikalischen Grundlagen zur Wetterkunde.

Für WEN ist der Kurs? 

Der Kurs ist für Anfänger. Du brauchst keine Vorkenntnisse im Umgang mit dem Arduino und kein spezielles Vorwissen in Physik dazu.

Grundlagen:

Aufgaben:

https://arduinoimphysikunterricht.wordpress.com/unterrichtsbeispiele-und-kurse/kurs-thermodynamik-eine-wetterstation/lernumgebung-wetter/
https://arduinoimphysikunterricht.wordpress.com/unterrichtsbeispiele-und-kurse/kurs-thermodynamik-eine-wetterstation/
https://arduinoimphysikunterricht.wordpress.com/unterrichtsbeispiele-und-kurse/kurs-thermodynamik-eine-wetterstation/lernumgebung-wetter/aufgabe-8/

********************************************************I*