ESP8266 AM2302 (DHT22) Sensor für Akkubetrieb, ein Projekt zum Mitmachen! (3-2)

Als letztes Programm bei diesem Mitmach-Projekt folgt nun das eigentlich wichtige Programm,
es nutzt den Sensor zur Langzeitdatenerfassung im reinen Akkubetrieb.

Der ESP8266 befindet sich also so lange wie immer möglich im DEEP-Sleep Modus.

Gleich vorweg muss dazu gesagt werden das die Abstände zwischen den Messungen nun mindestens
15 Minuten betragen um eine lange Akkulaufzeit zu erhalten.

Es geht hier also um eine Langzeitdatenerfassung mit max. 96 Einzelwerten pro Tag.

Bei fast leerem Akku erhält man in der Final Version dann über den Dienst Pushingbox eine Mail damit man den Akku rechtzeitig aufladen kann.

Über folgendes Menü kann man wieder zu den einzelnen Punkten dieses Teils der Anleitung springen.

Download der Software als ZIP-Archiv

Quellen der benutzen Libraries

Programm 2 Messen der Werte und Übertragung an ThingSpeak
Erklärung von Programm 2
Programm 3 zusätzliche Übertragung der Werte an PC-Client o. externen Server
Erklärung von Programm 3

Im Download Archiv sind bereits alle Programme (teilweise Vorabversionen) enthalten, wer also schon einmal spicken will… 🙂

Allen folgenden Programmen gemein ist die automatische Update-Funktion über den Blog-Server, man muss also nicht immer selber die Software auf das ESP8266 Modul übetragen, dies geschieht immer dann wenn eine neue Software veröffentlicht wird. Die Software wird vor jeder Datenübertragung nach neuen Updates suchen.


Hier nun das erste Programm dieses letzten Teils des Projektes. Im Downloadarchiv ist es zu finden unter dem Namen DHT22_SENSOR_DEEP_SLEEP.ino .

/* EEPROM Aufteilung für Konfigurationsdaten
Position     Länge    Wert
0            1        Firststart Flag
1            1        Updateintervall
2            1        Connectiontimeout
3            1        Flag für zu viele Connection Timeouts -> SETUP Modus wird aktiviert bei 3 aufeinanderfolgenden Timeouts
4            1        IP Typ 0=DHCP, 1=Statisch
5            4        IP-Adresse
9            4        Gateway IP-Adresse
13           4        Subnet Mask
17           4        DNS-Server IP-Adresse
18-20        3        Frei
21-52        32       WLAN SSID
53-116       64       WLAN PWD
117-148      32       SENSORSSID
149-212      64       SENSORPWD
213-237      25       Standort
238          1        Frei
239-255      16       Thingspeak API-Key
256-271      16       Pushingbox Scenario Device-ID
*/

/* RTC-Ram Aufteilung für Flags
Position     Wert
0            Startmodus Flag
1            Anzahl Wakeups
*/

#include <ESP8266WiFi.h>
#include <ESP8266httpUpdate.h>
#include <DNSServer.h>
#include <EEPROM.h>
#include <DHT.h>

extern "C" {
  #include "user_interface.h"
}

#define RESETPIN 2             
#define DHTPIN 4             
#define LEDPIN 5             
#define DHTPOWERPIN 14
#define DHTTYPE DHT22        
#define RTC_BASE 28
#define RTC_RAM_ARRAY_SIZE 2

ADC_MODE(ADC_VCC);                                  //Der ADC wird so konfiguriert das er die Systemspannung misst, es darf nichts am ADC (TOUT) Pin angechlossen sein!

const String SOFTWAREVERSION="2.020316.F";          //Version der Software (X.YYYYYY.Z X = Build des Tages, Y = Datum, Z = Typ (Z=Zwischenversion, F=Finale Version))

//Variablen werden mit EEPROM Konfiguration überschrieben wenn FirstStartFlag im EEPROM = 111 (bedeutet Sensor ist konfiguriert) ist!
byte FIRSTSTARTFLAG=0;                              //Flag zur Erkennung ob System im Setup Modus starten muss weil es keine Konfiguration im EEPROM hat
byte UPDATEINTERVAL=15;                             //Aktualisierungsinterval für den Thingspeak Channel in Minuten (Mindestens 15 lt. Thingspeak gewünscht 😉 )
byte CONNECTIONTIMEOUT=60;                          //Verbindungstimeout für die Verbindung mit unserem WLAN (Sekunden)
byte STATICIP=0;                                    //Art der IP-Adresszuteilung 0=IP per DHCP, 1=Statische IP
String THINGSPEAKAPIKEY="";                         //Write Key des Thingspeak Channels
String PUSHINGBOXID="";                             //Device-ID des Pushingbox Scenarios
String WLANSSID="";                                 //Die SSID eures WLAN kommt hier rein
String WLANPWD="";                                  //Das WLAN Passwort eures WLAN kommt hier rein
String SENSORSSID="ESP8266-DHT22-SENSOR";           //Die Standard SSID für unser Sensor WLAN
String SENSORPWD="";                                //Das Passwort für unser Sensor WLAN
String SENSORSTANDORT="";                           //Standort des Sensors (Max 25 Zeichen)
IPAddress ip(0,0,0,0);                              //Sensor Server IP-Adresse bei statischer Konfiguration
IPAddress gw(0,0,0,0);                              //Gateway IP-Adresse bei statischer Konfiguration
IPAddress sub(255,255,255,0);                       //Subnet Mask bei statischer Konfiguration
IPAddress dns(0,0,0,0);                             //DNS Server IP-Adresse bei statischer Konfiguration

//Konstanten definieren, diese Werte können nur im Programm angepasst werden
const char* PUSHINGBOXSERVER="api.pushingbox.com";  //Pushingbox API Hostadresse (NICHT ÄNDERN)
const int PUSHINGBOXPORT=80;                        //Port des Pushingbox Hosts (NICHT ÄNDERN)
const char* THINGSPEAKHOST="api.thingspeak.com";    //Thingspeak API Host (NICHT ÄNDERN)
const int THINGSPEAKPORT=80;                        //Der Port zum Zugriff auf Thingspeak (NICHT ÄNDERN)
const int SHUTDOWNVCC=3100;                         //Systemabschaltschwelle in Volt ohne Dezimalpunkt 4 Stellen (z.B. 3,1 V = 3100)
const int WARNVCC=3290;                             //Warnschwelle in Volt ohne Dezimalpunkt 4 Stellen (z.B. 3,29 V = 3290) ab der eine Pushingbox Warnamil versendet wird
const int MAXSENSORERRORCOUNT=5;                    //Maximale Anzahl Versuche vom Sensor zu lesen bevor das System resettet wird
const int MAXCONNECTIONTRIES=5;                     //Maximale Anzahl an WLAN Verbindungsversuchen bevor wieder in den Setup Modus gebootet wird
const int DNSPORT = 53;                             //Der Port unseres DNS-Servers (NICHT ÄNDERN)

//Vorgaben für das automatische Update, diese Daten können für einen eigenen Updateserver angepasst werden
const char* UPDATESERVERFILE="/ESPARDUINOOTA/DHT22_SENSOR_DEEP_SLEEP_UPDATE.php"; //(NICHT ÄNDERN)
const char* UPDATESERVER="blog.thomasheldt.de";     //(NICHT ÄNDERN)
const int UPDATESERVERPORT=80;                      //(NICHT ÄNDERN)

//Sonstige benötigte Variablen definieren 
String HTMLFORMULARWLAN="";                         //Hilfsvariable für das Formular zur Auswahl des WLAN
float AKTUELLETEMPERATUR=0;                         //Variable für die aktuelle Temperatur
float AKTUELLELUFTFEUCHTE=0;                        //Variable für die aktuelle Luftfeuchte
float KORREKTURTEMPERATUR=0;                        //Korrekturwert für die Temperatur
float KORREKTURLUFTFEUCHTE=0;                       //Korrekturwert für die Luftfeuchte
byte TIMEOUTFLAG=0;                                 //Hilfsvariable zum zählen der Verbindungstimeouts
unsigned char RAMFlags[2];                          //Hilfsarray für die RTC-Ram Daten
unsigned char ANZAHLWAKEUPS=0;                      //Anzahl aktuell durchgeführter Wakeupstarts
int step=0;                                         //Variable für den Setup-Wizzard

DHT dht(DHTPIN, DHTTYPE);
WiFiServer server(80);
DNSServer dnsServer;

// Daten der auf den Webseiten genutzen Bilder (Logo.png und Favicon)
const byte logo[1742] = {
    0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A,0x00,0x00,0x00,0x0D,0x49,0x48,0x44,0x52,
    0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x20,0x08,0x06,0x00,0x00,0x00,0x73,0x7A,0x7A,
    0xF4,0x00,0x00,0x06,0x95,0x49,0x44,0x41,0x54,0x58,0x85,0xB5,0x97,0x6B,0x8C,0x5D,
    0x55,0x15,0xC7,0x7F,0xFB,0x9C,0x73,0xEF,0x9D,0x7B,0xA7,0x9D,0xBE,0x1F,0xB4,0x92,
    0x86,0x8E,0xA4,0x28,0x01,0x8B,0x20,0x52,0x9A,0x5A,0x4D,0x49,0x8C,0xA1,0x4D,0x8B,
    0x14,0x0C,0x56,0xD1,0xA8,0x35,0xB1,0x88,0x7C,0x20,0x1A,0x45,0x31,0x88,0x89,0xF8,
    0x0A,0x92,0x46,0x6B,0xC0,0xE8,0x27,0x8D,0x51,0x04,0xDB,0x58,0x52,0x42,0xF8,0x50,
    0x1F,0x50,0x1B,0xA0,0xF6,0xA1,0x45,0xC9,0x4C,0xA5,0x0F,0xEA,0x4C,0x9D,0xC7,0xBD,
    0xF3,0xB8,0xE7,0x9E,0xB3,0xF7,0x5A,0xCB,0x0F,0x97,0x99,0xE1,0xF6,0x4E,0x69,0x0D,
    0x65,0x25,0x2B,0x39,0xC9,0x5A,0x7B,0xFD,0xFF,0xFB,0xBF,0xF6,0xEB,0x38,0xDE,0x60,
    0x0F,0x3E,0x39,0x7C,0x83,0xF7,0x6C,0xCB,0x02,0xD7,0x98,0x51,0x71,0x60,0x5C,0x04,
    0x33,0x70,0xCE,0x51,0x2F,0x26,0xFC,0xAD,0x94,0xB0,0xE3,0xFE,0x5B,0xE7,0xFC,0x75,
    0x22,0xE6,0x26,0x3E,0x1E,0x78,0x7C,0x78,0xE7,0xC9,0x21,0xDD,0xE8,0xC5,0xE1,0xDC,
    0xF4,0x85,0xDE,0x32,0x11,0x83,0x62,0x6C,0x2C,0x9D,0x1B,0xED,0xFA,0xD6,0x6D,0x73,
    0x36,0x4D,0x12,0xF8,0xE6,0x6F,0x87,0x76,0x1E,0xEB,0xD7,0x8D,0x71,0xE2,0x88,0xDE,
    0x26,0xF0,0x09,0x53,0x03,0x11,0x63,0xF9,0x82,0x68,0xD7,0x83,0x1F,0x9B,0xBB,0xC9,
    0xDD,0xFF,0x9B,0xA1,0x55,0x27,0x87,0xE4,0x79,0x53,0xC7,0xDB,0x8C,0x3D,0x69,0x06,
    0xB8,0xC8,0x78,0xC7,0xBC,0xF8,0xC6,0x24,0xF3,0x76,0x97,0xF7,0x46,0x12,0xBF,0xA1,
    0xE1,0x06,0xA9,0x57,0x7C,0x98,0x5A,0x02,0x91,0x83,0x28,0x72,0xC4,0x91,0x23,0x89,
    0x20,0x8E,0xDF,0x1A,0xDD,0xE0,0x8D,0x2C,0xB7,0xBB,0x92,0x86,0xB7,0x95,0x86,0x22,
    0x13,0x58,0x06,0xB5,0xD4,0xB8,0xE3,0xC6,0x4E,0xD6,0x5C,0xD1,0x41,0x50,0x23,0xCD,
    0x8C,0x6A,0x6A,0xF4,0x57,0x03,0xBD,0xFD,0x9E,0xBF,0x9F,0xF0,0xF4,0x8F,0x04,0x3A,
    0x0A,0x50,0x2A,0x44,0x24,0xF1,0xFF,0x4F,0x40,0x81,0x34,0x8F,0x56,0x26,0x5E,0xAC,
    0x6C,0x66,0x60,0xCD,0x19,0xA5,0xB9,0xF2,0xD1,0xEB,0x2B,0xDC,0xB1,0x7A,0xE6,0x9B,
    0x16,0x10,0x35,0xF6,0xFE,0x23,0x65,0xE7,0x0B,0xE3,0xF4,0xF6,0x7B,0xBA,0xCA,0x11,
    0x85,0xE4,0xC2,0x55,0x31,0x33,0x54,0xAD,0x9C,0x98,0x9A,0xA1,0x86,0xD9,0x84,0x34,
    0xCA,0xD5,0x97,0x16,0xCF,0x5B,0x20,0x8E,0x1C,0xEB,0xAE,0xAA,0xB0,0xEE,0xAA,0x0A,
    0xA7,0x87,0x3C,0x0F,0xEF,0xAE,0x72,0xF4,0x54,0xCE,0xEC,0x4A,0x44,0x74,0x21,0xDB,
    0xA8,0x49,0xC0,0xA2,0xA0,0x86,0x9A,0x21,0x34,0x3D,0x8E,0x1D,0xBB,0x0F,0x8C,0x5F,
    0xF0,0x4C,0x00,0x96,0xCC,0x2D,0xF0,0xC3,0x3B,0x17,0xF0,0xED,0xDB,0xE7,0x31,0x92,
    0x06,0x32,0xD1,0xC9,0x7A,0xE7,0x72,0x35,0x23,0xA8,0xE1,0x3E,0xB3,0xA3,0xAF,0x67,
    0xAC,0xEE,0xBB,0xDF,0xC8,0x7A,0x3C,0x13,0x56,0x2C,0x2D,0xF2,0xA1,0x2B,0x3B,0x49,
    0x62,0x47,0xA5,0xE4,0x58,0xD0,0x95,0xB0,0x7C,0x71,0x81,0x42,0x1C,0x9D,0x77,0x66,
    0x5B,0xB6,0xBF,0x46,0x9A,0x19,0xA5,0xE4,0xDC,0xB9,0x6A,0xC6,0x8C,0x4A,0xA1,0xD7,
    0x7D,0xFA,0xC7,0xA7,0x7B,0xC6,0x1A,0xBE,0xFB,0x6C,0xD5,0x42,0x30,0x72,0x69,0xB6,
    0xC6,0xAC,0xB9,0x7F,0x7D,0x30,0xE6,0x74,0xC6,0xAC,0x79,0x57,0x85,0xF5,0xD7,0xCD,
    0xA4,0x7B,0x71,0xE9,0x9C,0x00,0x77,0x6E,0x3F,0xC9,0x68,0xAA,0x14,0x0A,0xD3,0xB7,
    0xC3,0x0C,0x3A,0x3B,0x0A,0xBD,0xEE,0x93,0xDB,0x5F,0xEB,0xA9,0xA7,0xBE,0x3B,0xBA,
    0xC0,0x13,0x48,0xD4,0xF0,0xC1,0x18,0xCF,0x95,0x25,0x73,0x0A,0x7C,0x63,0xF3,0x7C,
    0x56,0x2C,0x2D,0x4F,0x07,0xC1,0x86,0x87,0x8E,0x53,0x8C,0xDC,0xB4,0x5B,0x56,0xD5,
    0xA8,0x94,0x0B,0xBD,0x91,0x88,0xA2,0xA6,0xA8,0xCA,0xA4,0xFB,0x20,0x0C,0x8F,0x7A,
    0xCE,0x54,0x33,0xCE,0x54,0x33,0x06,0x46,0x72,0xAA,0x63,0x9E,0xB1,0xD4,0xA3,0xA2,
    0x14,0x13,0x63,0x4E,0xC5,0x31,0x5A,0x0F,0x6C,0xDD,0x71,0x8A,0xEF,0x3D,0xD9,0x37,
    0x0D,0x01,0xC7,0xA3,0x9F,0x5F,0xC2,0x99,0x91,0x1C,0x11,0x69,0xA9,0xAF,0x2A,0xA8,
    0x29,0x22,0x4A,0x22,0x6A,0xA8,0x1A,0xF6,0x7A,0x0F,0x54,0x0D,0x33,0xE3,0xB1,0x6D,
    0x4B,0xB9,0x6C,0x51,0x07,0x60,0x8C,0xD4,0x85,0x63,0x7D,0x39,0x2F,0x1E,0xAB,0xF3,
    0xD4,0x8B,0x35,0x06,0x47,0x94,0xAE,0x72,0x4C,0x14,0x3B,0xE6,0xCD,0x4C,0x78,0xF6,
    0xD0,0x18,0x3D,0x7D,0xC7,0xF9,0xD9,0xB6,0x65,0x2D,0x14,0x96,0xCC,0x2B,0xB2,0xF9,
    0x86,0x59,0xEC,0x39,0x30,0x42,0xB9,0xD4,0x7A,0x58,0x98,0x19,0xA2,0x46,0xA4,0xA2,
    0xA0,0x53,0x3E,0x5E,0x0F,0x7C,0xED,0xD6,0x45,0xAF,0x83,0x37,0x67,0xD2,0x55,0x49,
    0x58,0xB9,0xBC,0xC2,0xE7,0x6E,0x9A,0xCF,0xEF,0xBF,0xDA,0xCD,0x0F,0x3E,0xB5,0x04,
    0x50,0xEA,0xA9,0x07,0x55,0x66,0x94,0x1C,0xC7,0xFB,0x32,0xEE,0xFD,0xC5,0xC9,0x36,
    0x1D,0xEE,0xD9,0xB0,0x90,0x46,0x26,0x98,0x48,0x0B,0x0E,0xDA,0x54,0xA0,0xD9,0x02,
    0x9D,0xF2,0x20,0xC2,0x82,0xAE,0x37,0x3F,0xDA,0xAE,0xBB,0xBC,0x93,0x5D,0x5F,0x7F,
    0x27,0xAB,0x56,0x74,0x32,0x34,0x92,0xA3,0xAA,0x94,0x8B,0x8E,0xFD,0xFF,0x1A,0x65,
    0xCF,0x8B,0xD5,0xB6,0xFC,0xCD,0xAB,0x67,0x31,0xDE,0x08,0x2D,0x38,0xAA,0x8A,0x4E,
    0x47,0xA0,0x98,0xC0,0x8E,0xA7,0xCE,0xBC,0x29,0x81,0x09,0x7B,0xE0,0xE3,0x4B,0x59,
    0xFF,0xBE,0x2E,0xAA,0x63,0x1E,0x55,0x65,0x56,0x39,0xE2,0xA1,0xC7,0x4F,0xB7,0xE5,
    0x7D,0xE2,0x03,0xF3,0x19,0xAD,0xB7,0x13,0x10,0x51,0xE2,0xCB,0xD7,0x7E,0xF1,0x4B,
    0xAA,0x32,0x77,0xA2,0x2F,0x71,0x04,0xA7,0x06,0x1B,0x3C,0xFE,0x97,0x21,0x7A,0xFE,
    0x53,0xE7,0x85,0x57,0xC6,0xE8,0xAF,0x05,0x96,0x2D,0x2C,0x4D,0x7B,0xD4,0xAE,0x7E,
    0x77,0x17,0x7B,0x0F,0x57,0xA9,0x8E,0x79,0xE2,0xC8,0x91,0x7B,0xA5,0xB3,0x23,0xE2,
    0xCA,0x65,0x95,0xC9,0x9C,0x8E,0x52,0xC4,0xD3,0x2F,0x0D,0x91,0x66,0x8A,0x73,0x4D,
    0x1C,0x33,0x03,0xA2,0xE1,0x48,0x44,0x50,0xD1,0x16,0x2F,0xC5,0x8E,0x3C,0x0B,0xEC,
    0x3D,0x54,0x63,0xF7,0xFE,0x41,0x1E,0x7E,0xE2,0x14,0xAB,0xEF,0x3D,0xC4,0x57,0x7E,
    0xFE,0xEA,0xB4,0x4A,0xFC,0xE4,0x0B,0x97,0x31,0x58,0xCB,0x91,0xA0,0x94,0x12,0xF8,
    0xF5,0xDE,0x76,0x05,0xD7,0x5E,0xD9,0x45,0x23,0x0B,0x2D,0x38,0x22,0x42,0xE4,0x43,
    0x73,0x81,0xA8,0x84,0x16,0x77,0x08,0x89,0x53,0x0A,0x91,0x51,0x29,0x1A,0x0B,0x67,
    0x46,0xEC,0x3B,0x3A,0xCC,0xDA,0x2F,0x1F,0xE2,0xEC,0x97,0xDA,0x8C,0x72,0xC2,0xBA,
    0xAB,0xBB,0x68,0x64,0x39,0x11,0xC2,0xAB,0xA7,0xEB,0x8C,0xA7,0xD2,0x92,0xF3,0xDE,
    0xEE,0x4E,0xF2,0xCC,0x4F,0xD6,0x37,0x69,0x6E,0xF7,0x28,0x04,0x41,0x54,0x09,0x62,
    0x2D,0x5E,0x1B,0x0B,0x0C,0x54,0x1B,0xD4,0xB3,0xC0,0x99,0xE1,0x9C,0xCC,0x0B,0xC5,
    0xC4,0x21,0x21,0xB0,0xE5,0xBB,0x2F,0xB7,0xCD,0x70,0xF3,0x9A,0x05,0x8C,0xD7,0x03,
    0x41,0x8C,0x42,0x0C,0xFB,0xFF,0x59,0x6B,0x89,0xAF,0xB8,0xB4,0x4C,0x23,0x9F,0xC2,
    0x11,0x55,0x42,0x10,0x22,0xF1,0x82,0x4A,0x53,0x85,0x09,0x1F,0x18,0x4E,0xF9,0xEC,
    0x87,0x17,0x73,0xE0,0xA7,0xEF,0xE7,0xB9,0x1F,0x5D,0xCB,0x33,0x0F,0xBD,0x87,0x52,
    0x01,0xF2,0xDC,0x53,0x8C,0xE1,0x70,0x4F,0x8D,0x43,0xC7,0x46,0x5B,0x00,0xAE,0xBF,
    0xA2,0x8B,0xF1,0xCC,0x63,0x41,0x70,0x28,0x2F,0x9F,0x18,0x6B,0x89,0xCF,0x9F,0x55,
    0x24,0xCF,0xFD,0x24,0x86,0x8A,0x20,0x7E,0x42,0x01,0x99,0xF2,0xB1,0x7A,0xCE,0x2D,
    0xAB,0xE7,0xB3,0xF5,0xE6,0xA5,0x93,0x83,0x17,0xCC,0x2E,0xF2,0xF4,0x77,0xAE,0x61,
    0xB0,0x96,0x11,0x42,0xA0,0xA3,0x08,0x4F,0xFC,0xA9,0xFD,0xF4,0x5B,0xDC,0x55,0x20,
    0xF7,0x01,0x53,0xE1,0xD4,0x40,0xA3,0x2D,0xDE,0x51,0x70,0x78,0x1F,0x26,0xB1,0x42,
    0x10,0xA2,0xE0,0x03,0x22,0xCD,0xFD,0x1F,0x44,0x18,0x6F,0x78,0x6E,0xFF,0xE0,0xE2,
    0xB6,0xC1,0xCE,0x39,0xAE,0xED,0x9E,0x41,0x23,0x0F,0x44,0x28,0x47,0x7A,0x47,0xDA,
    0x72,0x16,0xCD,0x4E,0xF0,0x21,0x60,0x26,0x0C,0xD5,0xB2,0xB6,0x78,0x67,0xD1,0x08,
    0xA1,0x89,0x23,0xA2,0x84,0x10,0x48,0x7C,0x08,0x24,0x4E,0x27,0xD7,0x95,0xFA,0x80,
    0xF7,0xD2,0x36,0x18,0xA0,0xDE,0xC8,0xB1,0x10,0x70,0x0E,0x6A,0xA3,0x69,0x5B,0xBC,
    0x54,0x30,0xC4,0x7B,0x0C,0xF0,0xDE,0xB7,0xC5,0x23,0x27,0x68,0x50,0x9C,0x3A,0xCC,
    0x81,0xF7,0x11,0x51,0x08,0xE2,0x44,0x84,0xA0,0x4A,0x50,0xA5,0x94,0x18,0xDB,0x7F,
    0xD7,0xDB,0x36,0x78,0xA0,0x9A,0x71,0xE0,0x95,0x21,0x1C,0x86,0x9A,0x72,0xAA,0xBF,
    0x9D,0xC0,0x91,0x9E,0x1A,0x98,0xE1,0x4C,0x39,0xFA,0xEF,0x76,0x85,0x4E,0xF4,0xA5,
    0x98,0x35,0x71,0x44,0x04,0x0D,0xE2,0xA2,0x10,0x24,0x6D,0x2E,0xC2,0x80,0x49,0xA0,
    0x10,0x1B,0x7F,0x3E,0xF8,0x5F,0xEE,0x7E,0xE4,0x20,0xA3,0xF5,0x00,0xC0,0x73,0x87,
    0x07,0x58,0x7B,0xF7,0x1F,0x99,0x53,0x89,0x31,0x0D,0xA0,0x42,0x31,0x31,0xB6,0x7E,
    0xFF,0x25,0xB2,0x5C,0xC8,0xBC,0x72,0xCF,0x23,0x07,0x49,0xB3,0x1C,0x47,0x73,0x11,
    0xD6,0x46,0x1A,0xDC,0xF7,0xE8,0x11,0xD2,0x86,0x30,0x30,0x9C,0x71,0xCB,0x7D,0xFB,
    0x98,0xD1,0x01,0xA6,0x4D,0x2C,0x15,0x21,0x0F,0x92,0xBA,0xE5,0xB7,0x3D,0xF3,0xCB,
    0xD9,0x9D,0x6C,0xD1,0xB3,0xD8,0x36,0x32,0x61,0x3C,0x0D,0xA8,0x41,0xB1,0xE0,0x98,
    0x59,0x2E,0x10,0x9D,0x75,0xAF,0x67,0xB9,0x4C,0x92,0x9C,0x51,0x4E,0xE8,0x38,0xEB,
    0xC6,0x4B,0xB3,0x40,0x3D,0x15,0x9C,0x83,0x99,0x95,0x84,0x42,0x61,0x2A,0x1E,0x01,
    0xD5,0x71,0x7E,0xE5,0x2E,0xD9,0xB0,0x67,0xD5,0xFC,0x59,0xF6,0x7C,0xE4,0xA2,0x8B,
    0xF4,0x27,0x78,0x01,0xE6,0x40,0x4D,0x19,0x1C,0xE1,0x46,0x07,0x70,0xC9,0xFA,0xA7,
    0x76,0x2E,0x9C,0x6D,0x1B,0xD5,0xCE,0xF3,0xDE,0xBB,0x48,0x16,0x39,0xA5,0xBF,0xEA,
    0x76,0xF5,0xED,0xBE,0x79,0xD3,0xA4,0xA6,0x8B,0x3E,0xF2,0x87,0x9D,0x73,0xBB,0x6C,
    0x63,0x12,0x47,0xCD,0x77,0xE0,0x45,0x06,0x75,0x80,0x73,0x10,0x44,0x19,0x1C,0x71,
    0xBB,0xCE,0xEC,0xD9,0x30,0xF5,0x73,0x3A,0x61,0x73,0x6F,0xDA,0xB5,0x2A,0x89,0x6D,
    0x5B,0x21,0x61,0x25,0x8E,0xCA,0xC5,0x6A,0x8A,0x82,0xC3,0xA8,0xFB,0xC0,0xC1,0x20,
    0xEC,0x18,0x7A,0x76,0xD3,0xBE,0x89,0xD8,0xFF,0x00,0xA6,0x43,0x59,0xF4,0x94,0x71,
    0x65,0xDF,0x00,0x00,0x00,0x00,0x49,0x45,0x4E,0x44,0xAE,0x42,0x60,0x82};

const byte favicon[777] = {
    0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A,0x00,0x00,0x00,0x0D,0x49,0x48,0x44,0x52,
    0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x10,0x08,0x06,0x00,0x00,0x00,0x1F,0xF3,0xFF,
    0x61,0x00,0x00,0x02,0xD0,0x49,0x44,0x41,0x54,0x38,0x8D,0x85,0x93,0xCD,0x6B,0x9C,
    0x65,0x14,0xC5,0x7F,0xCF,0xF3,0xBC,0xF3,0x4E,0xA6,0xD3,0x71,0x3A,0xCD,0x80,0x3A,
    0xA5,0x25,0x58,0xA4,0x50,0xB4,0x08,0x0A,0x21,0xB8,0x11,0x1B,0xDC,0x68,0x6B,0xB1,
    0xA9,0x42,0x50,0xD1,0xA5,0x10,0xA8,0x94,0x89,0x5F,0x20,0x15,0x89,0x74,0x91,0x42,
    0x05,0x0B,0xFE,0x01,0xEA,0xA2,0x28,0x7E,0xD0,0x9D,0x28,0x52,0x2B,0xEE,0x94,0x88,
    0xB6,0x55,0x92,0x94,0x40,0x63,0xD2,0x90,0xCC,0xB4,0x93,0xC9,0xFB,0xF5,0x7C,0xBA,
    0x88,0x8C,0x74,0xA1,0x1E,0xB8,0xAB,0x7B,0xCE,0xB9,0xE7,0x2C,0xAE,0x00,0x78,0xF7,
    0x2B,0xD3,0x5E,0xBF,0xD5,0x9F,0xF2,0x9E,0x3A,0xE0,0xF9,0x6F,0x48,0x29,0xE8,0x35,
    0x1B,0xD5,0xF3,0xA7,0x8F,0x95,0xCF,0x8A,0xD3,0x5F,0xE8,0xF6,0xFC,0x72,0x6F,0x36,
    0x92,0x02,0xE3,0x02,0x3E,0x04,0xA4,0x10,0x28,0xB9,0xCD,0xFC,0x37,0x58,0x17,0xB8,
    0xAF,0x55,0x9B,0x8E,0x56,0x37,0x7A,0x53,0x52,0x78,0x92,0x22,0x30,0xBA,0x3F,0xA6,
    0x5A,0x56,0xDC,0x4A,0x1D,0xF3,0x37,0x0D,0x1B,0x9B,0x9E,0x4A,0x2C,0x18,0x8A,0x05,
    0x52,0xDC,0x69,0x26,0x45,0x60,0xBD,0xDB,0x9F,0x8A,0xAC,0xF5,0x75,0x5D,0x78,0x1E,
    0x1A,0x29,0x31,0x7D,0xB4,0x71,0x07,0x49,0x5B,0xC7,0xC5,0x9F,0x52,0x3E,0xBA,0xD4,
    0x27,0x8E,0x04,0xE5,0x92,0x1C,0xEC,0x42,0x00,0x63,0x7C,0x5D,0x5A,0xEB,0x3C,0x38,
    0xAE,0x2C,0xE5,0x2C,0xDC,0x2C,0x58,0xBB,0x6D,0xF0,0x21,0x00,0x10,0x47,0x8A,0xE3,
    0xA3,0x35,0xBE,0x7C,0xED,0x5E,0x46,0x9A,0x8A,0x5E,0xA2,0x71,0xCE,0xFD,0x3D,0x16,
    0xEB,0x9C,0x17,0x93,0xE7,0x96,0x3B,0xC6,0xBA,0xDD,0x3E,0x40,0xA7,0xEF,0x70,0x3E,
    0x10,0x02,0xB4,0x1A,0x11,0x4F,0x3E,0x52,0xE3,0xC5,0xC7,0xFE,0x49,0xF5,0xC6,0xC7,
    0xAB,0x5C,0xBB,0xA1,0x19,0x8A,0x25,0x21,0x04,0x4A,0x91,0xEA,0x8A,0x13,0xB3,0x4B,
    0x1D,0x63,0xDD,0xEE,0x5C,0x07,0x9E,0x7D,0x74,0x17,0x42,0xC0,0xC2,0x4A,0xC1,0xE5,
    0xDF,0x13,0x08,0x81,0x4A,0xAC,0xF8,0xE4,0xD4,0x3E,0x86,0x6B,0x25,0x00,0x8E,0xCC,
    0x5C,0x47,0x29,0x90,0x02,0xA2,0x48,0x75,0xA5,0x35,0x8E,0x3C,0x37,0x8C,0x3F,0x58,
    0xE5,0xE5,0xC3,0xC3,0xBC,0xF4,0xF8,0x30,0x33,0xCF,0xB7,0xB8,0x34,0x73,0x3F,0xE3,
    0x87,0x76,0x92,0xA4,0x9A,0x89,0x33,0x8B,0xC0,0x76,0xAD,0x57,0x8F,0x0E,0xB3,0xB9,
    0x65,0x70,0xD6,0x61,0x8D,0x43,0x1A,0x63,0x21,0x78,0xBE,0x9D,0xBB,0xCD,0x0F,0x57,
    0x7B,0x5C,0xBB,0x91,0x0D,0x22,0xBF,0xFD,0x5C,0x8B,0xA7,0x47,0xEF,0x22,0x2B,0x0C,
    0x67,0x3E,0x5D,0x01,0xE0,0xF0,0xA1,0x3A,0x5A,0x5B,0x8C,0xB5,0x18,0x63,0x91,0x46,
    0x1B,0x82,0x73,0x58,0x63,0x38,0xF9,0xE1,0x75,0x4E,0xBC,0x77,0x95,0xB1,0x53,0x73,
    0x2C,0xAE,0x6C,0x1B,0xB5,0x9F,0xD9,0x43,0x2C,0x1C,0x9F,0x7D,0xBF,0x36,0x30,0x7E,
    0x78,0x7F,0x99,0x3C,0x33,0x18,0x6D,0x90,0x3A,0x37,0x18,0x5D,0xD0,0xED,0xA5,0x4C,
    0x8C,0x35,0x78,0x7D,0x62,0x0F,0x26,0x2F,0x38,0xF6,0xCE,0x2F,0x03,0xC1,0x91,0xD1,
    0x06,0x49,0x52,0xB0,0xB8,0x9A,0x02,0x70,0xA0,0x55,0x26,0xCB,0x73,0x74,0x6E,0x90,
    0xB9,0x2E,0x48,0xB6,0x34,0x63,0x07,0x76,0xF2,0xE6,0xE4,0x08,0x2F,0x8C,0xDF,0xC3,
    0x5B,0x93,0xFB,0x48,0xB6,0x0A,0xBE,0xF9,0x79,0x03,0x80,0x83,0x7B,0x87,0xD0,0xB9,
    0xE6,0xCF,0xF5,0x1C,0x80,0x66,0x4D,0x51,0xA4,0x86,0x5C,0x17,0x44,0x3A,0x2B,0xA4,
    0x0F,0x96,0x7E,0x12,0x0F,0x2E,0x26,0xA9,0xC1,0xD9,0x8C,0x6E,0x6F,0x5B,0x10,0x49,
    0xD0,0x3A,0xA5,0x28,0x2C,0x00,0xDE,0x39,0xB4,0xCE,0x90,0xC4,0x52,0x35,0x1F,0x98,
    0x7C,0x25,0x92,0xEC,0x5A,0x5C,0xEE,0x73,0x65,0xA9,0xC7,0xAF,0x8B,0x9B,0xBC,0x7F,
    0xE1,0x0F,0xEA,0x3B,0x14,0x3F,0xFE,0xD6,0x41,0x1B,0xCF,0xB9,0x0B,0xF3,0x94,0x55,
    0xE0,0xF2,0xDC,0x06,0xFD,0xCC,0xF2,0xC1,0xE7,0x0B,0xC4,0x0A,0x8C,0x75,0x6B,0x62,
    0xEF,0xF1,0xEF,0xDA,0xCD,0x6A,0x3A,0xEB,0xBC,0xA4,0xD0,0x0E,0x17,0x02,0x3B,0xE2,
    0x08,0x04,0x78,0x1F,0xC8,0xB5,0xA3,0x1C,0x2B,0x94,0x14,0x38,0x1F,0x28,0x8C,0xA3,
    0x12,0x2B,0x94,0x0A,0x74,0xD2,0xCA,0xB4,0x00,0xB8,0xFB,0xA9,0xAF,0xDB,0xD5,0x52,
    0x36,0x25,0x24,0x75,0xC2,0xFF,0xBC,0xB3,0x40,0x06,0x4F,0x2F,0xB3,0x95,0xF3,0xAB,
    0x17,0x9F,0x38,0xFB,0x17,0xEA,0x38,0x7E,0x72,0x8E,0x98,0xFE,0x68,0x00,0x00,0x00,
    0x00,0x49,0x45,0x4E,0x44,0xAE,0x42,0x60,0x82}; 
    
void GetSensorData() {
  digitalWrite(LEDPIN, 1);
  delay(50);
  digitalWrite(LEDPIN, 0);

  int SENSORERRORCOUNT=0;

  AKTUELLELUFTFEUCHTE = dht.readHumidity();
  AKTUELLETEMPERATUR = dht.readTemperature();

  while (isnan(AKTUELLELUFTFEUCHTE) || isnan(AKTUELLETEMPERATUR)) {
    SENSORERRORCOUNT+=1;
    
    digitalWrite(LEDPIN, 1);
    delay(50);
    digitalWrite(LEDPIN, 0);
    
    delay(2450);
    
    AKTUELLELUFTFEUCHTE = dht.readHumidity();
    AKTUELLETEMPERATUR = dht.readTemperature();

    if (SENSORERRORCOUNT >= MAXSENSORERRORCOUNT) {
      Serial.println(F("Zuviele Sensorfehler in Folge, starte Sensor neu..."));
      Serial.println(F(""));
      
      WiFi.disconnect();

      delay (100);
      
      ESP.deepSleep(1, WAKE_RF_DEFAULT);
      delay(100);
    }
  }
  
  AKTUELLELUFTFEUCHTE+=KORREKTURLUFTFEUCHTE;
  AKTUELLETEMPERATUR+=KORREKTURTEMPERATUR;
}

void ShowSensorData() {
  Serial.print(F("Luftfeuchte: "));
  Serial.print(AKTUELLELUFTFEUCHTE, 1);
  Serial.println(F(" %"));
  Serial.print(F("Temperatur: "));
  Serial.print(AKTUELLETEMPERATUR, 1);
  Serial.println(F(" *C"));
  Serial.println(F(""));
}

void ReadEEPROMConfig() {
  EEPROM.begin(512);

  EEPROM.get(0,FIRSTSTARTFLAG);
  
  Serial.print(F("FIRSTSTARTFLAG="));
  Serial.println(FIRSTSTARTFLAG);
  
  EEPROM.get(1,UPDATEINTERVAL);

  Serial.print(F("UPDATEINTERVAL="));
  Serial.println(UPDATEINTERVAL);

  EEPROM.get(2,CONNECTIONTIMEOUT);

  Serial.print(F("CONNECTIONTIMEOUT="));
  Serial.println(CONNECTIONTIMEOUT);

  EEPROM.get(3,TIMEOUTFLAG);

  Serial.print(F("TIMEOUTFLAG="));
  Serial.println(TIMEOUTFLAG);

  EEPROM.get(4,STATICIP);

  Serial.print(F("STATICIP="));
  Serial.println(STATICIP);

  ip[0]=EEPROM.read(5);
  ip[1]=EEPROM.read(6);
  ip[2]=EEPROM.read(7);
  ip[3]=EEPROM.read(8);
  
  gw[0]=EEPROM.read(9);
  gw[1]=EEPROM.read(10);
  gw[2]=EEPROM.read(11);
  gw[3]=EEPROM.read(12);
  
  sub[0]=EEPROM.read(13);
  sub[1]=EEPROM.read(14);
  sub[2]=EEPROM.read(15);
  sub[3]=EEPROM.read(16);

  dns[0]=EEPROM.read(17);
  dns[1]=EEPROM.read(18);
  dns[2]=EEPROM.read(19);
  dns[3]=EEPROM.read(20);

  Serial.print(F("IP="));
  Serial.println(ip);
  
  Serial.print(F("GATEWAY="));
  Serial.println(gw);
  
  Serial.print(F("SUBNET="));
  Serial.println(sub);
  
  Serial.print(F("DNS="));
  Serial.println(dns);
  
  WLANSSID="";
  
  for (int i = 21; i < 53; ++i)
  {
    WLANSSID += char(EEPROM.read(i));
  }

  Serial.print(F("WLANSSID="));
  Serial.println(WLANSSID.c_str());

  WLANPWD="";
  
  for (int i = 53; i < 117; ++i)
  {
    WLANPWD += char(EEPROM.read(i));
  }
  
  Serial.print(F("WLANPWD="));
  Serial.println(WLANPWD.c_str());

  SENSORSSID="";

  for (int i = 117; i < 149; ++i)
  {
    SENSORSSID += char(EEPROM.read(i));
  }
  
  Serial.print(F("SENSORSSID="));
  Serial.println(SENSORSSID.c_str());

  SENSORPWD="";

  for (int i = 149; i < 213; ++i)
  {
    SENSORPWD += char(EEPROM.read(i));
  }

  Serial.print(F("SENSORPWD="));
  Serial.println(SENSORPWD.c_str());

  SENSORSTANDORT="";

  for (int i = 213; i < 238; ++i)
  {
    SENSORSTANDORT += char(EEPROM.read(i));
  }

  Serial.print(F("SENSORSTANDORT="));
  Serial.println(SENSORSTANDORT.c_str());

  THINGSPEAKAPIKEY="";

  for (int i = 239; i < 256; ++i)
  {
    THINGSPEAKAPIKEY += char(EEPROM.read(i));
  }

  Serial.print(F("THINGSPEAKAPIKEY="));
  Serial.println(THINGSPEAKAPIKEY.c_str());

  PUSHINGBOXID="";

  for (int i = 256; i < 272; ++i)
  {
    PUSHINGBOXID += char(EEPROM.read(i));
  }

  Serial.print(F("PUSHINGBOXID="));
  Serial.println(PUSHINGBOXID.c_str());

  EEPROM.end();
}

void SendSensorData() {
  analogWrite(LEDPIN, 100);
  
  Serial.print(F("Verbinde mit "));
  Serial.println(THINGSPEAKHOST);

  WiFiClient client;

  delay(2000);

  if (!client.connect(THINGSPEAKHOST, THINGSPEAKPORT)) {
    Serial.println(F(""));
    Serial.println(F("Verbindung mit Thingspeak-Server fehlgeschlagen!"));
  } else {
    Serial.println(F("Verbindung mit Thingspeak-Server erfolgreich hergestellt"));
    Serial.println(F("Sende Daten an Thingspeak Channel..."));

    String POSTString ="api_key=";
    POSTString += THINGSPEAKAPIKEY.c_str();
    POSTString += "&field1=";
    POSTString += AKTUELLETEMPERATUR;
    POSTString += "&field2=";
    POSTString += AKTUELLELUFTFEUCHTE;
    POSTString += "&field3=";
    POSTString += String(ESP.getVcc()).substring(0,1);
    POSTString += ".";
    POSTString += String(ESP.getVcc()).substring(1);

    client.print(F("POST /update HTTP/1.1\n")); 
    client.print(F("HOST: "));
    client.print(THINGSPEAKHOST);
    client.print(F("\n"));
    client.print(F("X-THINGSPEAKAPIKEY:"));
    client.print(THINGSPEAKAPIKEY.c_str());
    client.print(F("\n"));
    client.print(F("Connection: close\n")); 
    client.print(F("Content-Type: application/x-www-form-urlencoded\n")); 
    client.print(F("Content-Length: "));
    client.print(POSTString.length()); 
    client.print(F("\n\n"));
    client.print(POSTString);

    delay(1000);
        
    client.stop();
    
    Serial.println(F("Verbindung zum Server beendet"));
    Serial.println(F("Daten an Thingspeak Channel gesendet"));
  }  

  analogWrite(LEDPIN, 0);
}

void SendAkkuWarnMail() {
  analogWrite(LEDPIN, 25);
  
  WiFiClient client;

  Serial.print(F("Verbinde mit "));
  Serial.print(PUSHINGBOXSERVER);
  Serial.println(F(" ..."));

  if (client.connect(PUSHINGBOXSERVER, PUSHINGBOXPORT)) { 
    Serial.println(F("Verbindung erfolgreich hergestellt..."));
    Serial.println(F(""));
    
    String getStr = "/pushingbox?devid=";
    getStr += PUSHINGBOXID.c_str();

    getStr += "&STANDORT=";
    getStr += SENSORSTANDORT.c_str();
    
    client.print("GET " + getStr + " HTTP/1.1\r\n"); 
    client.print("HOST: ");
    client.print(PUSHINGBOXSERVER);
    client.print("\r\n\r\n"); 
    
    delay(100);
    
    client.stop();

    Serial.println(F("Akku Warnmail versendet!"));
    Serial.println(F(""));
    Serial.println(F("Verbindung abgebaut."));
  }  

  analogWrite(LEDPIN, 0);
}

void ShowSysInfo(int typ) {
  if (typ==1) {
    Serial.print(F("Software-Version: "));
    Serial.println(SOFTWAREVERSION);
    Serial.print(F("SDK-Version: "));
    Serial.println(ESP.getSdkVersion());
    Serial.print(F("ESP8266 Chip-ID: "));
    Serial.println(ESP.getChipId());
    Serial.print(F("ESP8266 Speed: "));  
    Serial.print(ESP.getCpuFreqMHz());
    Serial.println(F(" MHz"));
  }
  
  Serial.print(F("Free Heap Size: "));
  Serial.print(ESP.getFreeHeap());
  Serial.println(F(" Bytes"));
  Serial.print(F("Systemspannung: "));
  Serial.print(String(ESP.getVcc()).substring(0,1));
  Serial.print(F(","));
  Serial.print(String(ESP.getVcc()).substring(1));
  Serial.println(F(" Volt"));  
  Serial.println(F(""));
}

void ResetWiFi() {
  //RTC-Ram Flags für Setup Modus setzen und speichern
  RAMFlags[0]=0;     
  RAMFlags[1]=0;     
  
  while(system_rtc_mem_write(RTC_BASE,RAMFlags,RTC_RAM_ARRAY_SIZE)!=true) {
    delay(1);
  }

  //Firststartflag auf Setup Modus setzen
  EEPROM.begin(512);
  EEPROM.write(0,0);
  EEPROM.end();

  delay(100);

  WiFi.disconnect();

  delay(100);
  
  ESP.deepSleep(1,WAKE_RF_DEFAULT);
  delay(100);
}

void CheckForUpdate() {
    t_httpUpdate_return ret = ESPhttpUpdate.update(UPDATESERVER, UPDATESERVERPORT, UPDATESERVERFILE, SOFTWAREVERSION);

    switch(ret) {
        case HTTP_UPDATE_FAILED:
            Serial.println(F("UPDATE FEHLGESCHLAGEN!"));
            Serial.println(F(""));
            break;

        case HTTP_UPDATE_NO_UPDATES:
            Serial.println(F("KEIN UPDATE VORHANDEN!"));
            Serial.println(F(""));
            break;

        case HTTP_UPDATE_OK:
            Serial.println(F("UPDATE ERFOLGREICH!"));
            break;
    }
}

void setup() {
  pinMode(RESETPIN, INPUT_PULLUP);
  pinMode(LEDPIN, OUTPUT);
  pinMode(DHTPOWERPIN, OUTPUT);
    
  Serial.begin(115200);

  Serial.println(F(""));  
  Serial.println(F(""));  
  Serial.println(F("Starte den ESP8266-DHT22-SENSOR..."));
  Serial.println(F(""));

  Serial.println(F("Teste Systemspannung..."));
  Serial.println(F(""));

  if (ESP.getVcc() <= SHUTDOWNVCC) {
      Serial.println(F("!!! Systemspannung zu niedrig, schalte Sensor ab !!!"));
      Serial.println(F(""));

      delay(100);
      
      ESP.deepSleep(0,WAKE_RF_DISABLED);
      delay(100);
  }
  
  Serial.print(String(ESP.getVcc()).substring(0,1));
  Serial.print(F(","));
  Serial.print(String(ESP.getVcc()).substring(1));
  Serial.println(F(" Volt ist OK"));
  Serial.println(F(""));
  
  Serial.println(F("Hole Konfiguration aus EEPROM..."));
  Serial.println(F(""));

  ReadEEPROMConfig();

  if (FIRSTSTARTFLAG == 111) {
    Serial.println(F(""));
    Serial.println(F("Gebe Zeit fuer Reset des ESP8266-DHT22-SENSOR..."));
    Serial.println(F(""));
  
    unsigned long STARTZEITPUNKT=millis();
    
    //5 Sekunden die Möglichkeit geben den Sensor zu resetten
    digitalWrite(LEDPIN, 1);

    while ((unsigned long)(millis()-STARTZEITPUNKT)<=5000) {
  
      yield();
          
      if (digitalRead(RESETPIN)==0) {
        digitalWrite(LEDPIN, 0);
        
        delay(500);
        
        while (digitalRead(RESETPIN)==0) {
          delay(100);
        }
      
        delay(500);
        
        ResetWiFi();
      }
    }
  
    digitalWrite(LEDPIN, 0);
  }
  
  //Flags aus RTC-Ram einlesen
  while(system_rtc_mem_read(RTC_BASE,RAMFlags,RTC_RAM_ARRAY_SIZE)!=true) {
    delay(1);
  }

  Serial.println(F("Ist der Sensor Konfiguriert?"));
  Serial.println(F(""));

  if (FIRSTSTARTFLAG == 111) {
    Serial.println(F("Sensor ist konfiguriert..."));
    Serial.println(F(""));

    Serial.println(F("Teste Startflag im RTC-Ram..."));
    Serial.println(F(""));

    if (RAMFlags[0] == 0) {
      Serial.println(F("Keine Datenuebertragung notwendig..."));
      Serial.println(F(""));
  
      ANZAHLWAKEUPS=RAMFlags[1];
      ANZAHLWAKEUPS+=1;
      
      Serial.print(F("Sensor ist "));
      Serial.print(ANZAHLWAKEUPS);
      Serial.println(F(" mal aufgewacht."));
      Serial.println(F(""));

      if(ANZAHLWAKEUPS>=UPDATEINTERVAL) {
        RAMFlags[0]=1;
        RAMFlags[1]=1;

        Serial.println(F("Sensor wird neu gestartet im Uebertragungs-Modus..."));
        Serial.println(F(""));
        
        while(system_rtc_mem_write(RTC_BASE,RAMFlags,RTC_RAM_ARRAY_SIZE)!=true) {
          delay(1);
        }
  
        ESP.deepSleep(1,WAKE_RF_DEFAULT);
        delay(100);
      } else {
    
        Serial.println(F("Gehe schlafen..."));
        Serial.println(F(""));

        RAMFlags[0]=0;
        RAMFlags[1]=ANZAHLWAKEUPS;
        
        while(system_rtc_mem_write(RTC_BASE,RAMFlags,RTC_RAM_ARRAY_SIZE)!=true) {
          delay(1);
        }
  
        ESP.deepSleep(52500000-millis(), WAKE_RF_DISABLED);
        delay(100);
      }
    }
  }

  Serial.println(F("Starte im Uebertragungs-Modus..."));
  Serial.println(F(""));

  ShowSysInfo(1);

  float TEMPTEMPERATUR1=0;
  float TEMPLUFTFEUCHTE1=0;
  float TEMPTEMPERATUR2=0;
  float TEMPLUFTFEUCHTE2=0;
  
  if (FIRSTSTARTFLAG == 111) {
    digitalWrite(DHTPOWERPIN, 1);
  
    Serial.println(F("Sensorkalibrierung gestartet..."));
    Serial.println(F(""));
  
    for (int i=1; i<=5; i++) {
      delay(2000);
      
      GetSensorData();
      
      ShowSensorData();
  
      TEMPTEMPERATUR1+=AKTUELLETEMPERATUR;
      TEMPLUFTFEUCHTE1+=AKTUELLELUFTFEUCHTE;  
    }
  
    digitalWrite(DHTPOWERPIN, 0);

    TEMPTEMPERATUR1/=5;
    TEMPLUFTFEUCHTE1/=5;
  
    Serial.print(F("Durchschnittliche Luftfeuchte: "));
    Serial.print(TEMPLUFTFEUCHTE1, 1);
    Serial.println(F(" %"));
    Serial.print(F("Durchschnittliche Temperatur: "));
    Serial.print(TEMPTEMPERATUR1, 1);
    Serial.println(F(" *C"));
  }
  
  Serial.println(F(""));
  Serial.println(F("WLAN-Netzwerk-Scan gestartet..."));
      
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();

  int n = WiFi.scanNetworks();
    
  Serial.println(F("WLAN-Netzwerk-Scan abgeschlossen..."));
  Serial.println(F(""));

  if (n == 0) {
    Serial.println(F("Kein WLAN-Netzwerk gefunden!"));
  } else {
    Serial.print(n);

    if(n<=1) {
     Serial.println(F(" WLAN-Netzwerk gefunden"));
    } else {
      Serial.println(F(" WLAN-Netzwerke gefunden"));
    }
  
    Serial.println(F(""));

    for (int i = 0; i < n; ++i) { 
      Serial.print(i + 1);
      Serial.print(F(": "));
      Serial.print(WiFi.SSID(i));
      Serial.print(F(" ("));
      Serial.print(WiFi.RSSI(i));
      Serial.print(F(")"));
      Serial.println((WiFi.encryptionType(i) == ENC_TYPE_NONE)?" ":"*");
    }
  }

  HTMLFORMULARWLAN = "<b><u>WLAN-Netzwerk ausw&auml;hlen:</u></b><br /><br />";

  for (int i = 0; i < n; ++i) {
    // Erstelle Webseite mit allen SSID und RSSI Werten der gefundenen Netzwerke
    HTMLFORMULARWLAN += "<input type='radio' name='WLANSSID' value='";
    HTMLFORMULARWLAN += WiFi.SSID(i);
    HTMLFORMULARWLAN += "'";

    if (WiFi.SSID(i)==WLANSSID.substring(0, WiFi.SSID(i).length()+1)) {
      HTMLFORMULARWLAN += " checked";
    } 

    HTMLFORMULARWLAN += ">";
    HTMLFORMULARWLAN += WiFi.SSID(i);
    HTMLFORMULARWLAN += " (";
    HTMLFORMULARWLAN += WiFi.RSSI(i);
    HTMLFORMULARWLAN += ")";
    HTMLFORMULARWLAN += (WiFi.encryptionType(i) == ENC_TYPE_NONE)?" ":"*";
    HTMLFORMULARWLAN += "<br />";
  }
  
  Serial.println(F("")); 

  if (FIRSTSTARTFLAG == 111) {
    dht.begin();
  
    Serial.print(F("Verbinde mit WLAN "));
    Serial.println(WLANSSID);
  
    if (STATICIP==1) {
      WiFi.config(ip, gw, sub, dns);
    }

    WiFi.begin(WLANSSID.c_str(), WLANPWD.c_str());
    
    int WLANTIMEOUT=0;
    
    while (WiFi.status() != WL_CONNECTED) {
      delay(1000);
      Serial.print(F("."));
      WLANTIMEOUT+=1;
  
      if (WLANTIMEOUT>=CONNECTIONTIMEOUT) {
        Serial.println(F(""));
        Serial.println(F("Timeout!"));  
        
        TIMEOUTFLAG+=1;

        if(TIMEOUTFLAG>=MAXCONNECTIONTRIES) {
          ResetWiFi();
        } else {
          EEPROM.begin(512);
          EEPROM.write(3, TIMEOUTFLAG);
          EEPROM.end();

          delay(100);
          
          WiFi.disconnect();

          delay(100);
          
          ESP.deepSleep(1000000,WAKE_RF_DEFAULT);
          delay(100);
        }
      }
    }
  
    EEPROM.begin(512);
    EEPROM.write(3, 0);
    EEPROM.end();

    Serial.println(F(""));
    Serial.println(F("Verbindung mit WLAN hergestellt"));  
    Serial.println(F(""));
    Serial.print(F("IP-Addresse: "));
    Serial.println(WiFi.localIP());
    Serial.println(F(""));
    Serial.println(F("Update-Check gestartet..."));
    
    CheckForUpdate();

    Serial.println(F("Setze Sensorkalibrierung fort... "));
    Serial.println(F(""));

    digitalWrite(DHTPOWERPIN, 1);
   
    for (int i=1; i<=5; i++) {
      delay(2000);

      GetSensorData();

      ShowSensorData();
      
      TEMPTEMPERATUR2+=AKTUELLETEMPERATUR;
      TEMPLUFTFEUCHTE2+=AKTUELLELUFTFEUCHTE;  
    }
  
    digitalWrite(DHTPOWERPIN, 0);

    TEMPTEMPERATUR2/=5;
    TEMPLUFTFEUCHTE2/=5;
  
    Serial.print(F("Durchschnittliche Luftfeuchte: "));
    Serial.print(TEMPLUFTFEUCHTE2, 1);
    Serial.println(F(" %"));
    Serial.print(F("Durchschnittliche Temperatur: "));
    Serial.print(TEMPTEMPERATUR2, 1);
    Serial.println(F(" *C"));
    Serial.println(F(""));
  
    KORREKTURTEMPERATUR=TEMPTEMPERATUR1-TEMPTEMPERATUR2;
    KORREKTURLUFTFEUCHTE=TEMPLUFTFEUCHTE1-TEMPLUFTFEUCHTE2;
    
    Serial.print(F("Luftfeuchte Korrekturwert: "));
    Serial.println(KORREKTURLUFTFEUCHTE, 2);
    Serial.print(F("Temperatur Korrekturwert: "));
    Serial.println(KORREKTURTEMPERATUR, 2);
    Serial.println(F(""));
  } else {
    Serial.println(F("Sensor ist nicht konfiguriert..."));
    Serial.println(F(""));

    digitalWrite(LEDPIN ,1);
    
    String SENSORSSIDSETUP = "ESP8266-DHT22-DS-SENSOR-SETUP";
    SENSORPWD = "";
    FIRSTSTARTFLAG=1;
    
    Serial.println(F("Starte im Setup-Modus!!!"));
    WiFi.softAP(SENSORSSIDSETUP.c_str(), SENSORPWD.c_str());
  
    delay(100);
    
    Serial.println(F(""));
    Serial.println(F("AP Modus gestartet"));
    Serial.print(F("SSID: "));
    Serial.println(SENSORSSIDSETUP.c_str());
    Serial.print(F("AP IP-Adresse: "));
    Serial.println(WiFi.softAPIP());
    
    Serial.println(F(""));
    Serial.println(F("Starte DNS-Server"));
    
    dnsServer.start(DNSPORT, "*", WiFi.softAPIP());
  
    Serial.println(F("DNS-Server gestartet")); 
    Serial.println(F(""));
    Serial.println(F("Starte HTTP-Server"));
  
    server.begin();
  
    Serial.println(F("HTTP-Server gestartet")); 
    Serial.println(F(""));
  } 

  Serial.println(F("...ESP8266-DHT22-SENSOR erfolgreich gestartet."));
  Serial.println(F(""));  
}

void loop() {    
  if (FIRSTSTARTFLAG == 111) {
    if (ESP.getVcc() <= WARNVCC && PUSHINGBOXID.length() == 16) {
      SendAkkuWarnMail();
    }
    
    digitalWrite(DHTPOWERPIN, 1);

    delay(2000);
    
    GetSensorData();

    //Sensor direkt wieder abschalten um Strom zu sparen
    digitalWrite(DHTPOWERPIN, 0);

    //Daten an Thingspeak senden
    SendSensorData();

    //RTC-Ram Flags neu setzen und speichern
    RAMFlags[0]=0;       //Startmodus auf Wakeup stellen
    RAMFlags[1]=0;       //Anzahl Wakeups auf 0 setzen
    
    while(system_rtc_mem_write(RTC_BASE,RAMFlags,RTC_RAM_ARRAY_SIZE)!=true) {
      delay(1);
    }

    WiFi.disconnect();
    
    delay(100);

    //Schlafen gehen
    Serial.println(F(""));
    Serial.println(F("Gehe schlafen..."));
    Serial.println(F(""));

    ESP.deepSleep(60000000-millis(), WAKE_RF_DISABLED);
    delay(100);
  }
  
  dnsServer.processNextRequest();

  WiFiClient client = server.available();

  if(client) {
    while(client.connected() && !client.available()){
      delay(1);
    }

    String RequestString = client.readStringUntil('\r');

    int addr_start = RequestString.indexOf(' ');
    int addr_end = RequestString.indexOf(' ', addr_start + 1);

    if (addr_start == -1 || addr_end == -1) {
      Serial.print(F("Ungueltige Anfrage: "));
      Serial.println(RequestString);
      Serial.println(F(""));
      
      client.stop();
    } else {
      RequestString = RequestString.substring(addr_start + 1, addr_end);

      Serial.print(F("Gueltige Anfrage: "));
      Serial.println(RequestString);
      Serial.println(F(""));
      
      String HTMLSite;
      String HTMLHeader;
      String ERRORTEXT;
      
      if ( RequestString.startsWith("/favicon.ico") ) 
      {
        HTMLHeader  = "HTTP/1.1 200 OK\r\n";
        HTMLHeader += "Content-Type: image/png\r\n";
        HTMLHeader += "Content-Length: ";
        HTMLHeader += sizeof(favicon);
        HTMLHeader += "\r\n";
        HTMLHeader += "Connection: close\r\n";
        HTMLHeader += "\r\n";
        
        client.print(HTMLHeader);
        delay(10);
        client.write(favicon,sizeof(favicon));
      }
      else if ( RequestString.startsWith("/logo.png")) 
      {
        HTMLHeader  = "HTTP/1.1 200 OK\r\n";
        HTMLHeader += "Content-Type: image/png\r\n";
        HTMLHeader += "Content-Length: ";
        HTMLHeader += sizeof(logo);
        HTMLHeader += "\r\n";
        HTMLHeader += "Connection: close\r\n";
        HTMLHeader += "\r\n";
        
        client.print(HTMLHeader);
        delay(10);
        client.write(logo,sizeof(logo));
      }

      if (RequestString.startsWith("/setwlanconfig?")) {
        step=2;
        
        //1. Wert extrahieren (WLAN SSID)
        int StartPosition=RequestString.indexOf('=');
        StartPosition++;
        
        int EndePosition=RequestString.indexOf("&");

        String NeueWLANSSID; 
        NeueWLANSSID = RequestString.substring(StartPosition,EndePosition);

        if (NeueWLANSSID.length()<1) {
          ERRORTEXT="Bitte WLAN SSID angeben!";
        }
        
        //2. Wert extrahieren (Netzwerk Passwort)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);
        
        String NeuesWLANPWD;
        NeuesWLANPWD = RequestString.substring(StartPosition,EndePosition);

        //3. Wert extrahieren (CONNECTIONTIMEOUT)
        int NeuesCONNECTIONTIMEOUT=0;
        NeuesCONNECTIONTIMEOUT=RequestString.substring(RequestString.lastIndexOf("=")+1).toInt();

        if(NeuesCONNECTIONTIMEOUT != 10 && NeuesCONNECTIONTIMEOUT != 30 && NeuesCONNECTIONTIMEOUT != 60) {
          ERRORTEXT="Falsches Connetion-Timeout!";
        }

        if(ERRORTEXT == "") {
          EEPROM.begin(512);
  
          delay(10);
  
          //Lösche alte Konfiguration
          for (int i=21; i<117; i++) {
            EEPROM.write(i ,0);
          }
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue WLANSSID ins EEPROM:"));
    
          for (int i = 0; i < NeueWLANSSID.length(); ++i){
            EEPROM.write(21+i, NeueWLANSSID[i]);
            
            Serial.print(F("schreibe: "));
            Serial.println(NeueWLANSSID[i]); 
          }    
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neues WLANPWD ins EEPROM:"));
  
          for (int i = 0; i < NeuesWLANPWD.length(); ++i){
            EEPROM.write(53+i, NeuesWLANPWD[i]);
            
            Serial.print(F("schreibe: "));
            Serial.println(NeuesWLANPWD[i]); 
          }    
  
          Serial.println(F(""));
          Serial.print(F("Schreibe neues CONNECTIONTIMEOUT ins EEPROM: "));
  
          Serial.print(F("schreibe: "));
          Serial.println(NeuesCONNECTIONTIMEOUT);
          
          EEPROM.write(2, NeuesCONNECTIONTIMEOUT);
  
          EEPROM.commit();
          EEPROM.end();
        } else {
          step=1;
        }
      }
      
      if (RequestString.startsWith("/setipconfig?")) {
        step=3;

        //1. Wert extrahieren (IP Typ)
        int StartPosition=RequestString.indexOf('=');
        StartPosition++;
        
        int EndePosition=RequestString.indexOf("&");

        int NeuerIPTYP; 
        NeuerIPTYP = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeuerIPTYP != 0 && NeuerIPTYP != 1) {
          ERRORTEXT="Falsche IP-Adressart (DHCP oder statisch)!";
        }
        
        //2. Wert extrahieren (IP-Adresse Teil 1)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);
        
        int NeueIP1;
        NeueIP1 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeuerIPTYP == 1) {
          if(NeueIP1 <1 || NeueIP1 >255) {
            ERRORTEXT="IP-Adresse Teil 1 ist falsch!";
          }
          
        } else if (NeueIP1 < 0 || NeueIP1 > 255) {
          ERRORTEXT="IP-Adresse Teil 1 ist falsch!";
        }
        
        //3. Wert extrahieren (IP-Adresse Teil 2)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueIP2;
        NeueIP2 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueIP2 < 0 || NeueIP2 > 255) {
          ERRORTEXT="IP-Adresse Teil 2 ist falsch!";
        }
        
        //4. Wert extrahieren (IP-Adresse Teil 3)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);
        
        int NeueIP3;
        NeueIP3 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueIP3 < 0 || NeueIP3 > 255) {
          ERRORTEXT="IP-Adresse Teil 3 ist falsch!";
        }
        
       //5. Wert extrahieren (IP-Adresse Teil 4)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueIP4;
        NeueIP4 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueIP4 < 0 || NeueIP4 > 255) {
          ERRORTEXT="IP-Adresse Teil 4 ist falsch!";
        }
        
        //6. Wert extrahieren (Gateway IP-Adresse Teil 1)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueGWIP1;
        NeueGWIP1 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeuerIPTYP == 1) {
          if(NeueGWIP1 <1 || NeueGWIP1 >255) {
            ERRORTEXT="Gateway IP-Adresse Teil 1 ist falsch!";
          }
          
        } else if(NeueGWIP1 < 0 || NeueGWIP1 > 255) {
          ERRORTEXT="Gateway IP-Adresse Teil 1 ist falsch!";
        }
        
        //7. Wert extrahieren (Gateway IP-Adresse Teil 2)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueGWIP2;
        NeueGWIP2 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueGWIP2 < 0 || NeueGWIP2 > 255) {
          ERRORTEXT="Gateway IP-Adresse Teil 2 ist falsch!";
        }

        //8. Wert extrahieren (Gateway IP-Adresse Teil 3)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueGWIP3;
        NeueGWIP3 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueGWIP3 < 0 || NeueGWIP3 > 255) {
          ERRORTEXT="Gateway IP-Adresse Teil 3 ist falsch!";
        }

        //9. Wert extrahieren (Gateway IP-Adresse Teil 4)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueGWIP4;
        NeueGWIP4 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueGWIP4 < 0 || NeueGWIP4 > 255) {
          ERRORTEXT="Gateway IP-Adresse Teil 4 ist falsch!";
        }

        //10. Wert extrahieren (Subnet Mask Teil 1)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueMASK1;
        NeueMASK1 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeuerIPTYP == 1) {
          if(NeueMASK1 != 255) {
            ERRORTEXT="Subnet Mask Teil 1 ist falsch (255)!";
          }
        } else if(NeueMASK1 < 0 || NeueMASK1 != 255) {
          NeueMASK1=0;
        }

        //11. Wert extrahieren (Subnet Mask Teil 2)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueMASK2;
        NeueMASK2 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeuerIPTYP == 1) {
          if(NeueMASK2 !=0 && NeueMASK2 != 255) {
            ERRORTEXT="Subnet Mask Teil 2 ist falsch (0 oder 255)!";
          }
          
        } else if(NeueMASK2 < 0 || NeueMASK2 != 255) {
          NeueMASK2=0;
        }

        //12. Wert extrahieren (Subnet Mask Teil 3)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueMASK3;
        NeueMASK3 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeuerIPTYP == 1) {
          if(NeueMASK3 !=0 && NeueMASK3 != 255) {
            ERRORTEXT="Subnet Mask Teil 3 ist falsch (0 oder 255)!";
          }
          
        } else if(NeueMASK3 < 0 || NeueMASK3 != 255) {
          NeueMASK3=0;
        }

        //13. Wert extrahieren (Subnet Mask Teil 4)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueMASK4;
        NeueMASK4 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeuerIPTYP == 1) {
          if(NeueMASK4 !=0 && NeueMASK4 != 255) {
            ERRORTEXT="Subnet Mask Teil 4 ist falsch (0 oder 255)!";
          }
          
        } else if(NeueMASK4 < 0 || NeueMASK4 != 255) {
          NeueMASK4=0;
        }

        //14. Wert extrahieren (DNS Server IP-Adresse Teil 1)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        int NeueDNSIP1;
        NeueDNSIP1 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueDNSIP1 < 0 || NeueDNSIP1 > 255) {
          ERRORTEXT="DNS-Server IP-Adresse Teil 1 ist falsch!";
        }

        //15. Wert extrahieren (DNS Server IP-Adresse Teil 2)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);
        
        int NeueDNSIP2;
        NeueDNSIP2 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueDNSIP2 < 0 || NeueDNSIP2 > 255) {
          ERRORTEXT="DNS-Server IP-Adresse Teil 2 ist falsch!";
        }

        //16. Wert extrahieren (DNS Server IP-Adresse Teil 3)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);
        
        int NeueDNSIP3;
        NeueDNSIP3 = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeueDNSIP3 < 0 || NeueDNSIP3 > 255) {
          ERRORTEXT="DNS-Server IP-Adresse Teil 3 ist falsch!";
        }

        //17. Wert extrahieren (DNS Server IP-Adresse Teil 4)
        int NeueDNSIP4;
        NeueDNSIP4 = RequestString.substring(RequestString.lastIndexOf("=")+1).toInt();

        if(NeueDNSIP4 < 0 || NeueDNSIP4 > 255) {
          ERRORTEXT="DNS-Server IP-Adresse Teil 4 ist falsch!";
        }
        
        if(ERRORTEXT == "") {
          EEPROM.begin(512);
  
          delay(10);
  
          //Alte Konfigurationsdaten löschen
          for (int i=4; i<21; i++) {
            EEPROM.write(i, 0);
          }
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neuen IPTYP ins EEPROM:"));
    
          EEPROM.write(4, NeuerIPTYP);
  
          Serial.print(F("schreibe: "));
          Serial.println(NeuerIPTYP); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue IP-Adresse Teil 1 ins EEPROM:"));
  
          EEPROM.write(5, NeueIP1);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueIP1); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue IP-Adresse Teil 2 ins EEPROM:"));
  
          EEPROM.write(6, NeueIP2);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueIP2); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue IP-Adresse Teil 3 ins EEPROM:"));
  
          EEPROM.write(7, NeueIP3);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueIP3); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue IP-Adresse Teil 4 ins EEPROM:"));
  
          EEPROM.write(8, NeueIP4);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueIP4); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue Gateway IP-Adresse Teil 1 ins EEPROM:"));
  
          EEPROM.write(9, NeueGWIP1);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueGWIP1); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue Gateway IP-Adresse Teil 2 ins EEPROM:"));
  
          EEPROM.write(10, NeueGWIP2);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueGWIP2); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue Gateway IP-Adresse Teil 3 ins EEPROM:"));
  
          EEPROM.write(11, NeueGWIP3);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueGWIP3); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue Gateway IP-Adresse Teil 4 ins EEPROM:"));
  
          EEPROM.write(12, NeueGWIP4);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueGWIP4); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue Subnet Mask Teil 1 ins EEPROM:"));
  
          EEPROM.write(13, NeueMASK1);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueMASK1); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue Subnet Mask Teil 2 ins EEPROM:"));
  
          EEPROM.write(14, NeueMASK2);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueMASK2); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue Subnet Mask Teil 3 ins EEPROM:"));
  
          EEPROM.write(15, NeueMASK3);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueMASK3); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue Subnet Mask Teil 4 ins EEPROM:"));
  
          EEPROM.write(16, NeueMASK4);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueMASK4); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue DNS Server IP-Adresse Teil 1 ins EEPROM:"));
  
          EEPROM.write(17, NeueDNSIP1);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueDNSIP1); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue DNS Server IP-Adresse Teil 2 ins EEPROM:"));
  
          EEPROM.write(18, NeueDNSIP2);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueDNSIP2); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue DNS Server IP-Adresse Teil 3 ins EEPROM:"));
  
          EEPROM.write(19, NeueDNSIP3);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueDNSIP3); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue DNS Server IP-Adresse Teil 4 ins EEPROM:"));
  
          EEPROM.write(20, NeueDNSIP4);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeueDNSIP4); 

          EEPROM.commit();
          EEPROM.end();
        } else {
          step=2;
        }
      }

      if (RequestString.startsWith("/settsconfig?")) {
        step=4;
        
        //1. Wert extrahieren (UPDATEINTERVAL)
        int StartPosition=RequestString.indexOf('=');
        StartPosition++;
        
        int EndePosition=RequestString.indexOf("&");

        int NeuesUPDATEINTERVAL = 0;
        NeuesUPDATEINTERVAL = RequestString.substring(StartPosition,EndePosition).toInt();

        if(NeuesUPDATEINTERVAL != 15 && NeuesUPDATEINTERVAL != 30 && NeuesUPDATEINTERVAL != 45 && NeuesUPDATEINTERVAL != 60) {
          ERRORTEXT="Falsches Update Interval!";
        }
        
        //2. Wert extrahieren (THINGSPEAKAPIKEY)
        String NeuerTHINGSPEAKAPIKEY; 

        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);
        
        NeuerTHINGSPEAKAPIKEY = RequestString.substring(StartPosition,EndePosition);

        if(NeuerTHINGSPEAKAPIKEY.length() > 16) {
          ERRORTEXT="Falscher ThingSpeak API Key!";
        }

        if(NeuerTHINGSPEAKAPIKEY == "") {
          ERRORTEXT="ThingSpeak API Key fehlt!";
        }
        
        //3. Wert extrahieren (PUSHINGBOXID)
        String NeuePUSHINGBOXID; 
        NeuePUSHINGBOXID = RequestString.substring(RequestString.lastIndexOf("=")+1);

        if(NeuePUSHINGBOXID.length() > 16) {
          ERRORTEXT="Falsche Pushingbox Scenario Device-ID!";
        }

        if(NeuePUSHINGBOXID == "") {
          ERRORTEXT="Pushingbox Scenario Device-ID fehlt!";
        }

        if(ERRORTEXT == "") {
          EEPROM.begin(512);
  
          delay(10);
          
          //Alte Konfigurationsdaten löschen
          for (int i=239; i<272; i++) {
            EEPROM.write(i, 0);
          }
    
          Serial.println(F(""));
          Serial.println(F("Schreibe neues UPDATEINTERVAL ins EEPROM:"));
  
          EEPROM.write(1, NeuesUPDATEINTERVAL);
          
          Serial.print(F("schreibe: "));
          Serial.println(NeuesUPDATEINTERVAL); 
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neuen THINGSPEAKAPIKEY ins EEPROM:"));
  
          for (int i = 0; i < NeuerTHINGSPEAKAPIKEY.length(); ++i){
            EEPROM.write(239+i, NeuerTHINGSPEAKAPIKEY[i]);
            
            Serial.print(F("schreibe: "));
            Serial.println(NeuerTHINGSPEAKAPIKEY[i]); 
          }    
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue PUSHINGBOXID ins EEPROM:"));
  
          for (int i = 0; i < NeuePUSHINGBOXID.length(); ++i){
            EEPROM.write(256+i, NeuePUSHINGBOXID[i]);
            
            Serial.print(F("schreibe: "));
            Serial.println(NeuePUSHINGBOXID[i]); 
          }    
  
          EEPROM.commit();
          EEPROM.end();
        } else {
          step=4;
        }
      }
      
      if (RequestString.startsWith("/setsensorconfig?")) {
        step=5;

        //1. Wert extrahieren (STANDORT)
        int StartPosition=RequestString.indexOf('=');
        StartPosition++;
        
        int EndePosition=RequestString.indexOf("&");

        String NeuerSTANDORT; 
        NeuerSTANDORT = RequestString.substring(StartPosition,EndePosition);

        //2. Wert extrahieren (SENSORSSID)
        StartPosition=RequestString.indexOf("=",EndePosition);
        StartPosition++;
        
        EndePosition=RequestString.indexOf("&",EndePosition+2);

        String NeueSENSORSSID = "";
        NeueSENSORSSID = RequestString.substring(StartPosition,EndePosition);

        //3. Wert extrahieren (SENSORPWD)
        String NeuesSENSORPWD = "";
        NeuesSENSORPWD = RequestString.substring(RequestString.lastIndexOf("=")+1);

        if(ERRORTEXT == "") {
          EEPROM.begin(512);
  
          delay(10);
          
          //Alte Konfigurationsdaten löschen
          for (int i=117; i<238; i++) {
            EEPROM.write(i, 0);
          }
   
          Serial.println(F(""));
          Serial.println(F("Schreibe neuen STANDORT ins EEPROM:"));
    
          for (int i = 0; i < NeuerSTANDORT.length(); ++i){
            EEPROM.write(213+i, NeuerSTANDORT[i]);
            
            Serial.print(F("schreibe: "));
            Serial.println(NeuerSTANDORT[i]); 
          }    
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neue SENSORSSID ins EEPROM:"));
  
          for (int i = 0; i < NeueSENSORSSID.length(); ++i){
            EEPROM.write(117+i, NeueSENSORSSID[i]);
            
            Serial.print(F("schreibe: "));
            Serial.println(NeueSENSORSSID[i]); 
          }    
  
          Serial.println(F(""));
          Serial.println(F("Schreibe neues SENSORPWD ins EEPROM:"));
  
          for (int i = 0; i < NeuesSENSORPWD.length(); ++i){
            EEPROM.write(149+i, NeuesSENSORPWD[i]);
            
            Serial.print(F("schreibe: "));
            Serial.println(NeuesSENSORPWD[i]); 
          }    
                   
          Serial.println(F("Schreibe neues FIRSTSTARTFLAG ins EEPROM:"));
          FIRSTSTARTFLAG=111;
          
          EEPROM.write(0, FIRSTSTARTFLAG);
  
          Serial.print(F("schreibe: "));
          Serial.println(FIRSTSTARTFLAG); 
  
          EEPROM.commit();
          EEPROM.end();

          //RTC-Ram Flags neu setzen und speichern
          RAMFlags[0]=1;    //Grundwert für Startmodus auf Normalstart setzen
          RAMFlags[1]=99;   //Grundwert für Wakeups auf 99 setzen damit nach Neustart direkt die erste Übertragung folgt
          
          while(system_rtc_mem_write(RTC_BASE,RAMFlags,RTC_RAM_ARRAY_SIZE)!=true) {
            delay(1);
          }
        } else {
          step=4;
        }
      }

      if (step == 5) {
        Serial.println(F("Abschlussseite des Setup wird ausgegeben"));
        Serial.println(F(""));
        
        HTMLSite ="<!DOCTYPE html><html><head>";
        HTMLSite += "<title>";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "</title>";
        HTMLSite += "</head><body style='font-family:Verdana, Arial, Sans-Serif'><center>";
        HTMLSite += "<img src='logo.png' border='0' /><br /><br />";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "<br /><br /><fieldset style='width:450px'><br />";
        HTMLSite += "<b>Das Setup des Sensors<br />";
        HTMLSite += "ist abgeschlossen.<br /><br />";
        HTMLSite += "Der Sensor startet jetzt neu!<br />";
        HTMLSite += "<br /></fieldset></center></body></html>\r\n\r\n";

        HTMLHeader  = "HTTP/1.1 200 OK\r\n";
        HTMLHeader += "Content-Length: ";
        HTMLHeader += HTMLSite.length();
        HTMLHeader += "\r\n";
        HTMLHeader += "Content-Type: text/html\r\n";
        HTMLHeader += "Connection: close\r\n";
        HTMLHeader += "\r\n";
        
        client.print(HTMLHeader);
        delay(100);
        client.print(HTMLSite);
        delay(100);
        
        client.stop();

        WiFi.disconnect();

        ESP.deepSleep(1000,WAKE_RF_DEFAULT); //System neu starten über Deep-Sleep Timer
        delay(100);
      }
      
      if (step == 1) {
        Serial.println(F("WLAN Konfigurationsseite wird ausgegeben"));
        Serial.println(F(""));

        HTMLSite ="<!DOCTYPE html><html><head><title>";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "</title>";
        HTMLSite += "</head><body style='font-family:Verdana, Arial, Sans-Serif'><center>";
        HTMLSite += "<img src='logo.png' border='0' /><br /><br />";
        HTMLSite += SENSORSSID.c_str();
        
        if(ERRORTEXT != "") {
          HTMLSite += "<br /><br /><fieldset style='width:450px'><legend>Es ist ein Fehler aufgetreten!</legend>";
          HTMLSite += "<font color='red'>";
          HTMLSite += ERRORTEXT;
          HTMLSite += "</font><br /></fieldset>";
        }

        HTMLSite += "<br /><br /><fieldset style='width:450px'><legend>Sensor Setup Schritt 1</legend>";
        HTMLSite += "<form method='GET' action='setwlanconfig'>";
        HTMLSite += "<br /><b>WLAN Einstellungen</b><br /><hr /><br />";
        HTMLSite += HTMLFORMULARWLAN;
        HTMLSite += "<br />WLAN-Passwort: <input name='WLANPWD' type='text' size='30' maxlength='64' value='";
        HTMLSite += WLANPWD.c_str();
        HTMLSite += "'></input><br />";
        HTMLSite += "<br />Verbindungs-Timeout: ";
        HTMLSite += "<select name='CONNECTIONTIMEOUT' size='1'>";

        if (CONNECTIONTIMEOUT==10) {
          HTMLSite += "<option value='10' selected>10</option><option value='30'>30</option><option value='60'>60</option>";
        } else if (CONNECTIONTIMEOUT==30) {
          HTMLSite += "<option value='10'>10</option><option value='30' selected>30</option><option value='60'>60</option>";
        } else {
          HTMLSite += "<option value='10'>10</option><option value='30'>30</option><option value='60' selected>60</option>";
        }
 
        HTMLSite += "</select> Sekunden<br />";
        HTMLSite += "<br /></fieldset>";
        HTMLSite += "<br /><input type='submit' value='Einstellungen speichern und weiter zu Schritt 2...'></form>";
        HTMLSite += "</center></body></html>\r\n\r\n";
      }
      
      if (step == 2) {
        Serial.println(F("IP Konfigurationsseite wird ausgegeben"));
        Serial.println(F(""));

        HTMLSite ="<!DOCTYPE html><html><head><title>";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "</title>";
        HTMLSite += "</head><body style='font-family:Verdana, Arial, Sans-Serif'><center>";
        HTMLSite += "<img src='logo.png' border='0' /><br /><br />";
        HTMLSite += SENSORSSID.c_str();
        
        if(ERRORTEXT != "") {
          HTMLSite += "<br /><br /><fieldset style='width:450px'><legend>Es ist ein Fehler aufgetreten!</legend>";
          HTMLSite += "<font color='red'>";
          HTMLSite += ERRORTEXT;
          HTMLSite += "</font><br /></fieldset>";
        }

        HTMLSite += "<br /><br /><fieldset style='width:450px'><legend>Sensor Setup Schritt 2</legend>";
        HTMLSite += "<form method='GET' action='setipconfig'>";
        HTMLSite += "<br /><b>IP Einstellungen</b><br /><hr />";
        HTMLSite += "<br />IP-Adresstyp: ";
        HTMLSite += "<select name='STATICIP' size='1'>";
        
        if (STATICIP==0) {
          HTMLSite += "<option value='0' selected>DHCP</option><option value='1'>Statisch</option></select>";
        } else {
          HTMLSite += "<option value='0'>DHCP</option><option value='1' selected>Statisch</option></select>";
        }
        HTMLSite += "<br /><br />IP-Adresse: <input name='IP1' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(ip[0]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='IP2' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(ip[1]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='IP3' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(ip[2]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='IP4' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(ip[3]);
        HTMLSite += "'></input>";
        HTMLSite += "<br /><br />Gateway IP-Adresse: <input name='GWIP1' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(gw[0]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='GWIP2' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(gw[1]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='GWIP3' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(gw[2]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='GWIP4' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(gw[3]);
        HTMLSite += "'></input>";
        HTMLSite += "<br /><br />Subnet Mask: <input name='MASK1' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(sub[0]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='MASK2' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(sub[1]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='MASK3' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(sub[2]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='MASK4' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(sub[3]);
        HTMLSite += "'></input>";
        HTMLSite += "<br /><br />DNS-Server IP-Adresse: <input name='DNSIP1' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(dns[0]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='DNSIP2' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(dns[1]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='DNSIP3' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(dns[2]);
        HTMLSite += "'></input>.";
        HTMLSite += "<input name='DNSIP4' type='text' size='3' maxlength='3' value='";
        HTMLSite += String(dns[3]);
        HTMLSite += "'></input><br />";
        HTMLSite += "<br /></fieldset>";
        HTMLSite += "<br /><input type='submit' value='Einstellungen speichern und weiter zu Schritt 3...'></form>";
        HTMLSite += "</center></body></html>\r\n\r\n";
      } 
      
      if (step == 3) {
        Serial.println(F("Thingspeak Konfigurationsseite wird ausgegeben"));
        Serial.println(F(""));

        HTMLSite ="<!DOCTYPE html><html><head><title>";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "</title>";
        HTMLSite += "</head><body style='font-family:Verdana, Arial, Sans-Serif'><center>";
        HTMLSite += "<img src='logo.png' border='0' /><br /><br />";
        HTMLSite += SENSORSSID.c_str();
        
        if(ERRORTEXT != "") {
          HTMLSite += "<br /><br /><fieldset style='width:450px'><legend>Es ist ein Fehler aufgetreten!</legend>";
          HTMLSite += "<font color='red'>";
          HTMLSite += ERRORTEXT;
          HTMLSite += "</font><br /></fieldset>";
        }

        HTMLSite += "<br /><br /><fieldset style='width:450px'><legend>Sensor Setup Schritt 3</legend>";
        HTMLSite += "<form method='GET' action='settsconfig'>";
        HTMLSite += "<br /><b>Thingspeak Einstellungen</b><br /><hr />";
        HTMLSite += "<br />&Uuml;bertrag alle ";
        HTMLSite += "<select name='UPDATEINTERVAL' size='1'>";

        if (UPDATEINTERVAL==15) {
          HTMLSite += "<option value='15' selected>15</option><option value='30'>30</option><option value='45'>45</option><option value='60'>60</option>";
        } else if (UPDATEINTERVAL==30) {  
          HTMLSite += "<option value='15'>15</option><option value='30' selected>30</option><option value='45'>45</option><option value='60'>60</option>";
        } else if (UPDATEINTERVAL==45) {  
          HTMLSite += "<option value='15'>15</option><option value='30'>30</option><option value='45' selected>45</option><option value='60'>60</option>";
        } else {  
          HTMLSite += "<option value='15'>15</option><option value='30'>30</option><option value='45'>45</option><option value='60' selected>60</option>";
        }

        HTMLSite += "</select> Minuten";
        HTMLSite += "<br /><br />API Write-Key: <input name='THINGSPEAKAPIKEY' type='text' size='20' maxlength='16' value='";
        HTMLSite += THINGSPEAKAPIKEY.c_str();
        HTMLSite += "'></input><br /><hr />";
        HTMLSite += "<br /><b>Pushingbox Einstellungen</b><br /><hr />";
        HTMLSite += "<br />Scenario Device-ID: <input name='PUSHINGBOXID' type='text' size='20' maxlength='16' value='";
        HTMLSite += PUSHINGBOXID.c_str();
        HTMLSite += "'></input><br />";
        HTMLSite += "<br /></fieldset>";
        HTMLSite += "<br /><input type='submit' value='Einstellungen speichern und weiter zu Schritt 4...'></form>";
        HTMLSite += "</center></body></html>\r\n\r\n";
      } 
      
      if (step == 4) {
        Serial.println(F("Sensor Konfigurationsseite wird ausgegeben"));
        Serial.println(F(""));

        HTMLSite ="<!DOCTYPE html><html><head><title>";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "</title>";
        HTMLSite += "</head><body style='font-family:Verdana, Arial, Sans-Serif'><center>";
        HTMLSite += "<img src='logo.png' border='0' /><br /><br />";
        HTMLSite += SENSORSSID.c_str();
        
        if(ERRORTEXT != "") {
          HTMLSite += "<br /><br /><fieldset style='width:450px'><legend>Es ist ein Fehler aufgetreten!</legend>";
          HTMLSite += "<font color='red'>";
          HTMLSite += ERRORTEXT;
          HTMLSite += "</font><br /></fieldset>";
        }

        HTMLSite += "<br /><br /><fieldset style='width:450px'><legend>Sensor Setup Schritt 4</legend>";
        HTMLSite += "<form method='GET' action='setsensorconfig'>";
        HTMLSite += "<br /><b>Sensor Einstellungen</b><br /><hr />";
        HTMLSite += "<br />Standort: <input name='SENSORSTANDORT' type='text' size='25' maxlength='25' value='";
        HTMLSite += SENSORSTANDORT.c_str();
        HTMLSite += "'></input><br />";
        HTMLSite += "<br />SSID: <input name='SENSORSSID' type='text' size='32' maxlength='32' value='";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "'></input><br />";
        HTMLSite += "<br />Passwort: <input name='SENSORPWD' type='text' size='30' maxlength='64' value='";
        HTMLSite += SENSORPWD.c_str();
        HTMLSite += "'></input><br /><br /></fieldset>";
        HTMLSite += "<br /><input type='submit' value='Einstellungen speichern und das Setup beenden'></form>";
        HTMLSite += "</center></body></html>\r\n\r\n";
      } 

      if (HTMLSite == "" && step == 0) {
        step=1;
        
        Serial.println(F("Setup Startseite wird ausgegeben"));
        Serial.println(F(""));

        HTMLSite ="<!DOCTYPE html><html><head><title>";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "</title>";
        HTMLSite += "</head><body style='font-family:Verdana, Arial, Sans-Serif'><center>";
        HTMLSite += "<img src='logo.png' border='0' /><br /><br />";
        HTMLSite += SENSORSSID.c_str();
        HTMLSite += "<br /><br /><fieldset style='width:450px'><br />";
        HTMLSite += "<b>Herzlich Willkommen zum Setup<br />";
        HTMLSite += "des ESP8266 DHT-22 Akku Sensors.<br /><br />";
        HTMLSite += "Sie werden jetzt Schritt f&uuml;r Schritt<br />";
        HTMLSite += "durch das Setup gef&uuml;hrt.<br /><br /></fieldset><br />";
        HTMLSite += "<form method='GET' action='wlanconfig.htm'>";
        HTMLSite += "<input type='submit' value='Weiter zu Schritt 1...'></form>";
        HTMLSite += "</center></body></html>\r\n\r\n";
      }

      if (HTMLSite.length() > 0) {
        HTMLHeader  = "HTTP/1.1 200 OK\r\n";
        HTMLHeader += "Content-Length: ";
        HTMLHeader += HTMLSite.length();
        HTMLHeader += "\r\n";
        HTMLHeader += "Content-Type: text/html\r\n";
        HTMLHeader += "Connection: close\r\n";
        HTMLHeader += "\r\n";
        
        client.print(HTMLHeader);
        delay(10);
        client.print(HTMLSite);
        delay(10);
      }
    }
  }

  delay(100);
}


Hier findet ihr Links zu den eingesetzen Libraries.

Adafuit DHT Library – Download unter https://github.com/adafruit/DHT-sensor-library

DNSServer Library by Kristian Novoselić – Bestandteil der ESP8266 Erweiterung der Arduino IDE Link


Über den nachfolgenden Link kann man sich die bisher veröffentlichte Software downloaden.

Produktivsoftware Download

Verlinke diesen Beitrag:

<a href="http://blog.thomasheldt.de/esp8266-am2302-dht22-sensor-fuer-akkubetrieb-ein-projekt-zum-mitmachen-3-2/">ESP8266 AM2302 (DHT22) Sensor für Akkubetrieb, ein Projekt zum Mitmachen! (3-2)</a>

The following two tabs change content below.
c7282393508c6050f22643a7feb8fec6?s=80&r=g ESP8266 AM2302 (DHT22) Sensor für Akkubetrieb, ein Projekt zum Mitmachen! (3-2)

Thomas H.

Als Betreiber dieses Blog versuche ich hier interessante Projekte und Tipps rund um die Elektronik zu bieten.
c7282393508c6050f22643a7feb8fec6?s=80&r=g ESP8266 AM2302 (DHT22) Sensor für Akkubetrieb, ein Projekt zum Mitmachen! (3-2)

Neueste Artikel von Thomas H. (alle ansehen)

Aktualisiert am: 2. März 2016

Es war leider noch ein Bug in der letzten Version, die Pushingbox ID wurde nicht gespeichert. Der Fehler ist im Archiv, auf dieser Seite und im autom. Update jetzt behoben.

15 Gedanken zu „ESP8266 AM2302 (DHT22) Sensor für Akkubetrieb, ein Projekt zum Mitmachen! (3-2)

  1. Stefan

    Hallo Thomas,

    kurze Frage: Hast du Probleme mit dem DHT22 und dem deep sleep? Gibt min. ein Beitrag im Netz der beschreibt, dass der DHT22 nach einigen Deep-Sleep Zyklen nicht mehr richtig funktioniert: https://tzapu.com/minimalist-battery-powered-esp8266-wifi-temperature-logger/

    Bin gerade dabei mir auch solch einen Sensor (und weitere) so bauen und frage daher nacht, wleche Erfahrungen du hier gemacht hast. Lt. Chart im Beitrag läuft der Sensor ja bei dir wohl..

    Danke und Gruß
    Stefan

    Antworten
    1. Thomas H. Beitragsautor

      Hallo Stefan,
      also ich habe keine Probleme, die einzigsten Zeiten die mir immer mal wieder fehlen sind die wenn der Akku leer ist und ich nicht gleich zum nachladen komme. Es hängt aber wohl auch sehr davon ab wie die Software programmiert ist, man sollte den DHT nicht direkt nach dem Aufwachen abfragen oder zumindest eine Messung verwerfen damit er stabil ist.

      Gruß
      Thomas

      Antworten
  2. Kai

    Hallo Thomas,

    kann es sein, dass er Sonderzeichen im WLAN Passwort nicht mcag/verträgt?

    In meinem offenen Freifunk-WLAN geht es, in meinem privaten WLAN offenbar nicht.
    Er zeigt bei zweitem Aufrufen des Webinterfaces das WLAN Passwort dann auch mit HTML-codierten Umlauten an. Ggf. speichert er es auch so im EEPROM ab und nutzt dann zB statt eines „!“ ein „%irgendwas“

    VG
    Kai

    Antworten
  3. Kai

    Hallo Thomas und alle Mitbastler,

    hat sich jemand von euch schonmal über ein passendes Gehäuse (Platine + 18650 Akku) Gedanken gemacht und ggf. irgendwelche Empfehlungen?
    Ich überlege, mir selbst etwas zu drucken, wäre aber auch einem Standardgehäuse aus der Massenproduktion nicht abgeneigt…

    VG
    Kai

    Antworten
    1. Lars

      Echt toller und ausführlicher Artikel. Ich will einen ähnlichen Sensor bauen und bin auch stark an der Akku Laufzeit interessiert. Schon Laufzeit werte vorhanden?

      Noch eine zweite frage: im ersten Teil des Artikel sieht man einen 18650 Akku, im zweiten Teil hingegen sieht es nach einem lipo aus? Welchen hast du nun produktiv im Einsatz?

      Vielen Dank vorab.
      VG Lars

      Antworten
      1. Thomas H. Beitragsautor

        Hallo Lars (und Kai),
        ich habe bisher immer wieder kurz bevor der Akku leer war nachgeladen, aber es sind über 2 Monate gewesen. Ich gehe je nach Akkukapazität sogar von einer längeren Betriebsdauer aus.

        Zumindest wenn man den Deep-Sleep nutzt und nur eine Übertragung z.B. jede Minute oder sogar nur jede halbe Stunde macht.

        Gruß
        Thomas

        Antworten
  4. Dieter B.

    Hallo Thomas

    Vielen Dank für das schöne Projekt.

    Habe die Version mit deep sleep eingespiel. ‚DHT22_SENSOR_DEEP_SLEEP.ino‘
    Version 2.020316.F

    Ist es so gewollt, das der ESP alle 52 Sekunde aufwacht ? Braucht doch nur unötig Energie.
    Finde gerade den Sinn nicht dahinter.

    Der ESP kann ja bis zu 71 Minuten in den DeepSleeip gehen.

    MFG
    Dieter

    Antworten
    1. Thomas H. Beitragsautor

      Hallo Dieter,

      ich komme so inkl. aufwachen auf fast genau 1 Minute.

      Da ja bei jedem Aufwachen ein Zähler um 1 erhöht wird kann man so die Übertragung fast exakt auf die Minute steuern.

      Mit 70 Sekunden wäre es komplizierter auf glatte Minuten-Intervalle zu kommen.

      Gruß
      Thomas

      Antworten
  5. Dieter B.

    Hallo Thomas

    Danke für die schnelle Antwort
    Ich komme auf ca 57 Sekunden.

    Mit dem Zähler ist das schon klar.

    Wieso lassen wir den ESP denn nicht 15 Minuten schlafen, dann brauchen wir keinen Zähler mehr. Spart doch „viel“ Energie. Ich sehe halt im Momnet nicht den Sinn darin, den ESP alle Minute zu wecken , dann was auszugeben, Zähler erhöhen und dann wieder schalfen zu gehen. Übertragung ins Web geschieht ja eh nur alle 15 Minuten.

    Gruß
    Dieter

    Antworten
    1. Thomas H. Beitragsautor

      Hallo Dieter,

      klar könnte man es mit 15 Minuten schlafen machen, kannst es ja mal umbauen und mir schicken dann kann ich es evtl. hier veröffentlichen.

      Gruß
      Thomas

      Antworten
  6. Chris

    Hey Thomas,
    dank für dein Projket hab genau so etwas mit meinem esp vorgehabt habs jetzt auch mal ausprobiert.
    Jedoch stoße ich auf probleme die Arduino IDe meldet mir :
    WARNUNG: Unberechtigter Ordner .github in der Bibliothek ‚DHT sensor library‘
    In file included from C:\Program Files (x86)\Arduino\libraries\DHT-sensor-library-master\DHT_U.cpp:22:0:

    C:\Program Files (x86)\Arduino\libraries\DHT-sensor-library-master\DHT_U.h:25:29: fatal error: Adafruit_Sensor.h: No such file or directory

    #include
    Habe die Lib aus deinem Blog genommen und auch eine angeblcih aktuellere von adafruit läuft aber nicht.
    Was ist der Fehler?
    Schonmal Danke

    Antworten

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.